fix(claude-code,m4): turn.result from JSONL turn_duration frame + synth token pill (v1.0.668-alpha)

ADR-027 W11 fix-up wedge #12. Two M4 polish gaps from v1.0.667 dev-box
smoke: context chip works now, but cancel-button stuck after MCP-tool
turns + token-flow pill blank.

- Cancel-button race: hookStop posted turn.result SYNCHRONOUSLY the
  moment claude invoked Stop hook — before the JSONL tailer had a
  chance to read + post the preceding assistant text frame. Wire seq
  order: turn.result(N) → text(N+1) → usage(N+2). Mobile's
  _isAgentBusy walks tail-first: usage skip (v1.0.667), text → busy.
  turn.result at lower seq never reached.

  Fix: emit turn.result from the JSONL's own system{subtype:
  turn_duration} frame (LAST frame of a turn, written after text +
  stop_hook_summary). Now turn.result has the HIGHEST seq, walker
  hits it first, idle. Dropped turn.result emission from hookStop;
  FSM transition kept.

- Token-flow pill: _TelemetryStrip gates on modelTotals.isNotEmpty,
  populated only from turn.result.by_model (codex/claude stream-json
  shape). M4's turn.result has no by_model. Pill suppressed even
  though usage was flowing.

  Fix: synthesise a _ModelTokens entry from per-message usage when
  modelTotals is empty. SET semantics on every field (NOT add) so
  the pre-v1.0.662 sum-across-tool-use-iterations bug doesn't
  reappear. Bucket key = per-message model or "claude-code".

Tests: TestMapLine_TurnDurationSystemEmitsTurnResult (new mapper
shape), TestOnHook_StopOnlyTransitionsFSM (rewrites the
"hookStop emits turn.result" assertion to "hookStop posts nothing").

Latency note: turn.result lands ~250ms later than before (one
tailer poll-tick after turn_duration frame written), in exchange
for deterministic seq ordering against text/usage. Net win — the
prior fast-but-out-of-order path left the cancel button stuck.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: Ubuntu

docs/changelog.md

@@ -3,7 +3,7 @@
 > **Type:** reference
 > **Status:** Current (2026-05-24)
 > **Audience:** contributors, operators
-> **Last verified vs code:** v1.0.667
+> **Last verified vs code:** v1.0.668
 
 **TL;DR.** Append-only record of what shipped in each tagged release.
 One section per version, newest first. Format follows
@@ -23,6 +23,63 @@ binding). Seed entries prior to that are in
 
 ---
 
+## v1.0.668-alpha — 2026-05-24
+
+ADR-027 W11 fix-up wedge #12. Two M4 polish gaps surfaced after the
+v1.0.667 APK install — context-utilisation chip now renders fine,
+cancel-button-race + token-flow pill remain.
+
+**Fixed.**
+
+- *Cancel button stuck after MCP-tool turns.* `hookStop` posted
+  `turn.result` SYNCHRONOUSLY the moment claude invoked the Stop
+  hook — before the JSONL tailer had a chance to read + post the
+  preceding assistant `text` frame. Wire seq order ended up
+  `turn.result(N) → text(N+1) → usage(N+2)`, and mobile's
+  `_isAgentBusy` walks tail-first: usage skip (v1.0.667), then
+  text → return busy. turn.result at seq N was never reached.
+
+  Fix: emit `turn.result` from the JSONL's OWN
+  `system{subtype:turn_duration}` frame — the LAST frame claude
+  writes for a turn, after assistant text + stop_hook_summary.
+  That guarantees turn.result has the HIGHEST seq of the turn,
+  so the walker hits it first and flips to idle. Dropped the
+  turn.result emission from `hookStop`; FSM transition kept.
+
+- *Token-flow pill stayed blank.* `_TelemetryStrip` gates the
+  pill on `modelTotals.isNotEmpty`, and the populating source is
+  `turn.result.by_model` (codex/claude stream-json shape). M4's
+  `turn.result` carries no `by_model`, so the pill stayed
+  suppressed even though every assistant message had full usage.
+
+  Fix: after the events loop, synthesise a `_ModelTokens` entry
+  from per-message usage when `modelTotals` is empty. SET semantics
+  on every field (NOT add) so the pre-v1.0.662 sum-across-tool-use-
+  iterations bug doesn't reappear. Bucket key = the per-message
+  `model` (e.g. `claude-opus-4-7`) or `claude-code` if unknown.
+
+**Test coverage.**
+
+- `TestMapLine_TurnDurationSystemEmitsTurnResult` — locks the new
+  mapper emission shape (kind/producer/reason/status/duration_ms/
+  message_count).
+- `TestOnHook_StopOnlyTransitionsFSM` — replaces
+  `TestOnHook_StopEmitsTurnResultForBusyWalker`; asserts hookStop
+  no longer posts ANY event, only flips FSM state.
+
+Mobile changes covered by CI flutter analyze.
+
+**Note on the change of emission timing.** Pre-v1.0.668, turn.result
+landed within milliseconds of claude finishing a turn (hook is
+synchronous on engine side). Post-v1.0.668, it lands within one
+tailer poll-tick (≤250ms default) after claude writes the
+`system{turn_duration}` frame. Net: ~250ms added latency on the
+cancel-button flip, in exchange for correct ordering against
+text/usage. Acceptable — the alternative was the cancel button
+never flipping at all.
+
+---
+
 ## v1.0.667-alpha — 2026-05-24
 
 ADR-027 W11 fix-up wedge #11 — three residual M4 polish gaps surfaced

hub/internal/buildinfo/buildinfo.go

@@ -13,7 +13,7 @@ import (
 // mobile and hub use the same x.y.z-alpha numbering. Use
 // `make bump VERSION=...` from the repo root to update both files
 // atomically.
-const Version = "1.0.667-alpha"
+const Version = "1.0.668-alpha"
 
 var (
 	Commit    string

hub/internal/drivers/local_log_tail/claude_code/hooks.go

@@ -69,31 +69,27 @@ func (a *Adapter) dispatchHook(ctx context.Context, name string, payload map[str
 
 // --- 7 observational handlers ---
 
-func (a *Adapter) hookStop(ctx context.Context, p map[string]any) (map[string]any, error) {
+func (a *Adapter) hookStop(_ context.Context, _ map[string]any) (map[string]any, error) {
 	if a.fsm != nil {
 		a.fsm.Transition(StateIdle, "Stop hook")
 	}
-	final, _ := p["last_assistant_message"].(string)
-	mode, _ := p["permission_mode"].(string)
-	// turn.result is the canonical end-of-turn signal mobile's
-	// _isAgentBusy() listens on (mobile skips `system` frames — they're
-	// a grab-bag of telemetry — and only flips to idle on turn.result /
-	// completion / session.init / certain lifecycle phases). Stop is
-	// claude's engine-level end-of-turn, so it must produce a
-	// turn.result for the UI contract to close. ACP and stream-json
-	// drivers already do this; M4 was the holdout (fixed at v1.0.647
-	// for agy with the same shape).
+	// v1.0.668 dropped the turn.result emission this handler used to
+	// own. Stop hook fires SYNCHRONOUSLY the moment claude finishes a
+	// turn — which is BEFORE the JSONL tailer has had a chance to read
+	// + post the assistant text frame that precedes the Stop
+	// attachment in the file. The pre-v1.0.668 wire order was thus
+	// `turn.result → text → usage` (turn.result got a lower seq than
+	// text), and mobile's tail-first busy walker hit text → returned
+	// busy → cancel button stuck.
 	//
-	// v1.0.661 dropped a sibling `system{subtype:turn_complete,…}`
-	// emission: the data is the same as what turn.result already
-	// carries, mobile had no renderer for the subtype, and the result
-	// was a raw JSON blob in the transcript every turn.
-	_ = a.post(ctx, "turn.result", "agent", map[string]any{
-		"reason":          "end_of_turn",
-		"status":          "success",
-		"final_message":   final,
-		"permission_mode": mode,
-	})
+	// turn.result is now emitted by the mapper from the JSONL's own
+	// `system{subtype:turn_duration}` frame (the LAST frame claude
+	// writes for a turn). That guarantees turn.result has a higher seq
+	// than any preceding text/tool_call/usage, so the walker hits it
+	// first and flips to idle. See mapper.go::mapSystem("turn_duration").
+	//
+	// FSM still transitions to idle here so other adapter consumers
+	// (none today, future probe contracts) see the correct state.
 	return map[string]any{}, nil
 }
 

hub/internal/drivers/local_log_tail/claude_code/hooks_test.go

@@ -103,13 +103,18 @@ func TestOnHook_StopTransitionsToIdle_NoSystemTurnComplete(t *testing.T) {
 	}
 }
 
-// Stop hook MUST also emit turn.result so mobile's _isAgentBusy()
-// drops the cancel-on-send overlay. The busy walker skips `system`
-// frames (the turn_complete event lives there) and only flips to
-// idle on turn.result / completion / session.init / certain lifecycle
-// phases. Same fix shape as the agy v1.0.647 fix-up. Without
-// turn.result the cancel button sticks forever at end of every turn.
-func TestOnHook_StopEmitsTurnResultForBusyWalker(t *testing.T) {
+// v1.0.668: Stop hook no longer emits turn.result — the mapper does,
+// from the JSONL's own `system{subtype:turn_duration}` frame, which
+// always lands AFTER the assistant text frame so seq order is
+// monotonic. Previously hookStop posted turn.result synchronously the
+// moment claude invoked the hook, which raced the tailer: the wire
+// order ended up `turn.result → text → usage` (turn.result with lower
+// seq), and mobile's tail-first busy walker hit text → returned
+// busy → cancel button stuck. New invariant: hookStop only
+// transitions FSM, posts NOTHING. Coverage for turn.result emission
+// moved to the mapper tests
+// (TestMapLine_TurnDurationSystemEmitsTurnResult).
+func TestOnHook_StopOnlyTransitionsFSM(t *testing.T) {
 	p := &hooksTestPoster{}
 	a := hooksTestAdapter(t, p)
 	a.fsm.Transition(StateStreaming, "seed")
@@ -121,21 +126,11 @@ func TestOnHook_StopEmitsTurnResultForBusyWalker(t *testing.T) {
 	if err != nil {
 		t.Fatalf("OnHook: %v", err)
 	}
-	ev, ok := findFirstByKind(p.snapshot(), "turn.result")
-	if !ok {
-		t.Fatalf("turn.result not emitted on Stop: %+v", p.snapshot())
-	}
-	if ev.producer != "agent" {
-		t.Errorf("turn.result producer = %q; want agent", ev.producer)
-	}
-	if ev.payload["reason"] != "end_of_turn" {
-		t.Errorf("turn.result reason = %v; want end_of_turn", ev.payload["reason"])
-	}
-	if ev.payload["status"] != "success" {
-		t.Errorf("turn.result status = %v; want success", ev.payload["status"])
+	if got := a.fsm.State(); got != StateIdle {
+		t.Errorf("state = %v, want StateIdle", got)
 	}
-	if ev.payload["final_message"] != "Done." {
-		t.Errorf("turn.result final_message = %v; want %q", ev.payload["final_message"], "Done.")
+	if _, ok := findFirstByKind(p.snapshot(), "turn.result"); ok {
+		t.Errorf("hookStop posted turn.result; v1.0.668 expects no posts at all: %+v", p.snapshot())
 	}
 }
 

hub/internal/drivers/local_log_tail/claude_code/mapper.go

@@ -416,6 +416,39 @@ func mapSystem(subtype string, raw json.RawMessage) ([]MappedEvent, error) {
 			Producer: "system",
 			Payload:  map[string]any{"subtype": "compact_boundary"},
 		}}, nil
+	case "turn_duration":
+		// v1.0.668: claude's own end-of-turn marker. It's the LAST
+		// frame claude writes for a turn (after assistant text +
+		// stop_hook_summary), so emitting turn.result here guarantees
+		// it lands on the hub with a higher seq than the preceding
+		// text + usage. Mobile's busy-walker scans tail-first and
+		// stops at the first turn.result/completion it finds, so
+		// having turn.result be the LATEST event in the session is
+		// what flips the cancel button off.
+		//
+		// Pre-v1.0.668 the only source of turn.result was the Stop
+		// hook handler (hookStop posted immediately on hook fire),
+		// which raced the tailer: hookStop's POST landed BEFORE the
+		// tailer caught up to the assistant text frame, so the wire
+		// order was turn.result → text → usage and the walker
+		// returned busy. Caught on v1.0.667 dev-box smoke when the
+		// cancel button stayed on after a multi-tool-use MCP turn.
+		var s struct {
+			Subtype     string `json:"subtype"`
+			DurationMs  int    `json:"durationMs"`
+			MessageCount int   `json:"messageCount"`
+		}
+		_ = json.Unmarshal(raw, &s)
+		return []MappedEvent{{
+			Kind:     "turn.result",
+			Producer: "agent",
+			Payload: map[string]any{
+				"reason":        "end_of_turn",
+				"status":        "success",
+				"duration_ms":   s.DurationMs,
+				"message_count": s.MessageCount,
+			},
+		}}, nil
 	default:
 		// Other system subtypes (debug telemetry, env diff, etc.)
 		// are noise on mobile; drop.

hub/internal/drivers/local_log_tail/claude_code/mapper_test.go

@@ -158,6 +158,41 @@ func TestMapLine_SystemOtherSubtypesDropped(t *testing.T) {
 	}
 }
 
+// v1.0.668: turn.result must be emitted from the JSONL's own
+// `system{subtype:turn_duration}` frame (the LAST frame claude
+// writes for a turn), not from the Stop hook handler. The hook
+// handler used to post turn.result synchronously the moment claude
+// invoked it — which raced the tailer that hadn't yet posted the
+// preceding assistant text frame, leaving turn.result with a lower
+// seq than text. Mobile's tail-first busy walker then hit text →
+// returned busy → cancel button stuck. Mapping from turn_duration
+// guarantees turn.result has the highest seq of the turn.
+func TestMapLine_TurnDurationSystemEmitsTurnResult(t *testing.T) {
+	raw := `{"type":"system","subtype":"turn_duration","durationMs":3054,"messageCount":8}`
+	got := mustMap(t, raw)
+	if len(got) != 1 {
+		t.Fatalf("want 1 event, got %d: %+v", len(got), got)
+	}
+	if got[0].Kind != "turn.result" {
+		t.Errorf("kind = %q, want turn.result", got[0].Kind)
+	}
+	if got[0].Producer != "agent" {
+		t.Errorf("producer = %q, want agent", got[0].Producer)
+	}
+	if got[0].Payload["reason"] != "end_of_turn" {
+		t.Errorf("reason = %v, want end_of_turn", got[0].Payload["reason"])
+	}
+	if got[0].Payload["status"] != "success" {
+		t.Errorf("status = %v, want success", got[0].Payload["status"])
+	}
+	if got[0].Payload["duration_ms"] != 3054 {
+		t.Errorf("duration_ms = %v, want 3054", got[0].Payload["duration_ms"])
+	}
+	if got[0].Payload["message_count"] != 8 {
+		t.Errorf("message_count = %v, want 8", got[0].Payload["message_count"])
+	}
+}
+
 func TestMapLine_KnownDroppedTypes(t *testing.T) {
 	for _, ty := range []string{
 		"permission-mode", "custom-title", "agent-name", "ai-title",

lib/widgets/agent_feed.dart

@@ -1059,6 +1059,15 @@ class _AgentFeedState extends ConsumerState<AgentFeed> {
     int? perMessageInput;
     int? perMessageCacheRead;
     int? perMessageCacheCreate;
+    // v1.0.668: also capture output + model so we can synthesise a
+    // _ModelTokens entry for the token-flow pill. M4 doesn't emit
+    // turn.result.by_model (the driver-of-record source for
+    // modelTotals), so the pill stayed blank even though every
+    // assistant message carried full usage. SET semantics here
+    // (overwrite, not sum) — same anti-double-count rule as the
+    // context-chip path.
+    int? perMessageOutput;
+    String? perMessageModel;
     for (final e in _events) {
       final kind = (e['kind'] ?? '').toString();
       final p = e['payload'];
@@ -1117,6 +1126,12 @@ class _AgentFeedState extends ConsumerState<AgentFeed> {
         if (i != null) perMessageInput = i;
         if (cr != null) perMessageCacheRead = cr;
         if (cc != null) perMessageCacheCreate = cc;
+        // v1.0.668: also capture output + model so we can synthesise
+        // a modelTotals entry below for the token-flow pill.
+        final o = (p['output_tokens'] as num?)?.toInt();
+        if (o != null) perMessageOutput = o;
+        final m = (p['model'] as String?);
+        if (m != null && m.isNotEmpty) perMessageModel = m;
         // v1.0.667: pick up `context_window` if present. The M4
         // mapper attaches it (derived from model name) so mobile can
         // render the context-utilisation chip. Without it the chip
@@ -1135,6 +1150,39 @@ class _AgentFeedState extends ConsumerState<AgentFeed> {
     if (modelTotals.isEmpty && cumulativeUsage != null) {
       modelTotals[cumulativeBucketKey] = cumulativeUsage;
     }
+    // v1.0.668: synthesise a modelTotals entry from per-message usage
+    // when no other source populated one. claude-code M4 doesn't emit
+    // turn.result.by_model, so without this the token-flow pill
+    // (which gates on modelTotals.isNotEmpty) stayed suppressed even
+    // though every assistant message carried full usage. SET
+    // semantics — `latestInput / latestCacheRead / latestCacheCreate`
+    // get the per-message snapshot directly, and we DO NOT increment
+    // `input / output / cacheRead / cacheCreate` (the cumulative
+    // fields), because per-message events would otherwise sum across
+    // a turn's many tool-use iterations and double-count by N× (the
+    // pre-v1.0.662 1M-tokens bug).
+    if (modelTotals.isEmpty &&
+        (perMessageInput != null || perMessageOutput != null)) {
+      final t = _ModelTokens.empty();
+      // Snapshot fields drive the chip; cumulative fields stay 0 so
+      // the SUM-on-display logic in _TelemetryStrip reads only the
+      // per-message values via billableInput / output.
+      t.latestInput = perMessageInput ?? 0;
+      t.latestCacheRead = perMessageCacheRead ?? 0;
+      t.latestCacheCreate = perMessageCacheCreate ?? 0;
+      // Token-flow pill reads `billableInput` (input + cacheCreate)
+      // and `output`. Populate them as snapshot too — they're meant
+      // to reflect what the user paid for on the LATEST message, not
+      // a session-wide aggregate that diverges from per-call usage.
+      t.input = perMessageInput ?? 0;
+      t.output = perMessageOutput ?? 0;
+      t.cacheRead = perMessageCacheRead ?? 0;
+      t.cacheCreate = perMessageCacheCreate ?? 0;
+      if (latestContextWindow != null && latestContextWindow! > 0) {
+        t.contextWindow = latestContextWindow!;
+      }
+      modelTotals[perMessageModel ?? 'claude-code'] = t;
+    }
     // Claude path for context window: the codex `usage` event already
     // populated latestContextWindow / latestContextUsed when present.
     // For claude (which carries the data per-model on turn.result and

pubspec.yaml

@@ -16,7 +16,7 @@ publish_to: 'none' # Remove this line if you wish to publish to pub.dev
 # https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html
 # In Windows, build-name is used as the major, minor, and patch parts
 # of the product and file versions while build-number is used as the build suffix.
-version: 1.0.667-alpha+10667
+version: 1.0.668-alpha+10668
 
 environment:
   sdk: ^3.10.7