Add a regression test for a crash during the run-end write

The existing crash-after-rotation test only covers a crash
arriving before any terminal write starts, so it stayed green
even with the run-end handle-clearing regression present. This
test parks the run-end write mid-flight and fires an unrelated
uncaughtException during that window, asserting the outcome is
never "crashed" — pinning the fix that moved finalizeRunState's
clear ahead of its own write.

Author: TheGreatAxios

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

@@ -0,0 +1,61 @@
+// Spawned as a subprocess by tests/integration/crash-finalize.test.ts. Mimics
+// the run-end write (writeRunSnapshot's "done" call through finalizeRunState
+// in state.ts) landing mid-flight when an unrelated uncaughtException fires,
+// rather than simulate-crash.ts's scenario of a crash escaping before any
+// terminal write is issued at all.
+import { installCrashHandlers } from "../../../src/index.js";
+import { setActiveRun, setTestWriteGate } from "../../../src/session/active-run.js";
+import { sessionDir } from "../../../src/session/index.js";
+import { finalizeRunState, saveState } from "../../../src/session/state.js";
+
+const cwd = process.cwd();
+const sessionId = process.env["RUN_END_TEST_SESSION_ID"];
+if (sessionId === undefined) {
+  throw new Error("RUN_END_TEST_SESSION_ID must be set");
+}
+
+const startedAt = Date.now();
+const task = "simulated run-end task";
+const model = "test-provider:test-model";
+
+await saveState(cwd, sessionId, {
+  status: "running",
+  turnsUsed: 3,
+  task,
+  startedAt,
+  model,
+});
+
+setActiveRun({ sessionId, cwd, task, startedAt, model });
+installCrashHandlers();
+
+process.stdout.write(`${sessionDir(cwd, sessionId)}\n`);
+
+// Held open for the rest of the process's life — saveCrashState (the crash
+// path) bypasses this gate entirely via a raw atomicWrite, so parking the
+// run-end write here forever is enough to simulate "the run-end snapshot
+// write is still in flight" without needing to release it: whether the
+// process observes "done" or "crashed" is decided before this write would
+// ever land.
+setTestWriteGate(new Promise(() => {}));
+
+// Fire the run-end write the same way writeRunSnapshot does for a terminal
+// status, but don't await it — runner.ts doesn't either from the crash
+// handler's point of view, since the crash below arrives asynchronously.
+void finalizeRunState(cwd, sessionId, {
+  status: "done",
+  turnsUsed: 3,
+  task,
+  startedAt,
+  finishedAt: Date.now(),
+  model,
+});
+
+// Runs after the synchronous portion of finalizeRunState above (its
+// clearActiveRun call, if placed before the saveState await) has already
+// executed, since setImmediate always waits for the current synchronous
+// script to finish. This is the window the bug reopened: an unrelated
+// exception landing while the run-end write is still in flight.
+setImmediate(() => {
+  throw new Error("simulated crash during run-end write");
+});

tests/integration/crash-finalize.test.ts

@@ -9,6 +9,7 @@ import type { RunState } from "../../src/session/state.js";
 import { isResumableByDefault } from "../../src/tui/pick-session.js";
 
 const FIXTURE = join(import.meta.dirname, "../fixtures/crash-run/simulate-crash.ts");
+const RUN_END_FIXTURE = join(import.meta.dirname, "../fixtures/crash-run/simulate-run-end-crash.ts");
 
 describe("integration — crash finalizes run.json", () => {
   test("uncaughtException writes status: crashed with finishedAt, racing in-flight snapshot writes", async () => {
@@ -99,4 +100,44 @@ describe("integration — crash finalizes run.json", () => {
       rmSync(home, { recursive: true, force: true });
     }
   }, 15_000);
+
+  test("an unrelated crash while the run-end write is in flight does not report crashed", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "corbits-crash-cwd-"));
+    const home = mkdtempSync(join(tmpdir(), "corbits-crash-home-"));
+    const sessionId = generateSessionId();
+
+    try {
+      const proc = Bun.spawn(["bun", "run", RUN_END_FIXTURE], {
+        cwd,
+        env: { ...process.env, HOME: home, RUN_END_TEST_SESSION_ID: sessionId },
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      const exitCode = await proc.exited;
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+
+      expect(exitCode).toBe(1);
+      expect(stderr).toContain("uncaughtException: Error: simulated crash during run-end write");
+
+      // The bug this pins: finalizeRunState used to clear the active-run
+      // handle only after its own saveState write resolved. With the
+      // run-end write parked mid-flight (this fixture's gate never
+      // releases), the handle stayed live for the entire window, so the
+      // crash handler saw a live run and wrote a "crashed" record via
+      // saveCrashState — which bypasses the gate — clobbering what should
+      // have been a clean finish. Clearing the handle before the await
+      // closes that window: the crash handler finds no active run and
+      // writes nothing, so the last write to land is the one from the
+      // initial saveState above ("running"), never "crashed".
+      const runJsonPath = join(stdout.trim(), "run.json");
+      const raw = readFileSync(runJsonPath, "utf8");
+      const state = JSON.parse(raw) as RunState;
+      expect(state.status).not.toBe("crashed");
+    } finally {
+      rmSync(cwd, { recursive: true, force: true });
+      rmSync(home, { recursive: true, force: true });
+    }
+  }, 15_000);
 });