fix(claude-code,m4): unstick cancel button + light context chip + synth session.init (v1.0.667-alpha)

ADR-027 W11 fix-up wedge #11. Three residual M4 polish gaps surfaced
on v1.0.666 (the load-bearing text-rendering fix) on-host smoke.

- Cancel button stuck on after end-of-turn. Mobile's _isAgentBusy
  walks events tail-first and treats every agent-produced kind as
  proof of in-flight turn. M4's wire order is
  turn.result → text → usage (Stop hook posts turn.result first,
  JSONL tail posts text+usage), so the LATEST event is `usage` and
  the walker fell through to "busy = true". Added usage + rate_limit
  to the skip list (both telemetry, similar shape).

- Context chip blank. The mapper's per-message usage event carried
  input_tokens/cache_read/cache_create but no context_window, so
  mobile couldn't compute pct (chip suppresses itself when cw=0).
  Mapper now derives capacity from model name via a small lookup
  (claude-opus-* / claude-sonnet-* / claude-haiku-* / claude-3-* →
  200000; otherwise omit). Mobile's per-message usage handler picks
  up the new field.

- Session.init chip empty. M4's on-disk JSONL has no equivalent of
  M2 stream-json's `init` frame. Adapter now synthesises a
  session.init from the FIRST usage frame carrying a model.
  Idempotent per Adapter lifetime — subsequent usage frames don't
  re-emit. Payload: engine=claude-code, model, cwd.

3 new tests: usage carries context_window for known models (sweep),
omits it for unknown, adapter synthesises one + only one session.init
that lands BEFORE the first usage so mobile picks both up in the
same build pass.

Co-Authored-By: Claude Opus 4.7 <[email protected]>

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.666
+> **Last verified vs code:** v1.0.667
 
 **TL;DR.** Append-only record of what shipped in each tagged release.
 One section per version, newest first. Format follows
@@ -23,6 +23,55 @@ binding). Seed entries prior to that are in
 
 ---
 
+## v1.0.667-alpha — 2026-05-24
+
+ADR-027 W11 fix-up wedge #11 — three residual M4 polish gaps surfaced
+after v1.0.666 (the text-rendering fix) on-host smoke.
+
+**Fixed.**
+
+- *Cancel button stuck on after end-of-turn.* Mobile's `_isAgentBusy`
+  walks events tail-first and treats any "agent-produced" kind as
+  proof a turn is still in motion. The M4 wire order at end-of-turn
+  is `turn.result → text → usage` (turn.result is posted from the
+  Stop hook handler, text+usage from the JSONL tail), so the LATEST
+  event is `usage`. Walker fell through to the default "busy = true"
+  branch. Added `usage` (and `rate_limit`, similar shape) to the
+  skip list — both are pure telemetry kinds that don't move the
+  turn-progress signal.
+
+- *Context-utilisation chip stayed blank.* The mapper's per-message
+  usage event carried `input_tokens`/`cache_read`/`cache_create` but
+  no `context_window`, so mobile couldn't compute the percentage
+  (chip suppresses itself when capacity is zero). Now the mapper
+  derives the capacity from the model name via a small lookup
+  (`claude-opus-*` / `claude-sonnet-*` / `claude-haiku-*` /
+  `claude-3-*` → 200000; everything else → omit so the chip
+  stays suppressed rather than render a wrong %). Mobile's
+  per-message usage branch picks up the new field.
+
+- *Session.init header chip blank.* M4's on-disk JSONL has no
+  equivalent of M2 stream-json's `init` frame, so mobile's AppBar
+  chip (engine + model + cwd row) stayed empty. The adapter now
+  synthesises a `session.init` event from the FIRST usage frame it
+  sees (the one that carries the model name). Idempotent per
+  Adapter lifetime — subsequent usage events don't re-emit.
+
+**Test coverage.**
+
+- `TestMapLine_UsageCarriesContextWindowFromModel` — sweeps all 4
+  known model prefixes, asserts 200K each.
+- `TestMapLine_UsageOmitsContextWindowForUnknownModel` — better blank
+  than wrong.
+- `TestAdapter_SynthesisesSessionInitFromFirstUsage` — exactly one
+  init landed; payload carries engine/model/cwd; lands BEFORE the
+  first usage event so mobile's build pass picks it up in the same
+  pass.
+
+Mobile changes covered by CI `flutter analyze`.
+
+---
+
 ## v1.0.666-alpha — 2026-05-24
 
 ADR-027 W11 fix-up wedge #10 — the load-bearing one. Closes the

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.666-alpha"
+const Version = "1.0.667-alpha"
 
 var (
 	Commit    string

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

@@ -133,6 +133,13 @@ type Adapter struct {
 	// Plan §5.B.1.
 	pickerMu   sync.Mutex
 	pickerDone chan struct{}
+
+	// sessionInitMu guards sessionInitSent. The flag is checked + set
+	// in runLoop so a second usage event on the same session doesn't
+	// re-emit the synthetic session.init (mobile would still merge it
+	// correctly, but the duplicate event is noise).
+	sessionInitMu   sync.Mutex
+	sessionInitSent bool
 }
 
 // NewAdapter constructs a claude-code Adapter. Returns an error early
@@ -270,6 +277,40 @@ func (a *Adapter) resolveAndRun(ctx context.Context) {
 	a.runLoop(ctx, lines)
 }
 
+// maybeEmitSessionInit posts a synthetic session.init the first time
+// we see a usage event carrying a model field. M4 (on-disk JSONL)
+// has no equivalent of M2 stream-json's `init` frame, so mobile's
+// AppBar chip stays empty for every M4 spawn without this. Idempotent
+// per Adapter lifetime — the flag prevents duplicate emits when many
+// usage events flow in the same session.
+func (a *Adapter) maybeEmitSessionInit(ctx context.Context, ev MappedEvent) {
+	if ev.Kind != "usage" {
+		return
+	}
+	model, _ := ev.Payload["model"].(string)
+	if model == "" {
+		return
+	}
+	a.sessionInitMu.Lock()
+	if a.sessionInitSent {
+		a.sessionInitMu.Unlock()
+		return
+	}
+	a.sessionInitSent = true
+	a.sessionInitMu.Unlock()
+
+	payload := map[string]any{
+		"engine":  "claude-code",
+		"model":   model,
+		"cwd":     a.Workdir,
+		"version": "claude-code", // mobile's chip shows engine alone if version absent
+	}
+	if err := a.Poster.PostAgentEvent(ctx, a.AgentID, "session.init", "agent", payload); err != nil {
+		a.Log.Warn("claude-code adapter: session.init post failed",
+			"agent_id", a.AgentID, "err", err)
+	}
+}
+
 // noteFailure logs and surfaces a soft failure: the pane is still
 // live, but JSONL-derived events won't flow for this session.
 // Best-effort post — a hub blip shouldn't escalate this further.
@@ -342,6 +383,17 @@ func (a *Adapter) runLoop(ctx context.Context, lines <-chan Line) {
 			}
 			for _, ev := range events {
 				payload := ev.Payload
+				// v1.0.667: synthesise a session.init event from the
+				// first per-message usage frame we see. The usage
+				// payload carries `model` (set by usageFromMessage),
+				// and the adapter's Workdir gives `cwd`; together
+				// that's enough for mobile's AppBar header chip to
+				// render the engine + model + cwd row that M1/M2
+				// drivers get for free from their engine-emitted
+				// init frame. claude-code's on-disk JSONL has no
+				// equivalent of M2 stream-json's `init` frame, so
+				// the chip was empty for every M4 spawn.
+				a.maybeEmitSessionInit(ctx, ev)
 				// v1.0.666: no replay tagging — see runLoop header note.
 				if err := a.Poster.PostAgentEvent(ctx, a.AgentID, ev.Kind, ev.Producer, payload); err != nil {
 					// v1.0.664 escalated from Debug to Warn. Silent

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

@@ -326,3 +326,72 @@ func TestAdapter_StopDrainsRunLoop(t *testing.T) {
 	// Idempotent.
 	a.Stop()
 }
+
+// v1.0.667 — the M4 adapter synthesises a session.init event on the
+// first usage frame carrying a model, since on-disk JSONL has no
+// equivalent of M2 stream-json's `init` frame. Without this mobile's
+// AppBar chip stays blank for every M4 spawn. Asserts:
+//   - session.init lands BEFORE the corresponding usage event so
+//     the chip can render in the same build pass
+//   - payload carries engine="claude-code", the model from the
+//     assistant frame, and the workdir
+//   - subsequent usage frames in the same session DO NOT re-emit
+//     session.init (would be benign but adds noise)
+func TestAdapter_SynthesisesSessionInitFromFirstUsage(t *testing.T) {
+	cwd := "/home/test/proj-sinit"
+	homeDir, projectDir := makeFakeHome(t, cwd)
+	jsonl := filepath.Join(projectDir, "sess.jsonl")
+	writeJSONL(t, jsonl,
+		`{"type":"assistant","message":{"model":"claude-opus-4-7","content":[{"type":"text","text":"hi"}],"usage":{"input_tokens":1,"cache_read_input_tokens":100}}}`,
+		`{"type":"assistant","message":{"model":"claude-opus-4-7","content":[{"type":"text","text":"more"}],"usage":{"input_tokens":2,"cache_read_input_tokens":200}}}`,
+	)
+
+	p := &capturingPoster{}
+	a, _ := NewAdapter(Config{AgentID: "ag", Workdir: cwd, Poster: p})
+	a.HomeDir = homeDir
+	a.SessionCutoff = time.Time{}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+	if err := a.Start(ctx); err != nil {
+		t.Fatalf("Start: %v", err)
+	}
+	defer a.Stop()
+
+	// Both assistant frames produce text + usage. With one
+	// synthetic session.init, that's 5 events total.
+	got := waitForN(t, p, 5, 2*time.Second)
+
+	// Find the session.init.
+	var initIdx = -1
+	initCount := 0
+	for i, ev := range got {
+		if ev.kind == "session.init" {
+			initCount++
+			if initIdx < 0 {
+				initIdx = i
+			}
+		}
+	}
+	if initCount != 1 {
+		t.Fatalf("want exactly 1 session.init, got %d in %+v", initCount, got)
+	}
+	init := got[initIdx]
+	if init.payload["engine"] != "claude-code" {
+		t.Errorf("engine = %v, want claude-code", init.payload["engine"])
+	}
+	if init.payload["model"] != "claude-opus-4-7" {
+		t.Errorf("model = %v, want claude-opus-4-7", init.payload["model"])
+	}
+	if init.payload["cwd"] != cwd {
+		t.Errorf("cwd = %v, want %s", init.payload["cwd"], cwd)
+	}
+	// session.init must precede the FIRST usage event so mobile's
+	// build-pass picks it up alongside the chip-driving values.
+	for i := 0; i < initIdx; i++ {
+		if got[i].kind == "usage" {
+			t.Errorf("usage at index %d landed BEFORE session.init at %d: %+v",
+				i, initIdx, got)
+		}
+	}
+}

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

@@ -160,6 +160,16 @@ func usageFromMessage(model string, raw json.RawMessage) *MappedEvent {
 	}
 	if model != "" {
 		payload["model"] = model
+		// v1.0.667: include context_window so mobile's telemetry
+		// strip can render the context-utilisation chip. Mobile's
+		// chip suppresses itself when contextWindow is zero (it
+		// can't compute the pct), so without this the chip stayed
+		// blank on M4 even though usage events were flowing. All
+		// current claude-* models are 200K; future models would
+		// extend the switch in claudeModelContextWindow.
+		if cw := claudeModelContextWindow(model); cw > 0 {
+			payload["context_window"] = cw
+		}
 	}
 	return &MappedEvent{
 		Kind:     "usage",
@@ -168,6 +178,31 @@ func usageFromMessage(model string, raw json.RawMessage) *MappedEvent {
 	}
 }
 
+// claudeModelContextWindow returns the context window of a claude
+// model identifier in tokens, or 0 if the identifier is unrecognised
+// (mobile then suppresses the chip rather than rendering a wrong %).
+//
+// Source: Anthropic public model docs (2026-05). claude-opus-4-*,
+// claude-sonnet-4-*, and claude-haiku-4-* all ship with a 200K
+// context window. claude-3-* are kept on the legacy 200K too. When a
+// new model size ships with a different capacity, add the prefix
+// here — keeping the map small + explicit so we don't fall back to
+// a wrong default.
+func claudeModelContextWindow(model string) int {
+	const k200 = 200_000
+	for _, prefix := range []string{
+		"claude-opus-",
+		"claude-sonnet-",
+		"claude-haiku-",
+		"claude-3-",
+	} {
+		if strings.HasPrefix(model, prefix) {
+			return k200
+		}
+	}
+	return 0
+}
+
 func mapAssistantBlock(raw json.RawMessage) *MappedEvent {
 	var b struct {
 		Type      string          `json:"type"`

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

@@ -277,6 +277,57 @@ func TestMapLine_AssistantWithoutUsageEmitsOnlyContent(t *testing.T) {
 	}
 }
 
+// v1.0.667 — usage events MUST carry context_window when the model
+// name resolves to a known capacity. Without it mobile's
+// context-utilisation chip suppresses itself entirely (cw==0 → no
+// tile). All current claude-* models are 200K.
+func TestMapLine_UsageCarriesContextWindowFromModel(t *testing.T) {
+	for _, model := range []string{
+		"claude-opus-4-7",
+		"claude-sonnet-4-6",
+		"claude-haiku-4-5-20251001",
+		"claude-3-5-sonnet-20240620",
+	} {
+		raw := `{"type":"assistant","message":{
+			"model":"` + model + `",
+			"content":[{"type":"text","text":"x"}],
+			"usage":{"input_tokens":1,"output_tokens":1}
+		}}`
+		got := mustMap(t, raw)
+		var usage *MappedEvent
+		for i := range got {
+			if got[i].Kind == "usage" {
+				usage = &got[i]
+			}
+		}
+		if usage == nil {
+			t.Fatalf("%s: usage not emitted: %+v", model, got)
+		}
+		if cw, _ := usage.Payload["context_window"].(int); cw != 200_000 {
+			t.Errorf("%s: context_window = %v, want 200000", model, usage.Payload["context_window"])
+		}
+	}
+}
+
+// An unrecognised model name must NOT have a context_window field —
+// better blank than wrong. Mobile then suppresses the chip.
+func TestMapLine_UsageOmitsContextWindowForUnknownModel(t *testing.T) {
+	raw := `{"type":"assistant","message":{
+		"model":"gpt-99-future",
+		"content":[{"type":"text","text":"x"}],
+		"usage":{"input_tokens":1,"output_tokens":1}
+	}}`
+	got := mustMap(t, raw)
+	for _, ev := range got {
+		if ev.Kind != "usage" {
+			continue
+		}
+		if _, has := ev.Payload["context_window"]; has {
+			t.Errorf("unknown model emitted context_window: %v", ev.Payload)
+		}
+	}
+}
+
 // An assistant message with all-zero usage fields must NOT emit a
 // usage event — the chip would be no better off seeing a {0,0,0}
 // snapshot than no event at all, and the zero would replace a real

lib/widgets/agent_feed.dart

@@ -1117,6 +1117,15 @@ class _AgentFeedState extends ConsumerState<AgentFeed> {
         if (i != null) perMessageInput = i;
         if (cr != null) perMessageCacheRead = cr;
         if (cc != null) perMessageCacheCreate = cc;
+        // 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
+        // suppresses itself (cw <= 0 → no tile). The cumulative
+        // branch above already handled this; the per-message branch
+        // didn't, leaving the chip blank for claude-code spawns
+        // even though usage was flowing.
+        final cw = (p['context_window'] as num?)?.toInt() ?? 0;
+        if (cw > 0) latestContextWindow = cw;
       }
     }
     // If no by_model rows arrived (codex's turn/completed doesn't
@@ -1395,6 +1404,17 @@ class _AgentFeedState extends ConsumerState<AgentFeed> {
       // mean a turn is in progress. Skip and keep scanning so a
       // real text/tool_call signal can win.
       if (kind == 'system') continue;
+      // v1.0.667: 'usage' is per-message telemetry too — the
+      // claude-code M4 adapter posts a usage frame AFTER each
+      // assistant message AND after each turn's Stop hook
+      // (turn.result). Concretely the wire order for an end-of-turn
+      // is: turn.result → text → usage. Reading from the tail back,
+      // the LATEST agent event is `usage`, which fell through to
+      // the default "return true" branch — keeping the busy pill
+      // stuck on forever even after turn.result fired. Treat usage
+      // as pure telemetry (same as 'rate_limit', also skipped via
+      // _isHiddenInFeed but not enumerated here pre-v1.0.667).
+      if (kind == 'usage' || kind == 'rate_limit') continue;
       // Any other agent-produced kind — text streaming, thought,
       // tool_call mid-flight, plan, raw, etc. — means the turn is
       // still in motion.

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.666-alpha+10666
+version: 1.0.667-alpha+10667
 
 environment:
   sdk: ^3.10.7