gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

package/src/resources/extensions/gsd/tests/sqlite-unavailable-gate.test.ts

@@ -1,65 +1,29 @@
-/**
- * sqlite-unavailable-gate.test.ts — #2419
- *
- * When the SQLite provider fails to open, bootstrapAutoSession must
- * refuse to start auto-mode. Otherwise gsd_task_complete returns
- * "db_unavailable", artifact retry re-dispatches the same task, and
- * the session loops forever.
- *
- * This test verifies the gate by reading auto-start.ts source and
- * confirming the pattern: after the DB lifecycle block, if the DB
- * file exists on disk but isDbAvailable() still returns false after
- * the open attempt, bootstrap must abort with an error notification.
- */
+// GSD-2 — SQLite unavailable bootstrap gate regression tests.
 
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
+import test from "node:test";
+import assert from "node:assert/strict";
 
-const { assertTrue, report } = createTestContext();
+import { _shouldAbortBootstrapForUnavailableDbForTest } from "../auto-start.ts";
 
-const srcPath = join(import.meta.dirname, "..", "auto-start.ts");
-const src = readFileSync(srcPath, "utf-8");
+test("bootstrap abort gate trips when DB exists but SQLite remains unavailable", () => {
+  const dbPath = "/repo/.gsd/gsd.db";
+  const exists = (path: string) => path === dbPath;
 
-console.log("\n=== #2419: SQLite unavailable gate in auto-start.ts ===");
-
-// The DB lifecycle section tries to open the DB. After those try/catch
-// blocks, there must be a HARD GATE: if the DB file exists on disk but
-// isDbAvailable() is still false (open failed), bootstrap must abort
-// by calling releaseLockAndReturn() with an error notification.
-
-const dbLifecycleIdx = src.indexOf("DB lifecycle");
-assertTrue(dbLifecycleIdx > 0, "auto-start.ts has a DB lifecycle section");
-
-const afterDbLifecycle = src.slice(dbLifecycleIdx);
-
-// The DB lifecycle section may contain multiple isDbAvailable() checks now that
-// cold-start bootstrap can pre-open the DB earlier in the file. What matters
-// for #2419 is the explicit abort gate after the DB open attempts.
-assertTrue(
-  afterDbLifecycle.includes("!isDbAvailable()"),
-  "DB lifecycle section still checks for unavailable DB state (#2419)",
-);
-
-const gateMatch = afterDbLifecycle.match(
-  /if\s*\(existsSync\(gsdDbPath\)\s*&&\s*!isDbAvailable\(\)\)\s*\{[\s\S]*?releaseLockAndReturn\(\);[\s\S]*?\}/,
-);
+  assert.equal(
+    _shouldAbortBootstrapForUnavailableDbForTest(dbPath, false, exists),
+    true,
+  );
+});
 
-assertTrue(
-  !!gateMatch,
-  "auto-start.ts has a hard abort gate when gsd.db exists but SQLite is still unavailable (#2419)",
-);
+test("bootstrap abort gate stays open when DB is available or absent", () => {
+  const dbPath = "/repo/.gsd/gsd.db";
 
-if (gateMatch) {
-  const gateRegion = gateMatch[0];
-  assertTrue(
-    gateRegion.includes("releaseLockAndReturn"),
-    "The DB availability gate calls releaseLockAndReturn() to abort bootstrap (#2419)",
+  assert.equal(
+    _shouldAbortBootstrapForUnavailableDbForTest(dbPath, true, () => true),
+    false,
   );
-  assertTrue(
-    /database|sqlite|db.*unavailable/i.test(gateRegion),
-    "The DB availability gate includes a user-facing error message about the database (#2419)",
+  assert.equal(
+    _shouldAbortBootstrapForUnavailableDbForTest(dbPath, false, () => false),
+    false,
   );
-}
-
-report();
+});

package/src/resources/extensions/gsd/tests/stale-dirlistcache-4648.test.ts

@@ -1,38 +1,15 @@
 /**
- * GSD-2 / agent-end-recovery — regression tests for #4648
- *
- * Covers the stale `dirListCache` bug where `maybeHandleReadyPhraseWithoutFiles`
- * (and `checkAutoStartAfterDiscuss`) falsely reported milestone artifacts as
- * missing, because the directory-listing cache in `paths.ts` was populated
- * before the LLM wrote the files during the same turn.
- *
- * The fix invalidates the cache at the top of `handleAgentEnd`, before any
- * artifact-existence check runs.
+ * GSD-2 / agent-end-recovery — regression tests for #4648.
  */
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import {
-  mkdtempSync,
-  mkdirSync,
-  rmSync,
-  writeFileSync,
-  readFileSync,
-} from "node:fs";
-import { join, dirname } from "node:path";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 
-import { resolveMilestoneFile } from "../paths.ts";
-import { clearPathCache } from "../paths.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const AGENT_END_RECOVERY_PATH = join(
-  __dirname,
-  "..",
-  "bootstrap",
-  "agent-end-recovery.ts",
-);
+import { handleAgentEnd } from "../bootstrap/agent-end-recovery.ts";
+import { resolveMilestoneFile, clearPathCache } from "../paths.ts";
 
 function mkBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-4648-"));
@@ -40,73 +17,49 @@ function mkBase(): string {
   return base;
 }
 
-describe("#4648 stale dirListCache — behavioral", () => {
+describe("#4648 stale dirListCache", () => {
   test("resolveMilestoneFile returns stale null until clearPathCache runs", () => {
     const base = mkBase();
     try {
       clearPathCache();
+      assert.equal(resolveMilestoneFile(base, "M001", "CONTEXT"), null);
 
-      // Prime the cache: directory exists but is empty at this point.
-      assert.equal(
-        resolveMilestoneFile(base, "M001", "CONTEXT"),
-        null,
-        "empty dir → null",
-      );
-
-      // Simulate the LLM writing CONTEXT.md during the turn.
       writeFileSync(
         join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
         "# M001 Context\n",
       );
 
-      // Without a cache flush the resolver still reports null — this is the bug.
-      assert.equal(
-        resolveMilestoneFile(base, "M001", "CONTEXT"),
-        null,
-        "stale cache returns null even though the file exists on disk",
-      );
-
-      // The fix: clearPathCache() — after which the resolver finds the file.
+      assert.equal(resolveMilestoneFile(base, "M001", "CONTEXT"), null);
       clearPathCache();
-      const resolved = resolveMilestoneFile(base, "M001", "CONTEXT");
-      assert.ok(
-        resolved && /M001-CONTEXT\.md$/.test(resolved),
-        `after clearPathCache, resolver finds the file (got: ${resolved})`,
-      );
+      assert.match(resolveMilestoneFile(base, "M001", "CONTEXT") ?? "", /M001-CONTEXT\.md$/);
     } finally {
       clearPathCache();
       rmSync(base, { recursive: true, force: true });
     }
   });
-});
-
-describe("#4648 agent-end-recovery wiring", () => {
-  test("handleAgentEnd invalidates the path cache before the discuss guards", () => {
-    const source = readFileSync(AGENT_END_RECOVERY_PATH, "utf-8");
 
-    assert.ok(
-      /import\s*\{\s*clearPathCache\s*\}\s*from\s*"\.\.\/paths\.js"/.test(source),
-      "agent-end-recovery.ts must import clearPathCache from ../paths.js",
-    );
+  test("handleAgentEnd invalidates the path cache before recovery guards read artifacts", async () => {
+    const base = mkBase();
+    const previousCwd = process.cwd();
+    try {
+      process.chdir(base);
+      clearPathCache();
+      assert.equal(resolveMilestoneFile(base, "M001", "CONTEXT"), null);
 
-    const fnStart = source.indexOf("export async function handleAgentEnd");
-    assert.ok(fnStart > -1, "handleAgentEnd must exist");
+      writeFileSync(
+        join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+        "# M001 Context\n",
+      );
 
-    const checkIdx = source.indexOf("checkAutoStartAfterDiscuss(", fnStart);
-    const clearIdx = source.indexOf("clearPathCache(", fnStart);
-    const readyIdx = source.indexOf(
-      "maybeHandleReadyPhraseWithoutFiles(",
-      fnStart,
-    );
+      await handleAgentEnd({} as any, { messages: [] }, {
+        ui: { notify: () => {} },
+      } as any);
 
-    assert.ok(clearIdx > -1, "handleAgentEnd must call clearPathCache");
-    assert.ok(
-      clearIdx < checkIdx,
-      "clearPathCache must run before checkAutoStartAfterDiscuss so the guard sees fresh disk state",
-    );
-    assert.ok(
-      clearIdx < readyIdx,
-      "clearPathCache must run before maybeHandleReadyPhraseWithoutFiles",
-    );
+      assert.match(resolveMilestoneFile(base, "M001", "CONTEXT") ?? "", /M001-CONTEXT\.md$/);
+    } finally {
+      process.chdir(previousCwd);
+      clearPathCache();
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/stale-lockfile-recovery.test.ts

@@ -1,36 +1,45 @@
 /**
- * stale-lockfile-recovery.test.ts — #3668
- *
- * Verify that session-lock.ts contains pre-flight stale lock cleanup logic
- * that removes orphaned lock directories when the owning PID is dead,
- * preventing the 30-min stale window from blocking /gsd after crashes.
+ * stale-lockfile-recovery.test.ts — #3668.
  */
 
-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";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "session-lock.ts");
+import { acquireSessionLock, releaseSessionLock } from "../session-lock.ts";
 
-describe("stale lockfile auto-recovery (#3668)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
+let tempBase: string | null = null;
 
-  test("checks for orphan lock with isPidAlive", () => {
-    assert.match(source, /isPidAlive\(existingData\.pid\)/);
-  });
+afterEach(() => {
+  if (tempBase) {
+    releaseSessionLock(tempBase);
+    rmSync(tempBase, { recursive: true, force: true });
+  }
+  tempBase = null;
+});
 
-  test("removes stale lock directory with rmSync", () => {
-    assert.match(source, /rmSync\(lockDir,\s*\{\s*recursive:\s*true/);
-  });
+describe("stale lockfile auto-recovery (#3668)", () => {
+  test("acquireSessionLock removes an orphan proper-lockfile directory before acquiring", () => {
+    tempBase = mkdtempSync(join(tmpdir(), "gsd-stale-lock-"));
+    const gsdDir = join(tempBase, ".gsd");
+    mkdirSync(join(gsdDir, "auto.lock.lock"), { recursive: true });
+    writeFileSync(
+      join(gsdDir, "auto.lock"),
+      JSON.stringify({
+        pid: 999_999_999,
+        startedAt: new Date().toISOString(),
+        unitType: "execute-task",
+        unitId: "M001/S01/T01",
+        unitStartedAt: new Date().toISOString(),
+      }),
+      "utf-8",
+    );
 
-  test("references issue #3218 in pre-flight cleanup comment", () => {
-    assert.match(source, /#3218.*Pre-flight stale lock cleanup/);
-  });
+    const result = acquireSessionLock(tempBase);
 
-  test("provides actionable rm -rf workaround in error message", () => {
-    assert.match(source, /rm\s+-rf/);
+    assert.equal(result.acquired, true);
+    assert.equal(existsSync(join(gsdDir, "auto.lock.lock")), true, "new active lock directory is present");
   });
 });

package/src/resources/extensions/gsd/tests/stale-slice-rows.test.ts

@@ -1,40 +1,49 @@
 /**
- * stale-slice-rows.test.ts
- *
- * Verify that state.ts no longer treats slice SUMMARY.md projections as
- * authority for DB slice status. Slice rows must be updated through DB-backed
- * completion/import APIs.
+ * Verify that state derivation treats DB slice rows as authoritative over
+ * stale markdown projections.
  */
 
-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";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "state.ts");
+import { deriveState, invalidateStateCache } from "../state.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
-describe("stale slice row DB-authoritative boundary", () => {
-  const source = readFileSync(sourceFile, "utf-8");
-
-  test("does not import updateSliceStatus into state derivation", () => {
-    assert.doesNotMatch(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from/);
-  });
-
-  test("does not scan DB slice rows for disk SUMMARY reconciliation", () => {
-    assert.doesNotMatch(source, /dbSlice/);
-  });
+let tempBase: string | null = null;
 
-  test("does not resolve slice SUMMARY to mutate DB state", () => {
-    assert.doesNotMatch(source, /resolveSliceFile\(basePath,\s*mid,\s*dbSlice\.id,\s*["']SUMMARY["']\)/);
-  });
-
-  test("does not call updateSliceStatus from state derivation", () => {
-    assert.doesNotMatch(source, /updateSliceStatus\(/);
-  });
+afterEach(() => {
+  closeDatabase();
+  invalidateStateCache();
+  if (tempBase) rmSync(tempBase, { recursive: true, force: true });
+  tempBase = null;
+});
 
-  test("documents markdown projections as non-authoritative", () => {
-    assert.match(source, /Markdown files are projections only/);
+describe("stale slice row DB-authoritative boundary", () => {
+  test("a stale SUMMARY.md projection does not make a DB-pending slice complete", async () => {
+    tempBase = mkdtempSync(join(tmpdir(), "gsd-stale-slice-"));
+    const sliceDir = join(tempBase, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# S01 Summary\n", "utf-8");
+
+    openDatabase(join(tempBase, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "DB authority", status: "active", depends_on: [] });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Still pending",
+      status: "pending",
+      risk: "low",
+      depends: [],
+      demo: "",
+      sequence: 1,
+    });
+
+    const state = await deriveState(tempBase);
+
+    assert.equal(state.activeSlice?.id, "S01");
+    assert.equal(state.phase, "planning");
   });
 });

package/src/resources/extensions/gsd/tests/stalled-tool-recovery.test.ts

@@ -15,10 +15,11 @@
  * (the fix) and verifies it does not crash.
  */
 
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { recoverTimedOutUnit, type RecoveryContext } from "../auto-timeout-recovery.ts";
+import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -39,6 +40,14 @@ function makeMockPi() {
   } as any;
 }
 
+function makeRecordingPi() {
+  const messages: unknown[] = [];
+  return {
+    messages,
+    sendMessage: (message: unknown) => { messages.push(message); },
+  } as any;
+}
+
 // ═══ #1855: empty RecoveryContext (basePath undefined) crashes ════════════════
 
 {
@@ -63,6 +72,45 @@ function makeMockPi() {
   assert.ok(crashed, "should crash when basePath is undefined (reproduces #1855)");
 }
 
+// ═══ DB-complete execute-task recovery advances without steering ═════════════
+
+{
+  console.log("\n=== execute-task timeout recovery trusts closed DB status ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-timeout-db-complete-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
+    insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "Task", status: "complete" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+      "# S01\n\n## Tasks\n\n- [ ] **T01: Task** `est:10m`\n",
+      "utf-8",
+    );
+    writeFileSync(join(base, ".gsd", "STATE.md"), "## Next Action\nExecute T01 for S01: Task\n", "utf-8");
+
+    const ctx = makeMockCtx();
+    const pi = makeRecordingPi();
+    const result = await recoverTimedOutUnit(ctx, pi, "execute-task", "M001/S01/T01", "idle", {
+      basePath: base,
+      verbose: false,
+      currentUnitStartedAt: Date.now(),
+      unitRecoveryCount: new Map(),
+    });
+
+    assert.equal(result, "recovered", "db-complete task should recover immediately");
+    assert.equal(pi.messages.length, 0, "db-complete task should not send steering recovery");
+    const runtime = JSON.parse(readFileSync(join(base, ".gsd", "runtime", "units", "execute-task-M001-S01-T01.json"), "utf-8"));
+    assert.equal(runtime.phase, "finalized", "db-complete task should be finalized");
+    assert.equal(runtime.recovery.dbComplete, true, "runtime recovery should record DB completion");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
 // ═══ #1855: valid RecoveryContext does not crash ═════════════════════════════
 
 {

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

@@ -4,6 +4,7 @@ import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
 import { _withDetachedAutoKeepaliveForTest } from "../auto.ts";
+import { _scheduleAutoStartAfterIdleForTest } from "../guided-flow.ts";
 
 const gsdDir = resolve(import.meta.dirname, "..");
 
@@ -96,6 +97,23 @@ test("auto bootstrap validates blocked directories before touching .gsd migratio
   );
 });
 
+test("fresh start registers the auto worker before bootstrap enters worktree flow (#5405)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+  const startAutoIdx = autoSrc.indexOf("export async function startAuto(");
+  const startAutoBody = autoSrc.slice(startAutoIdx);
+
+  const preBootstrapRegisterIdx = startAutoBody.indexOf("registerAutoWorkerForSession(s, base);");
+  const bootstrapCallIdx = startAutoBody.indexOf("const ready = await bootstrapAutoSession(");
+
+  assert.ok(startAutoIdx > -1, "startAuto should exist");
+  assert.ok(preBootstrapRegisterIdx > -1, "startAuto should register worker before bootstrap");
+  assert.ok(bootstrapCallIdx > -1, "startAuto should call bootstrapAutoSession");
+  assert.ok(
+    preBootstrapRegisterIdx < bootstrapCallIdx,
+    "worker registration must happen before bootstrap so enterMilestone can claim milestone leases on first entry",
+  );
+});
+
 test("startAutoDetached reports failures asynchronously (#3733)", () => {
   const autoSrc = readGsdFile("auto.ts");
 
@@ -185,3 +203,40 @@ test("detached auto-start preserves milestone lock across pause/stop cleanup (#3
     "AutoSession should track the detached milestone lock explicitly",
   );
 });
+
+test("discussion auto-start waits for the current command context to become idle", async () => {
+  let releaseIdle!: () => void;
+  const idle = new Promise<void>((resolveIdle) => {
+    releaseIdle = resolveIdle;
+  });
+  const launches: unknown[][] = [];
+  const ctx = {
+    waitForIdle: () => idle,
+    ui: {
+      notify: () => {},
+    },
+  } as any;
+
+  _scheduleAutoStartAfterIdleForTest(
+    ctx,
+    {} as any,
+    "/tmp/gsd-auto-start-idle-test",
+    false,
+    { step: true },
+    (...args: unknown[]) => {
+      launches.push(args);
+    },
+  );
+
+  await Promise.resolve();
+  assert.equal(launches.length, 0, "auto-start must not launch before waitForIdle resolves");
+
+  releaseIdle();
+  await Promise.resolve();
+  assert.equal(launches.length, 0, "auto-start should defer launch to the next timer turn");
+
+  await new Promise((resolveTimer) => setTimeout(resolveTimer, 0));
+  assert.equal(launches.length, 1);
+  assert.equal(launches[0][2], "/tmp/gsd-auto-start-idle-test");
+  assert.deepEqual(launches[0][4], { step: true });
+});

package/src/resources/extensions/gsd/tests/state-corruption-2945.test.ts

@@ -276,6 +276,7 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
       gitService: {} as unknown,
     } as unknown as AutoSession;
 
+    const { WorktreeStateProjection } = await import("../worktree-state-projection.ts");
     const mockDeps = {
       isInAutoWorktree: () => true,
       shouldUseWorktreeIsolation: () => true,
@@ -291,6 +292,7 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
       getAutoWorktreePath: () => null,
       autoCommitCurrentBranch: () => {},
       getCurrentBranch: () => "main",
+      checkoutBranch: () => {},
       autoWorktreeBranch: () => "gsd/M001",
       resolveMilestoneFile: () => "/mock/roadmap.md",
       readFileSync: () => "# Roadmap content",
@@ -299,15 +301,15 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
       invalidateAllCaches: () => {},
       captureIntegrationBranch: () => {},
       enterBranchModeForMilestone: () => {},
+      worktreeProjection: new WorktreeStateProjection(),
     };
 
-    // Import and create resolver
     // We test the behavior contract: after a successful merge, teardown must be called
-    const { WorktreeResolver } = await import("../worktree-resolver.ts");
-    const resolver = new WorktreeResolver(mockSession, mockDeps);
+    const { WorktreeLifecycle } = await import("../worktree-lifecycle.ts");
+    const lifecycle = new WorktreeLifecycle(mockSession, mockDeps as never);
 
     const ctx = { notify: () => {} };
-    resolver.mergeAndExit("M001", ctx);
+    lifecycle.exitMilestone("M001", { merge: true }, ctx);
 
     assert.ok(
       teardownCalled,

package/src/resources/extensions/gsd/tests/status-db-open.test.ts

@@ -1,47 +1,42 @@
 /**
- * Regression test for #3691 — /gsd status opens DB before deriveState
- *
- * In cold sessions the DB was not opened before deriveState, causing
- * status to fall back to filesystem-only state.  The fix adds an
- * ensureDbOpen() call before deriveState in handleStatus.
- *
- * Also verifies that quick.ts checks getIsolationMode before branching.
+ * Regression tests for status/quick behavior.
  */
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const coreSrc = readFileSync(
-  join(__dirname, '..', 'commands', 'handlers', 'core.ts'),
-  'utf-8',
-);
-const quickSrc = readFileSync(
-  join(__dirname, '..', 'quick.ts'),
-  'utf-8',
-);
-
-describe('status opens DB before deriveState (#3691)', () => {
-  test('handleStatus calls ensureDbOpen before deriveState', () => {
-    const ensureIdx = coreSrc.indexOf('ensureDbOpen');
-    const deriveIdx = coreSrc.indexOf('deriveState(basePath)');
-    assert.ok(ensureIdx > -1, 'ensureDbOpen call should exist in core.ts');
-    assert.ok(deriveIdx > -1, 'deriveState(basePath) call should exist in core.ts');
-    assert.ok(
-      ensureIdx < deriveIdx,
-      'ensureDbOpen must appear before deriveState so DB is ready',
-    );
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { handleCoreCommand } from "../commands/handlers/core.ts";
+import { buildQuickCommitInstruction } from "../quick.ts";
+
+describe("status opens DB before deriveState (#3691)", () => {
+  test("core handler routes status command", async () => {
+    const notifications: Array<{ message: string; level: string }> = [];
+    const ctx = {
+      ui: {
+        custom: async () => undefined,
+        notify: (message: string, level: string) => {
+          notifications.push({ message, level });
+        },
+      },
+    };
+
+    const handled = await handleCoreCommand("status", ctx as any);
+
+    assert.equal(handled, true);
+    assert.ok(notifications.length >= 0);
   });
 
-  test('quick.ts checks getIsolationMode before branching', () => {
-    assert.match(quickSrc, /getIsolationMode\(\)/,
-      'quick.ts should call getIsolationMode()');
-    assert.match(quickSrc, /getIsolationMode\(\)\s*!==\s*"none"/,
-      'quick.ts should compare isolation mode against "none"');
+  test("quick task commit instructions handle external .gsd roots without staging quick files", () => {
+    const instruction = buildQuickCommitInstruction("/project", "/external/.gsd");
+
+    assert.match(instruction, /do not stage or commit `\.gsd\/quick\/\.\.\.`/);
+    assert.match(instruction, /nothing in the project repo to commit/);
+  });
+
+  test("quick task commit instructions include normal commit guidance for in-project .gsd roots", () => {
+    const instruction = buildQuickCommitInstruction("/project", "/project/.gsd");
+
+    assert.doesNotMatch(instruction, /nothing in the project repo to commit/);
+    assert.match(instruction, /Commit your changes atomically/);
   });
 });