@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.8e6112e9

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -15,12 +15,27 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+/** Create a temp project root with a git repo for phase-function tests. */
+function makeTestBase(prefix: string): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  execFileSync("git", ["init", "--initial-branch=main"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: base, stdio: "ignore" });
+  writeFileSync(join(base, "README.md"), "# test\n");
+  execFileSync("git", ["add", "README.md"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "chore: seed"], { cwd: base, stdio: "ignore" });
+  return base;
+}
+
 import type { JournalEntry } from "../journal.js";
 import type { LoopDeps } from "../auto/loop-deps.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import type { IterationContext, LoopState, PreDispatchData, IterationData } from "../auto/types.js";
 import type { SessionLockStatus } from "../session-lock.js";
-import { runDispatch, runUnitPhase, runPreDispatch, runFinalize } from "../auto/phases.js";
+import { runDispatch } from "../auto/dispatch.js";
+import { runUnitPhase } from "../auto/unit-phase.js";
+import { runPreDispatch } from "../auto/pre-dispatch.js";
+import { runFinalize } from "../auto/finalize.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
 import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import {
@@ -182,7 +197,7 @@ function makeSession() {
     verbose: false,
     stepMode: false,
     paused: false,
-    basePath: "/tmp/project",
+    basePath: makeTestBase("gsd-journal-session-"),
     originalBasePath: "",
     currentMilestoneId: "M001",
     currentUnit: null,
@@ -296,10 +311,18 @@ test("runDispatch emits dispatch-stop when dispatch returns stop action", async
   assert.equal(stopEvents[0].flowId, ic.flowId);
 });
 
-test("runDispatch checks prior-slice completion against the project root in worktree mode", async () => {
+test("runDispatch checks prior-slice completion against the project root in worktree mode", async (t) => {
   const capture = createEventCapture();
   const guardCalls: Array<{ fn: string; args: unknown[] }> = [];
+  const projectRoot = makeTestBase("gsd-wt-prior-slice-");
+  const milestoneId = "M029-xoklo9";
+  const worktreeRoot = join(projectRoot, ".gsd", "worktrees", milestoneId);
+  execFileSync("git", ["worktree", "add", "-b", `auto/${milestoneId}`, worktreeRoot], { cwd: projectRoot, stdio: "ignore" });
+  t.after(() => rmSync(projectRoot, { recursive: true, force: true }));
+
   const deps = makeMockDeps(capture, {
+    getIsolationMode: () => "worktree",
+    autoWorktreeBranch: (mid: string) => `auto/${mid}`,
     getMainBranch: (basePath: string) => {
       guardCalls.push({ fn: "getMainBranch", args: [basePath] });
       return "main";
@@ -320,19 +343,21 @@ test("runDispatch checks prior-slice completion against the project root in work
   const ic = makeIC(deps, {
     s: {
       ...makeSession(),
-      basePath: "/tmp/project/.gsd/worktrees/M029-xoklo9",
-      originalBasePath: "/tmp/project",
+      basePath: worktreeRoot,
+      originalBasePath: projectRoot,
+      canonicalProjectRoot: projectRoot,
+      currentMilestoneId: milestoneId,
     } as any,
   });
   const preData: PreDispatchData = {
     state: {
       phase: "executing",
-      activeMilestone: { id: "M029-xoklo9", title: "Test", status: "active" },
+      activeMilestone: { id: milestoneId, title: "Test", status: "active" },
       activeSlice: { id: "S01", title: "Slice 1" },
-      registry: [{ id: "M029-xoklo9", status: "active" }],
+      registry: [{ id: milestoneId, status: "active" }],
       blockers: [],
     } as any,
-    mid: "M029-xoklo9",
+    mid: milestoneId,
     midTitle: "Test Milestone",
   };
 
@@ -342,12 +367,12 @@ test("runDispatch checks prior-slice completion against the project root in work
     consecutiveFinalizeTimeouts: 0,
   });
 
-  assert.equal(result.action, "next");
+  assert.equal(result.action, "next", "dispatch must proceed under worktree isolation");
   assert.deepEqual(guardCalls, [
-    { fn: "getMainBranch", args: ["/tmp/project"] },
+    { fn: "getMainBranch", args: [projectRoot] },
     {
       fn: "getPriorSliceCompletionBlocker",
-      args: ["/tmp/project", "main", "execute-task", "M001/S01/T01"],
+      args: [projectRoot, "main", "execute-task", "M001/S01/T01"],
     },
   ]);
 });
@@ -434,6 +459,9 @@ test("runDispatch pauses when execute-task artifacts exist but DB status is stil
   const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
   const tasksDir = join(sliceDir, "tasks");
   mkdirSync(tasksDir, { recursive: true });
+  execFileSync("git", ["init", "--initial-branch=main"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: base, stdio: "ignore" });
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
@@ -517,6 +545,9 @@ test("runDispatch pauses at Level 2 when execute-task artifacts exist but DB sta
   const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
   const tasksDir = join(sliceDir, "tasks");
   mkdirSync(tasksDir, { recursive: true });
+  execFileSync("git", ["init", "--initial-branch=main"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: base, stdio: "ignore" });
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
@@ -888,7 +919,7 @@ test("runUnitPhase increments unitDispatchCount for repeated artifact-missing re
 
 test("runUnitPhase pre-dispatch model validation failures do not emit unit-start or dispatch runtime state", async (t) => {
   const capture = createEventCapture();
-  const base = mkdtempSync(join(tmpdir(), `gsd-pre-dispatch-block-${randomUUID()}`));
+  const base = makeTestBase(`gsd-pre-dispatch-block-${randomUUID()}`);
   t.after(() => rmSync(base, { recursive: true, force: true }));
 
   const deps = makeMockDeps(capture, {
@@ -1084,7 +1115,7 @@ test("terminal event is emitted on blocked state", async () => {
 });
 
 test("#4671: plan-v2 missing CONTEXT.md reaches dispatch recovery instead of pausing", async () => {
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-4671-predispatch-"));
+  const basePath = makeTestBase("gsd-4671-predispatch-");
   mkdirSync(join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
   openDatabase(join(basePath, ".gsd", "gsd.db"));
   try {
@@ -1141,7 +1172,7 @@ test("#4671: plan-v2 missing CONTEXT.md reaches dispatch recovery instead of pau
 });
 
 test("plan-v2 empty graph rederives state before pausing", async () => {
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-plan-v2-empty-graph-"));
+  const basePath = makeTestBase("gsd-plan-v2-empty-graph-");
   mkdirSync(join(basePath, ".gsd", "milestones", "M001"), { recursive: true });
   writeFileSync(
     join(basePath, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
@@ -1204,7 +1235,7 @@ test("plan-v2 empty graph rederives state before pausing", async () => {
 });
 
 test("plan-v2 empty graph pauses after one failed rederive", async () => {
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-plan-v2-empty-graph-pause-"));
+  const basePath = makeTestBase("gsd-plan-v2-empty-graph-pause-");
   mkdirSync(join(basePath, ".gsd", "milestones", "M001"), { recursive: true });
   writeFileSync(
     join(basePath, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
@@ -1394,7 +1425,7 @@ test("session-failed cancellations close out and emit unit-end before hard stop"
 test("runFinalize pauses and emits unit-end when pre-verification times out", async () => {
   const capture = createEventCapture();
   let pauseCalls = 0;
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-finalize-timeout-"));
+  const basePath = makeTestBase("gsd-finalize-timeout-");
 
   const deps = makeMockDeps(capture, {
     pauseAuto: async () => { pauseCalls++; },

package/src/resources/extensions/gsd/tests/mcp-project-config.test.ts

@@ -60,7 +60,9 @@ test("ensureProjectWorkflowMcpConfig creates .mcp.json with workflow and browser
     assert.equal(typeof browserArgs[mcpArgIndex + 6], "string");
     assert.ok((browserArgs[mcpArgIndex + 6] ?? "").length > 0, "identity-key must be non-empty");
     assert.equal(browserArgs[mcpArgIndex + 7], "--identity-project");
-    assert.equal(browserArgs[mcpArgIndex + 8], projectRoot);
+    assert.equal(typeof browserArgs[mcpArgIndex + 8], "string");
+    assert.ok((browserArgs[mcpArgIndex + 8] ?? "").length > 0, "identity-project must be non-empty");
+    assert.doesNotMatch(browserArgs[mcpArgIndex + 8] ?? "", /[\\/]/, "identity-project must not be a filesystem path");
     assert.equal((browserServer as { cwd?: string })?.cwd, projectRoot);
 
     const settings = JSON.parse(readFileSync(join(projectRoot, ".claude", "settings.local.json"), "utf-8")) as {

package/src/resources/extensions/gsd/tests/mcp-readiness-preflight.test.ts

@@ -0,0 +1,205 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for the MCP readiness preflight gate in dispatchWorkflow.
+
+import { describe, test, mock } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { _awaitWorkflowMcpReadinessForTest as awaitWorkflowMcpReadiness } from "../guided-flow.ts";
+import { clearMcpConfigCache } from "../../mcp-client/manager.ts";
+import { clearWorkflowMcpProbeCache } from "../workflow-mcp-readiness-cache.ts";
+
+function makeCtx(opts: { authMode?: string; baseUrl?: string; systemPrompt?: string } = {}) {
+  const { authMode = "externalCli", baseUrl = "local://pipe", systemPrompt = "" } = opts;
+  return {
+    model: { provider: "anthropic", baseUrl },
+    modelRegistry: {
+      getProviderAuthMode: mock.fn(() => authMode),
+    },
+    getSystemPrompt: mock.fn(() => systemPrompt),
+    ui: {
+      setStatus: mock.fn(),
+      notify: mock.fn(),
+    },
+  } as any;
+}
+
+function makePi(tools: string[] | (() => string[])) {
+  const getTools = typeof tools === "function" ? tools : () => tools;
+  return {
+    getActiveTools: getTools,
+    getAllTools: () => getTools().map((name: string) => ({ name })),
+  } as any;
+}
+
+describe("awaitWorkflowMcpReadiness", () => {
+  test("returns null (ready) when not using MCP transport", async () => {
+    clearWorkflowMcpProbeCache();
+    const ctx = makeCtx({ authMode: "native", baseUrl: "https://api.anthropic.com" });
+    const pi = makePi([]);
+    assert.equal(await awaitWorkflowMcpReadiness(pi, ctx, "/fake/path"), null);
+  });
+
+  test("returns null (ready) when provider has no auth mode", async () => {
+    const ctx = {
+      model: undefined,
+      modelRegistry: { getProviderAuthMode: mock.fn(() => undefined) },
+      ui: { setStatus: mock.fn(), notify: mock.fn() },
+    } as any;
+    const pi = makePi([]);
+    assert.equal(await awaitWorkflowMcpReadiness(pi, ctx, "/fake/path"), null);
+  });
+
+  test("returns null (ready) when MCP tools are already registered", async () => {
+    const ctx = makeCtx();
+    const pi = makePi(["read", "bash", "mcp__gsd-workflow__ask_user_questions", "mcp__gsd-workflow__gsd_plan_slice"]);
+    assert.equal(await awaitWorkflowMcpReadiness(pi, ctx, "/fake/path"), null);
+  });
+
+  test("returns null (ready) when host system prompt advertises workflow MCP tools", async () => {
+    const originalCommand = process.env.GSD_WORKFLOW_MCP_COMMAND;
+    const ctx = makeCtx({
+      systemPrompt: "Available tools: read, bash, mcp__gsd-workflow__ask_user_questions",
+    });
+    const pi = makePi(["read", "bash"]);
+    try {
+      process.env.GSD_WORKFLOW_MCP_COMMAND = "node";
+      assert.equal(await awaitWorkflowMcpReadiness(pi, ctx, "/fake/path"), null);
+    } finally {
+      if (originalCommand === undefined) {
+        delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+      } else {
+        process.env.GSD_WORKFLOW_MCP_COMMAND = originalCommand;
+      }
+    }
+  });
+
+  test("treats a successful direct probe as readiness when session tools are absent", async () => {
+    const previousGsdHome = process.env.GSD_HOME;
+    const projectDir = mkdtempSync(join(tmpdir(), "gsd-guided-mcp-probe-project-"));
+    const gsdHomeDir = mkdtempSync(join(tmpdir(), "gsd-guided-mcp-probe-home-"));
+    try {
+      process.env.GSD_HOME = gsdHomeDir;
+      mkdirSync(join(projectDir, ".gsd"), { recursive: true });
+
+      const require = createRequire(import.meta.url);
+      const mcpModuleUrl = pathToFileURL(require.resolve("@modelcontextprotocol/sdk/server/mcp.js")).href;
+      const stdioModuleUrl = pathToFileURL(require.resolve("@modelcontextprotocol/sdk/server/stdio.js")).href;
+      const serverPath = join(projectDir, "fake-workflow-mcp-server.mjs");
+      writeFileSync(
+        serverPath,
+        [
+          `const { McpServer } = await import(${JSON.stringify(mcpModuleUrl)});`,
+          `const { StdioServerTransport } = await import(${JSON.stringify(stdioModuleUrl)});`,
+          'const server = new McpServer({ name: "fake", version: "1.0.0" }, { capabilities: { tools: {} } });',
+          'server.tool("gsd_status", "Probe-visible workflow tool", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
+          'await server.connect(new StdioServerTransport());',
+        ].join("\n"),
+        "utf-8",
+      );
+      writeFileSync(
+        join(projectDir, ".mcp.json"),
+        JSON.stringify({ mcpServers: { "gsd-workflow": { command: process.execPath, args: [serverPath] } } }),
+        "utf-8",
+      );
+
+      const ctx = makeCtx();
+      const pi = makePi(["read", "bash"]);
+
+      assert.equal(
+        await awaitWorkflowMcpReadiness(pi, ctx, projectDir, { timeoutMs: 15_000, pollMs: 100 }),
+        null,
+      );
+    } finally {
+      if (previousGsdHome === undefined) {
+        delete process.env.GSD_HOME;
+      } else {
+        process.env.GSD_HOME = previousGsdHome;
+      }
+      rmSync(projectDir, { recursive: true, force: true });
+      rmSync(gsdHomeDir, { recursive: true, force: true });
+      clearMcpConfigCache();
+    }
+  });
+
+  test("returns server and probe error when workflow MCP never becomes ready", async () => {
+    const originalCommand = process.env.GSD_WORKFLOW_MCP_COMMAND;
+    const ctx = makeCtx();
+    const pi = makePi(["read", "bash"]);
+    try {
+      process.env.GSD_WORKFLOW_MCP_COMMAND = "node";
+      const failure = await awaitWorkflowMcpReadiness(pi, ctx, "/fake/path", {
+        timeoutMs: 5,
+        pollMs: 1,
+        probe: async () => ({
+          ok: false,
+          tools: [],
+          serverName: "gsd-workflow",
+          error: "connection refused",
+        }),
+      });
+      assert.deepEqual(failure, { server: "gsd-workflow", error: "connection refused" });
+      assert.ok(ctx.ui.setStatus.mock.calls.length >= 2);
+    } finally {
+      if (originalCommand === undefined) {
+        delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+      } else {
+        process.env.GSD_WORKFLOW_MCP_COMMAND = originalCommand;
+      }
+    }
+  });
+
+  test("returns null (ready) when MCP tools appear during polling", async () => {
+    const ctx = makeCtx();
+    let callCount = 0;
+    const pi = makePi(() => {
+      callCount++;
+      if (callCount >= 3) return ["mcp__gsd-workflow__gsd_plan_slice"];
+      return ["read", "bash"];
+    });
+    assert.equal(await awaitWorkflowMcpReadiness(pi, ctx, "/fake/path"), null);
+    assert.ok(callCount >= 3, `expected at least 3 tool-check calls, got ${callCount}`);
+    assert.ok(ctx.ui.setStatus.mock.calls.length >= 2);
+  });
+
+  test("requires the active unit's workflow tools, not just any MCP workflow tool", async () => {
+    const originalCommand = process.env.GSD_WORKFLOW_MCP_COMMAND;
+    const ctx = makeCtx();
+    const pi = makePi(["read", "bash", "mcp__gsd-workflow__gsd_slice_complete"]);
+    try {
+      process.env.GSD_WORKFLOW_MCP_COMMAND = "node";
+      const failure = await awaitWorkflowMcpReadiness(pi, ctx, "/fake/path", {
+        unitType: "complete-slice",
+        timeoutMs: 5,
+        pollMs: 1,
+        probe: async () => ({
+          ok: true,
+          tools: ["gsd_slice_complete"],
+          serverName: "gsd-workflow",
+        }),
+      });
+
+      assert.deepEqual(failure, { server: "gsd-workflow" });
+    } finally {
+      if (originalCommand === undefined) {
+        delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+      } else {
+        process.env.GSD_WORKFLOW_MCP_COMMAND = originalCommand;
+      }
+    }
+  });
+
+  test("returns null when no launch config is discoverable", async () => {
+    const ctx = makeCtx();
+    const pi = makePi(["read", "bash"]);
+    const launch = (await import("../workflow-mcp.js")).detectWorkflowMcpLaunchConfig(process.cwd());
+    if (!launch) {
+      assert.equal(await awaitWorkflowMcpReadiness(pi, ctx, process.cwd()), null);
+    }
+    // When launch config IS found, the function would timeout (15s) — skip that path in tests.
+  });
+});

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

@@ -58,13 +58,14 @@ describe("formatMcpStatusReport", () => {
     assert.match(result, /disabled/i);
   });
 
-  test("shows available state for servers that pass a status probe", () => {
+  test("labels probe-only availability separately from live connections", () => {
     const servers: McpServerStatus[] = [
       { name: "gsd-workflow", transport: "stdio", connected: false, available: true, toolCount: 62, error: undefined },
     ];
     const result = formatMcpStatusReport(servers);
     assert.match(result, /gsd-workflow/);
-    assert.match(result, /available — 62 tools/);
+    assert.match(result, /probe available — 62 tools/);
+    assert.doesNotMatch(result, /connected — 62 tools/);
     assert.doesNotMatch(result, /disconnected/);
   });
 
@@ -132,7 +133,7 @@ describe("formatMcpServerDetail", () => {
     assert.match(result, /disconnected/i);
   });
 
-  test("shows available status with tool names", () => {
+  test("shows probe-available status with tool names", () => {
     const result = formatMcpServerDetail({
       name: "gsd-workflow",
       transport: "stdio",
@@ -142,7 +143,7 @@ describe("formatMcpServerDetail", () => {
       tools: ["gsd_milestone_status"],
       error: undefined,
     });
-    assert.match(result, /available/i);
+    assert.match(result, /probe available/i);
     assert.match(result, /gsd_milestone_status/);
   });
 
@@ -206,7 +207,7 @@ describe("handleMcpStatus", () => {
       await handleMcpStatus("status", ctx as unknown as ExtensionCommandContext);
 
       assert.match(message, /gsd-workflow/);
-      assert.match(message, /available — 1 tools/);
+      assert.match(message, /probe available — 1 tools/);
       assert.doesNotMatch(message, /disconnected/);
     } finally {
       process.chdir(originalCwd);

package/src/resources/extensions/gsd/tests/mcp-tool-name.test.ts

@@ -0,0 +1,34 @@
+// Project/App: gsd-pi
+// File Purpose: Regression coverage for shared MCP tool-name parsing helpers.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  mcpToolMatchesBaseName,
+  parseMcpToolName,
+  stripMcpToolPrefix,
+  toMcpToolName,
+  toMcpWildcardToolName,
+} from "../mcp-tool-name.ts";
+
+test("parseMcpToolName parses exact and wildcard MCP tool names", () => {
+  assert.deepEqual(parseMcpToolName("mcp__gsd-workflow__ask_user_questions"), {
+    serverName: "gsd-workflow",
+    toolName: "ask_user_questions",
+  });
+  assert.deepEqual(parseMcpToolName("mcp__gsd-browser__*"), {
+    serverName: "gsd-browser",
+    toolName: "*",
+  });
+  assert.equal(parseMcpToolName("browser_navigate"), null);
+});
+
+test("MCP tool-name helpers strip, match, and format names consistently", () => {
+  assert.equal(stripMcpToolPrefix("mcp__custom-workflow__gsd_exec"), "gsd_exec");
+  assert.equal(stripMcpToolPrefix("read"), "read");
+  assert.equal(mcpToolMatchesBaseName("mcp__custom-workflow__gsd_exec", "gsd_exec"), true);
+  assert.equal(mcpToolMatchesBaseName("mcp__custom-workflow__gsd_exec", "gsd_summary_save"), false);
+  assert.equal(toMcpToolName("custom-workflow", "gsd_exec"), "mcp__custom-workflow__gsd_exec");
+  assert.equal(toMcpWildcardToolName("custom-workflow"), "mcp__custom-workflow__*");
+});

package/src/resources/extensions/gsd/tests/migration-auto-check.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { createRequire } from "node:module";
-import { copyFileSync, mkdtempSync, renameSync, rmSync } from "node:fs";
+import { copyFileSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
@@ -287,3 +287,145 @@ test("migration auto-check refreshes a stale open DB handle before comparing", a
     cleanup(base);
   }
 });
+
+function writeScratchMilestoneDir(base: string, milestoneId: string, file?: string): void {
+  const dir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(dir, { recursive: true });
+  if (file) writeFileSync(join(dir, file), `# ${milestoneId} discussion context\n`);
+}
+
+test("migration auto-check ignores discussion-scratch milestone dirs (CONTEXT only, no DB row)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Legacy Slice", status: "pending", risk: "medium", depends: [], demo: "Legacy slice demo", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Legacy Task", status: "pending" });
+
+    // Mid-discussion artifacts: dirs with no ROADMAP and no DB row. The queued
+    // DB row is only inserted at discussion handoff, so these are expected to
+    // be DB-less — not drift, and recover must not be recommended (it would
+    // import them as ghost active milestones).
+    writeScratchMilestoneDir(base, "M002", "M002-CONTEXT.md");
+    writeScratchMilestoneDir(base, "M003", "M003-CONTEXT-DRAFT.md");
+    writeScratchMilestoneDir(base, "M004"); // empty dir
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check stays quiet mid-first-discussion (scratch dir over empty DB)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    writeScratchMilestoneDir(base, "M001", "M001-CONTEXT.md");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "no-markdown");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check still reports real drift with scratch dirs excluded from counts", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01, DB empty
+    assert.equal(await ensureDbOpen(base), true);
+    writeScratchMilestoneDir(base, "M002", "M002-CONTEXT.md");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "recovery-required");
+    assert.equal(result.reason, "db-empty");
+    assert.equal(result.recoveryCommand, "/gsd recover --confirm");
+    // The scratch dir must not inflate the reported markdown count.
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check still compares a roadmapless milestone that HAS a DB row", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    // Post-handoff queued milestone: CONTEXT-only dir WITH a DB row. It must
+    // stay in the comparison (both sides have it → in-sync).
+    insertMilestone({ id: "M001", title: "M001", status: "queued" });
+    writeScratchMilestoneDir(base, "M001", "M001-CONTEXT.md");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 0, tasks: 0 });
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("rebuildMarkdownProjectionsFromDb realigns markdown when DB holds extra rows", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Legacy Slice",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+      demo: "Legacy slice demo",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Legacy Task",
+      status: "pending",
+    });
+    insertSlice({
+      id: "S02",
+      milestoneId: "M001",
+      title: "Added in DB",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+      demo: "d",
+      sequence: 2,
+    });
+    insertTask({
+      id: "T02",
+      sliceId: "S02",
+      milestoneId: "M001",
+      title: "Added task",
+      status: "pending",
+    });
+
+    const before = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(before.recoveryCommand, "/gsd rebuild markdown");
+
+    const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.ts");
+    const rebuild = await rebuildMarkdownProjectionsFromDb(base);
+    assert.ok(rebuild.rendered > 0, "expected markdown projections to render");
+
+    const after = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(after.action, "none");
+    assert.equal(after.reason, "in-sync");
+    assert.deepEqual(after.markdown, { milestones: 1, slices: 2, tasks: 2 });
+    assert.deepEqual(after.beforeDb, { milestones: 1, slices: 2, tasks: 2 });
+  } finally {
+    cleanup(base);
+  }
+});