@opengsd/gsd-pi 1.1.1-dev.74e8dd1 → 1.1.1-dev.75048e7

package/src/resources/extensions/gsd/tests/gate-1b-orphan-discrimination.test.ts

@@ -1,12 +1,9 @@
 /**
- * gsd-pi / guided-flow — regression tests for Gate 1b orphan discrimination
+ * gsd-pi / guided-flow — regression tests for Gate 1b discussion handoff
  *
- * Gate 1b in checkAutoStartAfterDiscuss discriminates between two "queued" states:
- *   (a) plan-blocked: discuss completed (CONTEXT.md on disk), but gsd_plan_milestone
- *       was hard-blocked by the depth-verification gate.  DB row stuck at "queued".
- *       → emit recovery hint directing the LLM to retry gsd_plan_milestone.
- *   (b) discuss-incomplete: discuss did not finish, no CONTEXT.md, DB row "queued".
- *       → silent block (no recovery hint).
+ * Gate 1b treats queued + pinned CONTEXT.md as Discussion Complete, Planning
+ * Pending. It must accept the handoff without warning the user or injecting a
+ * hidden gsd_plan_milestone retry.
  */
 
 import { describe, test, beforeEach, afterEach } from "node:test";
@@ -27,8 +24,6 @@ import {
   insertMilestone,
 } from "../gsd-db.ts";
 
-// ─── Harness ───────────────────────────────────────────────────────────────
-
 interface MockCapture {
   notifies: Array<{ msg: string; level: string }>;
   messages: Array<{ payload: any; options: any }>;
@@ -58,24 +53,26 @@ function mkPi(cap: MockCapture): any {
   };
 }
 
-/**
- * Create a minimal temp tree with a .gsd/milestones/M001 directory.
- */
 function mkBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-gate1b-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
   return base;
 }
 
-// ─── Tests ─────────────────────────────────────────────────────────────────
+function writeContext(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001: Test Milestone\n\nContext written by discuss phase.\n",
+  );
+}
 
-describe("Gate 1b orphan discrimination in checkAutoStartAfterDiscuss", () => {
+describe("Gate 1b discussion handoff in checkAutoStartAfterDiscuss", () => {
   let base: string;
   let cap: MockCapture;
 
   beforeEach(() => {
     clearPendingAutoStart();
-    drainLogs(); // discard noise from prior tests
+    drainLogs();
   });
 
   afterEach(() => {
@@ -86,104 +83,59 @@ describe("Gate 1b orphan discrimination in checkAutoStartAfterDiscuss", () => {
     }
   });
 
-  test("plan-blocked: CONTEXT.md present + DB row queued → returns false + recovery hint emitted", () => {
+  test("queued row + CONTEXT.md accepts context-captured handoff without hidden retry", () => {
     base = mkBase();
     openDatabase(":memory:");
-
-    // DB row exists with status "queued" (plan_milestone was blocked)
     insertMilestone({ id: "M001", title: "Test Milestone", status: "queued" });
-
-    // CONTEXT.md on disk (discuss phase completed)
-    writeFileSync(
-      join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
-      "# M001: Test Milestone\n\nContext written by discuss phase.\n",
-    );
+    writeContext(base);
 
     cap = mkCapture();
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
+      startAuto: false,
       ctx: mkCtx(cap),
       pi: mkPi(cap),
     });
 
     const result = checkAutoStartAfterDiscuss();
 
-    // Must return false — auto-start should not proceed
-    assert.equal(result, false, "checkAutoStartAfterDiscuss must return false (plan still blocked)");
-
-    // Recovery hint must be sent to the LLM
-    assert.equal(
-      cap.messages.length,
-      1,
-      "exactly one sendMessage call expected for the recovery hint",
-    );
-    assert.equal(
-      cap.messages[0].payload.customType,
-      "gsd-plan-milestone-blocked-recovery",
-      "recovery message must have customType gsd-plan-milestone-blocked-recovery",
-    );
+    assert.equal(result, true, "queued + context is a valid planning-pending handoff");
+    assert.equal(cap.messages.length, 0, "must not inject a hidden recovery turn");
+    assert.equal(cap.notifies.length, 1, "must emit one success notification");
+    assert.deepEqual(cap.notifies[0], {
+      msg: "Milestone M001 context captured. Continuing the planning pipeline.",
+      level: "success",
+    });
     assert.equal(
-      cap.messages[0].options.triggerTurn,
-      true,
-      "recovery message must set triggerTurn: true",
-    );
-    assert.match(
-      cap.messages[0].payload.content,
-      /gsd_plan_milestone/,
-      "recovery message content must mention gsd_plan_milestone",
+      cap.notifies.some(n => /queued|gsd_plan_milestone/i.test(n.msg)),
+      false,
+      "user-visible copy must not mention queued state or internal plan tool retry",
     );
-
-    // User must be notified via ctx.ui.notify
-    assert.ok(
-      cap.notifies.some((n) => n.level === "warning" && /queued/.test(n.msg)),
-      "user must be notified with a warning about the queued state",
-    );
-
-    // logWarning must have recorded the Gate 1b event
-    const logs = drainLogs();
-    const gate1bLog = logs.find(
-      (e) => e.component === "guided" && /Gate 1b/.test(e.message),
-    );
-    assert.ok(gate1bLog, "Gate 1b warning must be logged via logWarning");
   });
 
-  test("discuss-incomplete: no CONTEXT.md + DB row queued → returns false silently (no recovery hint)", () => {
+  test("queued row without CONTEXT.md still waits silently for discussion output", () => {
     base = mkBase();
     openDatabase(":memory:");
-
-    // DB row exists with status "queued", but NO CONTEXT.md on disk
     insertMilestone({ id: "M001", title: "Test Milestone", status: "queued" });
 
-    // No CONTEXT.md written — discuss phase is incomplete
     cap = mkCapture();
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
+      startAuto: false,
       ctx: mkCtx(cap),
       pi: mkPi(cap),
     });
 
-    drainLogs(); // clear any noise before the call
+    drainLogs();
 
     const result = checkAutoStartAfterDiscuss();
 
-    // Must return false — silent block
-    assert.equal(result, false, "checkAutoStartAfterDiscuss must return false when discuss is incomplete");
-
-    // No recovery hint — Gate 1 blocks before Gate 1b is reached
-    assert.equal(
-      cap.messages.length,
-      0,
-      "no sendMessage calls expected when CONTEXT.md is absent",
-    );
-    assert.equal(
-      cap.notifies.length,
-      0,
-      "no user notifications expected for discuss-incomplete case",
-    );
+    assert.equal(result, false, "must keep waiting while discuss has not written context");
+    assert.equal(cap.messages.length, 0, "no hidden recovery turn expected");
+    assert.equal(cap.notifies.length, 0, "no user notifications expected");
 
-    // No Gate 1b log entry
     const logs = drainLogs();
     const gate1bLog = logs.find(
       (e) => e.component === "guided" && /Gate 1b/.test(e.message),

package/src/resources/extensions/gsd/tests/guided-discuss-milestone-prompt-rendering.test.ts

@@ -3,10 +3,11 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { VISION_ASK_VARIANTS } from "../vision-ask.ts";
+import { buildDiscussMilestonePrompt } from "../auto-prompts.ts";
 
 test("guided milestone prompt renders compact interview and context guidance", async (t) => {
   const previousGsdHome = process.env.GSD_HOME;
@@ -47,3 +48,41 @@ test("guided milestone prompt renders compact interview and context guidance", a
   assert.match(prompt, /milestone_id: M001/);
   assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
 });
+
+test("guided milestone prompt builder preloads milestone planning context", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-context-"));
+  try {
+    const milestonesRoot = join(base, ".gsd", "milestones");
+    const priorDir = join(milestonesRoot, "M001");
+    const currentDir = join(milestonesRoot, "M002");
+    const futureDir = join(milestonesRoot, "M003");
+    mkdirSync(priorDir, { recursive: true });
+    mkdirSync(currentDir, { recursive: true });
+    mkdirSync(futureDir, { recursive: true });
+
+    writeFileSync(join(base, ".gsd", "DECISIONS.md"), "# Decisions\n\nDECISION-SIGNAL", "utf-8");
+    writeFileSync(join(priorDir, "M001-SUMMARY.md"), "# M001 Summary\n\nPRIOR-SUMMARY-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-ROADMAP.md"), "# M002 Roadmap\n\nROADMAP-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-CONTEXT.md"), "# M002 Context\n\nCONTEXT-SIGNAL", "utf-8");
+    writeFileSync(join(currentDir, "M002-RESEARCH.md"), "# M002 Research\n\nRESEARCH-SIGNAL", "utf-8");
+    writeFileSync(join(futureDir, "M003-SUMMARY.md"), "# M003 Summary\n\nFUTURE-SUMMARY-SIGNAL", "utf-8");
+
+    const prompt = await buildDiscussMilestonePrompt("M002", "Checkout Polish", base, "true");
+
+    assert.match(prompt, /## Inlined Context \(preloaded — do not re-read these files\)/);
+    assert.match(prompt, /### Milestone Roadmap/);
+    assert.match(prompt, /ROADMAP-SIGNAL/);
+    assert.match(prompt, /### Milestone Context/);
+    assert.match(prompt, /CONTEXT-SIGNAL/);
+    assert.match(prompt, /### Milestone Research/);
+    assert.match(prompt, /RESEARCH-SIGNAL/);
+    assert.match(prompt, /### Decisions Register/);
+    assert.match(prompt, /DECISION-SIGNAL/);
+    assert.match(prompt, /### M001 Prior Milestone Summary/);
+    assert.match(prompt, /PRIOR-SUMMARY-SIGNAL/);
+    assert.doesNotMatch(prompt, /FUTURE-SUMMARY-SIGNAL/);
+    assert.match(prompt, /### Output Template: Context/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-dispatch-root.test.ts

@@ -104,3 +104,89 @@ test("guided dispatch passes the explicit project root through model and compati
     rmSync(otherRoot, { recursive: true, force: true });
   }
 });
+
+test("guided dispatch accepts workflow MCP tools absent from parent active tool surface", async () => {
+  const explicitRoot = mkdtempSync(join(tmpdir(), "gsd-guided-mcp-surface-"));
+  const workflowPath = join(explicitRoot, "GSD-WORKFLOW.md");
+  const originalWorkflowPath = process.env.GSD_WORKFLOW_PATH;
+  const originalMcpCommand = process.env.GSD_WORKFLOW_MCP_COMMAND;
+  const notifications: string[] = [];
+  let sent = false;
+
+  const ctx = {
+    model: { provider: "claude-code", baseUrl: "local://claude-code" },
+    modelRegistry: {
+      getProviderAuthMode: () => "externalCli",
+    },
+    ui: {
+      notify: (message: string) => {
+        notifications.push(message);
+      },
+    },
+  };
+
+  let activeTools = [
+    "ScheduleWakeup",
+    "ToolSearch",
+    "ask_user_questions",
+    "bash",
+    "read",
+    "write",
+  ];
+
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+    sendMessage: () => {
+      sent = true;
+    },
+  };
+
+  try {
+    writeFileSync(workflowPath, "# Workflow\n", "utf-8");
+    process.env.GSD_WORKFLOW_PATH = workflowPath;
+    process.env.GSD_WORKFLOW_MCP_COMMAND = "node";
+
+    await _dispatchWorkflowForTest(
+      pi as any,
+      "Discuss the milestone.",
+      "gsd-discuss",
+      ctx as any,
+      "discuss-milestone",
+      {
+        basePath: explicitRoot,
+        deps: {
+          loadPreferences: () => ({ preferences: {} }) as any,
+          selectModel: (async () => ({
+            routing: null,
+            appliedModel: {
+              provider: "claude-code",
+              id: "claude-opus-4-8",
+              baseUrl: "local://claude-code",
+            },
+          })) as any,
+        },
+      },
+    );
+
+    assert.equal(sent, true);
+    assert.equal(
+      notifications.some((message) => message.includes("cannot run guided flow")),
+      false,
+    );
+  } finally {
+    if (originalWorkflowPath === undefined) {
+      delete process.env.GSD_WORKFLOW_PATH;
+    } else {
+      process.env.GSD_WORKFLOW_PATH = originalWorkflowPath;
+    }
+    if (originalMcpCommand === undefined) {
+      delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+    } else {
+      process.env.GSD_WORKFLOW_MCP_COMMAND = originalMcpCommand;
+    }
+    rmSync(explicitRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-flow-session-isolation.test.ts

@@ -178,7 +178,7 @@ test("checkAutoStartAfterDiscuss(basePath) selects the matching pending entry wh
   }
 });
 
-test("checkAutoStartAfterDiscuss can emit ready without scheduling auto-start", () => {
+test("checkAutoStartAfterDiscuss can accept context handoff without scheduling auto-start", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-auto-start-headless-owned-"));
   let waitForIdleCalls = 0;
   const notifications: string[] = [];
@@ -209,9 +209,11 @@ test("checkAutoStartAfterDiscuss can emit ready without scheduling auto-start",
     });
 
     assert.equal(checkAutoStartAfterDiscuss(base), true);
-    assert.deepEqual(notifications, ["Milestone M001 ready."]);
+    assert.deepEqual(notifications, [
+      "Milestone M001 context captured. Continuing the planning pipeline.",
+    ]);
     assert.equal(waitForIdleCalls, 0, "headless-owned auto start must not schedule guided-flow auto");
-    assert.equal(getDiscussionMilestoneId(base), null, "ready handoff should still be cleared");
+    assert.equal(getDiscussionMilestoneId(base), null, "accepted handoff should still be cleared");
   } finally {
     clearPendingAutoStart();
     rmSync(base, { recursive: true, force: true });

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

@@ -135,7 +135,13 @@ describe("guided-flow STATE.md rebuild (#3475)", () => {
 
     assert.equal(accepted, true);
     assert.equal(notifications.some(n => n.level === "error" && n.message.includes("no DB row exists")), false);
-    assert.ok(notifications.some(n => n.level === "success" && n.message.includes("Milestone M001 ready.")));
+    assert.ok(
+      notifications.some(
+        n =>
+          n.level === "success" &&
+          n.message.includes("Milestone M001 context captured. Continuing the planning pipeline."),
+      ),
+    );
     clearPendingAutoStart(base);
   });
 
@@ -157,13 +163,13 @@ describe("guided-flow STATE.md rebuild (#3475)", () => {
     };
     setPendingAutoStart(base, { basePath: base, milestoneId: "M001", ctx: ctx as any, pi: {} as any });
 
-    for (let i = 0; i < 4; i += 1) {
+    for (let i = 0; i < 3; i += 1) {
       assert.equal(checkAutoStartAfterDiscuss(), false);
     }
 
     assert.equal(
-      notifications.filter(n => n.level === "warning" && n.message.includes("recovering. Retrying gsd_plan_milestone")).length,
-      3,
+      notifications.filter(n => n.level === "warning").length,
+      0,
     );
     assert.equal(
       notifications.filter(n => n.level === "error" && n.message.includes("DB row recovery failed")).length,
@@ -171,4 +177,34 @@ describe("guided-flow STATE.md rebuild (#3475)", () => {
     );
     clearPendingAutoStart(base);
   });
+
+  test("checkAutoStartAfterDiscuss does not double-notify on 4th+ call after recovery limit", () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+    const db = _getAdapter();
+    assert.ok(db, "database should be open");
+    db.exec("DROP TABLE milestones");
+    db.exec("CREATE TABLE milestones (id TEXT PRIMARY KEY)");
+
+    writeFile(base, "milestones/M001/M001-CONTEXT.md", "# M001: Planned\n");
+    writeFile(base, "STATE.md", "# GSD State\n\n**Active Milestone:** M001: Planned\n");
+
+    const notifications: Array<{ message: string; level: string }> = [];
+    const ctx = {
+      ui: { notify: (message: string, level: string) => notifications.push({ message, level }) },
+      waitForIdle: () => new Promise<void>(() => {}),
+    };
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001", ctx: ctx as any, pi: {} as any });
+
+    for (let i = 0; i < 5; i += 1) {
+      assert.equal(checkAutoStartAfterDiscuss(), false);
+    }
+
+    assert.equal(
+      notifications.filter(n => n.level === "error" && n.message.includes("DB row recovery failed")).length,
+      1,
+      "user must see exactly one error notification even after repeated calls past the recovery limit",
+    );
+    clearPendingAutoStart(base);
+  });
 });

package/src/resources/extensions/gsd/tests/guided-flow.test.ts

@@ -8,14 +8,17 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 
 test("guided milestone discussion callsites pass workingDirectory to loadPrompt", () => {
   const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
-  const calls = [...source.matchAll(/loadPrompt\("guided-discuss-milestone",\s*\{([\s\S]*?)\}\)/g)];
 
-  assert.equal(calls.length, 8, "all guided-flow guided-discuss-milestone callsites should be covered");
-  for (const call of calls) {
-    assert.match(
-      call[1] ?? "",
-      /\bworkingDirectory:\s*basePath\b/,
-      "guided-discuss-milestone prompts need workingDirectory so template validation does not crash",
-    );
-  }
+  // All guided-discuss-milestone dispatches now go through buildDiscussMilestonePrompt,
+  // which centralises the loadPrompt call and always passes workingDirectory.
+  // Verify no callsite bypasses the builder by calling loadPrompt directly.
+  const directCalls = [...source.matchAll(/loadPrompt\("guided-discuss-milestone"/g)];
+  assert.equal(
+    directCalls.length,
+    0,
+    'guided-flow.ts must not call loadPrompt("guided-discuss-milestone") directly — use buildDiscussMilestonePrompt',
+  );
+
+  const calls = [...source.matchAll(/\bawait buildDiscussMilestonePrompt\(/g)];
+  assert.equal(calls.length, 9, "all guided-flow guided-discuss-milestone callsites should be covered");
 });

package/src/resources/extensions/gsd/tests/integration/auto-recovery.test.ts

@@ -119,8 +119,8 @@ test("resolveExpectedArtifactPath returns correct path for all slice-level types
 // ─── run-uat artifact path contract (#2873) ──────────────────────────────
 
 test("resolveExpectedArtifactPath for run-uat returns ASSESSMENT path, not UAT (#2873)", (t) => {
-  // The run-uat prompt instructs the agent to call gsd_summary_save with
-  // artifact_type: "ASSESSMENT", which writes S##-ASSESSMENT.md. The artifact
+  // The run-uat prompt instructs the agent to call gsd_uat_result_save, which
+  // writes S##-ASSESSMENT.md through the workflow persistence path. The artifact
   // verification path must match — otherwise verification fails and auto-mode
   // retries the unit in an infinite loop.
   const base = makeTmpBase();
@@ -147,12 +147,12 @@ test("diagnoseExpectedArtifact for run-uat references ASSESSMENT (#2873)", (t) =
 });
 
 test("verifyExpectedArtifact passes for run-uat when ASSESSMENT file exists (#2873)", (t) => {
-  // Regression test: run-uat writes S##-ASSESSMENT.md via gsd_summary_save,
+  // Regression test: run-uat writes S##-ASSESSMENT.md via gsd_uat_result_save,
   // but verification looked for S##-UAT.md, causing false stuck retries.
   const base = makeTmpBase();
   t.after(() => cleanup(base));
 
-  // Write the ASSESSMENT file (what gsd_summary_save actually produces)
+  // Write the ASSESSMENT file (what gsd_uat_result_save actually produces)
   const assessPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-ASSESSMENT.md");
   writeFileSync(assessPath, "---\nverdict: PASS\n---\n# UAT Assessment\n");
 

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -29,6 +29,7 @@ import { nativeMergeSquash } from "../../native-git-bridge.ts";
 import { drainLogs, setStderrLoggingEnabled } from "../../workflow-logger.ts";
 import {
   closeDatabase,
+  insertAssessment,
   insertMilestone,
   insertSlice,
   insertTask,
@@ -207,6 +208,13 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
         });
       }
     }
+    insertAssessment({
+      path: "milestones/M020/M020-VALIDATION.md",
+      milestoneId: "M020",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     const roadmap = makeRoadmap("M020", "Backend foundation", [
       { id: "S01", title: "Core API" },

package/src/resources/extensions/gsd/tests/integration/parallel-merge.test.ts

@@ -41,6 +41,7 @@ import {
 import {
   openDatabase,
   closeDatabase,
+  insertAssessment,
   insertMilestone,
   insertSlice,
   updateMilestoneStatus,
@@ -347,6 +348,13 @@ test("mergeCompletedMilestone — synthesizes roadmap from DB when projection is
       title: "Search Bar",
       status: "complete",
     });
+    insertAssessment({
+      path: "milestones/M010/M010-VALIDATION.md",
+      milestoneId: "M010",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     createMilestoneBranch(repo, "M010", [
       { name: "app.js", content: "export const app = true;\n" },
@@ -671,6 +679,14 @@ function setupCanonicalDbWithWorktree(basePath: string, mid: string): void {
   const dbPath = join(basePath, ".gsd", "gsd.db");
   openDatabase(dbPath);
   insertMilestone({ id: mid, title: `Milestone ${mid}`, status: "complete" });
+  insertSlice({ id: "S01", milestoneId: mid, title: "Done Slice", status: "complete" });
+  insertAssessment({
+    path: `milestones/${mid}/${mid}-VALIDATION.md`,
+    milestoneId: mid,
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
   updateMilestoneStatus(mid, "complete", new Date().toISOString());
   closeDatabase();
 }