Keep a rotated session crash-coverable instead of inferring it

Routing every non-"running" run.json write through finalizeRunState
made the terminal status itself the signal that the run had ended,
and so cleared the active-run handle. Session rotation (/clear,
/new) breaks that equivalence: it persists a terminal "done" for
the outgoing session while the process keeps running under a fresh
session id. Clearing liveness there left getActiveRun() null for
the rest of the process, so a crash after the first rotation never
wrote a terminal record and the session read as "running" forever.

Why a write happens is now explicit (SnapshotKind: progress,
session-rotation, run-end) instead of inferred from what it writes.
Only run-end clears the handle; persistRunSnapshot cannot request
it, since everything routed there happens while the process is
still alive.

Also drops the deleted `active` field from the crash fixture, which
sits outside tsconfig's include and so escaped typecheck.

Author: TheGreatAxios

src/tui/run-snapshot-kind.test.ts

@@ -0,0 +1,76 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { clearActiveRun, getActiveRun, setActiveRun } from "../session/active-run.js";
+import { finalizeRunState, loadState, saveState, type RunState } from "../session/state.js";
+import { clearsActiveRun, type SnapshotKind } from "./runner.js";
+
+describe("clearsActiveRun", () => {
+  test("only the run-ending write clears the active-run handle", () => {
+    expect(clearsActiveRun("run-end")).toBe(true);
+    expect(clearsActiveRun("progress")).toBe(false);
+    // The regression this pins: a /clear or /new rotation persists a
+    // terminal "done" for the outgoing session, but the process lives on.
+    // Clearing liveness here leaves every later session uncovered by the
+    // crash handler, so a crash after the first rotation never writes a
+    // terminal record and the session reads as "running" forever.
+    expect(clearsActiveRun("session-rotation")).toBe(false);
+  });
+});
+
+describe("a snapshot write dispatched by kind", () => {
+  let cwd = "";
+  let home = "";
+
+  // Mirrors writeRunSnapshot's dispatch in runner.ts so the rule above is
+  // exercised against the real state writers, not just asserted in isolation.
+  const write = async (sessionId: string, state: RunState, kind: SnapshotKind): Promise<void> => {
+    if (clearsActiveRun(kind)) {
+      await finalizeRunState(cwd, sessionId, state, home);
+      return;
+    }
+    await saveState(cwd, sessionId, state, home);
+  };
+
+  const runState = (over: Partial<RunState>): RunState => ({
+    status: "running",
+    turnsUsed: 0,
+    task: "task",
+    startedAt: 1,
+    ...over,
+  });
+
+  beforeEach(() => {
+    cwd = mkdtempSync(join(tmpdir(), "snapshot-kind-cwd-"));
+    home = mkdtempSync(join(tmpdir(), "snapshot-kind-home-"));
+  });
+
+  afterEach(() => {
+    clearActiveRun();
+    rmSync(cwd, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  });
+
+  test("a rotation still records the outgoing session but leaves the run crash-coverable", async () => {
+    setActiveRun({ sessionId: "old", cwd, task: "task", startedAt: 1 });
+
+    await write("old", runState({ status: "done", finishedAt: 10 }), "session-rotation");
+
+    expect((await loadState(cwd, "old", home))?.status).toBe("done");
+    // The rotated-in session is repointed on the same handle, so the handle
+    // must survive the write for the crash handler to have anything to close.
+    expect(getActiveRun()).not.toBeNull();
+  });
+
+  test("the run-ending write records the session and disarms the handle", async () => {
+    setActiveRun({ sessionId: "last", cwd, task: "task", startedAt: 1 });
+
+    await write("last", runState({ status: "done", finishedAt: 20 }), "run-end");
+
+    expect((await loadState(cwd, "last", home))?.status).toBe("done");
+    expect(getActiveRun()).toBeNull();
+  });
+});

src/tui/runner.ts

@@ -248,6 +248,24 @@ export function resolveResumeSeed(pickedState: RunState | null): ResumeSeed {
   };
 }
 
+/**
+ * Why a run.json snapshot is being written. Only "run-end" ends the run
+ * itself and so clears the active-run handle that the crash handler in
+ * index.ts reads.
+ *
+ * RunState.status cannot stand in for this. A /clear or /new rotation
+ * persists a terminal "done" for the outgoing session while the process
+ * keeps running under a fresh session id, so inferring "the run is over"
+ * from a non-"running" status disarms crash finalization for everything
+ * after the first rotation -- the session that dies then never gets its
+ * terminal record and reads as "running" forever.
+ */
+export type SnapshotKind = "progress" | "session-rotation" | "run-end";
+
+export function clearsActiveRun(kind: SnapshotKind): boolean {
+  return kind === "run-end";
+}
+
 const GRANT_SCOPE_LABEL: Record<GrantScope, string> = {
   session: "This session",
   project: "This project",
@@ -1441,6 +1459,7 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   const writeRunSnapshot = async (
     status: RunState["status"],
     extra?: Pick<RunState, "finishedAt" | "error">,
+    kind: SnapshotKind = "progress",
   ): Promise<void> => {
     const task = runTaskTitle.trim().length > 0 ? runTaskTitle.trim() : "(conversation)";
     const model = `${liveSource.id}:${liveSource.model}`;
@@ -1458,28 +1477,29 @@ export async function runTUI(initialConfig: Config): Promise<number> {
       mcpServers: connectedMcpServers,
       ...extra,
     };
-    // "running" is the only non-terminal status writeRunSnapshot ever
-    // receives (progress snapshots); anything else closes the run out, so
-    // the active-run handle is cleared in the same call as the disk write
-    // rather than by a separate statement at each terminal call site.
-    if (status === "running") {
-      await saveState(config.cwd, sessionId, state);
-    } else {
+    if (clearsActiveRun(kind)) {
       await finalizeRunState(config.cwd, sessionId, state);
+    } else {
+      await saveState(config.cwd, sessionId, state);
     }
   };
 
   // Progress snapshots are fired unsequenced (model switch, MCP connect, turn
   // completion), so a straggler could otherwise land after the terminal write
   // and resurrect status "running" — atomicWrite is last-rename-wins. Once the
-  // run is finalized, drop them; the terminal paths write through
+  // run is finalized, drop them; the run-ending path writes through
   // writeRunSnapshot directly.
+  //
+  // Never a "run-end" write: everything routed here happens while the process
+  // is still alive and must stay crash-coverable, including the rotation
+  // "done" that closes out a session on /clear or /new.
   const persistRunSnapshot = async (
     status: RunState["status"],
     extra?: Pick<RunState, "finishedAt" | "error">,
+    kind: Exclude<SnapshotKind, "run-end"> = "progress",
   ): Promise<void> => {
     if (finalized) return;
-    await writeRunSnapshot(status, extra);
+    await writeRunSnapshot(status, extra, kind);
   };
 
   // Cycles persist to the context store only on inference.done; the recorder
@@ -1718,8 +1738,10 @@ export async function runTUI(initialConfig: Config): Promise<number> {
             error: err instanceof Error ? err.message : String(err),
           });
         });
-        await persistRunSnapshot("done", { finishedAt: Date.now() });
+        await persistRunSnapshot("done", { finishedAt: Date.now() }, "session-rotation");
         sessionId = generateSessionId();
+        // Repointed, not cleared: the process lives on, so the crash handler
+        // must keep finding this handle and close out the *new* session.
         activeRunHandle.sessionId = sessionId;
         startedAt = Date.now();
         runTaskTitle = config.task;
@@ -2388,13 +2410,17 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   // finished run (finishedAt set) can be left reading as still in progress.
   const persistedStatus: RunState["status"] = summaryStatus;
   finalized = true;
-  // writeRunSnapshot clears the active-run handle itself for a terminal
-  // status (via finalizeRunState in state.ts), pairing the on-disk write
-  // with the in-memory one instead of setting them at two call sites.
-  await writeRunSnapshot(persistedStatus, {
-    finishedAt,
-    ...(sinkError !== undefined ? { error: sinkError } : {}),
-  });
+  // The run itself is over here, so this write clears the active-run handle
+  // (via finalizeRunState in state.ts) in the same call, rather than pairing
+  // the on-disk write with a separate in-memory statement at this call site.
+  await writeRunSnapshot(
+    persistedStatus,
+    {
+      finishedAt,
+      ...(sinkError !== undefined ? { error: sinkError } : {}),
+    },
+    "run-end",
+  );
   const runSummary = createRunSummary({
     task: runTaskTitle.length > 0 ? runTaskTitle : config.task,
     status: summaryStatus,

tests/fixtures/crash-run/simulate-crash.ts

@@ -26,7 +26,7 @@ await saveState(cwd, sessionId, {
   model,
 });
 
-setActiveRun({ sessionId, cwd, active: true, task, startedAt, model });
+setActiveRun({ sessionId, cwd, task, startedAt, model });
 installCrashHandlers();
 
 process.stdout.write(`${sessionDir(cwd, sessionId)}\n`);