gsd-pi 2.78.1-dev.b0759e59b → 2.78.1-dev.d8826a445

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -4,11 +4,16 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
+const templatesDir = join(process.cwd(), "src/resources/extensions/gsd/templates");
 
 function readPrompt(name: string): string {
   return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
 }
 
+function readTemplate(name: string): string {
+  return readFileSync(join(templatesDir, `${name}.md`), "utf-8");
+}
+
 test("reactive-execute prompt keeps task summaries with subagents and avoids batch commits", () => {
   const prompt = readPrompt("reactive-execute");
   assert.match(prompt, /subagent-written summary as authoritative/i);
@@ -174,15 +179,15 @@ test("guided-resume-task prompt preserves recovery state until work is supersede
 
 // ─── Prompt migration: execute-task → gsd_complete_task ───────────────
 
-test("execute-task prompt references gsd_complete_task tool", () => {
+test("execute-task prompt references gsd_task_complete tool", () => {
   const prompt = readPrompt("execute-task");
-  assert.match(prompt, /gsd_complete_task/);
+  assert.match(prompt, /gsd_task_complete/);
 });
 
-test("execute-task prompt uses gsd_complete_task as canonical summary write path", () => {
+test("execute-task prompt uses gsd_task_complete as canonical summary write path", () => {
   const prompt = readPrompt("execute-task");
   assert.match(prompt, /\{\{taskSummaryPath\}\}/);
-  assert.match(prompt, /gsd_complete_task/);
+  assert.match(prompt, /gsd_task_complete/);
   assert.match(prompt, /DB-backed tool is the canonical write path/i);
   assert.match(prompt, /Do \*\*not\*\* manually write `?\{\{taskSummaryPath\}\}`?/i);
   assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{taskSummaryPath\}\}`?\s*$/m);
@@ -202,9 +207,9 @@ test("execute-task prompt still contains template variables for context", () =>
 
 // ─── Prompt migration: complete-slice → gsd_complete_slice ────────────
 
-test("complete-slice prompt references gsd_complete_slice tool", () => {
+test("complete-slice prompt references gsd_slice_complete tool", () => {
   const prompt = readPrompt("complete-slice");
-  assert.match(prompt, /gsd_complete_slice/);
+  assert.match(prompt, /gsd_slice_complete/);
 });
 
 test("complete-slice prompt does not instruct LLM to toggle checkboxes manually", () => {
@@ -216,7 +221,7 @@ test("complete-slice prompt instructs writing summary and UAT files before tool
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
   assert.match(prompt, /\{\{sliceUatPath\}\}/);
-  assert.match(prompt, /gsd_complete_slice/);
+  assert.match(prompt, /gsd_slice_complete/);
   assert.match(prompt, /DB-backed tool is the canonical write path/i);
   assert.match(prompt, /Do \*\*not\*\* manually write `?\{\{sliceSummaryPath\}\}`?/i);
   assert.match(prompt, /Do \*\*not\*\* manually write `?\{\{sliceUatPath\}\}`?/i);
@@ -398,3 +403,141 @@ test("reactive-execute prompt references tool calls instead of checkbox updates"
   assert.doesNotMatch(prompt, /checkbox edits/);
   assert.match(prompt, /completion tool calls/);
 });
+
+// ─── Project-shape classifier + 3-or-4-options-with-Other-hatch contract ──
+
+test("guided-discuss-project classifies project shape and persists the verdict to PROJECT.md", () => {
+  const prompt = readPrompt("guided-discuss-project");
+  assert.match(prompt, /Classify project shape/i, "must include the classifier section");
+  assert.match(prompt, /`simple`/);
+  assert.match(prompt, /`complex`/);
+  assert.match(prompt, /Default to `complex` when uncertain/i);
+  assert.match(prompt, /## Project Shape/, "must reference the persisted PROJECT.md section");
+  assert.match(prompt, /\*\*Complexity:\*\*\s*simple/);
+  assert.match(prompt, /\*\*Complexity:\*\*\s*complex/);
+});
+
+test("guided-discuss prompts require 3-or-4 options plus Other-let-me-discuss in complex mode", () => {
+  for (const name of [
+    "guided-discuss-project",
+    "guided-discuss-milestone",
+    "guided-discuss-slice",
+  ]) {
+    const prompt = readPrompt(name);
+    assert.match(
+      prompt,
+      /3 or 4 concrete, researched options/i,
+      `${name} must require 3 or 4 grounded options in complex mode`,
+    );
+    assert.match(
+      prompt,
+      /"Other — let me discuss"/,
+      `${name} must include the "Other — let me discuss" escape hatch`,
+    );
+    assert.match(
+      prompt,
+      /grounded in (the |your |)investigation/i,
+      `${name} must require options grounded in prior investigation`,
+    );
+  }
+});
+
+test("guided-discuss-requirements scopes the 3-or-4-options rule to free-form questions only", () => {
+  const prompt = readPrompt("guided-discuss-requirements");
+  assert.match(prompt, /3 or 4 concrete, researched options/i);
+  assert.match(prompt, /"Other — let me discuss"/);
+  // Class-assignment and status questions have fixed enumerations, so the rule must exempt them.
+  assert.match(prompt, /class-assignment.*status.*exempt/i);
+});
+
+test("downstream discuss prompts read project shape verdict from PROJECT.md", () => {
+  for (const name of [
+    "guided-discuss-milestone",
+    "guided-discuss-requirements",
+    "guided-discuss-slice",
+  ]) {
+    const prompt = readPrompt(name);
+    assert.match(
+      prompt,
+      /Project Shape/,
+      `${name} must reference Project Shape from PROJECT.md`,
+    );
+    assert.match(
+      prompt,
+      /default to `complex`/i,
+      `${name} must default to complex when the verdict is missing`,
+    );
+  }
+});
+
+test("project template includes the Project Shape section so the verdict has a home", () => {
+  const template = readTemplate("project");
+  assert.match(template, /## Project Shape/);
+  assert.match(template, /\*\*Complexity:\*\*/);
+});
+
+// ─── Project shape verdict — end-to-end propagation contract (F7 / #5267) ──
+// The verdict is propagated from discuss-project to downstream stages via
+// PROJECT.md text only, with no parser. These tests pin the round-trip:
+// the format the upstream stage is told to write must be discoverable by
+// the regex pattern the downstream stage is told to look for.
+
+/**
+ * Render the project.md template with a concrete complexity verdict so we
+ * can assert on a realistic PROJECT.md (the placeholder is filled the way
+ * an LLM following the prompt would fill it).
+ */
+function renderProjectMd(verdict: "simple" | "complex"): string {
+  return readTemplate("project")
+    .replace("{{simple | complex}}", verdict)
+    .replace("{{one-line rationale citing the signals that decided it}}", "Test fixture rationale.");
+}
+
+test("project shape verdict survives the discuss-project → discuss-milestone round trip", () => {
+  for (const verdict of ["simple", "complex"] as const) {
+    const projectMd = renderProjectMd(verdict);
+
+    // Upstream contract: the PROJECT.md the discuss-project prompt writes
+    // must contain the section header and the bolded `**Complexity:** <verdict>`
+    // marker that downstream stages are told to grep for.
+    assert.match(projectMd, /## Project Shape/, `rendered ${verdict} PROJECT.md must keep the section header`);
+    const complexityMarker = new RegExp(`\\*\\*Complexity:\\*\\*\\s*${verdict}\\b`);
+    assert.match(
+      projectMd,
+      complexityMarker,
+      `rendered ${verdict} PROJECT.md must expose the bolded Complexity marker the downstream regex looks for`,
+    );
+
+    // Downstream contract: discuss-milestone, discuss-requirements, and
+    // discuss-slice must each instruct the LLM to look at the same section
+    // header AND the same `**Complexity:**` marker the template writes.
+    // Without this, the upstream verdict is silently dropped.
+    for (const downstream of ["guided-discuss-milestone", "guided-discuss-requirements", "guided-discuss-slice"]) {
+      const prompt = readPrompt(downstream);
+      assert.match(
+        prompt,
+        /## Project Shape/,
+        `${downstream} must direct the LLM to the same section header the template writes`,
+      );
+      assert.match(
+        prompt,
+        /\*\*Complexity:\*\*/,
+        `${downstream} must direct the LLM to the same **Complexity:** marker the template writes`,
+      );
+    }
+  }
+});
+
+test("downstream discuss prompts default to complex when PROJECT.md lacks the verdict", () => {
+  // Safe-by-default: if upstream omits the section (existing projects, LLM
+  // drift, future template change), each downstream stage must explicitly
+  // fall back to complex so behavior is conservative rather than stuck.
+  for (const downstream of ["guided-discuss-milestone", "guided-discuss-requirements", "guided-discuss-slice"]) {
+    const prompt = readPrompt(downstream);
+    assert.match(
+      prompt,
+      /default to `complex`/i,
+      `${downstream} must default to complex when the upstream verdict is missing`,
+    );
+  }
+});

package/src/resources/extensions/gsd/tests/ready-phrase-no-files-4573.test.ts

@@ -21,6 +21,8 @@ import {
   maybeHandleEmptyIntentTurn,
   resetEmptyTurnCounter,
 } from "../guided-flow.ts";
+import { drainLogs } from "../workflow-logger.ts";
+import { resolveMilestoneFile, clearPathCache } from "../paths.ts";
 
 // ─── Test harness ──────────────────────────────────────────────────────────
 
@@ -177,6 +179,79 @@ describe("#4573 maybeHandleReadyPhraseWithoutFiles", () => {
     }
   });
 
+  test("stale path cache from a prior listing → fresh writes are detected (regression)", () => {
+    // Repro the live binary failure where:
+    //   1. paths.ts cached dir listings were populated when M001/ was empty
+    //      (or the milestone dir didn't yet exist).
+    //   2. The LLM then wrote M001-CONTEXT.md and M001-ROADMAP.md via the
+    //      standard Write tool — which has no awareness of paths.ts caches.
+    //   3. maybeHandleReadyPhraseWithoutFiles called resolveMilestoneFile,
+    //      which read the stale cache and reported the artifacts missing,
+    //      firing a false rejection nudge until MAX_READY_REJECTS aborted
+    //      the auto-start with `LLM signaled "ready" 3 times without
+    //      writing files`.
+    //
+    // The fix busts the path cache at the top of the validator before
+    // re-resolving. This test fails pre-fix (handled === true) because the
+    // cache returns the empty listing it captured in step (a).
+    const base = mkBase();
+    try {
+      const mDir = join(base, ".gsd", "milestones", "M001");
+
+      // (a) Prime the cache with a listing that DOES NOT include M001's
+      //     CONTEXT/ROADMAP files. mkBase() has already created the M001
+      //     directory but nothing inside it yet — so this readdir caches an
+      //     empty entry list keyed by the M001 dir path.
+      clearPathCache();
+      assert.equal(
+        resolveMilestoneFile(base, "M001", "CONTEXT"),
+        null,
+        "precondition: resolver must report missing before files are written",
+      );
+
+      // (b) Write the artifacts directly to disk (simulates the LLM Write
+      //     tool — no clearPathCache() call between the write and the
+      //     validator).
+      writeFileSync(join(mDir, "M001-CONTEXT.md"), "# ctx");
+      writeFileSync(join(mDir, "M001-ROADMAP.md"), "# roadmap");
+
+      // (c) Sanity: the cache is still stale. Without the fix, the
+      //     validator would still see the empty cached listing.
+      assert.equal(
+        resolveMilestoneFile(base, "M001", "CONTEXT"),
+        null,
+        "stale cache still reports missing pre-clearPathCache",
+      );
+
+      // (d) Run the validator. With the fix it busts the cache before
+      //     resolving and returns false (no nudge). Without the fix it
+      //     fires the nudge.
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles({
+        messages: [assistantMsg("Milestone M001 ready.")],
+      });
+      assert.equal(
+        handled,
+        false,
+        "fresh writes must not trigger the rejection nudge — cache must be busted before resolution",
+      );
+      assert.equal(cap.messages.length, 0, "no nudge sent");
+      assert.equal(
+        cap.notifies.length,
+        0,
+        "no rejection notify when files exist on disk",
+      );
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
   test("legacy unprefixed files present → no nudge", () => {
     const base = mkBase();
     try {
@@ -219,6 +294,81 @@ describe("#4573 maybeHandleReadyPhraseWithoutFiles", () => {
     }
   });
 
+  test("nudge fires → diagnostic warning logged with basePath, mDir, canonical-path existsSync results", () => {
+    // Diagnostic logging added so we can tell, in real failures, whether
+    // resolveMilestoneFile is reporting files missing that actually exist on
+    // disk (basePath/symlink mismatch, stale cache despite the
+    // agent-end-recovery flush, legacy descriptor dir, etc.).
+    const base = mkBase();
+    try {
+      drainLogs(); // discard prior test noise
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles({
+        messages: [assistantMsg("Milestone M001 ready.")],
+      });
+      assert.equal(handled, true);
+
+      const logs = drainLogs();
+      const diag = logs.find(
+        (e) => e.component === "guided" && /ready-phrase-reject diagnostic/.test(e.message),
+      );
+      assert.ok(diag, "expected diagnostic warning to be logged when nudge fires");
+      assert.match(diag!.message, /mid=M001/);
+      assert.match(diag!.message, new RegExp(`basePath=${base.replace(/[/\\]/g, "[/\\\\]")}`));
+      assert.match(diag!.message, /mDir=/);
+      assert.match(diag!.message, /ctx-exists=false/);
+      assert.match(diag!.message, /roadmap-exists=false/);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("diagnostic logs ctx-exists=true when file is on disk but cached resolver missed it", () => {
+    // Simulates the test123 #5xxx scenario: file exists on disk, cached
+    // resolver claims it doesn't. We drop a file with a non-canonical path
+    // (forces the legacy-descriptor pattern miss) so resolveMilestoneFile
+    // returns null but existsSync on the canonical path returns true.
+    //
+    // Note: the canonical path probe in the diagnostic uses the literal
+    // `${milestoneId}-CONTEXT.md` filename. If a file is at that path,
+    // existsSync will see it regardless of resolver behavior.
+    const base = mkBase();
+    try {
+      drainLogs();
+      // Write the canonical file directly — both resolver AND existsSync
+      // would normally see it. To prove the diagnostic captures the
+      // existsSync result independently, we cover the basic case here.
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      // No files written — both probes should report false.
+      maybeHandleReadyPhraseWithoutFiles({
+        messages: [assistantMsg("Milestone M001 ready.")],
+      });
+      const logs = drainLogs();
+      const diag = logs.find(
+        (e) => e.component === "guided" && /ready-phrase-reject diagnostic/.test(e.message),
+      );
+      assert.ok(diag, "diagnostic logged");
+      // mDir resolves because mkBase creates the directory
+      assert.match(diag!.message, /mDir=.+M001/);
+      assert.match(diag!.message, /canonical-ctx=.+M001-CONTEXT\.md/);
+      assert.match(diag!.message, /canonical-roadmap=.+M001-ROADMAP\.md/);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
   test("fresh entry after give-up resets counter", () => {
     const base = mkBase();
     try {
@@ -344,6 +494,40 @@ describe("#4573 maybeHandleEmptyIntentTurn", () => {
     }
   });
 
+  test("single-line approval prompt with mid-line `?` and conditional intent → treated as user-handoff (regression: #5187 follow-up)", () => {
+    // Regression for the discuss-milestone case where the LLM presented a
+    // depth summary and ended with: "Did I capture that correctly? If so,
+    // say yes and I'll write requirements and the roadmap preview."
+    // The previous heuristic only checked for lines *ending* in `?`, so
+    // this single-line paragraph (terminating in `.`) bypassed the
+    // user-handoff guard, then COMMIT_INTENT_RE matched "I'll write" and
+    // the nudge auto-replied while the user was meant to approve.
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        {
+          messages: [
+            assistantMsg(
+              "Did I capture that correctly? If so, say yes and I'll write requirements and the roadmap preview.",
+            ),
+          ],
+        },
+        false,
+      );
+      assert.equal(handled, false, "any sentence-terminating ? must defer to the user");
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
   test('"Let me make sure" meta phrase → not flagged as commit intent (regression)', () => {
     const base = mkBase();
     try {

package/src/resources/extensions/gsd/tests/register-hooks-compaction-checkpoint.test.ts

@@ -6,7 +6,7 @@ import { tmpdir } from "node:os";
 
 import { registerHooks } from "../bootstrap/register-hooks.ts";
 import { parseContinue } from "../files.ts";
-import { closeDatabase } from "../gsd-db.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { deriveState, invalidateStateCache } from "../state.ts";
 
 function createPlanningFixtureBase(): string {
@@ -39,6 +39,11 @@ function createPlanningFixtureBase(): string {
 `,
   );
 
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Test Slice", status: "active", risk: "low", depends: [] });
+  closeDatabase();
+
   return base;
 }
 

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -25,12 +25,15 @@ test("register-hooks unlocks milestone depth verification from question id witho
   const dir = makeTempDir("manual");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
@@ -101,12 +104,15 @@ test("register-hooks clears depth gate when remote (Telegram/Slack/Discord) answ
   const dir = makeTempDir("remote");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
@@ -167,12 +173,15 @@ test("register-hooks returns hard blocker when depth question is cancelled", asy
   const dir = makeTempDir("cancelled");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
@@ -228,12 +237,15 @@ test("register-hooks gates MCP ask_user_questions cancellation before requiremen
   const dir = makeTempDir("mcp-cancelled");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();

package/src/resources/extensions/gsd/tests/replan-slice.test.ts

@@ -8,6 +8,9 @@ import { fileURLToPath } from 'node:url';
 import { parseSummary } from '../files.ts';
 import { deriveState } from '../state.ts';
 
+// This suite exercises the explicit legacy markdown derivation path.
+process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK = '1';
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const worktreePromptsDir = join(__dirname, '..', 'prompts');
 

package/src/resources/extensions/gsd/tests/resolve-ts.mjs

@@ -1,5 +1,9 @@
 import { register } from 'node:module';
 import { pathToFileURL } from 'node:url';
 
+// Source legacy state tests exercise markdown derivation through deriveState().
+// Production/runtime keeps this fallback disabled unless explicitly requested.
+process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK ??= '1';
+
 // Register hook to redirect imports to the dist directory
 register(new URL('./dist-redirect.mjs', import.meta.url), pathToFileURL('./'));