gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

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

@@ -0,0 +1,144 @@
+// GSD-2 + src/resources/extensions/gsd/tests/orphan-merge-bootstrap.test.ts
+// Regression: bootstrap must actively merge orphan completed-but-unmerged
+// milestones, not just seed `s.currentMilestoneId` (the seed approach was
+// silently overwritten at auto-start.ts:948 — caught in audit of PR #5549).
+//
+// After ADR-016 / slice 7 step E, _mergeOrphanCompletedMilestone takes a
+// WorktreeLifecycle and inspects the typed ExitResult instead of catching
+// a throw — the fakeLifecycle below returns {ok:false, cause} to model the
+// previous throw shape.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { _mergeOrphanCompletedMilestone } from "../auto-start.js";
+import type { WorktreeLifecycle } from "../worktree-lifecycle.js";
+
+interface FakeLifecycleState {
+  mergeCalls: Array<{ milestoneId: string }>;
+  causeOnFail?: unknown;
+}
+
+function fakeLifecycle(state: FakeLifecycleState): WorktreeLifecycle {
+  return {
+    exitMilestone: (milestoneId: string) => {
+      state.mergeCalls.push({ milestoneId });
+      if (state.causeOnFail !== undefined) {
+        return { ok: false, reason: "teardown-failed", cause: state.causeOnFail };
+      }
+      return { ok: true, merged: true, codeFilesChanged: false };
+    },
+  } as unknown as WorktreeLifecycle;
+}
+
+interface FakeUiState {
+  notifications: Array<{ message: string; level: string }>;
+}
+
+function fakeUi(state: FakeUiState): {
+  notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void;
+} {
+  return {
+    notify: (message: string, level?: "info" | "warning" | "error" | "success") => {
+      state.notifications.push({ message, level: level ?? "info" });
+    },
+  };
+}
+
+test("happy path: orphan merge runs, returns merged:true, emits info notify", () => {
+  const lcState: FakeLifecycleState = { mergeCalls: [] };
+  const uiState: FakeUiState = { notifications: [] };
+  const result = _mergeOrphanCompletedMilestone(
+    fakeLifecycle(lcState),
+    "M002",
+    fakeUi(uiState),
+  );
+
+  assert.deepEqual(result, { merged: true });
+  assert.deepEqual(lcState.mergeCalls, [{ milestoneId: "M002" }]);
+  assert.equal(uiState.notifications.length, 1);
+  assert.deepEqual(uiState.notifications[0], {
+    message: "Detected unmerged completed milestone M002. Merging now.",
+    level: "info",
+  });
+});
+
+test("regression: failure from exitMilestone (e.g. wrong-branch from PR #5549 commit 5) does not bubble out", () => {
+  // Commit 5 (68ef58a3c) made `_mergeBranchMode` throw on wrong branch
+  // instead of silently returning false. Lifecycle now wraps the throw in
+  // {ok:false, cause}; _mergeOrphanCompletedMilestone must surface that as
+  // a notify, never re-throwing into the slash-command caller.
+  const boom = new Error("dirty working tree blocks checkout");
+  const lcState: FakeLifecycleState = { mergeCalls: [], causeOnFail: boom };
+  const uiState: FakeUiState = { notifications: [] };
+
+  const result = _mergeOrphanCompletedMilestone(
+    fakeLifecycle(lcState),
+    "M002",
+    fakeUi(uiState),
+  );
+
+  assert.equal(result.merged, false);
+  assert.equal(result.error, boom);
+
+  // First notify announces the merge attempt; second notify reports the failure.
+  assert.equal(uiState.notifications.length, 2);
+  assert.equal(uiState.notifications[0].level, "info");
+  assert.equal(uiState.notifications[1].level, "warning");
+  assert.match(
+    uiState.notifications[1].message,
+    /Could not merge orphan milestone M002/,
+  );
+  assert.match(uiState.notifications[1].message, /dirty working tree blocks checkout/);
+  assert.match(uiState.notifications[1].message, /Resolve manually/);
+});
+
+test("non-Error failure causes are still captured and notified", () => {
+  // Defensive: non-Error causes (strings, numbers) must not crash the formatter.
+  const lcState: FakeLifecycleState = {
+    mergeCalls: [],
+    // mimic a non-Error cause
+    causeOnFail: "git lock held",
+  };
+  const uiState: FakeUiState = { notifications: [] };
+
+  const result = _mergeOrphanCompletedMilestone(
+    fakeLifecycle(lcState),
+    "M002",
+    fakeUi(uiState),
+  );
+
+  assert.equal(result.merged, false);
+  assert.equal(uiState.notifications[1].level, "warning");
+  assert.match(uiState.notifications[1].message, /git lock held/);
+});
+
+test("the exitMilestone call receives a notify-bound NotifyCtx the lifecycle can invoke", () => {
+  // The lifecycle's NotifyCtx must be wired to ui.notify so user-facing
+  // messages from inside exitMilestone (e.g. "Milestone Mxxx merged") still
+  // reach the UI. Verify by having the fake invoke ctx.notify.
+  const uiState: FakeUiState = { notifications: [] };
+  const ui = fakeUi(uiState);
+
+  const lifecycle = {
+    exitMilestone: (
+      _milestoneId: string,
+      _opts: { merge: boolean },
+      ctx: { notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void },
+    ) => {
+      ctx.notify("inner success message", "success");
+      return { ok: true, merged: true, codeFilesChanged: false };
+    },
+  } as unknown as WorktreeLifecycle;
+
+  const result = _mergeOrphanCompletedMilestone(lifecycle, "M002", ui);
+
+  assert.equal(result.merged, true);
+  // 1: outer "Detected unmerged completed milestone..."
+  // 2: inner "inner success message" emitted via the bound ctx.notify
+  assert.equal(uiState.notifications.length, 2);
+  assert.deepEqual(uiState.notifications[1], {
+    message: "inner success message",
+    level: "success",
+  });
+});

package/src/resources/extensions/gsd/tests/orphan-stash-audit.test.ts

@@ -0,0 +1,201 @@
+// GSD-2 + src/resources/extensions/gsd/tests/orphan-stash-audit.test.ts
+// Regression: orphaned gsd-preflight-stash entries from completed milestones
+// must be auto-applied at startup so the user's pre-merge work returns.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  auditOrphanedPreflightStashes,
+  _isAlreadyRestoredApplyError,
+} from "../orphan-stash-audit.js";
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_AUTHOR_NAME: "test",
+      GIT_AUTHOR_EMAIL: "test@example.com",
+      GIT_COMMITTER_NAME: "test",
+      GIT_COMMITTER_EMAIL: "test@example.com",
+    },
+  });
+}
+
+function pushPreflightStash(repo: string, milestoneId: string, fileName: string, content: string): string {
+  writeFileSync(join(repo, fileName), content);
+  const marker = `gsd-preflight-stash:${milestoneId}:42:1700000000000:abcd`;
+  git(repo, "stash", "push", "--include-untracked", "-m", `gsd-preflight-stash [${marker}]`);
+  return marker;
+}
+
+describe("auditOrphanedPreflightStashes", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "orphan-stash-audit-"));
+    git(repo, "init", "-q");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "test");
+    writeFileSync(join(repo, "seed.txt"), "seed\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "initial");
+  });
+
+  afterEach(() => {
+    if (repo && existsSync(repo)) {
+      rmSync(repo, { recursive: true, force: true });
+    }
+  });
+
+  test("returns empty result when there are no stashes", () => {
+    const result = auditOrphanedPreflightStashes(repo, () => true);
+    assert.deepEqual(result, { applied: [], warnings: [] });
+  });
+
+  test("applies an orphan preflight stash when its milestone is complete", () => {
+    pushPreflightStash(repo, "M002", "leftover.txt", "lost work\n");
+
+    // Verify the file is gone (stashed away) before the audit runs.
+    assert.equal(existsSync(join(repo, "leftover.txt")), false, "stash push must remove the file");
+
+    const result = auditOrphanedPreflightStashes(repo, (id) => id === "M002");
+
+    assert.equal(result.applied.length, 1, "expected exactly one stash applied");
+    assert.equal(result.applied[0].milestoneId, "M002");
+    assert.match(result.applied[0].stashRef, /^stash@\{\d+\}$/);
+    assert.equal(result.warnings.length, 0);
+
+    // The user's pre-merge content must be back in the working tree.
+    assert.equal(existsSync(join(repo, "leftover.txt")), true);
+    assert.equal(readFileSync(join(repo, "leftover.txt"), "utf-8"), "lost work\n");
+
+    // The stash entry must remain (apply, not pop) so the user has a backup.
+    const list = git(repo, "stash", "list");
+    assert.match(list, /gsd-preflight-stash:M002:/);
+  });
+
+  test("ignores stashes whose milestone is not complete", () => {
+    pushPreflightStash(repo, "M003", "wip.txt", "still-working\n");
+
+    const result = auditOrphanedPreflightStashes(repo, () => false);
+
+    assert.deepEqual(result, { applied: [], warnings: [] });
+    // File stays stashed.
+    assert.equal(existsSync(join(repo, "wip.txt")), false);
+  });
+
+  test("ignores non-gsd stash entries", () => {
+    writeFileSync(join(repo, "manual.txt"), "manual\n");
+    git(repo, "stash", "push", "--include-untracked", "-m", "user manual stash");
+
+    const result = auditOrphanedPreflightStashes(repo, () => true);
+
+    assert.deepEqual(result, { applied: [], warnings: [] });
+  });
+
+  test("collects a warning when the completion callback throws", () => {
+    pushPreflightStash(repo, "M004", "danger.txt", "boom\n");
+
+    const result = auditOrphanedPreflightStashes(repo, () => {
+      throw new Error("db unavailable");
+    });
+
+    assert.equal(result.applied.length, 0);
+    assert.equal(result.warnings.length, 1);
+    assert.match(result.warnings[0], /Could not determine completion status for M004/);
+    assert.match(result.warnings[0], /db unavailable/);
+  });
+
+  test("collects a warning when stash apply fails (conflicting working tree)", () => {
+    // Push a stash containing a change to seed.txt; then dirty seed.txt with
+    // a conflicting modification before the audit runs so apply fails.
+    writeFileSync(join(repo, "seed.txt"), "stashed\n");
+    const marker = `gsd-preflight-stash:M005:42:1700:zz`;
+    git(repo, "stash", "push", "-m", `gsd-preflight-stash [${marker}]`);
+
+    // Dirty the working tree so apply will conflict.
+    writeFileSync(join(repo, "seed.txt"), "conflicting modification\n");
+
+    const result = auditOrphanedPreflightStashes(repo, () => true);
+
+    assert.equal(result.applied.length, 0);
+    assert.equal(result.warnings.length, 1);
+    assert.match(result.warnings[0], /Could not apply orphaned preflight stash/);
+    assert.match(result.warnings[0], /M005/);
+    assert.match(result.warnings[0], /git stash apply/);
+
+    const list = git(repo, "stash", "list");
+    assert.match(list, /gsd-preflight-stash:M005:/);
+  });
+
+  test("returns empty result when basePath is not a git repo", () => {
+    const nonRepo = mkdtempSync(join(tmpdir(), "orphan-stash-not-repo-"));
+    try {
+      const result = auditOrphanedPreflightStashes(nonRepo, () => true);
+      assert.deepEqual(result, { applied: [], warnings: [] });
+    } finally {
+      rmSync(nonRepo, { recursive: true, force: true });
+    }
+  });
+
+  test("repeat run is a silent no-op when files were already restored (peer-review regression)", () => {
+    // Codex peer review caught: the first audit applies the stash and the
+    // file appears in the working tree. The stash entry stays in `git stash
+    // list` (apply, not pop). On the next audit, `git stash apply` exits
+    // non-zero with "already exists, no checkout" because the untracked file
+    // already exists. The original code surfaced that as a warning every
+    // startup. The fix detects that error and treats it as the idempotent
+    // steady state.
+    pushPreflightStash(repo, "M002", "leftover.txt", "lost work\n");
+
+    const first = auditOrphanedPreflightStashes(repo, () => true);
+    assert.equal(first.applied.length, 1, "first run applies");
+    assert.equal(first.warnings.length, 0);
+
+    const second = auditOrphanedPreflightStashes(repo, () => true);
+    assert.equal(second.applied.length, 0, "second run skips silently");
+    assert.equal(
+      second.warnings.length,
+      0,
+      "second run must NOT warn — files are already restored from first run",
+    );
+  });
+});
+
+test("_isAlreadyRestoredApplyError detects the git stash apply already-exists error", () => {
+  // Real-world stderr produced by git when an --include-untracked stash is
+  // applied while the file already exists in the working tree.
+  const realError: { stderr: string } = {
+    stderr: "leftover.txt already exists, no checkout\nCould not restore untracked files from stash entry\n",
+  };
+  assert.equal(_isAlreadyRestoredApplyError(realError), true);
+
+  // Buffer-form stderr (when encoding is not set explicitly).
+  const bufErr = { stderr: Buffer.from("foo.ts already exists, no checkout\n") };
+  assert.equal(_isAlreadyRestoredApplyError(bufErr), true);
+
+  // Some Node versions surface the message in err.message.
+  const messageOnly = new Error("Command failed: git stash apply\nfoo.ts already exists, no checkout");
+  assert.equal(_isAlreadyRestoredApplyError(messageOnly), true);
+
+  // Unrelated errors must NOT be classified as already-restored.
+  const realConflict: { stderr: string } = {
+    stderr: "CONFLICT (content): Merge conflict in lib/models.ts\n",
+  };
+  assert.equal(_isAlreadyRestoredApplyError(realConflict), false);
+
+  // Defensive null/undefined handling.
+  assert.equal(_isAlreadyRestoredApplyError(null), false);
+  assert.equal(_isAlreadyRestoredApplyError(undefined), false);
+  assert.equal(_isAlreadyRestoredApplyError("not an error"), false);
+  assert.equal(_isAlreadyRestoredApplyError({}), false);
+});

package/src/resources/extensions/gsd/tests/parallel-monitor-overlay.test.ts

@@ -1,11 +1,19 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for parallel monitor overlay rendering and input handling.
+
 import { describe, it } from "node:test";
-import assert from "node:assert";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@gsd/pi-tui";
 
-/**
- * Basic tests for the parallel monitor overlay data helpers.
- * The overlay is primarily a rendering component that reads existing
- * status files — these tests verify the helper logic in isolation.
- */
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
 
 describe("parallel-monitor-overlay", () => {
   it("progressBar generates correct width", async () => {
@@ -37,6 +45,7 @@ describe("parallel-monitor-overlay", () => {
     const lines = overlay.render(80);
     assert.ok(Array.isArray(lines), "render should return an array");
     assert.ok(lines.length > 0, "render should return at least one line");
+    assertLinesFit(lines, 80);
 
     // Should contain header text
     const joined = lines.join("\n");
@@ -79,4 +88,27 @@ describe("parallel-monitor-overlay", () => {
     assert.equal((overlay as any).scrollOffset, 0, "empty overlays clamp scroll to zero");
     overlay.dispose();
   });
+
+  it("ParallelMonitorOverlay empty state fits narrow and wide widths", async () => {
+    const mod = await import("../parallel-monitor-overlay.js");
+
+    const mockTui = { requestRender: () => {} };
+    const mockTheme = {
+      fg: (_color: string, text: string) => text,
+      bold: (text: string) => text,
+    };
+    const overlay = new mod.ParallelMonitorOverlay(
+      mockTui,
+      mockTheme as any,
+      () => {},
+      "/nonexistent/path",
+    );
+
+    for (const width of [40, 80, 120]) {
+      assertLinesFit(overlay.render(width), width);
+      overlay.invalidate();
+    }
+
+    overlay.dispose();
+  });
 });

package/src/resources/extensions/gsd/tests/parallel-orchestrator-fast-forward.test.ts

@@ -0,0 +1,113 @@
+// GSD-2 + src/resources/extensions/gsd/tests/parallel-orchestrator-fast-forward.test.ts
+// Regression: parallel-orchestrator's `_createMilestoneWorktree` must
+// fast-forward a reused milestone branch onto integration before creating
+// the worktree, matching the behavior added to the auto-mode path in
+// commit 8996cb68e (#5549 post-merge audit, R3).
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { _createMilestoneWorktree } from "../parallel-orchestrator.js";
+
+const NO_PROMPT_ENV = {
+  ...process.env,
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_AUTHOR_NAME: "test",
+  GIT_AUTHOR_EMAIL: "test@example.com",
+  GIT_COMMITTER_NAME: "test",
+  GIT_COMMITTER_EMAIL: "test@example.com",
+};
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: NO_PROMPT_ENV,
+  });
+}
+
+function rev(cwd: string, ref: string): string {
+  return git(cwd, "rev-parse", ref).trim();
+}
+
+describe("_createMilestoneWorktree fast-forwards reused milestone branches (#5549 R3)", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "parallel-orch-ff-"));
+    git(repo, "init", "-q", "-b", "main");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "test");
+    writeFileSync(join(repo, "seed.txt"), "seed\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "initial");
+    // Minimal .gsd/ structure so syncGsdStateToWorktree doesn't crash on a
+    // bare repo. We don't care if it copies anything — only that the FF ran.
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("reused milestone branch behind main is fast-forwarded before worktree creation", () => {
+    // Worker N drained M001 in a previous run, leaving milestone/M001 forked
+    // from old main. Worker N+1 picks up M002 — but the milestone/M002 branch
+    // was created from old main in a sibling run, so it's now N commits behind.
+    git(repo, "branch", "milestone/M002");
+    const m002Initial = rev(repo, "milestone/M002");
+
+    writeFileSync(join(repo, "seed.txt"), "main moved forward\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main advanced");
+    const mainTip = rev(repo, "main");
+
+    assert.notEqual(m002Initial, mainTip, "main must be ahead before the test");
+
+    // _createMilestoneWorktree may throw inside createWorktree/syncGsdStateToWorktree
+    // (e.g. if the worktree-manager has stricter requirements than this minimal
+    // repo provides). The fast-forward runs BEFORE those calls, so the branch
+    // ref should have moved regardless. Catch and assert on observable state.
+    try {
+      _createMilestoneWorktree(repo, "M002");
+    } catch {
+      // Fine — we only care that FF executed.
+    }
+
+    assert.equal(
+      rev(repo, "milestone/M002"),
+      mainTip,
+      "milestone/M002 must be fast-forwarded to main's tip before worktree is built",
+    );
+  });
+
+  test("diverged milestone branch is NOT touched (would lose work)", () => {
+    git(repo, "checkout", "-q", "-b", "milestone/M002");
+    writeFileSync(join(repo, "wip.txt"), "milestone-only work\n");
+    git(repo, "add", "wip.txt");
+    git(repo, "commit", "-q", "-m", "M002 work");
+    const m002Tip = rev(repo, "milestone/M002");
+
+    git(repo, "checkout", "-q", "main");
+    writeFileSync(join(repo, "seed.txt"), "main moved forward\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main advanced");
+
+    try {
+      _createMilestoneWorktree(repo, "M002");
+    } catch {
+      // ignored
+    }
+
+    assert.equal(
+      rev(repo, "milestone/M002"),
+      m002Tip,
+      "diverged milestone branch must NOT be touched — would lose committed work",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/phantom-ghost-detection.test.ts

@@ -8,48 +8,35 @@
  * The fix makes isGhostMilestone treat a "queued" DB row with no disk
  * artifacts (CONTEXT, ROADMAP, SUMMARY) as a ghost.
  *
- * This structural test verifies the dbRow.status === 'queued' guard exists.
+ * This behavior test exercises isGhostMilestone against real DB rows and
+ * milestone artifacts.
  */
 
 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 source = readFileSync(join(__dirname, '..', 'state.ts'), 'utf-8');
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { closeDatabase, insertMilestone, openDatabase } from '../gsd-db.ts';
+import { clearPathCache } from '../paths.ts';
+import { isGhostMilestone } from '../state.ts';
 
 describe('isGhostMilestone phantom queued detection (#3671)', () => {
-  test('isGhostMilestone function exists', () => {
-    assert.match(source, /export function isGhostMilestone\(/,
-      'isGhostMilestone should be exported');
-  });
-
-  test('checks dbRow.status === queued', () => {
-    assert.match(source, /dbRow\.status\s*===\s*['"]queued['"]/,
-      'isGhostMilestone should check dbRow.status === "queued"');
-  });
-
-  test('checks for CONTEXT disk artifact', () => {
-    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']CONTEXT["']\)/,
-      'should check for CONTEXT file');
-  });
-
-  test('checks for ROADMAP disk artifact', () => {
-    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']ROADMAP["']\)/,
-      'should check for ROADMAP file');
-  });
-
-  test('checks for SUMMARY disk artifact', () => {
-    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']SUMMARY["']\)/,
-      'should check for SUMMARY file');
-  });
-
-  test('returns !hasContent for queued rows (ghost if no artifacts)', () => {
-    assert.match(source, /return !hasContent/,
-      'should return !hasContent for queued phantom milestones');
+  test('queued DB row with no artifacts is a ghost, but content makes it real', () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-phantom-ghost-'));
+    try {
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Reserved only', status: 'queued' });
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+
+      assert.equal(isGhostMilestone(base, 'M001'), true);
+
+      writeFileSync(join(base, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md'), '# Context\n');
+      clearPathCache();
+      assert.equal(isGhostMilestone(base, 'M001'), false);
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/phantom-milestone-default-queued.test.ts

@@ -8,32 +8,17 @@
 
 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 dbSrc = readFileSync(
-  join(__dirname, '..', 'gsd-db.ts'),
-  'utf-8',
-);
+import { closeDatabase, getMilestone, insertMilestone, openDatabase } from '../gsd-db.ts';
 
 describe('insertMilestone defaults status to queued (#3695)', () => {
-  test('insertMilestone function exists', () => {
-    assert.match(dbSrc, /export function insertMilestone\(/,
-      'insertMilestone should be exported from gsd-db.ts');
-  });
-
-  test('default status is "queued" not "active"', () => {
-    // The status parameter should default to "queued" via nullish coalescing
-    assert.match(dbSrc, /m\.status\s*\?\?\s*"queued"/,
-      'insertMilestone should default status to "queued"');
-  });
+  test('omitted status persists as queued, not active', () => {
+    try {
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Reserved milestone' });
 
-  test('comment explains the rationale', () => {
-    assert.match(dbSrc, /never auto-create milestones as "active"/i,
-      'should have a comment explaining why default is queued');
+      assert.equal(getMilestone('M001')?.status, 'queued');
+    } finally {
+      closeDatabase();
+    }
   });
 });