gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

package/src/resources/extensions/gsd/tests/originalbase-path-comparison.test.ts

@@ -34,12 +34,43 @@ import {
 } from "../auto-worktree.ts";
 import { normalizeWorktreePathForCompare } from "../worktree-root.ts";
 import {
-  WorktreeResolver,
-  type WorktreeResolverDeps,
+  WorktreeLifecycle,
+  type WorktreeLifecycleDeps,
   type NotifyCtx,
-} from "../worktree-resolver.ts";
+} from "../worktree-lifecycle.ts";
+import { WorktreeStateProjection } from "../worktree-state-projection.ts";
+import { resolveWorktreeProjectRoot } from "../worktree-root.ts";
 import { AutoSession } from "../auto/session.ts";
 
+// Test-local: LegacyTestDeps had three fields Lifecycle does not need
+// (shouldUseWorktreeIsolation, syncWorktreeStateBack, captureIntegrationBranch).
+// Permit them in test fixtures so existing override patterns keep working —
+// Lifecycle ignores the extras via structural typing.
+type LegacyTestDeps = WorktreeLifecycleDeps & {
+  shouldUseWorktreeIsolation?: () => boolean;
+  syncWorktreeStateBack?: (
+    mainBasePath: string,
+    worktreePath: string,
+    milestoneId: string,
+  ) => { synced: string[] };
+  captureIntegrationBranch?: (basePath: string, mid: string | undefined) => void;
+};
+
+/** Shim factory preserving the legacy WorktreeResolver throw shape for tests. */
+function makeResolver(s: AutoSession, deps: LegacyTestDeps) {
+  const lifecycle = new WorktreeLifecycle(s, deps);
+  return {
+    get workPath(): string { return s.basePath; },
+    get projectRoot(): string {
+      return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
+    },
+    mergeAndExit: (mid: string, ctx: NotifyCtx) => {
+      const r = lifecycle.exitMilestone(mid, { merge: true }, ctx);
+      if (!r.ok && r.cause instanceof Error) throw r.cause;
+    },
+  };
+}
+
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function git(args: string[], cwd: string): void {
@@ -69,10 +100,10 @@ function makeSession(overrides?: Partial<{ basePath: string; originalBasePath: s
 
 interface CallLog { fn: string; args: unknown[] }
 
-function makeDeps(overrides?: Partial<WorktreeResolverDeps>): WorktreeResolverDeps & { calls: CallLog[] } {
+function makeDeps(overrides?: Partial<LegacyTestDeps>): LegacyTestDeps & { calls: CallLog[] } {
   const calls: CallLog[] = [];
 
-  const deps: WorktreeResolverDeps & { calls: CallLog[] } = {
+  const deps: LegacyTestDeps & { calls: CallLog[] } = {
     calls,
     isInAutoWorktree: (basePath: string) => {
       calls.push({ fn: "isInAutoWorktree", args: [basePath] });
@@ -110,6 +141,9 @@ function makeDeps(overrides?: Partial<WorktreeResolverDeps>): WorktreeResolverDe
       calls.push({ fn: "getCurrentBranch", args: [basePath] });
       return "main";
     },
+    checkoutBranch: (basePath: string, branch: string) => {
+      calls.push({ fn: "checkoutBranch", args: [basePath, branch] });
+    },
     autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
     resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
       calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
@@ -121,11 +155,12 @@ function makeDeps(overrides?: Partial<WorktreeResolverDeps>): WorktreeResolverDe
     },
     GitServiceImpl: class {
       constructor(_basePath: string, _gitConfig: unknown) {}
-    } as unknown as WorktreeResolverDeps["GitServiceImpl"],
+    } as unknown as LegacyTestDeps["GitServiceImpl"],
     loadEffectiveGSDPreferences: () => ({ preferences: { git: {} } }),
     invalidateAllCaches: () => { calls.push({ fn: "invalidateAllCaches", args: [] }); },
-    captureIntegrationBranch: (_basePath: string, _mid: string) => {},
+    captureIntegrationBranch: (_basePath: string, _mid: string | undefined) => {},
     enterBranchModeForMilestone: (_basePath: string, _milestoneId: string) => {},
+    worktreeProjection: new WorktreeStateProjection(),
     ...overrides,
   };
 
@@ -270,7 +305,7 @@ describe("WorktreeResolver: roadmap-fallback skipped when basePath is same physi
     // Override calls ref so we can inspect it directly
     (deps as unknown as { calls: CallLog[] }).calls = calls;
 
-    const resolver = new WorktreeResolver(s, deps);
+    const resolver = makeResolver(s, deps);
     const ctx = makeNotifyCtx();
 
     // mergeAndExit → _mergeWorktreeMode
@@ -316,7 +351,7 @@ describe("WorktreeResolver: roadmap-fallback skipped when basePath is same physi
     });
     (deps as unknown as { calls: CallLog[] }).calls = calls;
 
-    const resolver = new WorktreeResolver(s, deps);
+    const resolver = makeResolver(s, deps);
     const ctx = makeNotifyCtx();
 
     resolver.mergeAndExit("M002", ctx);

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-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();
+    }
   });
 });