gsd-pi 2.52.0-dev.585e355 → 2.52.0-dev.655ad8a

package/src/resources/extensions/gsd/tests/auto-stale-lock-self-kill.test.ts

@@ -0,0 +1,87 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { writeLock, readCrashLock, clearLock } from "../crash-recovery.ts";
+import { checkRemoteAutoSession, stopAutoRemote } from "../auto.ts";
+
+function makeTmpProject(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-stale-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+// ─── checkRemoteAutoSession: own-PID filtering (#2730) ───────────────────
+
+test("#2730: checkRemoteAutoSession returns { running: false } when lock PID matches current process", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Write a lock with the current process PID — simulates a stale lock
+  // left behind after step-mode exit without full cleanup.
+  writeLock(dir, "execute-task", "M001/S01/T01");
+
+  const lock = readCrashLock(dir);
+  assert.ok(lock, "lock file should exist");
+  assert.equal(lock!.pid, process.pid, "lock should have our PID");
+
+  const result = checkRemoteAutoSession(dir);
+  assert.equal(result.running, false, "own PID must not be treated as a remote session");
+});
+
+test("#2730: checkRemoteAutoSession still detects a genuine remote session (different PID)", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Use parent PID — guaranteed alive, guaranteed not our PID.
+  const remotePid = process.ppid;
+  const lockData = {
+    pid: remotePid,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T02",
+    unitStartedAt: new Date().toISOString(),
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+
+  const result = checkRemoteAutoSession(dir);
+  assert.equal(result.running, true, "different live PID should be detected as running");
+  assert.equal(result.pid, remotePid);
+});
+
+// ─── stopAutoRemote: self-kill prevention (#2730) ────────────────────────
+
+test("#2730: stopAutoRemote does not send SIGTERM when lock PID matches current process", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Write a lock with our own PID
+  writeLock(dir, "execute-task", "M001/S01/T01");
+
+  const result = stopAutoRemote(dir);
+  assert.equal(result.found, false, "own PID must not be signalled");
+
+  // The lock should be cleared as part of the self-detection cleanup
+  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "stale self-lock should be cleared");
+});
+
+test("#2730: stopAutoRemote clears stale lock from dead remote process without error", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Simulate a stale lock from a process that no longer exists
+  const lockData = {
+    pid: 9999999,
+    startedAt: "2026-03-01T00:00:00Z",
+    unitType: "plan-slice",
+    unitId: "M001/S02",
+    unitStartedAt: "2026-03-01T00:05:00Z",
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+
+  const result = stopAutoRemote(dir);
+  assert.equal(result.found, false, "dead remote PID should not be reported as found");
+  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "stale lock should be cleaned up");
+});

package/src/resources/extensions/gsd/tests/auto-worktree-auto-resolve.test.ts

@@ -0,0 +1,80 @@
+/**
+ * auto-worktree-auto-resolve.test.ts — Unit tests for isSafeToAutoResolve.
+ *
+ * Covers: .gsd/ state files, build artifacts (.tsbuildinfo, .pyc, __pycache__,
+ * .DS_Store, .map), and rejection of real source files.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  isSafeToAutoResolve,
+  SAFE_AUTO_RESOLVE_PATTERNS,
+} from "../auto-worktree.ts";
+
+describe("isSafeToAutoResolve", () => {
+  // ─── .gsd/ state files ───────────────────────────────────────────────────
+  test("returns true for .gsd/ prefixed paths", () => {
+    assert.ok(isSafeToAutoResolve(".gsd/STATE.md"));
+    assert.ok(isSafeToAutoResolve(".gsd/milestones/M001/CONTEXT.md"));
+    assert.ok(isSafeToAutoResolve(".gsd/gsd.db"));
+  });
+
+  // ─── Build artifact patterns ─────────────────────────────────────────────
+  test("returns true for .tsbuildinfo files", () => {
+    assert.ok(isSafeToAutoResolve("tsconfig.tsbuildinfo"));
+    assert.ok(isSafeToAutoResolve("dist/tsconfig.tsbuildinfo"));
+  });
+
+  test("returns true for .pyc files", () => {
+    assert.ok(isSafeToAutoResolve("module.pyc"));
+    assert.ok(isSafeToAutoResolve("src/utils/helpers.pyc"));
+  });
+
+  test("returns true for __pycache__/ paths", () => {
+    assert.ok(isSafeToAutoResolve("src/__pycache__/module.cpython-311.pyc"));
+    assert.ok(isSafeToAutoResolve("lib/__pycache__/foo.py"));
+  });
+
+  test("returns true for .DS_Store files", () => {
+    assert.ok(isSafeToAutoResolve(".DS_Store"));
+    assert.ok(isSafeToAutoResolve("src/.DS_Store"));
+  });
+
+  test("returns true for .map source map files", () => {
+    assert.ok(isSafeToAutoResolve("dist/index.js.map"));
+    assert.ok(isSafeToAutoResolve("out/bundle.css.map"));
+  });
+
+  // ─── Real source files (should NOT be auto-resolved) ─────────────────────
+  test("returns false for .ts source files", () => {
+    assert.ok(!isSafeToAutoResolve("src/index.ts"));
+    assert.ok(!isSafeToAutoResolve("lib/utils.ts"));
+  });
+
+  test("returns false for .js source files", () => {
+    assert.ok(!isSafeToAutoResolve("src/index.js"));
+    assert.ok(!isSafeToAutoResolve("lib/helpers.js"));
+  });
+
+  test("returns false for .py source files", () => {
+    assert.ok(!isSafeToAutoResolve("src/main.py"));
+    assert.ok(!isSafeToAutoResolve("scripts/deploy.py"));
+  });
+
+  test("returns false for config and data files", () => {
+    assert.ok(!isSafeToAutoResolve("package.json"));
+    assert.ok(!isSafeToAutoResolve("tsconfig.json"));
+    assert.ok(!isSafeToAutoResolve("README.md"));
+  });
+
+  // ─── SAFE_AUTO_RESOLVE_PATTERNS export ────────────────────────────────────
+  test("SAFE_AUTO_RESOLVE_PATTERNS is a non-empty array of RegExp", () => {
+    assert.ok(Array.isArray(SAFE_AUTO_RESOLVE_PATTERNS));
+    assert.ok(SAFE_AUTO_RESOLVE_PATTERNS.length > 0);
+    for (const pattern of SAFE_AUTO_RESOLVE_PATTERNS) {
+      assert.ok(pattern instanceof RegExp);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -77,7 +77,7 @@ function addSliceToMilestone(
   run(`git branch -d ${sliceBranch}`, wtPath);
 }
 
-describe("auto-worktree-milestone-merge", () => {
+describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
   const savedCwd = process.cwd();
   const tempDirs: string[] = [];
 

package/src/resources/extensions/gsd/tests/collect-from-manifest.test.ts

@@ -227,6 +227,45 @@ test("collectSecretsFromManifest: manifest statuses are updated after collection
 		"KEY_TO_SKIP should have status 'skipped' after user skipped it");
 });
 
+test("collectSecretsFromManifest: applied keys hydrate process.env for the running session", async (t) => {
+	const { collectSecretsFromManifest } = await loadOrchestrator();
+
+	const tmp = makeTempDir("manifest-live-env");
+	const envKey = "CONTEXT7_API_KEY";
+	const saved = process.env[envKey];
+	t.after(() => {
+		if (saved === undefined) delete process.env[envKey];
+		else process.env[envKey] = saved;
+		rmSync(tmp, { recursive: true, force: true });
+	});
+
+	delete process.env[envKey];
+
+	const manifest = makeManifest([
+		{ key: envKey, status: "pending" },
+	]);
+	await writeManifestFile(tmp, manifest);
+
+	let callIndex = 0;
+	const mockCtx = {
+		cwd: tmp,
+		hasUI: true,
+		ui: {
+			custom: async (_factory: any) => {
+				callIndex++;
+				if (callIndex <= 1) return null; // summary screen dismiss
+				return "c7_live_test_key";
+			},
+		},
+	};
+
+	const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
+
+	assert.ok(result.applied.includes(envKey), "CONTEXT7_API_KEY should be applied");
+	assert.equal(process.env[envKey], "c7_live_test_key",
+		"applied keys should be available through process.env without restarting");
+});
+
 // ─── showSecretsSummary: render output ────────────────────────────────────────
 
 test("showSecretsSummary: produces lines with correct status glyphs for each entry status", async () => {

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -287,9 +287,9 @@ describe('git-service', async () => {
 
 
   const tempDir = mkdtempSync(join(tmpdir(), "gsd-git-service-test-"));
-  run("git init -b main", tempDir);
-  run('git config user.name "Pi Test"', tempDir);
-  run('git config user.email "pi@example.com"', tempDir);
+  runGit(tempDir, ["init", "-b", "main"]);
+  runGit(tempDir, ["config", "user.name", "Pi Test"]);
+  runGit(tempDir, ["config", "user.email", "pi@example.com"]);
 
   // runGit should work on a valid repo
   const branch = runGit(tempDir, ["branch", "--show-current"]);
@@ -334,13 +334,13 @@ describe('git-service', async () => {
 
   function initTempRepo(): string {
     const dir = mkdtempSync(join(tmpdir(), "gsd-git-t02-"));
-    run("git init -b main", dir);
-    run('git config user.name "Pi Test"', dir);
-    run('git config user.email "pi@example.com"', dir);
+    runGit(dir, ["init", "-b", "main"]);
+    runGit(dir, ["config", "user.name", "Pi Test"]);
+    runGit(dir, ["config", "user.email", "pi@example.com"]);
     // Need an initial commit so HEAD exists
     createFile(dir, ".gitkeep", "");
-    run("git add -A", dir);
-    run('git commit -m "init"', dir);
+    runGit(dir, ["add", "-A"]);
+    runGit(dir, ["commit", "-m", "init"]);
     return dir;
   }
 
@@ -577,12 +577,12 @@ describe('git-service', async () => {
 
   function initBranchTestRepo(): string {
     const dir = mkdtempSync(join(tmpdir(), "gsd-git-t03-"));
-    run("git init -b main", dir);
-    run('git config user.name "Pi Test"', dir);
-    run('git config user.email "pi@example.com"', dir);
+    runGit(dir, ["init", "-b", "main"]);
+    runGit(dir, ["config", "user.name", "Pi Test"]);
+    runGit(dir, ["config", "user.email", "pi@example.com"]);
     createFile(dir, ".gitkeep", "");
-    run("git add -A", dir);
-    run('git commit -m "init"', dir);
+    runGit(dir, ["add", "-A"]);
+    runGit(dir, ["commit", "-m", "init"]);
     return dir;
   }
 
@@ -618,12 +618,12 @@ describe('git-service', async () => {
   {
     // master-only repo
     const repo = mkdtempSync(join(tmpdir(), "gsd-git-t03-master-"));
-    run("git init -b master", repo);
-    run('git config user.name "Pi Test"', repo);
-    run('git config user.email "pi@example.com"', repo);
+    runGit(repo, ["init", "-b", "master"]);
+    runGit(repo, ["config", "user.name", "Pi Test"]);
+    runGit(repo, ["config", "user.email", "pi@example.com"]);
     createFile(repo, ".gitkeep", "");
-    run("git add -A", repo);
-    run('git commit -m "init"', repo);
+    runGit(repo, ["add", "-A"]);
+    runGit(repo, ["commit", "-m", "init"]);
 
     const svc = new GitServiceImpl(repo);
     assert.deepStrictEqual(svc.getMainBranch(), "master", "getMainBranch returns master when only master exists");
@@ -1115,9 +1115,9 @@ describe('git-service', async () => {
   test('untrackRuntimeFiles', async () => {
     const { untrackRuntimeFiles } = await import("../gitignore.ts");
     const repo = mkdtempSync(join(tmpdir(), "gsd-untrack-"));
-    run("git init -b main", repo);
-    run("git config user.email test@test.com", repo);
-    run("git config user.name Test", repo);
+    runGit(repo, ["init", "-b", "main"]);
+    runGit(repo, ["config", "user.email", "test@test.com"]);
+    runGit(repo, ["config", "user.name", "Test"]);
 
     // Create and track runtime files (simulates pre-.gitignore state)
     mkdirSync(join(repo, ".gsd", "activity"), { recursive: true });
@@ -1128,8 +1128,8 @@ describe('git-service', async () => {
     writeFileSync(join(repo, ".gsd", "activity", "log.jsonl"), "{}");
     writeFileSync(join(repo, ".gsd", "runtime", "data.json"), "{}");
     writeFileSync(join(repo, "src.ts"), "code");
-    run("git add -A", repo);
-    run("git commit -m init", repo);
+    runGit(repo, ["add", "-A"]);
+    runGit(repo, ["commit", "-m", "init"]);
 
     // Precondition: runtime files are tracked
     const trackedBefore = run("git ls-files .gsd/", repo);
@@ -1164,11 +1164,12 @@ describe('git-service', async () => {
 
   test('smartStage excludes runtime files, allows milestone artifacts', () => {
     const repo = mkdtempSync(join(tmpdir(), "gsd-smart-stage-excludes-"));
-    run("git init -b main", repo);
-    run("git config user.email test@test.com", repo);
-    run("git config user.name Test", repo);
+    runGit(repo, ["init", "-b", "main"]);
+    runGit(repo, ["config", "user.email", "test@test.com"]);
+    runGit(repo, ["config", "user.name", "Test"]);
     writeFileSync(join(repo, "README.md"), "init");
-    run("git add -A && git commit -m init", repo);
+    runGit(repo, ["add", "-A"]);
+    runGit(repo, ["commit", "-m", "init"]);
 
     // Create .gsd/ runtime files + milestone artifacts + a normal source file
     mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });

package/src/resources/extensions/gsd/tests/milestone-report-path.test.ts

@@ -0,0 +1,51 @@
+/**
+ * milestone-report-path.test.ts — Regression test for milestone report path resolution.
+ *
+ * When running in a worktree, milestone reports must be written to the
+ * original project root (originalBasePath), not the worktree path (basePath).
+ *
+ * Covers: _resolveReportBasePath from auto/phases.ts
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { _resolveReportBasePath } from "../auto/phases.ts";
+
+describe("_resolveReportBasePath", () => {
+  test("uses originalBasePath when set (worktree scenario)", () => {
+    const session = {
+      originalBasePath: "/projects/my-app",
+      basePath: "/projects/my-app/.claude/worktrees/agent-abc123",
+    };
+
+    assert.equal(_resolveReportBasePath(session), "/projects/my-app");
+  });
+
+  test("falls back to basePath when originalBasePath is empty", () => {
+    const session = {
+      originalBasePath: "",
+      basePath: "/projects/my-app",
+    };
+
+    assert.equal(_resolveReportBasePath(session), "/projects/my-app");
+  });
+
+  test("falls back to basePath when originalBasePath is undefined", () => {
+    const session = {
+      originalBasePath: undefined as unknown as string,
+      basePath: "/projects/my-app",
+    };
+
+    assert.equal(_resolveReportBasePath(session), "/projects/my-app");
+  });
+
+  test("uses originalBasePath even when basePath differs", () => {
+    const session = {
+      originalBasePath: "/home/user/repo",
+      basePath: "/tmp/worktree-xyz",
+    };
+
+    assert.equal(_resolveReportBasePath(session), "/home/user/repo");
+  });
+});

package/src/resources/extensions/gsd/tests/parallel-orchestrator-zombie-cleanup.test.ts

@@ -0,0 +1,277 @@
+/**
+ * Regression tests for zombie worker cleanup (#2736).
+ *
+ * Verifies that:
+ * 1. refreshWorkerStatuses() deactivates the orchestrator when all workers
+ *    are in terminal states (error/stopped).
+ * 2. restoreRuntimeState() (via getWorkerStatuses) returns empty when the
+ *    cached state has only dead workers.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import {
+  persistState,
+  resetOrchestrator,
+  refreshWorkerStatuses,
+  isParallelActive,
+  getOrchestratorState,
+  getWorkerStatuses,
+  type PersistedState,
+} from "../parallel-orchestrator.ts";
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-test-zombie-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd", "parallel"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch { /* non-fatal */ }
+}
+
+/** Write a fake orchestrator.json to simulate persisted state. */
+function writePersistedState(basePath: string, data: PersistedState): void {
+  const dest = join(basePath, ".gsd", "orchestrator.json");
+  writeFileSync(dest, JSON.stringify(data, null, 2), "utf-8");
+}
+
+/** Write a fake session status file to .gsd/parallel/<milestoneId>.status.json */
+function writeSessionStatusFile(
+  basePath: string,
+  milestoneId: string,
+  state: "running" | "paused" | "stopped" | "error",
+  pid: number,
+): void {
+  const dest = join(basePath, ".gsd", "parallel", `${milestoneId}.status.json`);
+  writeFileSync(
+    dest,
+    JSON.stringify({
+      milestoneId,
+      pid,
+      state,
+      currentUnit: null,
+      completedUnits: 0,
+      cost: 0.5,
+      lastHeartbeat: Date.now(),
+      startedAt: Date.now() - 60_000,
+      worktreePath: join(basePath, "worktrees", milestoneId),
+    }),
+    "utf-8",
+  );
+}
+
+// Use a PID that is guaranteed dead — PID 1 is init/launchd and won't be
+// killable by this process, but 2147483647 is unlikely to exist.
+const DEAD_PID = 2147483647;
+
+// ─── refreshWorkerStatuses: deactivates when all workers dead ──────────
+
+test("#2736: refreshWorkerStatuses deactivates orchestrator when all workers are error/stopped", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    resetOrchestrator();
+    cleanup(base);
+  });
+
+  // Seed persisted state with two workers using current PID (alive) so
+  // restoreState() accepts them, then immediately mark them as error via
+  // session status files so refreshWorkerStatuses sees terminal states.
+  const persisted: PersistedState = {
+    active: true,
+    workers: [
+      {
+        milestoneId: "M001",
+        title: "Milestone 1",
+        pid: process.pid, // alive PID so restoreState accepts it
+        worktreePath: join(base, "worktrees", "M001"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 1.0,
+      },
+      {
+        milestoneId: "M002",
+        title: "Milestone 2",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M002"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 0.5,
+      },
+    ],
+    totalCost: 1.5,
+    startedAt: Date.now() - 60_000,
+    configSnapshot: { max_workers: 3 },
+  };
+  writePersistedState(base, persisted);
+
+  // First, restore the state into memory via getWorkerStatuses (triggers restoreIfNeeded)
+  const workers = getWorkerStatuses(base);
+  assert.equal(workers.length, 2, "should have 2 workers after restore");
+  assert.ok(isParallelActive(), "orchestrator should be active after restore");
+
+  // Now write session status files marking both workers as error
+  writeSessionStatusFile(base, "M001", "error", process.pid);
+  writeSessionStatusFile(base, "M002", "error", process.pid);
+
+  // Refresh — should detect all-dead and deactivate
+  refreshWorkerStatuses(base);
+
+  assert.equal(isParallelActive(), false, "orchestrator should be inactive after all workers died");
+  assert.equal(getOrchestratorState(), null, "state should be null after cleanup");
+});
+
+test("#2736: refreshWorkerStatuses keeps orchestrator active when some workers are still running", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    resetOrchestrator();
+    cleanup(base);
+  });
+
+  const persisted: PersistedState = {
+    active: true,
+    workers: [
+      {
+        milestoneId: "M001",
+        title: "Milestone 1",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M001"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 1.0,
+      },
+      {
+        milestoneId: "M002",
+        title: "Milestone 2",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M002"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 0.5,
+      },
+    ],
+    totalCost: 1.5,
+    startedAt: Date.now() - 60_000,
+    configSnapshot: { max_workers: 3 },
+  };
+  writePersistedState(base, persisted);
+
+  // Restore state
+  getWorkerStatuses(base);
+
+  // Mark M001 as error but keep M002 running
+  writeSessionStatusFile(base, "M001", "error", process.pid);
+  writeSessionStatusFile(base, "M002", "running", process.pid);
+
+  refreshWorkerStatuses(base);
+
+  assert.ok(isParallelActive(), "orchestrator should remain active with a running worker");
+  assert.ok(getOrchestratorState() !== null, "state should still exist");
+});
+
+// ─── restoreRuntimeState: returns false when cached state has only dead workers ─
+
+test("#2736: getWorkerStatuses returns empty when all cached workers are in error state", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    resetOrchestrator();
+    cleanup(base);
+  });
+
+  // First, set up active state with live workers
+  const persisted: PersistedState = {
+    active: true,
+    workers: [
+      {
+        milestoneId: "M001",
+        title: "Milestone 1",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M001"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 0.5,
+      },
+    ],
+    totalCost: 0.5,
+    startedAt: Date.now() - 60_000,
+    configSnapshot: { max_workers: 3 },
+  };
+  writePersistedState(base, persisted);
+
+  // Restore into memory
+  getWorkerStatuses(base);
+  assert.ok(isParallelActive(), "should be active initially");
+
+  // Simulate all workers dying: write error status then refresh to update
+  writeSessionStatusFile(base, "M001", "error", process.pid);
+  refreshWorkerStatuses(base);
+
+  // State should now be cleared
+  assert.equal(getOrchestratorState(), null, "state should be null after all workers error");
+
+  // Reset and try again — getWorkerStatuses with restoreIfNeeded should
+  // find no live workers on disk (orchestrator.json was cleaned up)
+  const workers = getWorkerStatuses(base);
+  assert.equal(workers.length, 0, "should return empty when no live workers exist");
+});
+
+test("#2736: restoreRuntimeState clears stale state when all workers are stopped", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    resetOrchestrator();
+    cleanup(base);
+  });
+
+  // Set up and restore state
+  const persisted: PersistedState = {
+    active: true,
+    workers: [
+      {
+        milestoneId: "M001",
+        title: "Milestone 1",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M001"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 0.3,
+      },
+      {
+        milestoneId: "M002",
+        title: "Milestone 2",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M002"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 0.7,
+      },
+    ],
+    totalCost: 1.0,
+    startedAt: Date.now() - 60_000,
+    configSnapshot: { max_workers: 3 },
+  };
+  writePersistedState(base, persisted);
+
+  // Restore into memory
+  getWorkerStatuses(base);
+  assert.ok(isParallelActive(), "should be active initially");
+
+  // Mark all as stopped via session status, then refresh
+  writeSessionStatusFile(base, "M001", "stopped", process.pid);
+  writeSessionStatusFile(base, "M002", "stopped", process.pid);
+  refreshWorkerStatuses(base);
+
+  // Orchestrator should be deactivated and state cleaned
+  assert.equal(isParallelActive(), false, "should be inactive after all workers stopped");
+  assert.equal(getOrchestratorState(), null, "state should be null");
+
+  // Verify the state file was removed
+  const stateFile = join(base, ".gsd", "orchestrator.json");
+  assert.equal(existsSync(stateFile), false, "orchestrator.json should be removed");
+});