gsd-pi 2.82.0-dev.2841a1e44 → 2.82.0-dev.3709f22a5

package/src/resources/extensions/gsd/tests/guided-flow-session-isolation.test.ts

@@ -21,6 +21,15 @@ import {
   checkAutoStartAfterDiscuss,
 } from "../guided-flow.ts";
 
+function pendingInput(basePath: string, milestoneId: string) {
+  return {
+    basePath,
+    milestoneId,
+    ctx: { ui: { notify: () => undefined } } as any,
+    pi: { setActiveTools: () => undefined, getActiveTools: () => [] } as any,
+  };
+}
+
 // ─── Tests ─────────────────────────────────────────────────────────────────
 
 describe("#2985 Bug 3 — concurrent discuss sessions must be independent", () => {
@@ -34,13 +43,11 @@ describe("#2985 Bug 3 — concurrent discuss sessions must be independent", () =
     const projectB = "/projects/beta";
 
     setPendingAutoStart(projectA, {
-      basePath: projectA,
-      milestoneId: "M001-aaa111",
+      ...pendingInput(projectA, "M001-aaa111"),
     });
 
     setPendingAutoStart(projectB, {
-      basePath: projectB,
-      milestoneId: "M002-bbb222",
+      ...pendingInput(projectB, "M002-bbb222"),
     });
 
     // Both sessions should be retrievable
@@ -55,8 +62,8 @@ describe("#2985 Bug 3 — concurrent discuss sessions must be independent", () =
     const projectA = "/projects/alpha";
     const projectB = "/projects/beta";
 
-    setPendingAutoStart(projectA, { basePath: projectA, milestoneId: "M001-aaa111" });
-    setPendingAutoStart(projectB, { basePath: projectB, milestoneId: "M002-bbb222" });
+    setPendingAutoStart(projectA, pendingInput(projectA, "M001-aaa111"));
+    setPendingAutoStart(projectB, pendingInput(projectB, "M002-bbb222"));
 
     // Clear only projectA
     clearPendingAutoStart(projectA);
@@ -72,8 +79,8 @@ describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", (
   });
 
   test("getDiscussionMilestoneId(basePath) returns correct milestone for each project", () => {
-    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
-    setPendingAutoStart("/proj/b", { basePath: "/proj/b", milestoneId: "M002" });
+    setPendingAutoStart("/proj/a", pendingInput("/proj/a", "M001"));
+    setPendingAutoStart("/proj/b", pendingInput("/proj/b", "M002"));
 
     assert.equal(getDiscussionMilestoneId("/proj/a"), "M001");
     assert.equal(getDiscussionMilestoneId("/proj/b"), "M002");
@@ -81,8 +88,8 @@ describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", (
   });
 
   test("getDiscussionMilestoneId() without basePath returns null when multiple sessions exist", () => {
-    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
-    setPendingAutoStart("/proj/b", { basePath: "/proj/b", milestoneId: "M002" });
+    setPendingAutoStart("/proj/a", pendingInput("/proj/a", "M001"));
+    setPendingAutoStart("/proj/b", pendingInput("/proj/b", "M002"));
 
     // Without a key, the function should not blindly return the first entry
     const result = getDiscussionMilestoneId();
@@ -92,7 +99,7 @@ describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", (
   });
 
   test("getDiscussionMilestoneId() without basePath returns the milestone when only one session", () => {
-    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
+    setPendingAutoStart("/proj/a", pendingInput("/proj/a", "M001"));
 
     // With only one session, backward compat — return it
     const result = getDiscussionMilestoneId();
@@ -129,3 +136,44 @@ test("checkAutoStartAfterDiscuss ignores missing manifest for single-milestone d
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("checkAutoStartAfterDiscuss(basePath) selects the matching pending entry when multiple sessions exist", () => {
+  const projectA = mkdtempSync(join(tmpdir(), "gsd-auto-start-project-a-"));
+  const projectB = mkdtempSync(join(tmpdir(), "gsd-auto-start-project-b-"));
+
+  function writeReadyArtifacts(base: string, milestoneId: string): void {
+    const gsdDir = join(base, ".gsd");
+    const milestoneDir = join(gsdDir, "milestones", milestoneId);
+    mkdirSync(milestoneDir, { recursive: true });
+    writeFileSync(join(gsdDir, "PROJECT.md"), `# Project\n\n| ${milestoneId} | Milestone | active |\n`);
+    writeFileSync(join(gsdDir, "STATE.md"), "# State\n");
+    writeFileSync(join(milestoneDir, `${milestoneId}-CONTEXT.md`), "# Context\n");
+  }
+
+  try {
+    clearPendingAutoStart();
+    writeReadyArtifacts(projectA, "M001");
+    writeReadyArtifacts(projectB, "M002");
+    setPendingAutoStart(projectA, {
+      basePath: projectA,
+      milestoneId: "M001",
+      ctx: { ui: { notify: () => undefined } } as any,
+      pi: { setActiveTools: () => undefined, getActiveTools: () => [] } as any,
+    });
+    setPendingAutoStart(projectB, {
+      basePath: projectB,
+      milestoneId: "M002",
+      ctx: { ui: { notify: () => undefined } } as any,
+      pi: { setActiveTools: () => undefined, getActiveTools: () => [] } as any,
+    });
+
+    assert.equal(checkAutoStartAfterDiscuss(), false, "ambiguous pending sessions should not auto-start");
+    assert.equal(checkAutoStartAfterDiscuss(projectB), true, "explicit basePath should select projectB");
+    assert.equal(getDiscussionMilestoneId(projectA), "M001", "projectA should remain pending");
+    assert.equal(getDiscussionMilestoneId(projectB), null, "projectB should be cleared after start");
+  } finally {
+    clearPendingAutoStart();
+    rmSync(projectA, { recursive: true, force: true });
+    rmSync(projectB, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-flow.test.ts

@@ -0,0 +1,21 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+test("guided milestone discussion callsites pass workingDirectory to loadPrompt", () => {
+  const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+  const calls = [...source.matchAll(/loadPrompt\("guided-discuss-milestone",\s*\{([\s\S]*?)\}\)/g)];
+
+  assert.equal(calls.length, 6, "all guided-flow guided-discuss-milestone callsites should be covered");
+  for (const call of calls) {
+    assert.match(
+      call[1] ?? "",
+      /\bworkingDirectory:\s*basePath\b/,
+      "guided-discuss-milestone prompts need workingDirectory so template validation does not crash",
+    );
+  }
+});

package/src/resources/extensions/gsd/tests/guided-tool-contract.test.ts

@@ -0,0 +1,65 @@
+// GSD-2 — Guided Unit Tool Contract tests.
+// Verifies guided workflow turns use manifest tool policy without auto-mode state.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import {
+  clearGuidedUnitContext,
+  getGuidedUnitContext,
+  setGuidedUnitContext,
+} from "../guided-unit-context.ts";
+
+test("guided Unit context applies Tool Contract policy when auto-mode has no current Unit", async () => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-guided-tool-contract-"));
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  };
+
+  try {
+    clearGuidedUnitContext();
+    registerHooks(pi as any, []);
+    setGuidedUnitContext(basePath, "plan-slice");
+
+    let blockResult: { block?: boolean; reason?: string } | undefined;
+    for (const handler of handlers.get("tool_call") ?? []) {
+      const result = await handler({
+        toolName: "edit",
+        input: {
+          path: join(basePath, "src", "main.ts"),
+        },
+      }, { cwd: basePath });
+      if (result?.block) {
+        blockResult = result;
+        break;
+      }
+    }
+
+    assert.equal(blockResult?.block, true);
+    assert.match(blockResult?.reason ?? "", /plan-slice|ToolsPolicy|not allowed|blocked/i);
+  } finally {
+    clearGuidedUnitContext();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("guided Unit context can be cleared by project root", () => {
+  clearGuidedUnitContext();
+  setGuidedUnitContext("/project/a", "plan-slice");
+  setGuidedUnitContext("/project/b", "complete-slice");
+
+  clearGuidedUnitContext("/project/a");
+
+  assert.equal(getGuidedUnitContext("/project/a"), null);
+  assert.equal(getGuidedUnitContext("/project/b")?.unitType, "complete-slice");
+  clearGuidedUnitContext();
+});

package/src/resources/extensions/gsd/tests/headless-milestone-parity.test.ts

@@ -45,7 +45,7 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
 
     // Match only the actual dispatchWorkflow call — comments in the body
     // may mention "plan-milestone" as part of the fix rationale.
-    const dispatchMatches = [...fnBody.matchAll(/dispatchWorkflow\([^)]*,\s*"([^"]+)"\s*\)/g)];
+    const dispatchMatches = [...fnBody.matchAll(/dispatchWorkflow\([\s\S]*?,\s*"([^"]+)"\s*,\s*\{\s*basePath\s*\}\s*\)/g)];
     assert.strictEqual(
       dispatchMatches.length,
       1,
@@ -65,15 +65,15 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
       /### Ready-phrase pre-condition \(NON-BYPASSABLE\)/.test(section),
       "single-milestone ready-phrase section must be present",
     );
-    // All four required artifacts must appear as checkboxes, not a prose list.
+    // All four required outcomes must appear as checkboxes, not a prose list.
     for (const artifact of [
-      "`.gsd/PROJECT.md`",
-      "`.gsd/REQUIREMENTS.md`",
+      "PROJECT artifact",
+      "REQUIREMENTS artifact",
       "`{{contextPath}}`",
       "`gsd_plan_milestone`",
     ]) {
       assert.ok(
-        new RegExp(`- \\[ \\] [A-Za-z]+ ${artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(section),
+        new RegExp(`- \\[ \\] [^\\n]*${artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(section),
         `single-milestone pre-condition must include a checkbox for ${artifact}`,
       );
     }
@@ -103,8 +103,8 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
       "multi-milestone ready-phrase section must be present",
     );
     for (const artifact of [
-      "`.gsd/PROJECT.md`",
-      "`.gsd/REQUIREMENTS.md`",
+      "PROJECT artifact",
+      "REQUIREMENTS artifact",
       "`gsd_plan_milestone`",
       "`.gsd/DISCUSSION-MANIFEST.json`",
     ]) {

package/src/resources/extensions/gsd/tests/hook-model-resolution.test.ts

@@ -92,6 +92,11 @@ test("resolveModelId: returns undefined for unknown model", () => {
   assert.equal(match, undefined);
 });
 
+test("resolveModelId: returns undefined for missing model ID", () => {
+  const match = resolveModelId(undefined, AVAILABLE_MODELS, "anthropic");
+  assert.equal(match, undefined);
+});
+
 test("resolveModelId: returns undefined for unknown provider/model combo", () => {
   const match = resolveModelId("fakeprovider/fake-model", AVAILABLE_MODELS, undefined);
   assert.equal(match, undefined);

package/src/resources/extensions/gsd/tests/infra-error.test.ts

@@ -9,11 +9,11 @@ import { isInfrastructureError, INFRA_ERROR_CODES } from "../auto/infra-errors.j
 test("INFRA_ERROR_CODES contains the expected codes", () => {
   for (const code of [
     "ENOSPC", "ENOMEM", "EROFS", "EDQUOT", "EMFILE", "ENFILE",
-    "EAGAIN", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
+    "EAGAIN", "ENOBUFS", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
   ]) {
     assert.ok(INFRA_ERROR_CODES.has(code), `missing ${code}`);
   }
-  assert.equal(INFRA_ERROR_CODES.size, 10, "unexpected extra codes");
+  assert.equal(INFRA_ERROR_CODES.size, 11, "unexpected extra codes");
 });
 
 // ── isInfrastructureError: code property detection ───────────────────────────

package/src/resources/extensions/gsd/tests/infra-errors-cooldown.test.ts

@@ -5,6 +5,8 @@ import test, { describe } from "node:test";
 import assert from "node:assert/strict";
 
 import {
+  INFRA_ERROR_CODES,
+  isInfrastructureError,
   isTransientCooldownError,
   getCooldownRetryAfterMs,
   MAX_COOLDOWN_RETRIES,
@@ -13,6 +15,13 @@ import {
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 
+describe("infra error classification", () => {
+  test("ENOBUFS is treated as infrastructure exhaustion", () => {
+    assert.equal(INFRA_ERROR_CODES.has("ENOBUFS"), true);
+    assert.equal(isInfrastructureError(Object.assign(new Error("spawnSync git ENOBUFS"), { code: "ENOBUFS" })), "ENOBUFS");
+  });
+});
+
 describe("infra-errors cooldown constants", () => {
   test("COOLDOWN_FALLBACK_WAIT_MS is a positive number greater than the 30s rate-limit backoff", () => {
     assert.ok(typeof COOLDOWN_FALLBACK_WAIT_MS === "number");

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

@@ -446,6 +446,26 @@ node_modules/
       const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
       assert.deepStrictEqual(strandedIssues.length, 0, "live lock holder: stranded_lock_directory NOT detected");
     });
+
+    test('stranded_lock_directory still reports when worker lookup fails', async () => {
+      const dir = createMinimalProject();
+      cleanups.push(dir);
+
+      const lockDir = join(dir, ".gsd.lock");
+      mkdirSync(lockDir, { recursive: true });
+      const { openDatabase, _getAdapter, closeDatabase } = await import("../../gsd-db.ts");
+      openDatabase(join(dir, ".gsd", "gsd.db"));
+      const db = _getAdapter()!;
+      db.exec("DROP TABLE workers");
+
+      try {
+        const detect = await runGSDDoctor(dir);
+        const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
+        assert.ok(strandedIssues.length > 0, "reports stranded lock directory even when active worker lookup fails");
+      } finally {
+        closeDatabase();
+      }
+    });
     } else {
     }
 

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

@@ -5,7 +5,7 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, symlinkSync, readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 
 import {
   inferCommitType,
@@ -371,6 +371,18 @@ describe('git-service', async () => {
     return dir;
   }
 
+  function gitRun(args: string[], cwd: string): string {
+    return execFileSync("git", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: {
+        ...process.env,
+        GIT_ALLOW_PROTOCOL: "file",
+      },
+    }).trim();
+  }
+
   // ─── GitServiceImpl: smart staging ─────────────────────────────────────
 
   test('GitServiceImpl: smart staging', () => {
@@ -413,6 +425,96 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('GitServiceImpl: task autoCommit skips keyFiles inside submodules', () => {
+    const repo = initTempRepo();
+    const subSrc = mkdtempSync(join(tmpdir(), "gsd-git-submodule-src-"));
+
+    try {
+      gitRun(["init", "-b", "main"], subSrc);
+      gitRun(["config", "user.name", "Pi Test"], subSrc);
+      gitRun(["config", "user.email", "pi@example.com"], subSrc);
+      createFile(subSrc, "tracked.txt", "initial\n");
+      gitRun(["add", "-A"], subSrc);
+      gitRun(["commit", "-m", "init submodule"], subSrc);
+
+      gitRun(["-c", "protocol.file.allow=always", "submodule", "add", `file://${subSrc}`, "sub"], repo);
+      gitRun(["commit", "-m", "add submodule"], repo);
+
+      createFile(repo, "sub/copied.txt", "copied from source\n");
+      createFile(repo, "src/feature.ts", "export const feature = true;\n");
+      createFile(repo, "src/unrelated.ts", "export const unrelated = true;\n");
+
+      const svc = new GitServiceImpl(repo);
+      const taskContext: TaskCommitContext = {
+        taskId: "S01/T01",
+        taskDisplayId: "T01",
+        taskTitle: "fix submodule staging",
+        milestoneId: "M001",
+        milestoneTitle: "Submodule auto commit",
+        sliceId: "S01",
+        sliceTitle: "Commit scoped files",
+        oneLiner: "Fixed auto commit when key files include submodule paths",
+        keyFiles: ["sub/copied.txt", "src/feature.ts"],
+      };
+
+      const result = svc.autoCommit("execute-task", "M001/S01/T01", [], taskContext);
+
+      assert.ok(result !== null, "autoCommit should commit non-submodule changes");
+      const committed = gitRun(["show", "--name-only", "--format=", "HEAD"], repo);
+      assert.ok(committed.includes("src/feature.ts"), "non-submodule keyFile is committed");
+      assert.ok(!committed.includes("sub/copied.txt"), "submodule inner keyFile is not pathspec-staged");
+      assert.ok(!committed.includes("src/unrelated.ts"), "scoped staging does not fall back to smartStage");
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(subSrc, { recursive: true, force: true });
+    }
+  });
+
+  test('GitServiceImpl: all keyFiles inside submodules falls back to smartStage', () => {
+    const repo = initTempRepo();
+    const subSrc = mkdtempSync(join(tmpdir(), "gsd-git-all-submodule-src-"));
+
+    try {
+      gitRun(["init", "-b", "main"], subSrc);
+      gitRun(["config", "user.name", "Pi Test"], subSrc);
+      gitRun(["config", "user.email", "pi@example.com"], subSrc);
+      createFile(subSrc, "tracked.txt", "initial\n");
+      gitRun(["add", "-A"], subSrc);
+      gitRun(["commit", "-m", "init submodule"], subSrc);
+
+      gitRun(["-c", "protocol.file.allow=always", "submodule", "add", `file://${subSrc}`, "sub"], repo);
+      gitRun(["commit", "-m", "add submodule"], repo);
+
+      createFile(repo, "sub/file1.txt", "inside submodule\n");
+      createFile(repo, "sub/file2.txt", "also inside\n");
+      createFile(repo, "src/real.ts", "export const real = true;\n");
+
+      const svc = new GitServiceImpl(repo);
+      const taskContext: TaskCommitContext = {
+        taskId: "S01/T02",
+        taskDisplayId: "T02",
+        taskTitle: "all keyFiles inside submodule",
+        milestoneId: "M001",
+        milestoneTitle: "Submodule auto commit",
+        sliceId: "S01",
+        sliceTitle: "Commit scoped files",
+        oneLiner: "Fell back when all key files are inside submodules",
+        keyFiles: ["sub", "sub/file1.txt", "sub/file2.txt"],
+      };
+
+      const result = svc.autoCommit("execute-task", "M001/S01/T02", [], taskContext);
+
+      assert.ok(result !== null, "autoCommit falls back to smartStage when all keyFiles are filtered");
+      const committed = gitRun(["show", "--name-only", "--format=", "HEAD"], repo);
+      assert.ok(!committed.includes("sub/file1.txt"), "submodule keyFile is not committed");
+      assert.ok(!committed.includes("sub/file2.txt"), "submodule keyFile is not committed");
+      assert.ok(committed.includes("src/real.ts"), "smartStage fallback commits other dirty files");
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(subSrc, { recursive: true, force: true });
+    }
+  });
+
   // ─── GitServiceImpl: smart staging excludes tracked runtime files ──────
 
   test('GitServiceImpl: smart staging excludes tracked runtime files', () => {

package/src/resources/extensions/gsd/tests/integration/state-machine-runtime-failures.test.ts

@@ -195,6 +195,11 @@ describe("infrastructure error detection", () => {
     assert.equal(isInfrastructureError(err), "EAGAIN");
   });
 
+  test("ENOBUFS (no buffer space available) is detected", () => {
+    const err = Object.assign(new Error("spawnSync git ENOBUFS"), { code: "ENOBUFS" });
+    assert.equal(isInfrastructureError(err), "ENOBUFS");
+  });
+
   test("SQLite WAL corruption is detected via message scan", () => {
     const err = new Error("database disk image is malformed");
     assert.equal(isInfrastructureError(err), "SQLITE_CORRUPT");
@@ -223,7 +228,7 @@ describe("infrastructure error detection", () => {
   test("all INFRA_ERROR_CODES are covered", () => {
     const expectedCodes = [
       "ENOSPC", "ENOMEM", "EROFS", "EDQUOT", "EMFILE",
-      "ENFILE", "EAGAIN", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
+      "ENFILE", "EAGAIN", "ENOBUFS", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
     ];
     for (const code of expectedCodes) {
       assert.ok(INFRA_ERROR_CODES.has(code), `${code} should be in INFRA_ERROR_CODES`);

package/src/resources/extensions/gsd/tests/migrate-validator-parsers.test.ts

@@ -41,6 +41,15 @@ const SAMPLE_ROADMAP = `# Project Roadmap
 - [ ] 31 — Notifications
 `;
 
+const SAMPLE_VERSION_PREFIX_ROADMAP = `# Project Roadmap
+
+## Phases
+
+- ✅ **v1.0 MVP** — Phases 1-6 (shipped 2026-02-24)
+- ✅ **v1.1 Onboarding** — Phases 7-9 (shipped 2026-03-01)
+- 🚧 **v1.8 Production** — Phases 44-53
+`;
+
 const SAMPLE_PROJECT = `# My Project
 
 A sample project for testing the migration parser.
@@ -246,6 +255,21 @@ test('parseOldRoadmap: flat format', () => {
     assert.deepStrictEqual(roadmap.phases[1].done, false, 'flat roadmap: second phase not done');
 });
 
+test('parseOldRoadmap: emoji version-prefix phase ranges', () => {
+    const roadmap = parseOldRoadmap(SAMPLE_VERSION_PREFIX_ROADMAP);
+    assert.deepStrictEqual(roadmap.milestones.length, 0, 'version roadmap: no milestone sections');
+    assert.deepStrictEqual(roadmap.phases.length, 3, 'version roadmap: 3 phase ranges');
+    assert.deepStrictEqual(roadmap.phases[0].number, 1, 'version roadmap: first range starts at phase 1');
+    assert.deepStrictEqual(roadmap.phases[0].title, 'MVP', 'version roadmap: first title');
+    assert.deepStrictEqual(roadmap.phases[0].done, true, 'version roadmap: first range done');
+    assert.deepStrictEqual(roadmap.phases[1].number, 7, 'version roadmap: second range starts at phase 7');
+    assert.deepStrictEqual(roadmap.phases[1].title, 'Onboarding', 'version roadmap: second title');
+    assert.deepStrictEqual(roadmap.phases[1].done, true, 'version roadmap: second range done');
+    assert.deepStrictEqual(roadmap.phases[2].number, 44, 'version roadmap: third range starts at phase 44');
+    assert.deepStrictEqual(roadmap.phases[2].title, 'Production', 'version roadmap: third title');
+    assert.deepStrictEqual(roadmap.phases[2].done, false, 'version roadmap: third range in progress');
+});
+
 test('parseOldRoadmap: milestone-sectioned with <details>', () => {
     const roadmap = parseOldRoadmap(SAMPLE_MILESTONE_SECTIONED_ROADMAP);
     assert.ok(roadmap.milestones.length >= 2, 'ms roadmap: has milestone sections');
@@ -387,4 +411,3 @@ test('parseOldProject', () => {
     const project = parseOldProject(SAMPLE_PROJECT);
     assert.deepStrictEqual(project, SAMPLE_PROJECT, 'project: returns raw content');
 });
-

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

@@ -6,13 +6,15 @@ import test from "node:test";
 
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.ts";
 import {
-  _getAdapter,
   closeDatabase,
   getAllMilestones,
+  insertMilestone,
+  insertSlice,
+  insertTask,
   getSliceTasks,
 } from "../gsd-db.ts";
 import {
-  autoImportMarkdownHierarchyIfDbMismatch,
+  checkMarkdownHierarchyAgainstDb,
   countMarkdownHierarchy,
 } from "../migration-auto-check.ts";
 import { writeGSDDirectory } from "../migrate/writer.ts";
@@ -70,7 +72,7 @@ function projectFixture(): GSDProject {
   };
 }
 
-test("migration auto-check imports markdown hierarchy when DB is empty", async () => {
+test("migration auto-check preserves empty DB and reports explicit recovery", async () => {
   const base = makeBase();
   try {
     await writeGSDDirectory(projectFixture(), base);
@@ -79,32 +81,35 @@ test("migration auto-check imports markdown hierarchy when DB is empty", async (
     assert.equal(await ensureDbOpen(base), true);
     assert.equal(getAllMilestones().length, 0, "fresh authoritative DB starts empty");
 
-    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
-    assert.equal(result.action, "imported");
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "recovery-required");
     assert.equal(result.reason, "db-empty");
-    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 1 });
-    assert.equal(getAllMilestones().length, 1);
-    assert.equal(getSliceTasks("M001", "S01").length, 1);
+    assert.deepEqual(result.afterDb, { milestones: 0, slices: 0, tasks: 0 });
+    assert.equal(result.recoveryCommand, "gsd recover");
+    assert.match(result.message ?? "", /will not import markdown automatically/);
+    assert.equal(getAllMilestones().length, 0);
+    assert.equal(getSliceTasks("M001", "S01").length, 0);
   } finally {
     cleanup(base);
   }
 });
 
-test("migration auto-check repairs DB hierarchy count mismatch", async () => {
+test("migration auto-check preserves DB on hierarchy count mismatch", async () => {
   const base = makeBase();
   try {
     await writeGSDDirectory(projectFixture(), base);
-    await autoImportMarkdownHierarchyIfDbMismatch(base);
-
-    _getAdapter()!.prepare("DELETE FROM tasks WHERE milestone_id = ? AND slice_id = ? AND id = ?").run("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 });
     assert.equal(getSliceTasks("M001", "S01").length, 0, "test fixture simulates stale DB task count");
 
-    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
-    assert.equal(result.action, "imported");
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "recovery-required");
     assert.equal(result.reason, "count-mismatch");
     assert.deepEqual(result.beforeDb, { milestones: 1, slices: 1, tasks: 0 });
-    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 1 });
-    assert.equal(getSliceTasks("M001", "S01").length, 1);
+    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 0 });
+    assert.equal(result.recoveryCommand, "gsd recover");
+    assert.equal(getSliceTasks("M001", "S01").length, 0);
   } finally {
     cleanup(base);
   }
@@ -114,9 +119,12 @@ test("migration auto-check leaves matching DB hierarchy alone", async () => {
   const base = makeBase();
   try {
     await writeGSDDirectory(projectFixture(), base);
-    await autoImportMarkdownHierarchyIfDbMismatch(base);
+    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" });
 
-    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
+    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 });