gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/auto-start-bootstrap-await-3420.test.ts

@@ -1,141 +1,45 @@
 /**
  * auto-start-bootstrap-await-3420.test.ts — Regression test for #3420.
  *
- * Bug: In bootstrapAutoSession, when state.phase === "pre-planning" and no
- * context file exists, showSmartEntry is called to dispatch a discuss workflow.
- * showSmartEntry calls dispatchWorkflow which calls pi.sendMessage() — a
- * fire-and-forget call that returns immediately. The LLM discussion runs
- * asynchronously in a separate turn.
- *
- * The bug: after showSmartEntry returns (before the LLM has run), the code
- * immediately calls invalidateAllCaches() + deriveState() + checks postState.
- * Since the discussion hasn't run yet, postState.phase is still "pre-planning"
- * and the context check fails, producing the warning:
- *   "Discussion completed but milestone context is still missing. Run /gsd to try again."
- *
- * The discussion never ran — the warning fires immediately.
- *
- * Fix: bootstrapAutoSession must return false (release lock) after showSmartEntry
- * dispatches the workflow. The checkAutoStartAfterDiscuss callback in guided-flow.ts
- * already handles re-entering auto-mode when the discussion completes.
- *
- * This test verifies the fix by asserting that the pre-planning !hasContext block
- * does NOT contain a postState phase check after showSmartEntry — it must
- * return false immediately to let the async dispatch complete.
+ * The discussion handoff is asynchronous: bootstrap queues a discuss turn and
+ * releases the lock; checkAutoStartAfterDiscuss is responsible for re-entry
+ * once artifacts exist.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const sourcePath = join(import.meta.dirname, "..", "auto-start.ts");
-const source = readFileSync(sourcePath, "utf-8");
-
-test("bootstrapAutoSession: pre-planning no-context path does NOT check postState immediately after showSmartEntry (#3420)", () => {
-  // Find the pre-planning block that handles the case where context is missing.
-  // This block dispatches showSmartEntry which is async (fire-and-forget via pi.sendMessage).
-  // After the dispatch, checking postState.phase immediately is premature — the
-  // LLM discussion hasn't run yet. The block should return false instead.
-  const prePlanningNoContextBlock = source.match(
-    /\/\/ Active milestone exists but has no roadmap\s*\n\s*if\s*\(\s*state\.phase\s*===\s*"pre-planning"\s*\)([\s\S]*?)\/\/ Active milestone has CONTEXT-DRAFT/,
-  );
-  assert.ok(
-    !!prePlanningNoContextBlock,
-    "auto-start.ts must have the pre-planning handler block before needs-discussion",
-  );
+import {
+  checkAutoStartAfterDiscuss,
+  clearPendingAutoStart,
+  setPendingAutoStart,
+} from "../guided-flow.ts";
 
-  const block = prePlanningNoContextBlock![1];
-
-  // The block must call showSmartEntry when !hasContext
-  assert.ok(
-    block.includes("showSmartEntry"),
-    "pre-planning !hasContext block must call showSmartEntry to dispatch the discuss workflow",
-  );
-
-  // FAILING ASSERTION (before fix): after showSmartEntry, the block must NOT
-  // immediately check postState.phase — that check fires before the LLM runs.
-  // Instead, it must return false (release lock) so the async dispatch can complete.
-  // The warning "Discussion completed but milestone context is still missing"
-  // fires prematurely when this postState check exists.
-  assert.ok(
-    !block.includes("Discussion completed but milestone context is still missing"),
-    "pre-planning !hasContext block must NOT check postState.phase immediately after showSmartEntry — " +
-    "the dispatch is async (pi.sendMessage is fire-and-forget) and the discussion hasn't run yet; " +
-    "return false instead so checkAutoStartAfterDiscuss can re-enter auto-mode after discussion completes (#3420)",
-  );
+test.afterEach(() => {
+  clearPendingAutoStart();
 });
 
-test("bootstrapAutoSession: complete/no-milestone path does NOT check postState immediately after showSmartEntry (#3420)", () => {
-  // Find the complete/no-milestone block
-  const completeBlock = source.match(
-    /\/\/ No active work — start a new milestone via discuss flow\s*\n\s*if\s*\(!state\.activeMilestone\s*\|\|\s*state\.phase\s*===\s*"complete"\s*\)([\s\S]*?)\/\/ Active milestone exists but has no roadmap/,
-  );
-  assert.ok(
-    !!completeBlock,
-    "auto-start.ts must have the complete/no-milestone handler block",
-  );
-
-  const block = completeBlock![1];
-
-  // The block must call showSmartEntry
-  assert.ok(
-    block.includes("showSmartEntry"),
-    "complete/no-milestone block must call showSmartEntry",
-  );
-
-  // After showSmartEntry dispatches, checking postState.phase is premature —
-  // the LLM hasn't had a turn yet. The block should return false.
-  // Specifically, the "no milestone context was written" warning fires too early.
-  assert.ok(
-    !block.includes("Discussion completed but no milestone context was written"),
-    "complete/no-milestone block must NOT check postState.phase immediately after showSmartEntry dispatch — " +
-    "return false instead so the async LLM turn can complete (#3420)",
-  );
-});
-
-test("bootstrapAutoSession: showSmartEntry in pre-planning path is followed by releaseLockAndReturn, not postState check (#3420)", () => {
-  // After the fix, the pre-planning !hasContext branch should call showSmartEntry
-  // and then immediately return releaseLockAndReturn() — not check postState.
-  const prePlanningNoContextBlock = source.match(
-    /\/\/ Active milestone exists but has no roadmap\s*\n\s*if\s*\(\s*state\.phase\s*===\s*"pre-planning"\s*\)([\s\S]*?)\/\/ Active milestone has CONTEXT-DRAFT/,
-  );
-  assert.ok(!!prePlanningNoContextBlock, "pre-planning handler block found");
-
-  const block = prePlanningNoContextBlock![1];
-
-  // After the fix, the !hasContext branch ends with releaseLockAndReturn
-  assert.ok(
-    block.includes("releaseLockAndReturn"),
-    "pre-planning !hasContext block must call releaseLockAndReturn() after showSmartEntry dispatch (#3420)",
-  );
-
-  // The showSmartEntry call must appear before releaseLockAndReturn
-  const showSmartEntryIdx = block.indexOf("showSmartEntry");
-  const releaseLockIdx = block.indexOf("releaseLockAndReturn");
-  assert.ok(
-    showSmartEntryIdx > -1 && releaseLockIdx > -1,
-    "both showSmartEntry and releaseLockAndReturn must appear in the block",
-  );
-  assert.ok(
-    showSmartEntryIdx < releaseLockIdx,
-    "showSmartEntry must appear before releaseLockAndReturn in pre-planning !hasContext block",
-  );
-
-  // There must be NO invalidateAllCaches between showSmartEntry and releaseLockAndReturn
-  // (invalidateAllCaches + deriveState after showSmartEntry is the buggy premature check)
-  const afterShowSmartEntry = block.substring(showSmartEntryIdx);
-  const cacheInvalidateIdx = afterShowSmartEntry.indexOf("invalidateAllCaches");
-  const releaseFromShowIdx = afterShowSmartEntry.indexOf("releaseLockAndReturn");
-
-  // If invalidateAllCaches appears, it must appear AFTER releaseLockAndReturn
-  // (which is impossible since releaseLockAndReturn returns) — so invalidateAllCaches
-  // must not appear at all between showSmartEntry and the end of the !hasContext block.
-  if (cacheInvalidateIdx !== -1) {
-    assert.ok(
-      cacheInvalidateIdx > releaseFromShowIdx,
-      "invalidateAllCaches must NOT appear between showSmartEntry and releaseLockAndReturn — " +
-      "this is the premature postState check that causes #3420",
-    );
-  }
+test("checkAutoStartAfterDiscuss waits until discussion artifacts exist before re-entering auto-mode", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-bootstrap-await-"));
+  const notifications: string[] = [];
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  setPendingAutoStart(base, {
+    basePath: base,
+    milestoneId: "M001",
+    ctx: { ui: { notify: (message: string) => notifications.push(message) } } as any,
+    pi: { sendMessage: () => {} } as any,
+  });
+
+  assert.equal(checkAutoStartAfterDiscuss(), false);
+  assert.deepEqual(notifications, []);
+
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# Context\n", "utf-8");
+  writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
+
+  assert.equal(checkAutoStartAfterDiscuss(), true);
+  assert.deepEqual(notifications, ["Milestone M001 ready."]);
 });

package/src/resources/extensions/gsd/tests/auto-start-clean-runtime-db-gated.test.ts

@@ -1,72 +1,38 @@
 // GSD-2 auto-start regression test: cleanStaleRuntimeUnits is DB-gated (#4663)
-//
-// Source-level structural check that the stale-runtime-cleanup predicate in
-// auto-start.ts consults DB status when available instead of treating a
-// SUMMARY-file on disk as proof of milestone completion. Pairs with #4658 /
-// PR #4660 fix in auto-dispatch + auto-recovery.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 import { cleanStaleRuntimeUnits } from "../auto-worktree.ts";
-import { extractSourceRegion } from "./test-helpers.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "auto-start.ts");
+function makeBase(): string {
+  return join(tmpdir(), `gsd-clean-runtime-${randomUUID()}`);
+}
 
 describe("auto-start cleanStaleRuntimeUnits DB gating (#4663)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
-
-  test("imports isClosedStatus for DB-status check", () => {
-    assert.match(
-      source,
-      /import\s*\{\s*isClosedStatus\s*\}\s*from\s*["']\.\/status-guards/,
-    );
-  });
-
-  test("cleanStaleRuntimeUnits is called after openProjectDbIfPresent", () => {
-    const openDbIdx = source.indexOf("await openProjectDbIfPresent(base)");
-    assert.ok(openDbIdx > -1, "openProjectDbIfPresent should be called in auto-start");
-    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(", openDbIdx);
-    assert.ok(
-      cleanIdx > -1,
-      "cleanStaleRuntimeUnits must run AFTER openProjectDbIfPresent so predicate can consult DB",
-    );
-  });
+  test("predicate controls whether milestone runtime units are removed", () => {
+    const base = makeBase();
+    const unitsDir = join(base, ".gsd", "runtime", "units");
+    try {
+      mkdirSync(unitsDir, { recursive: true });
+      const unitFile = join(unitsDir, "execute-task-M001-S01-T01.json");
+      writeFileSync(unitFile, "{}\n", "utf-8");
 
-  test("cleanStaleRuntimeUnits predicate consults DB status when available", () => {
-    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(");
-    assert.ok(cleanIdx > -1);
-    const snippet = extractSourceRegion(source, "cleanStaleRuntimeUnits(");
-    assert.match(
-      snippet,
-      /isDbAvailable\(\)/,
-      "predicate must branch on DB availability",
-    );
-    assert.match(
-      snippet,
-      /isClosedStatus\(/,
-      "predicate must check DB status via isClosedStatus",
-    );
-  });
+      assert.equal(cleanStaleRuntimeUnits(join(base, ".gsd"), () => false), 0);
+      assert.equal(existsSync(unitFile), true);
 
-  test("cleanStaleRuntimeUnits predicate still falls back to SUMMARY-file when DB unavailable", () => {
-    const cleanIdx = source.indexOf("cleanStaleRuntimeUnits(");
-    assert.ok(cleanIdx > -1);
-    const snippet = extractSourceRegion(source, "cleanStaleRuntimeUnits(");
-    assert.match(
-      snippet,
-      /resolveMilestoneFile\(base,\s*mid,\s*["']SUMMARY["']\)/,
-      "legacy FS-fallback branch should still use SUMMARY file presence",
-    );
+      assert.equal(cleanStaleRuntimeUnits(join(base, ".gsd"), (mid) => mid === "M001"), 1);
+      assert.equal(existsSync(unitFile), false);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 
   test("cleanStaleRuntimeUnits removes legacy pseudo deep-setup runtime files", () => {
-    const base = join(tmpdir(), `gsd-clean-runtime-${randomUUID()}`);
+    const base = makeBase();
     const gsdRoot = join(base, ".gsd");
     const unitsDir = join(gsdRoot, "runtime", "units");
     try {

package/src/resources/extensions/gsd/tests/auto-start-cold-db-bootstrap.test.ts

@@ -1,37 +1,27 @@
-import { readFileSync } from "node:fs";
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
+import { openProjectDbIfPresent } from "../auto-start.ts";
+import { closeDatabase, isDbAvailable, openDatabase } from "../gsd-db.ts";
 
-const { assertTrue, report } = createTestContext();
+test.afterEach(() => {
+  if (isDbAvailable()) closeDatabase();
+});
 
-const srcPath = join(import.meta.dirname, "..", "auto-start.ts");
-const src = readFileSync(srcPath, "utf-8");
+test("#2841: cold DB bootstrap opens an existing project database before state derivation", async (t) => {
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-cold-db-")));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  const dbPath = join(base, ".gsd", "gsd.db");
 
-console.log("\n=== #2841: cold DB opened before initial deriveState ===");
+  assert.equal(openDatabase(dbPath), true);
+  closeDatabase();
+  assert.equal(isDbAvailable(), false);
 
-const helperIdx = src.indexOf("async function openProjectDbIfPresent");
-assertTrue(helperIdx >= 0, "auto-start.ts defines a helper for pre-derive DB open (#2841)");
+  await openProjectDbIfPresent(base);
 
-const helperRegion = helperIdx >= 0 ? extractSourceRegion(src, "async function openProjectDbIfPresent") : "";
-assertTrue(
-  helperRegion.includes("resolveProjectRootDbPath(basePath)"),
-  "pre-derive DB helper resolves the project-root DB path (#2841)",
-);
-assertTrue(
-  helperRegion.includes("openDatabase(gsdDbPath)"),
-  "pre-derive DB helper opens the resolved DB path (#2841)",
-);
-
-const firstDeriveIdx = src.indexOf("let state = await deriveState(base);");
-assertTrue(firstDeriveIdx > 0, "auto-start.ts has the initial deriveState(base) call");
-
-const preDeriveRegion = firstDeriveIdx > 0 ? src.slice(0, firstDeriveIdx) : "";
-const preDeriveOpenIdx = preDeriveRegion.lastIndexOf("await openProjectDbIfPresent(base);");
-
-assertTrue(
-  preDeriveOpenIdx > 0,
-  "bootstrapAutoSession opens the DB before the first deriveState(base) call (#2841)",
-);
-
-report();
+  assert.equal(isDbAvailable(), true);
+});

package/src/resources/extensions/gsd/tests/auto-start-index-lock.test.ts

@@ -1,38 +1,26 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const sourcePath = join(import.meta.dirname, "..", "auto-start.ts");
-const source = readFileSync(sourcePath, "utf-8");
+import { hasGitIndexLockForTest } from "../auto-start.ts";
 
-test("bootstrapAutoSession blocks on .git/index.lock before git mutations", () => {
-  const preflightIdx = source.indexOf('join(base, ".git", "index.lock")');
-  const initIdx = source.indexOf("nativeInit(base, mainBranch)");
-  const addIdx = source.indexOf("nativeAddAll(base)");
-  const commitIdx = source.indexOf('nativeCommit(base, "chore: init gsd")');
+test("bootstrapAutoSession detects .git/index.lock without deleting it", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-index-lock-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  const lockPath = join(base, ".git", "index.lock");
+  mkdirSync(join(base, ".git"), { recursive: true });
+  writeFileSync(lockPath, "locked\n", "utf-8");
 
-  assert.ok(preflightIdx > -1, "bootstrap must check for .git/index.lock");
-  assert.ok(initIdx > -1, "bootstrap still initializes git when safe");
-  assert.ok(addIdx > -1, "bootstrap still stages bootstrap files when safe");
-  assert.ok(commitIdx > -1, "bootstrap still commits bootstrap files when safe");
-
-  assert.ok(preflightIdx < initIdx, "index.lock preflight must run before git init");
-  assert.ok(preflightIdx < addIdx, "index.lock preflight must run before git add");
-  assert.ok(preflightIdx < commitIdx, "index.lock preflight must run before git commit");
+  assert.equal(hasGitIndexLockForTest(base), true);
+  assert.equal(existsSync(lockPath), true);
 });
 
-test("bootstrapAutoSession never deletes .git/index.lock", () => {
-  assert.ok(
-    !source.includes("unlinkSync(gitLockFile)") && !source.includes("rmSync(gitLockFile"),
-    "bootstrap must not remove .git/index.lock because git lock staleness is not safe to infer",
-  );
-  assert.ok(
-    !source.includes("STALE_GIT_LOCK_THRESHOLD_MS"),
-    "bootstrap must not use lock age as a deletion heuristic",
-  );
-  assert.ok(
-    source.includes("return releaseLockAndReturn();"),
-    "bootstrap must abort and release the session lock when the git index is locked",
-  );
+test("bootstrapAutoSession reports no index lock when the lock file is absent", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-index-lock-missing-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".git"), { recursive: true });
+
+  assert.equal(hasGitIndexLockForTest(base), false);
 });

package/src/resources/extensions/gsd/tests/auto-start-orphan-bootstrap.test.ts

@@ -0,0 +1,160 @@
+// Project/App: GSD-2
+// File Purpose: Bootstrap behavior tests for completed milestone orphan merges.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { bootstrapAutoSession } from "../auto-start.ts";
+import { AutoSession } from "../auto/session.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+} from "../gsd-db.ts";
+
+function runGit(base: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd: base,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+  }).trim();
+}
+
+function makeRepoWithUnmergedCompletedMilestone(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orphan-bootstrap-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: \"branch\"\n---\n",
+  );
+  runGit(base, ["init"]);
+  runGit(base, ["config", "user.email", "test@test.com"]);
+  runGit(base, ["config", "user.name", "Test"]);
+  writeFileSync(join(base, "README.md"), "# test\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "init"]);
+  runGit(base, ["branch", "-M", "main"]);
+
+  runGit(base, ["checkout", "-b", "milestone/M002"]);
+  writeFileSync(join(base, "m002.txt"), "complete but unmerged\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "feat: M002 work"]);
+  runGit(base, ["checkout", "main"]);
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M002", title: "Completed milestone", status: "complete" });
+  insertMilestone({ id: "M003", title: "Next milestone", status: "active" });
+  closeDatabase();
+
+  return base;
+}
+
+function makeCtx(notifications: Array<{ message: string; level?: string }>) {
+  const model = { provider: "claude-code", id: "claude-sonnet-4-6", contextWindow: 128000 };
+  return {
+    ui: {
+      notify: (message: string, level?: string) => {
+        notifications.push({ message, level });
+      },
+      setStatus: () => {},
+      setWidget: () => {},
+    },
+    model,
+    modelRegistry: {
+      getAvailable: () => [model],
+      isProviderRequestReady: () => true,
+      getProviderAuthMode: () => "oauth",
+    },
+    sessionManager: {
+      getSessionId: () => "orphan-bootstrap-test",
+      getSessionFile: () => null,
+      getEntries: () => [],
+    },
+  };
+}
+
+test("bootstrap aborts before starting next milestone when completed orphan merge fails", async () => {
+  const base = makeRepoWithUnmergedCompletedMilestone();
+  const previousCwd = process.cwd();
+  const s = new AutoSession();
+  const mergeCalls: string[] = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => true,
+        registerSigtermHandler: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          exitMilestone: (milestoneId: string) => {
+            mergeCalls.push(milestoneId);
+            return {
+              ok: false,
+              reason: "teardown-failed",
+              cause: new Error("synthetic merge failure"),
+            };
+          },
+          enterMilestone: () => ({ ok: true, mode: "none", path: base }),
+          // ADR-016 phase 2 / B4 (#5622): the orphan-merge dance now goes
+          // through `adoptOrphanWorktree`. The mock invokes the callback
+          // and returns its result without exercising the swap-revert
+          // protocol — this test only cares about the merge call being
+          // recorded and the bootstrap returning `false` on failure.
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    assert.equal(ready, false);
+    assert.deepEqual(mergeCalls, ["M002"]);
+    assert.equal(s.active, false);
+    assert.match(
+      notifications.map((entry) => entry.message).join("\n"),
+      /Could not merge orphan milestone M002: synthetic merge failure/,
+    );
+  } finally {
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/auto-start-time-persistence.test.ts

@@ -1,50 +1,32 @@
-// GSD2 — Verify autoStartTime is persisted in paused-session.json and restored on resume
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-
-/**
- * auto-start-time-persistence.test.ts — Ensures autoStartTime survives
- * cross-session resume via paused-session.json (#3585).
- *
- * Source-code regression guards: verify auto.ts saves and restores
- * autoStartTime so the elapsed timer doesn't vanish after /exit + resume.
- */
+// GSD2 — Verify autoStartTime is carried through dashboard state
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
 
-const source = readFileSync(AUTO_TS_PATH, "utf-8");
+import { getAutoDashboardData } from "../auto.ts";
+import { autoSession } from "../auto-runtime-state.ts";
 
-test("pauseAuto persists autoStartTime in paused-session.json (#3585)", () => {
-  assert.ok(
-    source.includes("autoStartTime: s.autoStartTime"),
-    "pausedMeta must include autoStartTime so the timer survives /exit",
-  );
+test.afterEach(() => {
+  autoSession.reset();
 });
 
-test("cross-session resume restores autoStartTime from paused-session.json (#3585)", () => {
-  const matches = source.match(/s\.autoStartTime\s*=\s*meta\.autoStartTime/g);
-  assert.ok(
-    matches && matches.length >= 2,
-    "both resume paths (custom workflow + milestone) must restore autoStartTime from meta",
-  );
-});
+test("getAutoDashboardData exposes the active autoStartTime (#3585)", () => {
+  const start = Date.now() - 5_000;
+  autoSession.active = true;
+  autoSession.autoStartTime = start;
 
-test("resume path falls back to Date.now() when autoStartTime is missing (#3585)", () => {
-  assert.ok(
-    source.includes("meta.autoStartTime || Date.now()"),
-    "restore should fall back to Date.now() for old paused-session files without autoStartTime",
-  );
+  const data = getAutoDashboardData();
+
+  assert.equal(data.startTime, start);
+  assert.ok(data.elapsed >= 0);
 });
 
-test("resume path guards against zero autoStartTime (#3585)", () => {
-  assert.ok(
-    source.includes("if (!s.autoStartTime || s.autoStartTime <= 0) s.autoStartTime = Date.now()"),
-    "resume path must set autoStartTime to Date.now() if still zero after restore",
-  );
+test("getAutoDashboardData suppresses elapsed time when autoStartTime is zero (#3585)", () => {
+  autoSession.active = true;
+  autoSession.autoStartTime = 0;
+
+  const data = getAutoDashboardData();
+
+  assert.equal(data.startTime, 0);
+  assert.equal(data.elapsed, 0);
 });