@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

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

@@ -11,6 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { extractUatType } from '../../files.ts';
 import { resolveSliceFile } from '../../paths.ts';
 import { buildRunUatPrompt, checkNeedsRunUat } from '../../auto-prompts.ts';
+import { buildRunUatResultPresentation, RUN_UAT_TOOL_PRESENTATION_PLAN_ID } from '../../tool-presentation-plan.ts';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const worktreePromptsDir = join(__dirname, '../..', 'prompts');
@@ -20,6 +21,8 @@ function loadPromptFromWorktree(name: string, vars: Record<string, string> = {})
   let content = readFileSync(path, 'utf-8');
   const effectiveVars = {
     skillActivation: 'If no installed skill clearly matches this unit, skip explicit skill activation and continue with the required workflow.',
+    canonicalPresentation: JSON.stringify(buildRunUatResultPresentation(), null, 2),
+    toolPresentationPlanId: RUN_UAT_TOOL_PRESENTATION_PLAN_ID,
     ...vars,
   };
   for (const [key, value] of Object.entries(effectiveVars)) {
@@ -72,6 +75,38 @@ function makeBrowserObservableUatContent(mode = 'artifact-driven'): string {
   ].join('\n');
 }
 
+function makeDeferredBrowserUatContent(): string {
+  return [
+    '# UAT File',
+    '',
+    '## UAT Type',
+    '',
+    '- UAT mode: artifact-driven',
+    '- Why this mode is sufficient: Node interaction tests exercise the real app.js render/event/localStorage loop through a DOM harness. Live browser, keyboard, responsive, and visual-polish UAT remain intentionally deferred to S02.',
+    '',
+    '## Smoke Test',
+    '',
+    'Run `node --test tests/s01-static-interactions.test.js` and confirm all tests pass.',
+    '',
+    '## Test Cases',
+    '',
+    '1. Click the todo row edit control in the DOM harness.',
+    '2. Save changed text and reload/recreate the app from persisted localStorage.',
+    '3. Expected: the stored record shape remains unchanged.',
+    '',
+    '## Not Proven By This UAT',
+    '',
+    '- Final visual polish of edit controls.',
+    '- Keyboard usability through a real browser.',
+    '- Browser console and local network cleanliness.',
+    '',
+    '## Notes for Tester',
+    '',
+    'S02 should capture browser evidence for the full loop rather than changing this persisted model.',
+    '',
+  ].join('\n');
+}
+
 describe('run-uat', () => {
 test('(a) artifact-driven', () => {
   assert.deepStrictEqual(
@@ -232,8 +267,8 @@ test('(k) run-uat prompt template', () => {
     `prompt contains detected dynamic uatType value "${uatType}" after substitution`,
   );
   assert.ok(
-    promptResult?.includes(`uatType: ${uatType}`) ?? false,
-    `prompt contains dynamic uatType frontmatter value "${uatType}" after substitution`,
+    promptResult?.includes(`uatType: "${uatType}"`) ?? false,
+    `prompt contains dynamic uatType field "${uatType}" after substitution`,
   );
   assert.ok(
     !/\{\{[^}]+\}\}/.test(promptResult ?? ''),
@@ -249,7 +284,7 @@ test('(k) run-uat prompt template', () => {
   );
 });
 
-test('(k2) run-uat prompt references gsd_summary_save, not direct write', () => {
+test('(k2) run-uat prompt references gsd_uat_result_save, not direct write', () => {
   const promptResult = loadPromptFromWorktree('run-uat', {
     workingDirectory: '/tmp/test-project',
     milestoneId: 'M001',
@@ -261,17 +296,25 @@ test('(k2) run-uat prompt references gsd_summary_save, not direct write', () =>
   });
 
   assert.ok(
-    promptResult.includes('gsd_summary_save'),
-    'run-uat prompt should reference gsd_summary_save tool',
+    promptResult.includes('gsd_uat_result_save'),
+    'run-uat prompt should reference gsd_uat_result_save tool',
+  );
+  assert.ok(
+    promptResult.includes('presentedTools') && promptResult.includes('blockedTools'),
+    'run-uat prompt should specify the tool presentation contract',
   );
   assert.ok(
-    promptResult.includes('artifact_type: "ASSESSMENT"'),
-    'run-uat prompt should specify ASSESSMENT artifact type',
+    !promptResult.includes('Call `gsd_summary_save`'),
+    'run-uat prompt should not instruct direct summary-save UAT persistence',
   );
   assert.ok(
     !promptResult.includes('MUST write'),
     'run-uat prompt should not instruct direct file write in footer',
   );
+  assert.ok(
+    !promptResult.includes('Call `gsd_summary_save` with `artifact_type: "ASSESSMENT"`'),
+    'run-uat prompt should not instruct the legacy summary-save UAT path',
+  );
 });
 
 test('(l) dispatch preconditions via resolveSliceFile', () => {
@@ -482,8 +525,8 @@ test('(n) stale replay guard', async () => {
 });
 
 test('(q) verdict in ASSESSMENT file skips UAT dispatch (file-based path)', async () => {
-    // Regression test for #2644: run-uat prompt writes the verdict to
-    // S{sid}-ASSESSMENT.md (via gsd_summary_save artifact_type:"ASSESSMENT"),
+    // Regression test for #2644: run-uat writes the verdict to
+    // S{sid}-ASSESSMENT.md through the structured UAT save path,
     // but checkNeedsRunUat only checked S{sid}-UAT.md — causing a stuck loop.
     const base = createFixtureBase();
     try {
@@ -679,11 +722,30 @@ test('(u) run-uat prompt promotes artifact-driven browser specs to browser-execu
       const prompt = await buildRunUatPrompt('M001', 'S01', uatRel, uatContent, base);
 
       assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`browser-executable`/);
-      assert.match(prompt, /uatType: browser-executable/);
+      assert.match(prompt, /uatType: "browser-executable"/);
       assert.match(prompt, /use gsd-browser tools/i);
+      assert.match(prompt, /"browser_navigate"/);
+      assert.match(prompt, /"browser_assert"/);
     } finally {
       cleanup(base);
     }
 });
 
+test('(v) run-uat prompt keeps deferred browser work artifact-driven', async () => {
+    const base = createFixtureBase();
+    try {
+      const uatRel = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
+      const uatContent = makeDeferredBrowserUatContent();
+      writeSliceFile(base, 'M001', 'S01', 'UAT', uatContent);
+
+      const prompt = await buildRunUatPrompt('M001', 'S01', uatRel, uatContent, base);
+
+      assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`artifact-driven`/);
+      assert.match(prompt, /uatType: "artifact-driven"/);
+      assert.doesNotMatch(prompt, /uatType: "browser-executable"/);
+      assert.doesNotMatch(prompt, /"browser_navigate"/);
+    } finally {
+      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,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import {
+  buildProjectBrowserMcpServerConfig,
+  ensureClaudeCodeMcpJsonServerEnabled,
   ensureProjectWorkflowMcpConfig,
   GSD_BROWSER_MCP_SERVER_NAME,
   GSD_WORKFLOW_MCP_SERVER_NAME,
@@ -54,6 +56,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 +125,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 +151,42 @@ 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 });
+  }
+});
+
+test("buildProjectBrowserMcpServerConfig prefers newer gsd-browser on PATH", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-browser-"));
+
+  try {
+    const config = buildProjectBrowserMcpServerConfig(projectRoot, {
+      GSD_BROWSER_PATH_VERSION: "99.0.0",
+    });
+
+    assert.equal(config?.command, "gsd-browser");
+    assert.equal(config?.args?.[0], "mcp");
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("buildProjectBrowserMcpServerConfig keeps bundled browser when PATH version is older", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-browser-"));
+
+  try {
+    const config = buildProjectBrowserMcpServerConfig(projectRoot, {
+      GSD_BROWSER_PATH_VERSION: "0.0.1",
+    });
+
+    assert.equal(config?.command, process.execPath);
+    assert.match(config?.args?.[0] ?? "", /@opengsd[\/\\]gsd-browser[\/\\]bin[\/\\]gsd-browser/);
+    assert.equal(config?.args?.[1], "mcp");
   } finally {
     rmSync(projectRoot, { recursive: true, force: true });
   }
@@ -156,3 +207,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({
@@ -164,6 +341,8 @@ describe("formatMcpInitResult", () => {
     assert.match(result, /created project mcp config/i);
     assert.match(result, /\/tmp\/project\/\.mcp\.json/);
     assert.match(result, /mcp-capable clients/i);
+    assert.match(result, /workflow and gsd-browser MCP servers/i);
+    assert.match(result, /Pi Providers use the managed gsd-browser engine/i);
     assert.doesNotMatch(result, /claude code/i);
   });
 

package/src/resources/extensions/gsd/tests/memory-maintenance.test.ts

@@ -11,6 +11,16 @@ import {
 import { createMemoryRelation, listRelationsFor } from '../memory-relations.ts';
 import { saveEmbedding, getEmbeddingForMemory } from '../memory-embeddings.ts';
 
+function markProcessedUnits(count = 21): void {
+  const now = Date.now();
+  for (let i = 0; i < count; i++) {
+    markUnitProcessed(`unit/${i}`, `file-${i}`);
+    _getAdapter()!
+      .prepare('UPDATE memory_processed_units SET processed_at = :ts WHERE unit_key = :key')
+      .run({ ':ts': new Date(now + i * 1000).toISOString(), ':key': `unit/${i}` });
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // enforceMemoryCap — cascade cleanup of embeddings and relations
 // ═══════════════════════════════════════════════════════════════════════════
@@ -71,14 +81,7 @@ test('memory-decay: returns decayed memory IDs', () => {
   openDatabase(':memory:');
 
   // Insert processed units — decayStaleMemories needs at least N rows.
-  const now = Date.now();
-  for (let i = 0; i < 21; i++) {
-    markUnitProcessed(`unit/${i}`, `file-${i}`);
-    // small spacing to create deterministic ordering
-    const row = _getAdapter()!
-      .prepare('UPDATE memory_processed_units SET processed_at = :ts WHERE unit_key = :key');
-    row.run({ ':ts': new Date(now + i * 1000).toISOString(), ':key': `unit/${i}` });
-  }
+  markProcessedUnits();
 
   // Create memory with updated_at in the distant past
   createMemory({ category: 'pattern', content: 'stale entry', confidence: 0.9 });
@@ -98,6 +101,34 @@ test('memory-decay: returns decayed memory IDs', () => {
   closeDatabase();
 });
 
+test('memory-decay: skips stale decision-sourced memories', () => {
+  openDatabase(':memory:');
+  markProcessedUnits();
+
+  createMemory({ category: 'pattern', content: 'stale working note', confidence: 0.9 });
+  createMemory({
+    category: 'architecture',
+    content: 'decision-backed architecture memory',
+    confidence: 0.85,
+    structuredFields: { sourceDecisionId: 'D001' },
+  });
+  _getAdapter()!
+    .prepare("UPDATE memories SET updated_at = '2000-01-01T00:00:00Z' WHERE id IN ('MEM001', 'MEM002')")
+    .run({});
+
+  const decayed = decayStaleMemories(20);
+  assert.ok(decayed.includes('MEM001'));
+  assert.ok(!decayed.includes('MEM002'));
+
+  const rows = _getAdapter()!
+    .prepare("SELECT id, confidence FROM memories WHERE id IN ('MEM001', 'MEM002') ORDER BY id")
+    .all() as Array<{ id: string; confidence: number }>;
+  assert.ok(rows.find((row) => row.id === 'MEM001')!.confidence < 0.9);
+  assert.equal(rows.find((row) => row.id === 'MEM002')!.confidence, 0.85);
+
+  closeDatabase();
+});
+
 test('memory-decay: returns empty when there are fewer processed units than the threshold', () => {
   openDatabase(':memory:');
   createMemory({ category: 'pattern', content: 'fresh' });