Seed turnsUsed and mcpServers when resuming a session

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. resolveResumeSeed folds a picked session's
run.json into a single concrete seed once, at the resume boundary, so
createRunSink, connectedMcpServers, and the immediate post-resume
saveState all read a trusted value instead of each repeating its own
`?? 0` / `?? []` default.

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/resume-seed.test.ts

@@ -0,0 +1,41 @@
+import { describe, test, expect } from "bun:test";
+import { resolveResumeSeed } from "./runner.js";
+import type { RunState } from "../session/state.js";
+
+function pickedState(overrides: Partial<RunState>): RunState {
+  return {
+    status: "running",
+    turnsUsed: 0,
+    task: "task",
+    startedAt: 1,
+    ...overrides,
+  };
+}
+
+describe("resolveResumeSeed", () => {
+  test("a fresh (non-resumed) run seeds zero turns and no servers", () => {
+    expect(resolveResumeSeed(null)).toEqual({ turnsUsed: 0, mcpServers: [] });
+  });
+
+  test("carries forward a resumed session's non-zero turnsUsed and non-empty mcpServers", () => {
+    const seed = resolveResumeSeed(
+      pickedState({
+        turnsUsed: 12,
+        mcpServers: [{ name: "filesystem", toolCount: 5 }, { name: "search", toolCount: 2 }],
+      }),
+    );
+
+    expect(seed.turnsUsed).toBe(12);
+    expect(seed.mcpServers).toEqual([
+      { name: "filesystem", toolCount: 5 },
+      { name: "search", toolCount: 2 },
+    ]);
+  });
+
+  test("defaults mcpServers to empty when a resumed record predates that field", () => {
+    const seed = resolveResumeSeed(pickedState({ turnsUsed: 3 }));
+
+    expect(seed.turnsUsed).toBe(3);
+    expect(seed.mcpServers).toEqual([]);
+  });
+});

src/tui/runner.ts

@@ -211,6 +211,29 @@ export function resumeTranscriptLoadErrorBlock(err: unknown): {
   return { type: "error", message: `Could not load prior session transcript: ${message}` };
 }
 
+export type ResumeSeed = {
+  turnsUsed: number;
+  mcpServers: ConnectedMcpServer[];
+};
+
+const FRESH_RESUME_SEED: ResumeSeed = { turnsUsed: 0, mcpServers: [] };
+
+/**
+ * Fold a resumed session's run.json into a concrete seed once, at the
+ * resume boundary, so every downstream reader (the run sink, the
+ * connected-servers list, the immediate post-resume saveState) trusts a
+ * fully-populated value instead of each repeating its own `?? 0` / `?? []`
+ * default. A fresh (non-resumed) run gets the same shape via
+ * FRESH_RESUME_SEED, so callers never branch on "was this a resume."
+ */
+export function resolveResumeSeed(pickedState: RunState | null): ResumeSeed {
+  if (pickedState === null) return FRESH_RESUME_SEED;
+  return {
+    turnsUsed: pickedState.turnsUsed,
+    mcpServers: pickedState.mcpServers ?? [],
+  };
+}
+
 const GRANT_SCOPE_LABEL: Record<GrantScope, string> = {
   session: "This session",
   project: "This project",
@@ -406,13 +429,17 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   let resumeSkipInitialTask = config.skipInitialTask === true;
   let startedAt = Date.now();
   let runTaskTitle = config.task;
+  // Resolved once at the resume boundary so turnsUsed/mcpServers reads
+  // downstream never repeat their own omission-handling default.
+  let resumeSeed: ResumeSeed = FRESH_RESUME_SEED;
 
   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);
+    resumeSeed = resolveResumeSeed(pickedState);
     if (pickedState !== null) {
       startedAt = pickedState.startedAt;
       runTaskTitle = pickedState.task;
@@ -435,11 +462,11 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   // run.json at all.
   await saveState(config.cwd, sessionId, {
     status: "running",
-    turnsUsed: 0,
+    turnsUsed: resumeSeed.turnsUsed,
     task: runTaskTitle.trim().length > 0 ? runTaskTitle.trim() : "(conversation)",
     startedAt,
     model: `${config.providerName}:${config.model}`,
-    mcpServers: [],
+    mcpServers: resumeSeed.mcpServers,
   });
 
   // Crash guard: if anything from setup onward throws all the way out of
@@ -1313,6 +1340,7 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   const runSink = createRunSink({
     emitter,
     hookManager,
+    initialTurnCount: resumeSeed.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
@@ -1332,7 +1360,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[] = resumeSeed.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.