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

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/status-db-open.test.ts

@@ -1,56 +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 prompt handles external .gsd without staging quick files', () => {
-    assert.match(quickSrc, /isExternalGsdRoot/,
-      'quick.ts should detect whether .gsd resolves outside the project repo');
-    assert.match(quickSrc, /do not stage or commit `\.gsd\/quick\/\.\.\.`/,
-      'external-state quick tasks must tell the agent not to stage .gsd/quick files');
-    assert.match(quickSrc, /nothing in the project repo to commit/,
-      'external-state quick tasks should allow summary-only work without a git 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/);
   });
 });

package/src/resources/extensions/gsd/tests/stop-auto-merge-back.test.ts

@@ -1,5 +1,7 @@
+// Project/App: GSD-2
+// File Purpose: Stop-auto worktree exit strategy regression tests.
 /**
- * stop-auto-merge-back.test.ts — Regression test for #2317.
+ * stop-auto-merge-back.test.ts — Regression test for #5576.
  *
  * When auto-mode stops after a milestone is complete, stopAuto should trigger
  * merge-back (mergeAndExit) instead of just exiting the worktree with
@@ -9,59 +11,59 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { _selectStopAutoWorktreeExit } from "../auto.ts";
 
-// ─── Source analysis: stopAuto calls mergeAndExit for complete milestones ────
-
-const autoSrcPath = join(import.meta.dirname, "..", "auto.ts");
-const autoSrc = readFileSync(autoSrcPath, "utf-8");
-
-test("#2317: stopAuto should check milestone completion status before choosing exit strategy", () => {
-  // stopAuto Step 4 should NOT unconditionally call exitMilestone(preserveBranch: true).
-  // It should check if the milestone is complete and call mergeAndExit instead.
-
-  // Find the Step 4 section
-  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-  assert.ok(step4Idx !== -1, "Step 4 comment exists in stopAuto");
-
-  // Extract a reasonable window around Step 4 (up to Step 5)
-  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
-  const step4Block = autoSrc.slice(step4Idx, step5Idx);
-
-  // The fix: Step 4 should call mergeAndExit when milestone is complete
-  assert.ok(
-    step4Block.includes("mergeAndExit"),
-    "Step 4 should call mergeAndExit for completed milestones",
+test("#5576: stopAuto should check milestone completion status before choosing exit strategy", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: true,
+      milestoneMergedInPhases: false,
+    }),
+    "merge",
   );
 });
 
-test("#2317: stopAuto should detect milestone completion via SUMMARY file or DB", () => {
-  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
-  const step4Block = autoSrc.slice(step4Idx, step5Idx);
-
-  // Should check completion status — either via SUMMARY file, DB getMilestone, or phase
-  const checksCompletion =
-    step4Block.includes("SUMMARY") ||
-    step4Block.includes("getMilestone") ||
-    step4Block.includes("complete") ||
-    step4Block.includes("isMilestoneComplete");
+test("#5576: stopAuto still preserves branch for incomplete milestones", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: false,
+      milestoneMergedInPhases: false,
+    }),
+    "preserve",
+  );
+});
 
-  assert.ok(
-    checksCompletion,
-    "Step 4 should check if milestone is complete before deciding exit strategy",
+test("#5576: stopAuto does not merge a milestone already merged in phases", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: true,
+      milestoneMergedInPhases: true,
+    }),
+    "none",
   );
 });
 
-test("#2317: stopAuto still preserves branch for incomplete milestones", () => {
-  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
-  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+test("#5576: stopAuto skips worktree teardown when no milestone is active", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: null,
+      milestoneComplete: true,
+      milestoneMergedInPhases: false,
+    }),
+    "none",
+  );
+});
 
-  // preserveBranch should still be used as fallback for non-complete milestones
-  assert.ok(
-    step4Block.includes("preserveBranch"),
-    "Step 4 should still preserve branch for incomplete milestones (fallback path)",
+test("#5576: stopAuto returns none when phases are already merged even if milestone is not flagged complete", () => {
+  assert.equal(
+    _selectStopAutoWorktreeExit({
+      currentMilestoneId: "M001",
+      milestoneComplete: false,
+      milestoneMergedInPhases: true,
+    }),
+    "none",
   );
 });