Persist run.json's turn count at every turn boundary

The mid-run progress snapshot in the TUI runner only re-fired on
reactor.done, which fires exactly once, at agent shutdown, and never
between turns of a long-lived interactive session. A live monorepo
session showed run.json stuck at turnsUsed: 0 and status: running for
its entire multi-turn lifetime, with dozens of completed turns
already in context/turns.jsonl -- resume pickers and anything else
trusting run.json had no truthful signal until the process closed.

inference.done is the turn boundary every reactor cycle guarantees
(the same one the shell's run-idle transition keys off), so key the
snapshot write off that instead. The terminal write on clean exit and
the crash path both already write through directly with the final
status, so this only changes progress snapshots taken while the run
is still live.

Author: TheGreatAxios

src/tui/runner.ts

@@ -201,6 +201,18 @@ export function resolveExitCode(args: ResolveExitCodeArgs): number {
   return 0;
 }
 
+// `inference.done` is the turn boundary every reactor cycle guarantees;
+// `reactor.done` fires once, at shutdown, and never between turns of a
+// long-lived interactive session. Keying the mid-run run.json snapshot off
+// `reactor.done` left turnsUsed frozen at its resume-time value for the
+// entire session — a live monorepo session showed turnsUsed: 0 with dozens
+// of turns already in the turns log. The terminal write on close still goes
+// through writeRunSnapshot directly with the real final status, so this
+// only needs to cover progress snapshots taken while the run is live.
+export function isRunSnapshotTurnBoundary(eventType: string): boolean {
+  return eventType === "inference.done";
+}
+
 /** One-line transcript block when resume history fails to load. */
 export function resumeTranscriptLoadErrorBlock(err: unknown): {
   type: "error";
@@ -1399,7 +1411,7 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   const streamSink = (event: Parameters<typeof runSink.sink>[0]): void => {
     runSink.sink(event);
     cycleRecorder.handleEvent(event);
-    if (event.type === "reactor.done") {
+    if (isRunSnapshotTurnBoundary(event.type)) {
       void persistRunSnapshot("running");
     }
   };

tests/unit/tui/runner.test.ts

@@ -3,6 +3,7 @@ import { EventEmitter } from "node:events";
 import {
   createTUIEventEmitter,
   getTUIRunSummaryStatus,
+  isRunSnapshotTurnBoundary,
   loadLocalSettingsWriteBase,
   resumeTranscriptLoadErrorBlock,
 } from "../../../src/tui/runner.js";
@@ -21,6 +22,19 @@ test("createTUIEventEmitter can emit and receive events", () => {
   expect(received.length).toBe(1);
 });
 
+// Regression: run.json's turnsUsed must update every turn, not only once
+// at reactor shutdown. reactor.done fires exactly once, at agent shutdown,
+// so a live multi-turn interactive session never had its progress snapshot
+// re-fire until close — turnsUsed sat frozen at its resume-time value the
+// whole session (CL-5534). inference.done is the turn boundary every
+// reactor cycle guarantees, so that's what a mid-run snapshot must key off.
+test("isRunSnapshotTurnBoundary fires on inference.done, not reactor.done", () => {
+  expect(isRunSnapshotTurnBoundary("inference.done")).toBe(true);
+  expect(isRunSnapshotTurnBoundary("reactor.done")).toBe(false);
+  expect(isRunSnapshotTurnBoundary("reactor.error")).toBe(false);
+  expect(isRunSnapshotTurnBoundary("connector.reply")).toBe(false);
+});
+
 test("getTUIRunSummaryStatus distinguishes done, failed, and cancelled runs", () => {
   expect(getTUIRunSummaryStatus(true, undefined)).toBe("done");
   expect(getTUIRunSummaryStatus(true, "network failed")).toBe("failed");