fix: stop losing turn-lifecycle events (dangling sub-agents, stuck 'thinking')

[saucam]

Sub-agent counts climbed turn after turn and never came down, and sessions sat spinning at "thinking" after the model had visibly answered. Both trace to the same place: the provider's event channel loses turn-lifecycle events, silently.

This PR fixes the causes and keeps reconciliation as a backstop.

---

Cause 1 — mid-turn accounting counted pushes that produce no turn_done

#pendingMidTurnCount exists so #consumeEvents can absorb the intermediate turn_done the SDK emits when a mid-turn push starts a new query. It was incremented for every mid-turn push — including "later", which merges into the running turn and starts no query at all (ClaudeProvider: shouldQuery = priority !== "later").

session.send exposes priority on the wire, so any client sending "later" while the session was working left the counter one too high. The consumer then hit its terminal turn_done, treated it as an intermediate boundary, decremented, re-asserted "thinking" (session.ts:3379) and continued — waiting for a turn_done that was never going to be emitted.

That is the stuck spinner. It also stranded that turn's sub-agents and tools, because the loop never exited, so neither the boundary flush nor the consumer's finally ever ran. Recovery came only from the 5-minute stall watchdog or the next send — which is why it looked intermittent.

Now only querying pushes are counted.

Cause 2 — #emit dropped events silently

// before
#emit(event) { try { this.#currentTurnQueue?.push(event); } catch {} }

Three distinct losses in one expression — null queue, closed queue, full queue — indistinguishable and none logged. A lost subagent_stop left its sub-agent dangling with a live delegated ZeroID token; a lost tool_complete stranded status at tool_running. Nothing recorded either, which is why this was invisible for so long.

Now #emit reports the disposition, and id-keyed lifecycle events (subagent_stop, tool_complete) are buffered and replayed into the next turn rather than vanishing — their handlers are idempotent on unknown ids, so a late duplicate costs nothing. turn_done and streamed text are deliberately not carried: a stale turn_done would end the next turn the instant it began. Buffer is bounded (100); the log is deduped per loop generation so a persistent fault reports once, not once per event.

The fourth, invisible loss

After the consumer broke on turn_done, the turn queue stayed open and unread until the next turn replaced it. Late events were accepted into a queue nobody would ever drain — push succeeded, so there was no error and no log to catch. TurnRun.endTurn() (optional, called once from the consumer's finally) closes it, converting that silent case into the observable carryover path.

Cause 3 — the sweep was in the wrong place

#completeActiveTools() has always run in the consumer's finally precisely because provider events can be lost. Sub-agents were simply never added to that same backstop. The sweep now sits beside it, covering every exit path — clean turn_done, error, stall recovery, ownership loss — plus the mid-turn continuation branch, which continues without dispatching to #handleProviderEvent and so was missed entirely by the earlier turn_done-case sweep.

Abort-path sweeps (interrupt(), #teardownProvider()) stay as defence in depth, since those abort the SDK query and the hooks provably never fire.

What was leaking

All bounded by session destroy (deactivateSessionAgent cascades), but real while a session lives:

Session.#subagents	one entry per orphan — this drove the wrong count
Session.#subagentRegistrations	a retained Promise<void> per orphan
AgentIdentityManager.#agents	identityId, wimseUri, token, apiKey — a live credential for a dead sub-agent

The third is the one that matters: revocation is meant to ride the sub-agent's own stop, and instead waited for session teardown.

Verification

src/tests/session-subagent-lifecycle.test.ts — 13 cases. Verified by reverting the source and re-running:

Fail against original main (the sweep work): turn-end sweep · non-accumulation across turns · ZeroID revocation of an orphan · sweep on interrupt · sweep on provider teardown · info_update broadcast.

Fail against the first commit (the root-cause work): the "later" mid-turn push no longer swallowing its terminal turn_done — which fails by timing out, the bug exactly · sub-agent reconciliation at an absorbed mid-turn boundary · endTurn() closing the turn stream.

Also pinned: "now" pushes still correctly absorb their intermediate boundary (so the fix didn't just disable the mechanism), the normal subagent_stop path still works, orphans are revoked exactly once, and the carryover policy excludes turn_done/text.

• bun run typecheck clean (root + protocol + core)
• bun run lint clean, 347 files
• bun test — 2203 pass, 19 skip, 0 fail across 152 files

Known gaps

• The provider's carryover/replay path has no automated integration test — exercising it needs a live SDK query loop. Only the policy (which event types carry) is unit-tested. The Session-side half (endTurn) is covered.
• A dropped turn_done still hangs the consumer until the stall watchdog. Making the queue close a non-lossy terminal signal would need the provider to distinguish terminal from intermediate turn_done, duplicating a fragile state machine that currently lives only in Session — deliberately not attempted here. With Cause 1 fixed, the reachable path to that hang is closed; what remains is now logged rather than silent.
• active: boolean on each sub-agent entry is still vestigial (set true, never false). Untouched because subagents is client-visible in the protocol (types.ts:220).

🤖 Generated with Claude Code

[gemini-code-assist]

Caution

The consumer version of Gemini Code Assist on GitHub has been sunset. All code review activity has officially ceased.