@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tests/validation-gate-patterns.test.ts

@@ -1,11 +1,11 @@
 /**
  * Unit tests for the milestone completion validation gate pattern matching.
  *
- * The gate in auto-dispatch accepts two evidence formats:
- *   1. Structured template: content contains "Operational" AND ("MET" or "N/A")
- *   2. Prose evidence: matches /[Oo]perational[\s:][^\n]*(?:pass|verified|...)/i
+ * The milestone closeout gate accepts two evidence formats:
+ *   1. Structured template: content contains "Operational" AND an accepted verdict
+ *   2. Prose evidence: matches an Operational-local accepted verdict
  *
- * These tests exercise the exact same expressions used in auto-dispatch.ts
+ * These tests exercise the exact same expressions used in milestone-closeout.ts
  * to ensure both formats are correctly recognized, and that content without
  * operational evidence is properly rejected.
  */
@@ -23,9 +23,9 @@ import assert from "node:assert/strict";
 function hasOperationalEvidence(validationContent: string): boolean {
   const structuredMatch =
     validationContent.includes("Operational") &&
-    (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED") || validationContent.includes("DEFERRED"));
+    (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED") || validationContent.includes("DEFERRED") || validationContent.includes("PASS") || validationContent.includes("COVERED"));
   const proseMatch =
-    /[Oo]perational[\s\S]{0,500}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|deferred|n\/a|not[\s-]+applicable)/i.test(
+    /[Oo]perational[\s\S]{0,2000}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|deferred|n\/a|not[\s-]+applicable)/i.test(
       validationContent,
     );
   return structuredMatch || proseMatch;
@@ -116,6 +116,34 @@ test("structured: Operational + DEFERRED passes", () => {
   assert.ok(hasOperationalEvidence(content));
 });
 
+test("structured: Operational + PASS passes", () => {
+  const content = `| Class | Planned Check | Evidence | Verdict |
+| --- | --- | --- | --- |
+| Operational | Process lifecycle proof | Validation command exited cleanly. | PASS |`;
+  assert.ok(content.includes("PASS"));
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test("structured: Operational + COVERED passes", () => {
+  const content = `| Class | Planned Check | Evidence | Verdict |
+| --- | --- | --- | --- |
+| Operational | Process lifecycle proof | Validation command exited cleanly. | COVERED |`;
+  assert.ok(content.includes("COVERED"));
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test("prose: evidence-rich Operational row can place verdict after 500 characters", () => {
+  const evidence = "Lifecycle evidence from restart, reconnect, supervision, cleanup, and operator notification checks. ".repeat(7);
+  const content = `| Class | Planned Check | Evidence | Verdict |
+| --- | --- | --- | --- |
+| Operational | Headless process exits cleanly without orphaned subprocesses and preserves operator-visible state through restart. | ${evidence} | pass |`;
+  assert.ok(
+    content.toLowerCase().indexOf("pass", content.indexOf("Operational")) > content.indexOf("Operational") + 500,
+    "test fixture should place pass beyond the old 500-character window",
+  );
+  assert.ok(hasOperationalEvidence(content));
+});
+
 // ─── Issue #2862: checkmark emoji ────────────────────────────────────────────
 
 test('prose: "Operational: ✅" checkmark emoji passes (issue #2862)', () => {

package/src/resources/extensions/gsd/tests/verify-artifact-tightened.test.ts

@@ -202,3 +202,93 @@ test("execute-task DB lag branch — summary without checked plan still fails",
     "pending DB status plus summary is insufficient without a checked task checkbox",
   );
 });
+
+// ── #852 follow-up: worktree→project-root artifact fallback ──────────────────
+//
+// A milestone running in a worktree may not have its CONTEXT projected into the
+// worktree (the worktree only has the META dir until planning writes its
+// projections). When verifyExpectedArtifact can't find the artifact at the
+// worktree base, it must fall back to the project root — where the artifact
+// genuinely lives. Without this, discuss-milestone verification returned false
+// ("resolveExpectedArtifactPath returned null") and trapped the unit in a
+// finalize-retry loop.
+
+test("#852: discuss-milestone falls back to project root when CONTEXT not in worktree", () => {
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-fallback-proj-"));
+  try {
+    // Flat-phase CONTEXT lives at the project root.
+    const phaseDir = join(projectRoot, ".gsd", "phases", "15-m015");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "15-CONTEXT.md"), "# M015 context\n");
+
+    // Simulate the worktree: exists, registered with git (.git file), but has
+    // NO phases/ dir and no real CONTEXT — only the META dir git-service.ts
+    // created. resolveCanonicalMilestoneRoot redirects here.
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    const wtGsd = join(wtRoot, ".gsd");
+    mkdirSync(join(wtGsd, "milestones", "M015"), { recursive: true });
+    writeFileSync(join(wtGsd, "milestones", "M015", "M015-META.json"), '{"branch":"milestone/M015"}');
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+
+    // Verification with the worktree as base must fall back to the project root
+    // and find 15-CONTEXT.md there.
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", projectRoot),
+      true,
+      "must fall back to project root when CONTEXT is not in the worktree",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("#852: discuss-milestone passes when CONTEXT is in the worktree (no fallback needed)", () => {
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-present-"));
+  try {
+    // CONTEXT lives in BOTH the project root AND the worktree.
+    const projPhase = join(projectRoot, ".gsd", "phases", "15-m015");
+    mkdirSync(projPhase, { recursive: true });
+    writeFileSync(join(projPhase, "15-CONTEXT.md"), "# project context\n");
+
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    const wtGsd = join(wtRoot, ".gsd");
+    const wtPhase = join(wtGsd, "phases", "15-m015");
+    mkdirSync(wtPhase, { recursive: true });
+    writeFileSync(join(wtPhase, "15-CONTEXT.md"), "# worktree context\n");
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", projectRoot),
+      true,
+      "must pass when CONTEXT is in the worktree",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("#852: discuss-milestone fails when CONTEXT is in neither worktree nor project root", () => {
+  // If the artifact genuinely doesn't exist anywhere, verification must still
+  // fail (fail-closed) — the fallback must not mask a real absence.
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-absent-"));
+  try {
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    mkdirSync(join(wtRoot, ".gsd", "milestones", "M015"), { recursive: true });
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+    // No phases/ anywhere, no CONTEXT anywhere.
+
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", projectRoot),
+      false,
+      "must fail when CONTEXT exists in neither root",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/visualizer-data.test.ts

@@ -11,6 +11,8 @@ import {
   loadVisualizerData,
   type VisualizerMilestone,
 } from "../visualizer-data.ts";
+import { _getAdapter, closeDatabase, openDatabase } from "../gsd-db.ts";
+import { createMemory } from "../memory-store.ts";
 
 test("computeCriticalPath follows milestone dependencies", () => {
   const milestones: VisualizerMilestone[] = [
@@ -82,3 +84,88 @@ test("loadVisualizerData hydrates milestones, captures, stats, and health fields
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("loadVisualizerData includes active memory-store entries", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-visualizer-memories-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(":memory:");
+
+    createMemory({
+      category: "gotcha",
+      content: "Visualizer memory rows must come from the memory store",
+      confidence: 0.92,
+      scope: "M001/S01",
+      tags: ["visualizer", "memory"],
+    });
+    createMemory({
+      category: "pattern",
+      content: "Superseded rows should stay out of the visualizer",
+      confidence: 0.2,
+    });
+
+    const adapter = _getAdapter();
+    adapter?.prepare("UPDATE memories SET superseded_by = 'MEM999' WHERE id = 'MEM002'").run();
+
+    const data = await loadVisualizerData(base);
+
+    assert.equal(data.memories.totalCount, 1);
+    assert.equal(data.memories.entries[0]?.id, "MEM001");
+    assert.equal(data.memories.entries[0]?.category, "gotcha");
+    assert.equal(data.memories.entries[0]?.content, "Visualizer memory rows must come from the memory store");
+    assert.equal(data.memories.entries[0]?.scope, "M001/S01");
+    assert.deepEqual(data.memories.entries[0]?.tags, ["visualizer", "memory"]);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("loadVisualizerData opens the project DB for memory entries when none is open", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-visualizer-memories-db-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    createMemory({
+      category: "gotcha",
+      content: "Browser visualizer child processes must open the project DB",
+      confidence: 0.88,
+      tags: ["browser", "visualizer"],
+    });
+    closeDatabase();
+
+    const data = await loadVisualizerData(base);
+
+    assert.equal(data.memories.totalCount, 1);
+    assert.equal(data.memories.entries[0]?.id, "MEM001");
+    assert.equal(data.memories.entries[0]?.content, "Browser visualizer child processes must open the project DB");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("loadVisualizerData caps memory content for visualizer payloads", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-visualizer-memory-cap-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(":memory:");
+    const largeContent = "A".repeat(2500);
+    createMemory({
+      category: "gotcha",
+      content: largeContent,
+      confidence: 0.9,
+    });
+
+    const data = await loadVisualizerData(base);
+
+    const content = data.memories.entries[0]?.content ?? "";
+    assert.equal(data.memories.totalCount, 1);
+    assert.ok(content.length < largeContent.length);
+    assert.ok(content.length <= 2003);
+    assert.ok(content.endsWith("..."));
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/visualizer-views.test.ts

@@ -49,6 +49,7 @@ function makeVisualizerData(overrides: Partial<VisualizerData> = {}): Visualizer
     changelog: { entries: [] },
     sliceVerifications: [],
     knowledge: { rules: [], patterns: [], lessons: [], exists: false },
+    memories: { entries: [], totalCount: 0 },
     captures: { entries: [], pendingCount: 0, totalCount: 0 },
     health: {
       budgetCeiling: undefined,
@@ -617,6 +618,32 @@ console.log("\n=== renderKnowledgeView ===");
   assert.ok(lines.some(l => l.includes("No KNOWLEDGE.md found")), "shows no-knowledge message");
 }
 
+{
+  const data = makeVisualizerData({
+    memories: {
+      totalCount: 1,
+      entries: [
+        {
+          id: "MEM001",
+          category: "gotcha",
+          content: "Use memory store rows for durable project facts",
+          confidence: 0.91,
+          hitCount: 3,
+          scope: "M001/S01",
+          tags: ["visualizer"],
+          updatedAt: "2026-06-21T12:00:00.000Z",
+        },
+      ],
+    },
+  });
+  const lines = renderKnowledgeView(data, mockTheme, 100);
+  assert.ok(lines.some(l => l.includes("Memories")), "shows memories section");
+  assert.ok(lines.some(l => l.includes("MEM001")), "shows memory ID");
+  assert.ok(lines.some(l => l.includes("(gotcha")), "shows memory category");
+  assert.ok(lines.some(l => l.includes("Use memory store rows")), "shows memory content");
+  assert.ok(lines.some(l => l.includes("M001/S01")), "shows memory scope");
+}
+
 // ─── renderCapturesView ─────────────────────────────────────────────────────
 
 console.log("\n=== renderCapturesView ===");

package/src/resources/extensions/gsd/tests/workflow-kernel.test.ts

@@ -203,6 +203,57 @@ test("decideFinalizeResult maps continue and next results", () => {
   assert.deepEqual(decideFinalizeResult({ action: "next" }), { action: "complete" });
 });
 
+// ── #852 follow-up: carry the specific verification failure into the ledger ──
+//
+// A bare "finalize-retry" ledger summary makes the stuck-loop kill message
+// ("Same error repeated: finalize-retry") opaque — it took a full forensics
+// dive to learn the real reason was "roadmap has zero slices". The retry
+// decision now appends the failureDetail so the summary is actionable while
+// preserving the stable "finalize-retry" prefix for legacy filters.
+
+test("decideFinalizeResult appends failureDetail to the retry ledger summary (#852)", () => {
+  assert.deepEqual(
+    decideFinalizeResult({ action: "continue", failureDetail: "roadmap has zero slices" }),
+    { action: "retry", ledgerErrorSummary: "finalize-retry: roadmap has zero slices" },
+  );
+  // The prefix is preserved so dashboards/filters matching "finalize-retry" still hit.
+  // Narrow to the retry arm before accessing ledgerErrorSummary (FinalizeDecision is a union).
+  const suffixed = decideFinalizeResult({ action: "continue", failureDetail: "15-SUMMARY.md was not found on disk" });
+  assert.strictEqual(suffixed.action, "retry");
+  assert.match(
+    (suffixed as { action: "retry"; ledgerErrorSummary: string }).ledgerErrorSummary,
+    /^finalize-retry:/,
+  );
+});
+
+test("decideFinalizeResult collapses whitespace-only / empty failureDetail to the bare token (#852)", () => {
+  assert.deepEqual(
+    decideFinalizeResult({ action: "continue", failureDetail: "   " }),
+    { action: "retry", ledgerErrorSummary: "finalize-retry" },
+  );
+  assert.deepEqual(
+    decideFinalizeResult({ action: "continue", failureDetail: "" }),
+    { action: "retry", ledgerErrorSummary: "finalize-retry" },
+  );
+});
+
+test("decideFinalizeResult strips per-attempt suffixes for stable repeat-error detection (#852)", () => {
+  const base = "Artifact verification failed: roadmap has zero slices";
+  const attempt1 = decideFinalizeResult({
+    action: "continue",
+    failureDetail: `${base} (attempt 1/3).`,
+  });
+  const attempt2 = decideFinalizeResult({
+    action: "continue",
+    failureDetail: `${base} (attempt 2/3).`,
+  });
+  assert.deepEqual(attempt1, attempt2);
+  assert.deepEqual(attempt1, {
+    action: "retry",
+    ledgerErrorSummary: `finalize-retry: ${base}`,
+  });
+});
+
 test("decideEngineReconcile maps terminal outcomes", () => {
   assert.deepEqual(
     decideEngineReconcile({ outcome: "milestone-complete" }),

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

@@ -0,0 +1,133 @@
+// Project/App: gsd-pi
+// File Purpose: Regression coverage for workflow MCP preflight probing before Claude Code starts a model turn.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import { mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
+
+import { awaitWorkflowMcpToolRegistration } from "../tool-surface-readiness.ts";
+import { clearWorkflowMcpProbeCache } from "../workflow-mcp-readiness-cache.ts";
+
+const SERVER = "gsd-workflow";
+
+test("preflight uses inline workflow MCP config when no project config is persisted", async () => {
+  clearWorkflowMcpProbeCache();
+  const projectRoot = realpathSync(mkdtempSync(join(tmpdir(), "workflow-mcp-inline-preflight-")));
+  try {
+    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(projectRoot, "fake-workflow-mcp-server.mjs");
+    writeFileSync(
+      serverPath,
+      [
+        `const { McpServer } = await import(${JSON.stringify(mcpModuleUrl)});`,
+        `const { StdioServerTransport } = await import(${JSON.stringify(stdioModuleUrl)});`,
+        'const server = new McpServer({ name: "fake", version: "1.0.0" }, { capabilities: { tools: {} } });',
+        'server.tool("gsd_plan_slice", "Plan slice", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
+        'server.tool("gsd_reassess_roadmap", "Reassess roadmap", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
+        'await server.connect(new StdioServerTransport());',
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const error = await awaitWorkflowMcpToolRegistration({
+      unitType: "plan-slice",
+      workflowServerName: SERVER,
+      projectRoot,
+      timeoutMs: 10_000,
+      pollMs: 1,
+      workflowServerConfig: { command: process.execPath, args: [serverPath] },
+    });
+
+    assert.equal(error, null);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("preflight reuses one inline stdio MCP child while polling incomplete tool registration", async () => {
+  clearWorkflowMcpProbeCache();
+  const projectRoot = realpathSync(mkdtempSync(join(tmpdir(), "workflow-mcp-reuse-preflight-")));
+  try {
+    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 spawnCountPath = join(projectRoot, "spawn-count.txt");
+    const serverPath = join(projectRoot, "incomplete-workflow-mcp-server.mjs");
+    writeFileSync(
+      serverPath,
+      [
+        'const { appendFileSync } = await import("node:fs");',
+        `appendFileSync(${JSON.stringify(spawnCountPath)}, "spawn\\n");`,
+        `const { McpServer } = await import(${JSON.stringify(mcpModuleUrl)});`,
+        `const { StdioServerTransport } = await import(${JSON.stringify(stdioModuleUrl)});`,
+        'const server = new McpServer({ name: "fake", version: "1.0.0" }, { capabilities: { tools: {} } });',
+        'server.tool("gsd_uat_result_save", "Save UAT result", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
+        'await server.connect(new StdioServerTransport());',
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const error = await awaitWorkflowMcpToolRegistration({
+      unitType: "run-uat",
+      workflowServerName: SERVER,
+      projectRoot,
+      timeoutMs: 1_000,
+      pollMs: 10,
+      workflowServerConfig: { command: process.execPath, args: [serverPath] },
+    });
+
+    assert.ok(error);
+    assert.match(error, /did not register required tools before session start/);
+    const spawnCount = readFileSync(spawnCountPath, "utf-8").trim().split("\n").filter(Boolean).length;
+    assert.equal(spawnCount, 1);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("preflight timeout includes the last probe error", async () => {
+  clearWorkflowMcpProbeCache();
+  const error = await awaitWorkflowMcpToolRegistration({
+    unitType: "run-uat",
+    workflowServerName: SERVER,
+    projectRoot: "/tmp/project",
+    timeoutMs: 5,
+    pollMs: 1,
+    probe: async () => ({ ok: false, tools: [], error: "Unknown MCP server." }),
+  });
+
+  assert.ok(error);
+  assert.match(error, /last probe error: Unknown MCP server\./);
+});
+
+test("preflight timeout does not report stale error when a later probe connects without error", async () => {
+  clearWorkflowMcpProbeCache();
+  let call = 0;
+  // First call throws a connection error; subsequent calls return a successful
+  // connection with no error but without the required tools (server connected,
+  // tools not yet registered).
+  const probe = async (): Promise<{ ok: boolean; tools: string[]; error?: string }> => {
+    if (call++ === 0) throw new Error("Unknown MCP server.");
+    return { ok: false, tools: [], error: undefined };
+  };
+
+  const error = await awaitWorkflowMcpToolRegistration({
+    unitType: "run-uat",
+    workflowServerName: SERVER,
+    projectRoot: "/tmp/project",
+    timeoutMs: 20,
+    pollMs: 1,
+    probe,
+  });
+
+  assert.ok(error);
+  // The stale connection-failure error should have been cleared once the later
+  // probe returned a result without an error field.
+  assert.doesNotMatch(error, /last probe error/);
+});

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

@@ -82,8 +82,9 @@ test("refine-slice requires canonical slice planning tool", () => {
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("refine-slice"), ["gsd_plan_slice"]);
 });
 
-test("complete-slice requires closeout and execution handoff tools", () => {
+test("complete-slice requires status, closeout, and execution handoff tools", () => {
   const expected = [
+    "gsd_milestone_status",
     "gsd_exec",
     "gsd_capture_thought",
     "gsd_slice_complete",
@@ -283,6 +284,35 @@ test("detectWorkflowMcpLaunchConfig resolves the bundled server from GSD_BIN_PAT
   assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
 });
 
+test("detectWorkflowMcpLaunchConfig memoizes repo root discovery for the same deep GSD_BIN_PATH", () => {
+  const repoRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-root-cache-"));
+  const worktreeRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-root-cache-wt-"));
+  const cliPath = join(repoRoot, "packages", "mcp-server", "dist", "cli.js");
+  const devCliPath = join(repoRoot, ".gsd", "worktrees", "M001", "S01", "deep", "bin", "gsd");
+
+  mkdirSync(join(repoRoot, "packages", "mcp-server", "dist"), { recursive: true });
+  mkdirSync(join(repoRoot, ".gsd", "worktrees", "M001", "S01", "deep", "bin"), { recursive: true });
+  writeFileSync(cliPath, "#!/usr/bin/env node\n", "utf-8");
+  writeFileSync(devCliPath, "#!/usr/bin/env node\n", "utf-8");
+
+  try {
+    const firstLaunch = detectWorkflowMcpLaunchConfig(worktreeRoot, {
+      GSD_BIN_PATH: devCliPath,
+    });
+    assert.equal(firstLaunch?.args?.[0], cliPath);
+
+    rmSync(cliPath, { force: true });
+
+    const secondLaunch = detectWorkflowMcpLaunchConfig(worktreeRoot, {
+      GSD_BIN_PATH: devCliPath,
+    });
+    assert.equal(secondLaunch?.args?.[0], cliPath);
+  } finally {
+    rmSync(repoRoot, { recursive: true, force: true });
+    rmSync(worktreeRoot, { recursive: true, force: true });
+  }
+});
+
 test("detectWorkflowMcpLaunchConfig resolves the bundled server from a symlinked GSD_BIN_PATH", () => {
   const repoRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-symlink-root-"));
   const binDir = mkdtempSync(join(tmpdir(), "gsd-workflow-symlink-bin-"));
@@ -526,16 +556,12 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
       ((sliceResult.content as Array<{ text?: string }>)?.[0])?.text ?? "",
       /Planned slice S01/,
     );
+    // Flat-phase: M001 title "Transport planning" → phases/01-transport-planning/01-01-PLAN.md
     assert.ok(
-      existsSync(join(projectRoot, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md")),
+      existsSync(join(projectRoot, ".gsd", "phases", "01-transport-planning", "01-01-PLAN.md")),
       "expected slice plan artifact to be written through stdio MCP",
     );
-    assert.ok(
-      existsSync(
-        join(projectRoot, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-PLAN.md"),
-      ),
-      "expected task plan artifact to be written through stdio MCP",
-    );
+    // Flat-phase: tasks are checkboxes in the slice plan file, no per-task plan files.
   } finally {
     await client.close().catch(() => {});
     rmSync(projectRoot, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/workflow-projections.test.ts

@@ -226,9 +226,9 @@ test('workflow-projections: regenerateIfMissing PLAN restores slice plan and tas
       planning: { description: 'Do the second thing.', estimate: '2h' },
     });
 
+    // Legacy layout: renderer writes milestones/M001/slices/S01/S01-PLAN.md
+    // (relSliceFile detects milestones/ prefix → uses legacy S01-PLAN.md filename).
     const slicePlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md');
-    const t1PlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T01-PLAN.md');
-    const t2PlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T02-PLAN.md');
 
     assert.ok(!existsSync(slicePlanPath), 'precondition: slice plan absent');
 
@@ -236,8 +236,7 @@ test('workflow-projections: regenerateIfMissing PLAN restores slice plan and tas
 
     assert.equal(regenerated, true, 'regenerateIfMissing reports the PLAN was rebuilt');
     assert.ok(existsSync(slicePlanPath), 'slice PLAN restored on disk');
-    assert.ok(existsSync(t1PlanPath), 'T01 task plan restored');
-    assert.ok(existsSync(t2PlanPath), 'T02 task plan restored');
+    // Flat-phase: tasks are checkboxes inside the plan file, not separate task plan files.
   } finally {
     closeDatabase();
     rmSync(base, { recursive: true, force: true });