gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.8b8d129d7

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

@@ -0,0 +1,287 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { discoverMcpServerNames, computeMcpDisallowedTools } from "../mcp-filter.ts";
+import type { ClaudeCodeMcpConfig } from "../preferences-types.ts";
+
+// ─── discoverMcpServerNames ────────────────────────────────────────────────
+
+describe("discoverMcpServerNames", () => {
+  it("reads server names from .mcp.json mcpServers keys", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({ mcpServers: { "server-a": {}, "server-b": {} } }),
+    );
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result.sort(), ["server-a", "server-b"]);
+  });
+
+  it("returns [] when .mcp.json does not exist (ENOENT)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result, []);
+  });
+
+  it("returns [] when .mcp.json has no mcpServers key", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    writeFileSync(join(dir, ".mcp.json"), JSON.stringify({ version: 1 }));
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result, []);
+  });
+
+  it("reads from both .mcp.json and .claude/settings.json, deduplicates", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({ mcpServers: { "server-a": {}, "shared": {} } }),
+    );
+    mkdirSync(join(dir, ".claude"), { recursive: true });
+    writeFileSync(
+      join(dir, ".claude", "settings.json"),
+      JSON.stringify({ mcpServers: { "server-b": {}, "shared": {} } }),
+    );
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result.sort(), ["server-a", "server-b", "shared"]);
+  });
+
+  it("handles .claude/settings.json missing gracefully", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({ mcpServers: { "only-server": {} } }),
+    );
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result, ["only-server"]);
+  });
+});
+
+// ─── computeMcpDisallowedTools ─────────────────────────────────────────────
+
+describe("computeMcpDisallowedTools", () => {
+  it("returns [] when mcpConfig is undefined (no filtering)", () => {
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      undefined,
+      ["server-a", "server-b"],
+      "gsd-workflow",
+    );
+    assert.deepEqual(result, []);
+  });
+
+  it("returns [] when no model prefix matches any config key", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { allowed_servers: ["server-a"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-opus-4-7",
+      config,
+      ["server-a", "server-b"],
+      "gsd-workflow",
+    );
+    assert.deepEqual(result, []);
+  });
+
+  it("allowlist-only: blocks all discovered servers not in allowed_servers (R002)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { allowed_servers: ["server-a"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["server-a", "server-b", "server-c"],
+      "gsd-workflow",
+    );
+    assert.deepEqual(result.sort(), ["mcp__server-b__*", "mcp__server-c__*"]);
+  });
+
+  it("blocklist-only: blocks only servers in blocked_servers (R002)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { blocked_servers: ["server-b"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["server-a", "server-b", "server-c"],
+      "gsd-workflow",
+    );
+    assert.deepEqual(result, ["mcp__server-b__*"]);
+  });
+
+  it("both lists: allowlist applies first, then blocklist removes; blocklist wins on overlap (R002)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": {
+          allowed_servers: ["server-a", "server-b"],
+          blocked_servers: ["server-b"],
+        },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["server-a", "server-b", "server-c"],
+      "gsd-workflow",
+    );
+    // server-c blocked by allowlist, server-b blocked by blocklist (wins over allowlist)
+    assert.deepEqual(result.sort(), ["mcp__server-b__*", "mcp__server-c__*"]);
+  });
+
+  it("gsd-workflow implicitly allowed even when not in allowlist (R003)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { allowed_servers: ["server-a"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["server-a", "server-b"],
+      "gsd-workflow",
+    );
+    assert.ok(!result.includes("mcp__gsd-workflow__*"), "gsd-workflow must not be blocked");
+    assert.deepEqual(result, ["mcp__server-b__*"]);
+  });
+
+  it("gsd-workflow blocked when explicitly in blocked_servers (R003 override)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { blocked_servers: ["gsd-workflow"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["server-a"],
+      "gsd-workflow",
+    );
+    assert.ok(result.includes("mcp__gsd-workflow__*"), "gsd-workflow must be blocked");
+  });
+
+  it("returns mcp__<name>__* pattern format for each blocked server (R006)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { blocked_servers: ["my-server", "other-server"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["my-server", "other-server"],
+      "gsd-workflow",
+    );
+    assert.deepEqual(result.sort(), ["mcp__my-server__*", "mcp__other-server__*"]);
+  });
+});
+
+// ─── Integration: empirical tool-count reduction ───────────────────────────
+
+describe("integration: empirical tool-count reduction", () => {
+  it("disallowedTools count equals discovered minus allowed (5 servers, 1 allowed → 4 blocked)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-integration-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          "server-alpha": {},
+          "server-beta": {},
+          "server-gamma": {},
+          "server-delta": {},
+          "server-epsilon": {},
+        },
+      }),
+    );
+
+    const discovered = discoverMcpServerNames(dir);
+    assert.equal(discovered.length, 5, "fixture must have 5 servers");
+
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "test-model": { allowed_servers: ["server-alpha"] },
+      },
+    };
+
+    const disallowedTools = computeMcpDisallowedTools(
+      "test-model",
+      config,
+      discovered,
+      "gsd-workflow",
+    );
+
+    // 5 discovered - 1 allowed = 4 blocked
+    assert.equal(disallowedTools.length, 4, "4 servers must be blocked");
+
+    // The allowed server must NOT be in disallowedTools
+    assert.ok(
+      !disallowedTools.includes("mcp__server-alpha__*"),
+      "server-alpha (allowed) must not be blocked",
+    );
+
+    // Each blocked server must produce the correct pattern
+    assert.deepEqual(disallowedTools.sort(), [
+      "mcp__server-beta__*",
+      "mcp__server-delta__*",
+      "mcp__server-epsilon__*",
+      "mcp__server-gamma__*",
+    ]);
+  });
+
+  it("negative: empty .mcp.json → disallowedTools empty", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-integration-empty-"));
+    writeFileSync(join(dir, ".mcp.json"), JSON.stringify({}));
+
+    const discovered = discoverMcpServerNames(dir);
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "test-model": { allowed_servers: ["server-alpha"] },
+      },
+    };
+
+    const disallowedTools = computeMcpDisallowedTools(
+      "test-model",
+      config,
+      discovered,
+      "gsd-workflow",
+    );
+
+    assert.deepEqual(disallowedTools, [], "no servers discovered → nothing to block");
+  });
+
+  it("negative: model ID matches no per_model key → disallowedTools empty", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-integration-nomatch-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: { "server-a": {}, "server-b": {}, "server-c": {} },
+      }),
+    );
+
+    const discovered = discoverMcpServerNames(dir);
+    assert.equal(discovered.length, 3);
+
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { allowed_servers: ["server-a"] },
+      },
+    };
+
+    // "gpt-4o" doesn't match "claude-haiku" prefix → no filtering
+    const disallowedTools = computeMcpDisallowedTools(
+      "gpt-4o",
+      config,
+      discovered,
+      "gsd-workflow",
+    );
+
+    assert.deepEqual(disallowedTools, [], "unmatched model must produce no blocks");
+  });
+});

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

@@ -5,6 +5,7 @@ import {
   formatMcpInitResult,
   formatMcpStatusReport,
   formatMcpServerDetail,
+  hasHostMcpTool,
   type McpServerStatus,
 } from "../commands-mcp-status.ts";
 
@@ -116,3 +117,13 @@ describe("formatMcpInitResult", () => {
     assert.match(result, /already up to date/i);
   });
 });
+
+describe("hasHostMcpTool", () => {
+  test("detects host-provided MCP tool prefix for a server", () => {
+    assert.equal(hasHostMcpTool("tools: mcp__gsd-workflow__*", "gsd-workflow"), true);
+  });
+
+  test("does not match other servers", () => {
+    assert.equal(hasHostMcpTool("tools: mcp__other-server__*", "gsd-workflow"), false);
+  });
+});

package/src/resources/extensions/gsd/tests/merge-db-cycle.test.ts

@@ -0,0 +1,179 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.js";
+import { _clearGsdRootCache } from "../paths.ts";
+import { _resetServiceCache } from "../worktree.ts";
+import { worktreePath } from "../worktree-manager.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function withPlatform<T>(platform: NodeJS.Platform, fn: () => T): T {
+  const descriptor = Object.getOwnPropertyDescriptor(process, "platform");
+  Object.defineProperty(process, "platform", { value: platform });
+  try {
+    return fn();
+  } finally {
+    if (descriptor) {
+      Object.defineProperty(process, "platform", descriptor);
+    }
+  }
+}
+
+function realGitPath(): string {
+  const gitExecPath = execFileSync("git", ["--exec-path"], {
+    encoding: "utf-8",
+  }).trim();
+  return join(gitExecPath, process.platform === "win32" ? "git.exe" : "git");
+}
+
+function installGitShim(bin: string, probePath: string): void {
+  const shim = join(bin, "git-proxy.cjs");
+  writeFileSync(
+    shim,
+    `
+const { appendFileSync, existsSync } = require("node:fs");
+const { join } = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const realGit = ${JSON.stringify(realGitPath())};
+const probePath = ${JSON.stringify(probePath)};
+const args = process.argv.slice(2);
+
+if (args[0] === "merge" && args[1] === "--squash") {
+  const sidecars = [
+    join(process.cwd(), ".gsd", "gsd.db-wal"),
+    join(process.cwd(), ".gsd", "gsd.db-shm"),
+  ];
+  const locked = sidecars.find((path) => existsSync(path));
+  if (locked) {
+    appendFileSync(probePath, "blocked:" + locked + "\\n");
+    console.error("error: local changes would be overwritten by merge");
+    console.error("\\t" + locked);
+    process.exit(1);
+  }
+  appendFileSync(probePath, "clean\\n");
+}
+
+const result = spawnSync(realGit, args, { stdio: "inherit", env: process.env });
+process.exit(result.status ?? 1);
+`,
+    "utf-8",
+  );
+
+  if (process.platform === "win32") {
+    writeFileSync(join(bin, "git.cmd"), `@echo off\r\nnode "%~dp0git-proxy.cjs" %*\r\n`, "utf-8");
+  } else {
+    const executable = join(bin, "git");
+    writeFileSync(executable, `#!/bin/sh\nexec node "${shim}" "$@"\n`, "utf-8");
+    chmodSync(executable, 0o755);
+  }
+}
+
+function createRepo(root: string): { repo: string; worktree: string } {
+  const repo = join(root, "repo");
+  mkdirSync(repo, { recursive: true });
+  git(["init"], repo);
+  git(["config", "user.email", "test@test.com"], repo);
+  git(["config", "user.name", "Test"], repo);
+  writeFileSync(join(repo, ".gitignore"), ".gsd/\n", "utf-8");
+  writeFileSync(join(repo, "README.md"), "# test\n", "utf-8");
+  git(["add", "."], repo);
+  git(["commit", "-m", "init"], repo);
+  git(["branch", "-M", "main"], repo);
+
+  git(["checkout", "-b", "milestone/M001"], repo);
+  writeFileSync(join(repo, "feature.txt"), "milestone change\n", "utf-8");
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(join(repo, ".gsd", "gsd.db-shm"), "milestone placeholder\n", "utf-8");
+  git(["add", "feature.txt"], repo);
+  git(["add", "-f", ".gsd/gsd.db-shm"], repo);
+  git(["commit", "-m", "feat: milestone change"], repo);
+  git(["checkout", "main"], repo);
+
+  const wt = worktreePath(repo, "M001");
+  mkdirSync(join(repo, ".gsd", "worktrees"), { recursive: true });
+  git(["worktree", "add", wt, "milestone/M001"], repo);
+  return { repo, worktree: wt };
+}
+
+test("mergeMilestoneToMain keeps the Windows DB cycle closed through squash merge", () => {
+  const savedCwd = process.cwd();
+  const originalPath = process.env.PATH ?? "";
+  const gitEnv = GIT_NO_PROMPT_ENV as NodeJS.ProcessEnv;
+  const originalGitEnvPath = gitEnv.PATH;
+  const originalHome = process.env.HOME;
+  const originalGsdHome = process.env.GSD_HOME;
+
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-db-cycle-")));
+  const fakeHome = join(root, "home");
+  const bin = join(root, "bin");
+  const probePath = join(root, "merge-probe.txt");
+  mkdirSync(fakeHome, { recursive: true });
+  mkdirSync(bin, { recursive: true });
+  installGitShim(bin, probePath);
+
+  try {
+    process.env.HOME = fakeHome;
+    process.env.GSD_HOME = join(fakeHome, ".gsd");
+    _clearGsdRootCache();
+    _resetServiceCache();
+
+    const { repo, worktree } = createRepo(root);
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+
+    withPlatform("win32", () => {
+      assert.equal(openDatabase(join(repo, ".gsd", "gsd.db")), true);
+      assert.equal(existsSync(join(repo, ".gsd", "gsd.db-shm")), true);
+
+      process.env.PATH = `${bin}${delimiter}${originalPath}`;
+      gitEnv.PATH = process.env.PATH;
+      process.chdir(worktree);
+
+      const result = mergeMilestoneToMain(repo, "M001", "# M001: Windows DB cycle\n");
+      assert.equal(result.codeFilesChanged, true);
+    });
+
+    assert.equal(git(["show", "HEAD:feature.txt"], repo), "milestone change");
+    assert.equal(readFileSync(probePath, "utf-8"), "clean\n");
+  } finally {
+    closeDatabase();
+    process.chdir(savedCwd);
+    process.env.PATH = originalPath;
+    gitEnv.PATH = originalGitEnvPath;
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    if (originalGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = originalGsdHome;
+    }
+    _clearGsdRootCache();
+    _resetServiceCache();
+    if (existsSync(root)) rmSync(root, { recursive: true, force: true });
+  }
+});

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