@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.74e8dd1

package/src/resources/extensions/gsd/tests/gsd-rebuild.test.ts

@@ -0,0 +1,199 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { handleRebuild } from "../commands-maintenance.ts";
+import {
+  closeDatabase,
+  getTask,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+import { invalidateStateCache } from "../state.ts";
+
+type Note = { message: string; kind: string };
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-rebuild-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), {
+    recursive: true,
+  });
+  return base;
+}
+
+function cleanup(base: string): void {
+  closeDatabase();
+  invalidateStateCache();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function makeCtx(): { ctx: any; notes: Note[] } {
+  const notes: Note[] = [];
+  return {
+    ctx: {
+      ui: {
+        notify: (message: string, kind: string) => notes.push({ message, kind }),
+      },
+    },
+    notes,
+  };
+}
+
+function seedOpenTask(): void {
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Slice",
+    status: "in_progress",
+    risk: "low",
+    depends: [],
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task",
+    status: "pending",
+  });
+}
+
+function listFiles(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  const out: string[] = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else {
+        out.push(full);
+      }
+    }
+  }
+  return out.sort();
+}
+
+test("handleRebuild quarantines stale completion projections without mutating DB state", async () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    seedOpenTask();
+
+    const summaryPath = join(
+      base,
+      ".gsd",
+      "milestones",
+      "M001",
+      "slices",
+      "S01",
+      "tasks",
+      "T01-SUMMARY.md",
+    );
+    writeFileSync(summaryPath, "# T01 Summary\n\nDisk-only completion.\n", "utf-8");
+
+    const { ctx, notes } = makeCtx();
+    await handleRebuild(ctx, base, "markdown");
+
+    assert.equal(existsSync(summaryPath), false, "stale SUMMARY projection should be moved aside");
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending", "DB task status remains authoritative");
+    assert.equal(task?.full_summary_md, "", "disk summary must not be imported into DB");
+
+    const quarantined = listFiles(join(base, ".gsd", "quarantine", "projections"));
+    assert.equal(quarantined.length, 1);
+    assert.match(readFileSync(quarantined[0]!, "utf-8"), /Disk-only completion/);
+    assert.match(notes.at(-1)?.message ?? "", /Quarantined:\s+1/);
+    assert.equal(notes.at(-1)?.kind, "success");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("handleRebuild re-renders missing task summary projections from DB", async () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    seedOpenTask();
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task",
+      status: "complete",
+      oneLiner: "Task complete",
+      narrative: "Finished through the DB.",
+      verificationResult: "passed",
+      fullSummaryMd: "# T01 Summary\n\nRendered from DB.\n",
+    });
+
+    const summaryPath = join(
+      base,
+      ".gsd",
+      "milestones",
+      "M001",
+      "slices",
+      "S01",
+      "tasks",
+      "T01-SUMMARY.md",
+    );
+    rmSync(summaryPath, { force: true });
+
+    const { ctx, notes } = makeCtx();
+    await handleRebuild(ctx, base);
+
+    assert.equal(existsSync(summaryPath), true, "missing SUMMARY projection should be regenerated");
+    assert.equal(readFileSync(summaryPath, "utf-8"), "# T01 Summary\n\nRendered from DB.\n");
+    assert.match(notes.at(-1)?.message ?? "", /rebuilt markdown projections from the canonical DB/);
+    assert.match(notes.at(-1)?.message ?? "", /Quarantined:\s+0/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("handleRebuild database target is reserved and does not import markdown", async () => {
+  const base = makeBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    seedOpenTask();
+
+    const summaryPath = join(
+      base,
+      ".gsd",
+      "milestones",
+      "M001",
+      "slices",
+      "S01",
+      "tasks",
+      "T01-SUMMARY.md",
+    );
+    writeFileSync(summaryPath, "# T01 Summary\n\nShould not import.\n", "utf-8");
+
+    const { ctx, notes } = makeCtx();
+    await handleRebuild(ctx, base, "database");
+
+    assert.equal(existsSync(summaryPath), true, "reserved DB rebuild must not move projection files");
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending", "reserved DB rebuild must not mutate task status");
+    assert.equal(task?.full_summary_md, "", "reserved DB rebuild must not import markdown");
+    assert.match(notes.at(-1)?.message ?? "", /reserved/);
+    assert.match(notes.at(-1)?.message ?? "", /\/gsd recover --confirm/);
+    assert.equal(notes.at(-1)?.kind, "warning");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/gsd-recover.test.ts

@@ -24,6 +24,7 @@ import {
 } from '../gsd-db.ts';
 import { migrateHierarchyToDb } from '../md-importer.ts';
 import { deriveStateFromDb, invalidateStateCache } from '../state.ts';
+import { handleRecover } from '../commands-maintenance.ts';
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -42,6 +43,22 @@ function cleanup(base: string): void {
   rmSync(base, { recursive: true, force: true });
 }
 
+function makeCtx(confirm?: () => Promise<boolean>): {
+  ctx: any;
+  notes: Array<{ message: string; kind: string }>;
+} {
+  const notes: Array<{ message: string; kind: string }> = [];
+  return {
+    ctx: {
+      ui: {
+        notify: (message: string, kind: string) => notes.push({ message, kind }),
+        ...(confirm ? { confirm: async () => confirm() } : {}),
+      },
+    },
+    notes,
+  };
+}
+
 // ─── Fixture Content ──────────────────────────────────────────────────────
 
 const ROADMAP_M001 = `# M001: Recovery Test
@@ -437,4 +454,62 @@ describe('gsd-recover', async () => {
       cleanup(base);
     }
   });
+
+  test('handleRecover warns and does not import markdown without confirmation', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx, notes } = makeCtx();
+      await handleRecover(ctx, base);
+
+      assert.ok(getMilestone('M999'), 'existing DB row remains when recover is unconfirmed');
+      assert.equal(getMilestone('M001'), null, 'markdown milestone is not imported without confirmation');
+      assert.equal(notes.at(-1)?.kind, 'warning');
+      assert.match(notes.at(-1)?.message ?? '', /\/gsd recover --confirm/);
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('handleRecover interactive cancellation leaves DB unchanged', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx, notes } = makeCtx(async () => false);
+      await handleRecover(ctx, base);
+
+      assert.ok(getMilestone('M999'), 'existing DB row remains when recover is cancelled');
+      assert.equal(getMilestone('M001'), null, 'markdown milestone is not imported after cancellation');
+      assert.match(notes.at(-1)?.message ?? '', /cancelled/);
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('handleRecover imports markdown after explicit confirmation', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_M001);
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M999', title: 'Existing DB State', status: 'active' });
+
+      const { ctx, notes } = makeCtx();
+      await handleRecover(ctx, base, '--confirm');
+
+      assert.equal(getMilestone('M999'), null, 'confirmed recover clears old hierarchy rows');
+      assert.ok(getMilestone('M001'), 'confirmed recover imports markdown hierarchy');
+      assert.equal(notes.at(-1)?.kind, 'success');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/integration/state-machine-live-validation.test.ts

@@ -50,6 +50,7 @@ import { handleCompleteSlice } from "../../tools/complete-slice.ts";
 import { handleCompleteMilestone } from "../../tools/complete-milestone.ts";
 import { handleReopenTask } from "../../tools/reopen-task.ts";
 import { handleReopenSlice } from "../../tools/reopen-slice.ts";
+import { handleReopenMilestone } from "../../tools/reopen-milestone.ts";
 
 // ── State derivation ──────────────────────────────────────────────────────
 import {
@@ -700,9 +701,7 @@ describe("state-machine-live-validation", () => {
       assert.match((result as any).error, /closed milestone/);
     });
 
-    test("no reopen-milestone tool exists — milestone completion is irrevocable (H5)", async () => {
-      // This test documents the H5 finding: there is no handleReopenMilestone function.
-      // A completed milestone can only be undone via direct DB manipulation.
+    test("closed milestone cannot be reopened by generic DB update", async () => {
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Done", status: "complete" });
@@ -710,10 +709,18 @@ describe("state-machine-live-validation", () => {
       const milestone = getMilestone("M001");
       assert.ok(isClosedStatus(milestone!.status), "milestone is closed");
 
-      // The only escape is direct DB manipulation — no handler exists
-      updateMilestoneStatus("M001", "active", null);
+      assert.throws(
+        () => updateMilestoneStatus("M001", "active", null),
+        /use gsd_milestone_reopen for an explicit reopen/,
+      );
+
+      const result = await handleReopenMilestone(
+        { milestoneId: "M001", reason: "regression surfaced after closure" },
+        base,
+      );
+      assert.ok(!("error" in result), `unexpected reopen error: ${"error" in result ? result.error : ""}`);
       const reopened = getMilestone("M001");
-      assert.equal(reopened!.status, "active", "direct DB manipulation can reopen, but no tool exposes this");
+      assert.equal(reopened!.status, "active", "explicit reopen handler reopens the milestone");
     });
   });
 

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

@@ -48,6 +48,21 @@ describe("discoverMcpServerNames", () => {
     assert.deepEqual(result.sort(), ["server-a", "server-b", "shared"]);
   });
 
+  it("reads from .claude/settings.local.json for Claude Code project-local servers", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    mkdirSync(join(dir, ".claude"), { recursive: true });
+    writeFileSync(
+      join(dir, ".claude", "settings.local.json"),
+      JSON.stringify({ mcpServers: { "local-server": {}, "shared": {} } }),
+    );
+    writeFileSync(
+      join(dir, ".claude", "settings.json"),
+      JSON.stringify({ mcpServers: { "project-server": {}, "shared": {} } }),
+    );
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result.sort(), ["local-server", "project-server", "shared"]);
+  });
+
   it("handles .claude/settings.json missing gracefully", () => {
     const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
     writeFileSync(

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

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import {
+  ensureClaudeCodeMcpJsonServerEnabled,
   ensureProjectWorkflowMcpConfig,
   GSD_BROWSER_MCP_SERVER_NAME,
   GSD_WORKFLOW_MCP_SERVER_NAME,
@@ -54,6 +55,14 @@ test("ensureProjectWorkflowMcpConfig creates .mcp.json with workflow and browser
     ]);
     assert.equal(browserArgs[mcpArgIndex + 6], projectRoot);
     assert.equal((browserServer as { cwd?: string })?.cwd, projectRoot);
+
+    const settings = JSON.parse(readFileSync(join(projectRoot, ".claude", "settings.local.json"), "utf-8")) as {
+      enabledMcpjsonServers?: string[];
+    };
+    assert.deepEqual(settings.enabledMcpjsonServers, [
+      GSD_WORKFLOW_MCP_SERVER_NAME,
+      GSD_BROWSER_MCP_SERVER_NAME,
+    ]);
   } finally {
     rmSync(projectRoot, { recursive: true, force: true });
   }
@@ -115,6 +124,11 @@ test("ensureProjectWorkflowMcpConfig uses custom workflow server name from env",
     assert.ok(parsed.mcpServers?.["custom-workflow"]);
     assert.ok(parsed.mcpServers?.[GSD_BROWSER_MCP_SERVER_NAME]);
     assert.equal(parsed.mcpServers?.[GSD_WORKFLOW_MCP_SERVER_NAME], undefined);
+
+    const settings = JSON.parse(readFileSync(join(projectRoot, ".claude", "settings.local.json"), "utf-8")) as {
+      enabledMcpjsonServers?: string[];
+    };
+    assert.deepEqual(settings.enabledMcpjsonServers, ["custom-workflow", GSD_BROWSER_MCP_SERVER_NAME]);
   } finally {
     rmSync(projectRoot, { recursive: true, force: true });
   }
@@ -136,6 +150,11 @@ test("ensureProjectWorkflowMcpConfig can disable the default browser MCP server"
     };
     assert.ok(parsed.mcpServers?.[GSD_WORKFLOW_MCP_SERVER_NAME]);
     assert.equal(parsed.mcpServers?.[GSD_BROWSER_MCP_SERVER_NAME], undefined);
+
+    const settings = JSON.parse(readFileSync(join(projectRoot, ".claude", "settings.local.json"), "utf-8")) as {
+      enabledMcpjsonServers?: string[];
+    };
+    assert.deepEqual(settings.enabledMcpjsonServers, [GSD_WORKFLOW_MCP_SERVER_NAME]);
   } finally {
     rmSync(projectRoot, { recursive: true, force: true });
   }
@@ -156,3 +175,52 @@ test("ensureProjectWorkflowMcpConfig is idempotent when config is already curren
     rmSync(projectRoot, { recursive: true, force: true });
   }
 });
+
+test("ensureProjectWorkflowMcpConfig updates stale Claude Code MCP approval state", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+  const settingsPath = join(projectRoot, ".claude", "settings.local.json");
+
+  try {
+    const first = ensureProjectWorkflowMcpConfig(projectRoot);
+    assert.equal(first.status, "created");
+
+    writeFileSync(
+      settingsPath,
+      `${JSON.stringify({
+        permissions: { allow: ["Bash(gh issue *)"] },
+        enabledMcpjsonServers: [],
+        disabledMcpjsonServers: [GSD_WORKFLOW_MCP_SERVER_NAME, GSD_BROWSER_MCP_SERVER_NAME],
+      }, null, 2)}\n`,
+      "utf-8",
+    );
+
+    const second = ensureProjectWorkflowMcpConfig(projectRoot);
+    assert.equal(second.status, "updated");
+
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8")) as {
+      permissions?: { allow?: string[] };
+      enabledMcpjsonServers?: string[];
+      disabledMcpjsonServers?: string[];
+    };
+    assert.deepEqual(settings.permissions?.allow, ["Bash(gh issue *)"]);
+    assert.deepEqual(settings.enabledMcpjsonServers, [
+      GSD_WORKFLOW_MCP_SERVER_NAME,
+      GSD_BROWSER_MCP_SERVER_NAME,
+    ]);
+    assert.deepEqual(settings.disabledMcpjsonServers, []);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("ensureClaudeCodeMcpJsonServerEnabled is idempotent", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
+
+  try {
+    assert.equal(ensureClaudeCodeMcpJsonServerEnabled(projectRoot, "gsd-workflow"), true);
+    assert.equal(ensureClaudeCodeMcpJsonServerEnabled(projectRoot, "gsd-workflow"), false);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

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

@@ -1,14 +1,23 @@
 import test, { describe } 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 type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
 
 import {
+  formatMcpDiscoveryResult,
   formatMcpInitResult,
   formatMcpConnectionTestResult,
   formatMcpStatusReport,
   formatMcpServerDetail,
   hasHostMcpTool,
+  handleMcpStatus,
   type McpServerStatus,
 } from "../commands-mcp-status.ts";
+import { clearMcpConfigCache } from "../../mcp-client/manager.ts";
 
 // ─── formatMcpStatusReport ──────────────────────────────────────────────────
 
@@ -49,6 +58,16 @@ describe("formatMcpStatusReport", () => {
     assert.match(result, /disabled/i);
   });
 
+  test("shows available state for servers that pass a status probe", () => {
+    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.doesNotMatch(result, /disconnected/);
+  });
+
   test("includes server count in header", () => {
     const servers: McpServerStatus[] = [
       { name: "a", transport: "stdio", connected: true, toolCount: 3, error: undefined },
@@ -113,6 +132,20 @@ describe("formatMcpServerDetail", () => {
     assert.match(result, /disconnected/i);
   });
 
+  test("shows available status with tool names", () => {
+    const result = formatMcpServerDetail({
+      name: "gsd-workflow",
+      transport: "stdio",
+      connected: false,
+      available: true,
+      toolCount: 1,
+      tools: ["gsd_milestone_status"],
+      error: undefined,
+    });
+    assert.match(result, /available/i);
+    assert.match(result, /gsd_milestone_status/);
+  });
+
   test("shows env warnings for server detail", () => {
     const result = formatMcpServerDetail({
       name: "warned",
@@ -128,6 +161,150 @@ describe("formatMcpServerDetail", () => {
   });
 });
 
+describe("handleMcpStatus", () => {
+  test("probes configured stdio servers before reporting disconnected", async () => {
+    const previousGsdHome = process.env.GSD_HOME;
+    const originalCwd = process.cwd();
+    const projectDir = mkdtempSync(join(tmpdir(), "gsd-mcp-status-project-"));
+    const gsdHomeDir = mkdtempSync(join(tmpdir(), "gsd-mcp-status-home-"));
+    try {
+      process.env.GSD_HOME = gsdHomeDir;
+      process.chdir(projectDir);
+      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-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("fake_tool", "Probe-visible 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",
+      );
+
+      let message = "";
+      const ctx = {
+        getSystemPrompt: () => "",
+        ui: {
+          notify: (text: string) => {
+            message = text;
+          },
+        },
+      };
+
+      await handleMcpStatus("status", ctx as unknown as ExtensionCommandContext);
+
+      assert.match(message, /gsd-workflow/);
+      assert.match(message, /available — 1 tools/);
+      assert.doesNotMatch(message, /disconnected/);
+    } finally {
+      process.chdir(originalCwd);
+      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("discovers the only configured server when no server name is provided", async () => {
+    const previousGsdHome = process.env.GSD_HOME;
+    const originalCwd = process.cwd();
+    const projectDir = mkdtempSync(join(tmpdir(), "gsd-mcp-discover-project-"));
+    const gsdHomeDir = mkdtempSync(join(tmpdir(), "gsd-mcp-discover-home-"));
+    try {
+      process.env.GSD_HOME = gsdHomeDir;
+      process.chdir(projectDir);
+
+      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, "discover-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("discover_tool", "Discover-visible 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",
+      );
+
+      let message = "";
+      const ctx = {
+        getSystemPrompt: () => "",
+        ui: {
+          notify: (text: string) => {
+            message = text;
+          },
+        },
+      };
+
+      await handleMcpStatus("discover", ctx as unknown as ExtensionCommandContext);
+
+      assert.match(message, /MCP discovery completed for gsd-workflow/);
+      assert.match(message, /discover_tool/);
+      assert.doesNotMatch(message, /Usage: \/gsd mcp/);
+    } finally {
+      process.chdir(originalCwd);
+      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();
+    }
+  });
+});
+
+describe("formatMcpDiscoveryResult", () => {
+  test("summarizes discovered tools", () => {
+    const result = formatMcpDiscoveryResult({
+      ok: true,
+      server: "demo",
+      transport: "stdio",
+      toolCount: 1,
+      tools: ["ping"],
+      warnings: [],
+    });
+    assert.match(result, /discovery completed/i);
+    assert.match(result, /ping/);
+    assert.match(result, /mcp_call/);
+  });
+
+  test("summarizes discovery failures", () => {
+    const result = formatMcpDiscoveryResult({
+      ok: false,
+      server: "demo",
+      transport: "http",
+      toolCount: 0,
+      tools: [],
+      warnings: ["url references unset environment variable TOKEN."],
+      error: "bad config",
+    });
+    assert.match(result, /discovery failed/i);
+    assert.match(result, /bad config/);
+    assert.match(result, /TOKEN/);
+  });
+});
+
 describe("formatMcpConnectionTestResult", () => {
   test("summarizes successful tools/list", () => {
     const result = formatMcpConnectionTestResult({

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

@@ -102,8 +102,8 @@ test("migration auto-check preserves empty DB and reports explicit recovery", as
     assert.equal(result.action, "recovery-required");
     assert.equal(result.reason, "db-empty");
     assert.deepEqual(result.afterDb, { milestones: 0, slices: 0, tasks: 0 });
-    assert.equal(result.recoveryCommand, "/gsd recover");
-    assert.match(result.message ?? "", /run `\/gsd recover`/);
+    assert.equal(result.recoveryCommand, "/gsd recover --confirm");
+    assert.match(result.message ?? "", /run `\/gsd recover --confirm`/);
     assert.equal(getAllMilestones().length, 0);
     assert.equal(getSliceTasks("M001", "S01").length, 0);
   } finally {
@@ -125,7 +125,7 @@ test("migration auto-check preserves DB on hierarchy count mismatch", async () =
     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: 0 });
-    assert.equal(result.recoveryCommand, "/gsd recover");
+    assert.equal(result.recoveryCommand, "/gsd recover --confirm");
     assert.equal(getSliceTasks("M001", "S01").length, 0);
   } finally {
     cleanup(base);