@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

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

@@ -24,6 +24,7 @@ import {
 } from '../gsd-db.ts';
 import {
   writeManifest,
+  flushManifest,
   readManifest,
   snapshotState,
   bootstrapFromManifest,
@@ -42,6 +43,11 @@ function cleanupDir(dirPath: string): void {
   try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
 }
 
+async function writeManifestAndFlush(base: string): Promise<void> {
+  writeManifest(base);
+  await flushManifest(base);
+}
+
 function insertMemoryBackedDecision(id: string): void {
   const now = '2026-01-01T00:00:00.000Z';
   insertMemoryRow({
@@ -83,12 +89,14 @@ test('workflow-manifest: readManifest returns null when file does not exist', ()
 
 // ─── writeManifest + readManifest round-trip ─────────────────────────────
 
-test('workflow-manifest: writeManifest creates state-manifest.json with version 1', () => {
+test('workflow-manifest: writeManifest creates state-manifest.json with version 1 after flush', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     writeManifest(base);
     const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
+    assert.equal(fs.existsSync(manifestPath), false, 'writeManifest should not synchronously write state-manifest.json');
+    await flushManifest(base);
     assert.ok(fs.existsSync(manifestPath), 'state-manifest.json should exist');
     const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
     assert.strictEqual(raw.version, 1);
@@ -98,11 +106,11 @@ test('workflow-manifest: writeManifest creates state-manifest.json with version
   }
 });
 
-test('workflow-manifest: readManifest parses manifest written by writeManifest', () => {
+test('workflow-manifest: readManifest parses manifest written by writeManifest', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     const manifest = readManifest(base);
     assert.ok(manifest !== null);
     assert.strictEqual(manifest!.version, 1);
@@ -124,6 +132,25 @@ test('workflow-manifest: readManifest parses manifest written by writeManifest',
   }
 });
 
+test('workflow-manifest: flushManifest writes the latest queued payload', async () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001', title: 'First Milestone' });
+    writeManifest(base);
+    insertMilestone({ id: 'M002', title: 'Latest Milestone' });
+    writeManifest(base);
+
+    await flushManifest(base);
+
+    const manifest = readManifest(base);
+    assert.ok(manifest?.milestones.some((m) => m.id === 'M002'), 'latest queued write should be durable');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
 // ─── snapshotState: captures DB rows ─────────────────────────────────────
 
 test('workflow-manifest: snapshotState includes inserted milestone', () => {
@@ -181,7 +208,7 @@ test('workflow-manifest: snapshotState captures memory-backed decisions', () =>
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest restores extended correctness rows', () => {
+test('workflow-manifest: bootstrapFromManifest restores extended correctness rows', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
@@ -256,7 +283,7 @@ test('workflow-manifest: bootstrapFromManifest restores extended correctness row
       createdAt: '2026-06-05T00:00:00.000Z',
     });
 
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');
@@ -306,7 +333,7 @@ test('workflow-manifest: bootstrapFromManifest returns false when no manifest fi
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-trip)', () => {
+test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-trip)', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
@@ -326,7 +353,7 @@ test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-
       status: 'complete',
       planning: { fullPlanMd: '# Full Task Plan\n\nKeep this body.', targetRepositories: ['project'] },
     });
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     // Open a fresh DB and bootstrap from manifest
@@ -356,14 +383,14 @@ test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest preserves target_repositories', () => {
+test('workflow-manifest: bootstrapFromManifest preserves target_repositories', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMilestone({ id: 'M001', title: 'Restored Milestone' });
     insertSlice({ id: 'S01', milestoneId: 'M001', planning: { targetRepositories: ['frontend'] } });
     insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', planning: { targetRepositories: ['backend'] } });
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');
@@ -380,14 +407,68 @@ test('workflow-manifest: bootstrapFromManifest preserves target_repositories', (
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest preserves optional rows from old manifests', () => {
+test('workflow-manifest: bootstrapFromManifest does not truncate projections when artifact content is empty', async () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001', title: 'Projection Milestone' });
+    insertArtifact({
+      path: '.gsd/milestones/M001/M001-PLAN.md',
+      artifact_type: 'PLAN',
+      milestone_id: 'M001',
+      slice_id: null,
+      task_id: null,
+      full_content: '# Manifest Plan',
+    });
+    insertArtifact({
+      path: '.gsd/milestones/M001/M001-VALIDATION.md',
+      artifact_type: 'VALIDATION',
+      milestone_id: 'M001',
+      slice_id: null,
+      task_id: null,
+      full_content: '# Manifest Validation',
+    });
+    await writeManifestAndFlush(base);
+
+    const planPath = path.join(base, '.gsd', 'milestones', 'M001', 'M001-PLAN.md');
+    const validationPath = path.join(base, '.gsd', 'milestones', 'M001', 'M001-VALIDATION.md');
+    fs.mkdirSync(path.dirname(planPath), { recursive: true });
+    fs.writeFileSync(planPath, '# Existing Plan\n\nKeep this.');
+    fs.writeFileSync(validationPath, '# Existing Validation\n\nKeep this.');
+
+    const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')) as Record<string, unknown>;
+    const artifacts = manifest['artifacts'] as Array<Record<string, unknown>>;
+    const emptyArtifact = artifacts.find((r) => r['path'] === '.gsd/milestones/M001/M001-PLAN.md');
+    const absentArtifact = artifacts.find((r) => r['path'] === '.gsd/milestones/M001/M001-VALIDATION.md');
+    assert.ok(emptyArtifact !== undefined);
+    assert.ok(absentArtifact !== undefined);
+    emptyArtifact['full_content'] = '';
+    delete absentArtifact['full_content'];
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    closeDatabase();
+
+    const newDbPath = path.join(base, 'new.db');
+    openDatabase(newDbPath);
+    const restored = bootstrapFromManifest(base);
+    assert.strictEqual(restored, true);
+
+    assert.strictEqual(fs.readFileSync(planPath, 'utf-8'), '# Existing Plan\n\nKeep this.');
+    assert.strictEqual(fs.readFileSync(validationPath, 'utf-8'), '# Existing Validation\n\nKeep this.');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('workflow-manifest: bootstrapFromManifest preserves optional rows from old manifests', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMilestone({ id: 'M001', title: 'Old Manifest Milestone' });
     insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Old Manifest Slice' });
     insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Old Manifest Task' });
-    writeManifest(base);
+    await writeManifestAndFlush(base);
 
     const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
     const oldManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')) as Record<string, unknown>;
@@ -450,12 +531,12 @@ test('workflow-manifest: bootstrapFromManifest preserves optional rows from old
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest restores memory-backed decisions', () => {
+test('workflow-manifest: bootstrapFromManifest restores memory-backed decisions', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMemoryBackedDecision('D901');
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');
@@ -472,12 +553,12 @@ test('workflow-manifest: bootstrapFromManifest restores memory-backed decisions'
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest replaces stale memory-backed decisions', () => {
+test('workflow-manifest: bootstrapFromManifest replaces stale memory-backed decisions', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMemoryBackedDecision('D902');
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');

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

@@ -0,0 +1,134 @@
+// 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_plan_task", "Plan task", {}, 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

@@ -65,14 +65,18 @@ test("auto execute-task requires canonical task completion tool", () => {
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("execute-task"), expected);
 });
 
-test("plan-slice requires planning and roadmap reassessment tools", () => {
-  const expected = ["gsd_plan_slice", "gsd_reassess_roadmap"];
+test("plan-slice requires slice + incremental task planning and roadmap reassessment tools", () => {
+  // Incremental planning (#1027): gsd_plan_slice persists metadata, then
+  // gsd_plan_task adds tasks one at a time, so both must be on the surface.
+  const expected = ["gsd_plan_slice", "gsd_plan_task", "gsd_reassess_roadmap"];
   assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("plan-slice"), expected);
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("plan-slice"), expected);
 });
 
-test("plan-milestone requires status, roadmap, and single-slice planning tools", () => {
-  const expected = ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice"];
+test("plan-milestone requires status, roadmap, and slice + task planning tools", () => {
+  // gsd_plan_task is required alongside gsd_plan_slice for incremental
+  // milestone planning (#1027).
+  const expected = ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice", "gsd_plan_task"];
   assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("plan-milestone"), expected);
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("plan-milestone"), expected);
 });
@@ -82,8 +86,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 +288,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 +560,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 });