Seed turnsUsed and mcpServers from the resumed session's run.json

Resuming a session unconditionally reset the run sink's turn counter
to zero and connectedMcpServers to empty, both in memory and by
immediately persisting those zeroed values to run.json before the
reactor even started. Seed createRunSink's collector and the
connectedMcpServers list from the picked session's prior state so
resume continues the count instead of restarting it.

Author: TheGreatAxios

src/session/hooks.ts

@@ -174,6 +174,9 @@ export type TurnContextCollectorOptions = {
   // standing copy of recent history, so callers with nothing to hand it to
   // (no lifecycle hook) can opt out of retaining it.
   retainHistory?: boolean;
+  // Resuming a session should continue the persisted run.json turn count
+  // rather than restart it at zero.
+  initialTurnCount?: number;
 };
 
 export function createTurnContextCollector(
@@ -193,7 +196,7 @@ export function createTurnContextCollector(
 } {
   const retainHistory = options.retainHistory ?? true;
   const turns: TurnContext[] = [];
-  let turnCount = 0;
+  let turnCount = options.initialTurnCount ?? 0;
   let pending: PendingTurn | null = null;
   let cycleStartedAt = now();
   let tokenUsage: TokenUsage = { ...emptyUsage };

src/session/run-sink.test.ts

@@ -77,6 +77,24 @@ describe("createRunSink", () => {
     expect(runSink.getTokenUsage()).toEqual({ input: 1, output: 1, cacheRead: 0, cacheWrite: 0, thinking: 0 });
   });
 
+  test("seeds the turn count from a resumed session's prior turnsUsed", () => {
+    const runSink = createRunSink({
+      emitter: new EventEmitter(),
+      hookManager: stubHookManager([]),
+      initialTurnCount: 7,
+    });
+
+    expect(runSink.getTurnCount()).toBe(7);
+
+    runSink.sink(event("inference.done", {
+      turn: { role: "assistant", content: [], model: "test", timestamp: 0 },
+      usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, thinking: 0 },
+      source: { provider: "test", model: "test" },
+    }));
+
+    expect(runSink.getTurnCount()).toBe(8);
+  });
+
   test("getLastTurnUsage reports the latest turn alone, not the running sum", () => {
     const runSink = createRunSink({
       emitter: new EventEmitter(),

src/session/run-sink.ts

@@ -19,6 +19,9 @@ export type RunSinkArgs = {
   // turn actually ran against, so consumers report per-turn provider/model
   // even if the live selection changed mid-run.
   onTurnComplete?: (ctx: import("./hooks.js").TurnContext) => void;
+  // Continues a resumed session's persisted run.json turn count instead of
+  // restarting the collector at zero.
+  initialTurnCount?: number;
 };
 
 export type RunSink = {
@@ -66,7 +69,7 @@ export function resolveExecRunStatus(args: {
 }
 
 export function createRunSink(args: RunSinkArgs): RunSink {
-  const { emitter, hookManager, onTurnComplete } = args;
+  const { emitter, hookManager, onTurnComplete, initialTurnCount } = args;
 
   function hasConfiguredHooks(): boolean {
     return hookManager.getStatuses().length > 0;
@@ -82,15 +85,19 @@ export function createRunSink(args: RunSinkArgs): RunSink {
     onTurnComplete?.(ctx);
   };
 
-  function createCollector(): TurnCollector {
+  // The initial seed only applies to the run's first collector (a resumed
+  // session's prior turnsUsed); a later reset() starts a fresh sub-session
+  // and should count from zero, not re-seed.
+  function createCollector(seedTurnCount?: number): TurnCollector {
     return createTurnContextCollector(handleTurn, Date.now, {
       retainHistory: hasConfiguredHooks(),
+      ...(seedTurnCount !== undefined ? { initialTurnCount: seedTurnCount } : {}),
     });
   }
 
   let runCompleted = false;
   let runError: string | undefined;
-  let turnCollector = createCollector();
+  let turnCollector = createCollector(initialTurnCount);
   // Always-on local PerfTrace: not gated by lifecycle hooks.
   let perfObserver = createPerfReactorObserver();
 

src/tui/runner.ts

@@ -406,13 +406,17 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   let resumeSkipInitialTask = config.skipInitialTask === true;
   let startedAt = Date.now();
   let runTaskTitle = config.task;
+  // Carries the resumed session's prior run.json forward so turnsUsed and
+  // mcpServers can be seeded instead of silently reset to zero/empty.
+  let resumedState: RunState | null = null;
 
   if (config.resumePicker) {
     const picked = await pickSession(config.cwd, { includeCompleted: config.force });
     if (picked === null) return 0;
     sessionId = picked.sessionId;
     resumeSkipInitialTask = true;
     const pickedState = await loadState(config.cwd, sessionId);
+    resumedState = pickedState;
     if (pickedState !== null) {
       startedAt = pickedState.startedAt;
       runTaskTitle = pickedState.task;
@@ -435,11 +439,11 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   // run.json at all.
   await saveState(config.cwd, sessionId, {
     status: "running",
-    turnsUsed: 0,
+    turnsUsed: resumedState?.turnsUsed ?? 0,
     task: runTaskTitle.trim().length > 0 ? runTaskTitle.trim() : "(conversation)",
     startedAt,
     model: `${config.providerName}:${config.model}`,
-    mcpServers: [],
+    mcpServers: resumedState?.mcpServers ?? [],
   });
 
   // Crash guard: if anything from setup onward throws all the way out of
@@ -1305,6 +1309,7 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   const runSink = createRunSink({
     emitter,
     hookManager,
+    ...(resumedState !== null ? { initialTurnCount: resumedState.turnsUsed } : {}),
     onTurnComplete: (ctx) => {
       // provider_id is the canonical provider kind, never ctx.source.sourceId:
       // sourceId is the user-typed label from onboarding/settings, and free
@@ -1324,7 +1329,7 @@ export async function runTUI(initialConfig: Config): Promise<number> {
 
   // MCP servers connected so far, keyed by name so a reconnect after a failure
   // replaces rather than duplicates the entry.
-  let connectedMcpServers: ConnectedMcpServer[] = [];
+  let connectedMcpServers: ConnectedMcpServer[] = resumedState?.mcpServers ?? [];
   // Every configured server's latest state, for the /mcp surface. Unlike
   // `connectedMcpServers` (persisted run metadata) this keeps the ones that
   // failed or are still waiting on authorization.