gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/tests/auto-wrapup-inflight-guard.test.ts

@@ -3,7 +3,7 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -12,18 +12,6 @@ import { dispatchHookUnit } from "../auto.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
 import { clearDiscussionFlowState, getPendingGate } from "../bootstrap/write-gate.ts";
 
-const autoTimersPath = join(import.meta.dirname, "..", "auto-timers.ts");
-const autoTimersSrc = readFileSync(autoTimersPath, "utf-8");
-
-const autoPath = join(import.meta.dirname, "..", "auto.ts");
-const autoSrc = readFileSync(autoPath, "utf-8");
-
-const runUnitPath = join(import.meta.dirname, "..", "auto", "run-unit.ts");
-const runUnitSrc = readFileSync(runUnitPath, "utf-8");
-
-const registerHooksPath = join(import.meta.dirname, "..", "bootstrap", "register-hooks.ts");
-const registerHooksSrc = readFileSync(registerHooksPath, "utf-8");
-
 function makeHookHarness() {
   const handlers = new Map<string, Array<(event: any, ctx: any) => Promise<any>>>();
   const pi = {
@@ -55,61 +43,6 @@ function makeHookHarness() {
   return { emit };
 }
 
-describe("#3512: gsd-auto-wrapup must not interrupt in-flight tool calls", () => {
-  test("soft timeout wrapup gates triggerTurn on getInFlightToolCount() === 0", () => {
-    // The soft timeout sendMessage must NOT use a hardcoded `triggerTurn: true`.
-    // It must check getInFlightToolCount() before deciding whether to trigger.
-    // Use the section marker comment to isolate the soft timeout block.
-    const startMarker = "── 1. Soft timeout warning";
-    const endMarker = "── 2. Idle watchdog";
-    const softTimeoutSection = autoTimersSrc.slice(
-      autoTimersSrc.indexOf(startMarker),
-      autoTimersSrc.indexOf(endMarker),
-    );
-    assert.ok(
-      softTimeoutSection.length > 0,
-      "Could not locate soft timeout section",
-    );
-
-    // Must reference getInFlightToolCount to gate the trigger
-    assert.ok(
-      softTimeoutSection.includes("getInFlightToolCount"),
-      "Soft timeout wrapup must gate triggerTurn behind getInFlightToolCount() check",
-    );
-
-    // Must NOT have a hardcoded triggerTurn: true
-    assert.ok(
-      !softTimeoutSection.includes("triggerTurn: true"),
-      "Soft timeout wrapup must not use hardcoded triggerTurn: true",
-    );
-  });
-
-  test("context-pressure wrapup gates triggerTurn on getInFlightToolCount() === 0", () => {
-    // The context budget sendMessage must NOT use a hardcoded `triggerTurn: true`.
-    // Use the section marker to isolate the context-pressure block.
-    const startMarker = "── 4. Context-pressure continue-here monitor";
-    const contextSection = autoTimersSrc.slice(
-      autoTimersSrc.indexOf(startMarker),
-    );
-    assert.ok(
-      contextSection.length > 0,
-      "Could not locate context budget section",
-    );
-
-    // Must reference getInFlightToolCount to gate the trigger
-    assert.ok(
-      contextSection.includes("getInFlightToolCount"),
-      "Context budget wrapup must gate triggerTurn behind getInFlightToolCount() check",
-    );
-
-    // Must NOT have a hardcoded triggerTurn: true
-    assert.ok(
-      !contextSection.includes("triggerTurn: true"),
-      "Context budget wrapup must not use hardcoded triggerTurn: true",
-    );
-  });
-});
-
 describe("hook dispatch session workspace root", () => {
   test("dispatchHookUnit passes basePath explicitly to newSession", async (t) => {
     const originalCwd = process.cwd();
@@ -165,156 +98,7 @@ describe("hook dispatch session workspace root", () => {
   });
 });
 
-describe("#4276: pending/skipped tools stay visible to auto-mode hooks", () => {
-  test("tool_call handler marks GSD tools in-flight before execution_start", () => {
-    const startMarker = 'pi.on("tool_call", async (event, ctx) => {';
-    const endMarker = 'pi.on("tool_result", async (event, ctx) => {';
-    const toolCallSection = registerHooksSrc.slice(
-      registerHooksSrc.indexOf(startMarker),
-      registerHooksSrc.indexOf(endMarker),
-    );
-
-    assert.ok(toolCallSection.length > 0, "Could not locate tool_call handler section");
-    assert.ok(
-      toolCallSection.includes("markToolStart(event.toolCallId, event.toolName)"),
-      "tool_call handler must mark tools pending before tool_execution_start fires",
-    );
-  });
-
-  test("tool_result handler clears pending tools and records queued-skip errors", () => {
-    const startMarker = 'pi.on("tool_result", async (event, ctx) => {';
-    const endMarker = 'pi.on("tool_execution_start", async (event) => {';
-    const toolResultSection = registerHooksSrc.slice(
-      registerHooksSrc.indexOf(startMarker),
-      registerHooksSrc.indexOf(endMarker),
-    );
-
-    assert.ok(toolResultSection.length > 0, "Could not locate tool_result handler section");
-    assert.ok(
-      toolResultSection.includes("markToolEnd(event.toolCallId)"),
-      "tool_result handler must clear pending tool tracking even when execution hooks never fire",
-    );
-    assert.ok(
-      toolResultSection.includes("recordToolInvocationError(event.toolName, errorText)"),
-      "tool_result handler must surface queued-skip errors for GSD tools",
-    );
-  });
-});
-
-describe("#3512: pauseAuto and stopAuto must flush queued follow-up messages", () => {
-  test("stopAuto calls clearQueue()", () => {
-    // stopAuto must flush queued messages to prevent late async_job_result
-    // notifications from triggering extra LLM turns after stop.
-    const stopAutoSection = autoSrc.slice(
-      autoSrc.indexOf("export async function stopAuto("),
-      autoSrc.indexOf("export async function pauseAuto("),
-    );
-    assert.ok(stopAutoSection, "Could not locate stopAuto function");
-    assert.ok(
-      stopAutoSection.includes("clearQueue"),
-      "stopAuto must call clearQueue() to flush queued follow-up messages",
-    );
-  });
-
-  test("pauseAuto calls clearQueue()", () => {
-    // pauseAuto must also flush queued messages — same issue as stopAuto.
-    const pauseAutoSection = autoSrc.slice(
-      autoSrc.indexOf("export async function pauseAuto("),
-    );
-    assert.ok(pauseAutoSection, "Could not locate pauseAuto function");
-    assert.ok(
-      pauseAutoSection.includes("clearQueue"),
-      "pauseAuto must call clearQueue() to flush queued follow-up messages",
-    );
-  });
-
-  test("pauseAuto rebuilds STATE.md before releasing the session lock", () => {
-    // pauseAuto must persist the DB-backed state projection so resume/debugging
-    // does not see a stale STATE.md after a mid-unit interruption.
-    const start = autoSrc.indexOf("export async function pauseAuto(");
-    const end = autoSrc.indexOf("/**\n * Build a WorktreeResolverDeps", start);
-    const pauseAutoSection = autoSrc.slice(start, end);
-    assert.ok(pauseAutoSection.length > 0, "Could not locate pauseAuto function");
-
-    const rebuildIndex = pauseAutoSection.indexOf("await rebuildState(s.basePath)");
-    const releaseIndex = pauseAutoSection.indexOf("releaseSessionLock(lockBase())");
-    assert.ok(
-      rebuildIndex >= 0,
-      "pauseAuto must rebuild STATE.md from DB-backed state before pause completes",
-    );
-    assert.ok(
-      releaseIndex >= 0,
-      "pauseAuto must still release the session lock",
-    );
-    assert.ok(
-      rebuildIndex < releaseIndex,
-      "pauseAuto must rebuild state before releasing the session lock",
-    );
-  });
-
-  test("run-unit.ts still has its existing clearQueue() call (baseline)", () => {
-    // Verify the original clearQueue pattern in run-unit.ts hasn't been removed.
-    assert.ok(
-      runUnitSrc.includes("clearQueue"),
-      "run-unit.ts must retain its clearQueue() call after unit completion",
-    );
-  });
-});
-
-describe("#4365: tool_execution_start hook must pass toolName to markToolStart", () => {
-  test("tool_execution_start handler passes event.toolName to markToolStart", () => {
-    // The tool_execution_start handler must forward toolName so that
-    // hasInteractiveToolInFlight() can correctly identify ask_user_questions
-    // and prevent the idle watchdog from firing during interactive tool calls.
-    const startMarker = 'pi.on("tool_execution_start", async (event) => {';
-    const endMarker = 'pi.on("tool_execution_end", async (event) => {';
-    const toolExecutionStartSection = registerHooksSrc.slice(
-      registerHooksSrc.indexOf(startMarker),
-      registerHooksSrc.indexOf(endMarker),
-    );
-
-    assert.ok(
-      toolExecutionStartSection.length > 0,
-      "Could not locate tool_execution_start handler section",
-    );
-    assert.ok(
-      toolExecutionStartSection.includes("markToolStart(event.toolCallId, event.toolName)"),
-      "tool_execution_start handler must pass event.toolName to markToolStart so hasInteractiveToolInFlight() works correctly",
-    );
-  });
-});
-
 describe("deep setup approval questions pause immediately", () => {
-  test("register-hooks defers the pending gate during message_update without aborting the stream", () => {
-    const startMarker = 'pi.on("message_update"';
-    const endMarker = 'pi.on("session_shutdown"';
-    const messageUpdateSection = registerHooksSrc.slice(
-      registerHooksSrc.indexOf(startMarker),
-      registerHooksSrc.indexOf(endMarker),
-    );
-
-    assert.ok(
-      messageUpdateSection.length > 0,
-      "Could not locate message_update approval pause handler",
-    );
-    assert.ok(
-      messageUpdateSection.includes("shouldPauseForUserApprovalQuestion"),
-      "message_update must detect approval/question boundaries",
-    );
-    assert.ok(
-      messageUpdateSection.includes("approvalGateIdForUnit") && messageUpdateSection.includes("deferApprovalGate"),
-      "plain-text approval questions must defer the durable write gate until same-turn draft persistence can finish",
-    );
-    assert.ok(
-      messageUpdateSection.includes("getDiscussionMilestoneIdFor") && messageUpdateSection.includes('"discuss-milestone"'),
-      "foreground milestone discussion questions must also set the durable write gate",
-    );
-    assert.ok(
-      !messageUpdateSection.includes("ctx.abort()"),
-      "message_update must NOT abort the stream — aborting eats the model's question text on external CLI providers; the pending gate set above blocks subsequent tool calls instead",
-    );
-  });
-
   test("plain-text approval boundary defers durable gate until same-turn CONTEXT-DRAFT can save", async () => {
     const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-deferred-approval-")));
     const previousCwd = process.cwd();

package/src/resources/extensions/gsd/tests/bootstrap-derive-state-db-open.test.ts

@@ -1,40 +1,23 @@
-import { describe, test } from "node:test";
+import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { extractSourceRegion } from "./test-helpers.ts";
+import { tmpdir } from "node:os";
 
-const systemContextSrc = readFileSync(
-  join(import.meta.dirname, "..", "bootstrap", "system-context.ts"),
-  "utf-8",
-);
-const registerHooksSrc = readFileSync(
-  join(import.meta.dirname, "..", "bootstrap", "register-hooks.ts"),
-  "utf-8",
-);
+import { ensureDbOpen } from "../bootstrap/dynamic-tools.ts";
+import { closeDatabase, isDbAvailable } from "../gsd-db.ts";
+
+afterEach(() => {
+  if (isDbAvailable()) closeDatabase();
+});
 
 describe("bootstrap deriveState DB guards (#3844)", () => {
-  test("system-context opens DB before deriveState in resume flows", () => {
-    const helperIdx = systemContextSrc.indexOf("const ensureStateDbOpen = async () => {");
-    const firstDeriveIdx = systemContextSrc.indexOf("const state = await deriveState(basePath);");
-    assert.ok(helperIdx > -1, "system-context should define a DB-open helper for deriveState callers");
-    assert.ok(firstDeriveIdx > -1, "system-context should still derive state for resume flows");
-    assert.ok(helperIdx < firstDeriveIdx, "system-context should prepare DB opening before deriveState resume calls");
-    assert.match(
-      systemContextSrc,
-      /await ensureStateDbOpen\(\);\s*\n\s*const state = await deriveState\(basePath\);/g,
-      "system-context resume flows should open DB before deriveState",
-    );
-  });
+  test("ensureDbOpen creates and opens the project DB when .gsd exists", async (t) => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-ensure-db-")));
+    t.after(() => rmSync(base, { recursive: true, force: true }));
+    mkdirSync(join(base, ".gsd"), { recursive: true });
 
-  test("register-hooks opens DB before deriveState in session_before_compact", () => {
-    const compactIdx = registerHooksSrc.indexOf('pi.on("session_before_compact"');
-    assert.ok(compactIdx > -1, "register-hooks should define session_before_compact");
-    const compactSection = extractSourceRegion(registerHooksSrc, 'pi.on("session_before_compact"');
-    const ensureIdx = compactSection.indexOf("ensureDbOpen(basePath)");
-    const deriveIdx = compactSection.indexOf("deriveGsdState(basePath)");
-    assert.ok(ensureIdx > -1, "session_before_compact should call ensureDbOpen(basePath)");
-    assert.ok(deriveIdx > -1, "session_before_compact should derive state");
-    assert.ok(ensureIdx < deriveIdx, "session_before_compact should open DB before deriveState");
+    assert.equal(await ensureDbOpen(base), true);
+    assert.equal(isDbAvailable(), true);
   });
 });

package/src/resources/extensions/gsd/tests/browser-teardown.test.ts

@@ -90,44 +90,3 @@ test("getBrowser() guard triggers closeBrowser when browser is active", async ()
   assert.equal(closeCalled, true, "browser.close() should have been called");
   assert.equal(getBrowser(), null, "browser should be null after guarded teardown");
 });
-
-// ─── Source code verification ───────────────────────────────────────────────
-
-test("stopAuto finally block includes browser teardown", async () => {
-  // Verify the source code contains the browser teardown call
-  const { readFileSync } = await import("node:fs");
-  const { resolve } = await import("node:path");
-  const autoSource = readFileSync(resolve(import.meta.dirname, "..", "auto.ts"), "utf-8");
-
-  assert.ok(
-    autoSource.includes("closeBrowser"),
-    "auto.ts should reference closeBrowser for teardown in stopAuto",
-  );
-  assert.ok(
-    autoSource.includes("getBrowser"),
-    "auto.ts should check getBrowser() before calling closeBrowser",
-  );
-  assert.ok(
-    autoSource.includes("browser-tools/lifecycle"),
-    "auto.ts should import from browser-tools/lifecycle",
-  );
-});
-
-test("postUnitPreVerification includes browser teardown between units", async () => {
-  const { readFileSync } = await import("node:fs");
-  const { resolve } = await import("node:path");
-  const postUnitSource = readFileSync(resolve(import.meta.dirname, "..", "auto-post-unit.ts"), "utf-8");
-
-  assert.ok(
-    postUnitSource.includes("closeBrowser"),
-    "auto-post-unit.ts should reference closeBrowser for inter-unit teardown",
-  );
-  assert.ok(
-    postUnitSource.includes("getBrowser"),
-    "auto-post-unit.ts should check getBrowser() before calling closeBrowser",
-  );
-  assert.ok(
-    postUnitSource.includes("browser-teardown"),
-    "auto-post-unit.ts should have browser-teardown debug phase",
-  );
-});

package/src/resources/extensions/gsd/tests/clear-stale-autostart.test.ts

@@ -1,41 +1,48 @@
 /**
  * clear-stale-autostart.test.ts — #3667
  *
- * Verify that guided-flow.ts adds a createdAt timestamp to pending auto-start
- * entries and implements a staleness check (30s age guard) so that /clear
- * interrupted discussions don't permanently block future /gsd invocations.
+ * Pending auto-start entries carry a createdAt timestamp so later /gsd
+ * invocations can distinguish an in-flight discussion from a stale one.
  */
 
-import { describe, test } from "node:test";
+import { describe, test, afterEach } 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 sourceFile = join(__dirname, "..", "guided-flow.ts");
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  _getPendingAutoStart,
+  clearPendingAutoStart,
+  setPendingAutoStart,
+} from "../guided-flow.ts";
+
+afterEach(() => {
+  clearPendingAutoStart();
+});
 
 describe("clear stale pending auto-start (#3667)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
-
-  test("PendingAutoStartEntry interface includes createdAt field", () => {
-    assert.match(source, /createdAt:\s*number/);
+  test("setPendingAutoStart defaults createdAt to Date.now()", (t) => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-pending-autostart-")));
+    t.after(() => rmSync(base, { recursive: true, force: true }));
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    const before = Date.now();
+
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+
+    const entry = _getPendingAutoStart(base);
+    assert.ok(entry);
+    assert.equal(typeof entry!.createdAt, "number");
+    assert.ok(entry!.createdAt >= before);
   });
 
-  test("setPendingAutoStart defaults createdAt to Date.now()", () => {
-    assert.match(source, /createdAt:\s*Date\.now\(\)/);
-  });
+  test("setPendingAutoStart preserves explicit createdAt for stale-entry checks", (t) => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-pending-autostart-old-")));
+    t.after(() => rmSync(base, { recursive: true, force: true }));
+    mkdirSync(join(base, ".gsd"), { recursive: true });
 
-  test("staleness check uses 30_000ms threshold", () => {
-    assert.match(source, /30[_]?000/);
-  });
-
-  test("stale entry detection checks manifest and context files", () => {
-    assert.match(source, /DISCUSSION-MANIFEST\.json/);
-    assert.match(source, /CONTEXT\.md/);
-  });
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001", createdAt: 123 });
 
-  test("stale entries are deleted from the map", () => {
-    assert.match(source, /pendingAutoStartMap\.delete\(basePath\)/);
+    assert.equal(_getPendingAutoStart(base)?.createdAt, 123);
   });
 });

package/src/resources/extensions/gsd/tests/cmux.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for cmux integration, layout, and CLI isolation.
 import test, { describe, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import * as fs from "node:fs";
@@ -7,6 +9,7 @@ import { fileURLToPath } from "node:url";
 import {
   buildCmuxProgress,
   buildCmuxStatusLabel,
+  CmuxClient,
   detectCmuxEnvironment,
   markCmuxPromptShown,
   resetCmuxPromptState,
@@ -256,60 +259,55 @@ describe("createGridLayout", () => {
 });
 
 describe("CmuxClient stdio isolation", () => {
-  test("runSync and runAsync explicitly set stdio to prevent terminal interference", () => {
-    // Read the cmux index source and verify that execFileSync/spawn calls
-    // inside runSync/runAsync include stdio options that isolate stdin and stderr.
-    // This prevents the cmux CLI child process from inheriting the parent's
-    // stdin/stderr, which can steal keyboard input or corrupt TUI rendering (#1922).
-    const cmuxIndexPath = path.resolve(
-      path.dirname(fileURLToPath(import.meta.url)),
-      "../../cmux/index.ts",
-    );
-    const source = fs.readFileSync(cmuxIndexPath, "utf-8");
-
-    // Extract runSync method body
-    const runSyncMatch = source.match(/private runSync\(args: string\[\]\)[^{]*\{([\s\S]*?)\n  \}/);
-    assert.ok(runSyncMatch, "runSync method must exist");
-    const runSyncBody = runSyncMatch[1];
-    assert.ok(
-      runSyncBody.includes('stdio:'),
-      "runSync must explicitly set stdio to prevent terminal interference (see #1922)",
-    );
-    assert.ok(
-      runSyncBody.includes('"ignore"'),
-      "runSync stdio must ignore stdin to prevent stealing keyboard input from TUI",
-    );
-
-    // Extract runAsync method body
-    const runAsyncMatch = source.match(/private async runAsync\(args: string\[\]\)[^{]*\{([\s\S]*?)\n  \}/);
-    assert.ok(runAsyncMatch, "runAsync method must exist");
-    const runAsyncBody = runAsyncMatch[1];
-    assert.ok(
-      runAsyncBody.includes('stdio:'),
-      "runAsync must explicitly set stdio to prevent terminal interference (see #1922)",
-    );
-    assert.ok(
-      runAsyncBody.includes('"ignore"'),
-      "runAsync stdio must ignore stdin to prevent stealing keyboard input from TUI",
-    );
-  });
-
-  test("isCmuxCliAvailable uses stdio ignore to prevent terminal interference", () => {
-    const cmuxIndexPath = path.resolve(
-      path.dirname(fileURLToPath(import.meta.url)),
-      "../../cmux/index.ts",
-    );
-    const source = fs.readFileSync(cmuxIndexPath, "utf-8");
-
-    // Find isCmuxCliAvailable or the cli-check function body
-    const fnMatch = source.match(/function isCmuxCliAvailable[\s\S]*?\{([\s\S]*?)\n\}/);
-    if (!fnMatch) return; // function may be inlined or renamed — skip rather than fail
-
-    const fnBody = fnMatch[1];
-    assert.ok(
-      fnBody.includes('"ignore"') || !fnBody.includes('execFileSync'),
-      "isCmuxCliAvailable must not inherit parent stdio (see #1922)",
+  test("runSync and runAsync execute the cmux CLI without inheriting test stdin", async () => {
+    const binDir = fs.mkdtempSync(path.join(tmpdir(), "cmux-bin-"));
+    const logPath = path.join(binDir, "calls.jsonl");
+    const cmuxPath = path.join(binDir, "cmux");
+    const originalPath = process.env.PATH;
+    fs.writeFileSync(
+      cmuxPath,
+      [
+        "#!/usr/bin/env node",
+        "const fs = require('node:fs');",
+        `fs.appendFileSync(${JSON.stringify(logPath)}, JSON.stringify(process.argv.slice(2)) + '\\n');`,
+        "if (process.argv.includes('--json')) process.stdout.write(JSON.stringify({surfaces:[{id:'surface-1'}]}));",
+        "else process.stdout.write('ok');",
+      ].join("\n"),
+      "utf-8",
     );
+    fs.chmodSync(cmuxPath, 0o755);
+    process.env.PATH = `${binDir}:${originalPath ?? ""}`;
+    try {
+      const client = new CmuxClient({
+        enabled: true,
+        available: true,
+        cliAvailable: true,
+        notifications: true,
+        sidebar: true,
+        splits: true,
+        browser: false,
+        workspaceId: "workspace-1",
+        surfaceId: "surface-0",
+        socketPath: "/tmp/cmux.sock",
+      });
+
+      client.setStatus("M001", "executing");
+      await client.listSurfaceIds();
+
+      const calls = fs.readFileSync(logPath, "utf-8").trim().split("\n").map((line) => JSON.parse(line));
+      const commandPrefixes = calls.map((call) => call.slice(0, 2));
+      assert.ok(
+        commandPrefixes.some((prefix) => JSON.stringify(prefix) === JSON.stringify(["set-status", "gsd"])),
+        "set-status command should be invoked",
+      );
+      assert.ok(
+        commandPrefixes.some((prefix) => JSON.stringify(prefix) === JSON.stringify(["list-surfaces", "--json"])),
+        "list-surfaces command should be invoked",
+      );
+    } finally {
+      process.env.PATH = originalPath;
+      fs.rmSync(binDir, { recursive: true, force: true });
+    }
   });
 });
 

package/src/resources/extensions/gsd/tests/cold-resume-db-reopen.test.ts

@@ -1,65 +1,43 @@
 /**
  * cold-resume-db-reopen.test.ts — Regression test for #2940.
- *
- * Validates that the paused-session resume path in auto.ts opens the project
- * database before calling rebuildState() / deriveState(), matching the fresh
- * bootstrap path in auto-start.ts.
- *
- * Without this, cold resume falls back to markdown parsing which misreads
- * done cells and redispatches wrong slices.
  */
 
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertTrue, report } = createTestContext();
-
-const autoSrc = readFileSync(join(import.meta.dirname, "..", "auto.ts"), "utf-8");
-
-console.log("\n=== resume path refreshes resources and opens DB before rebuildState/deriveState ===");
-
-// The resume block is the `if (s.paused) { ... }` section that calls rebuildState/deriveState.
-// Locate the resume section by finding `s.paused = false;` followed by `rebuildState`.
-const resumeSectionStart = autoSrc.indexOf("if (s.paused) {", autoSrc.indexOf("// If resuming from paused state"));
-assertTrue(resumeSectionStart > 0, "auto.ts has the paused-session resume block");
-
-const resumeSectionEndCandidates = [
-  autoSrc.indexOf("await runAutoLoopWithUok(", resumeSectionStart),
-  autoSrc.indexOf("await autoLoop(", resumeSectionStart),
-].filter((idx) => idx > resumeSectionStart);
-const resumeSectionEnd = resumeSectionEndCandidates.length > 0 ? Math.min(...resumeSectionEndCandidates) : -1;
-assertTrue(resumeSectionEnd > resumeSectionStart, "resume block reaches the dispatch loop");
-
-const resumeSection = autoSrc.slice(resumeSectionStart, resumeSectionEnd);
-
-// The resume path must refresh managed resources and open the DB before
-// rebuildState/deriveState so resumed auto-mode uses current extension code.
-const rebuildIdx = resumeSection.indexOf("rebuildState(");
-assertTrue(rebuildIdx > 0, "resume block calls rebuildState");
-
-const deriveIdx = resumeSection.indexOf("deriveState(");
-assertTrue(deriveIdx > 0, "resume block calls deriveState");
-
-const preDeriveSection = resumeSection.slice(0, rebuildIdx);
-
-assertTrue(
-  preDeriveSection.includes("initResources("),
-  "resume path must refresh managed resources before rebuildState/deriveState (#3761)",
-);
-
-// There must be a DB open call before the first rebuildState call
-const dbOpenPatterns = [
-  "openProjectDbIfPresent(",
-  "openDatabase(",
-  "ensureDbOpen(",
-];
-
-const hasDbOpen = dbOpenPatterns.some(pat => preDeriveSection.includes(pat));
-assertTrue(
-  hasDbOpen,
-  "resume path must open DB before rebuildState/deriveState (#2940)",
-);
-
-report();
+import test from "node:test";
+import assert from "node:assert/strict";
+import { refreshResumeResourcesAndDb } from "../auto.ts";
+
+test("resume refreshes managed resources and opens DB before state rebuild", async () => {
+  const calls: string[] = [];
+
+  await refreshResumeResourcesAndDb("/tmp/project", {
+    env: {
+      GSD_CODING_AGENT_DIR: "/tmp/agent",
+      GSD_PKG_ROOT: "/tmp/pkg",
+    } as NodeJS.ProcessEnv,
+    importModule: async (specifier: string) => {
+      calls.push(`import:${specifier}`);
+      if (specifier.endsWith("/dist/resource-loader.js")) {
+        return {
+          initResources: (agentDir: string) => calls.push(`initResources:${agentDir}`),
+        };
+      }
+      if (specifier === "./prompt-loader.js") {
+        return {
+          primeCache: () => calls.push("primeCache"),
+        };
+      }
+      throw new Error(`unexpected import: ${specifier}`);
+    },
+    openProjectDb: async (basePath: string) => {
+      calls.push(`openDb:${basePath}`);
+    },
+  });
+
+  assert.deepEqual(calls, [
+    "import:file:///tmp/pkg/dist/resource-loader.js",
+    "initResources:/tmp/agent",
+    "import:./prompt-loader.js",
+    "primeCache",
+    "openDb:/tmp/project",
+  ]);
+});