gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.2ff77b0ce

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

@@ -76,6 +76,88 @@ test("guided milestone discussion scopes depth verification to the milestone id"
   assert.doesNotMatch(prompt, /depth_verification_confirm" — this enables the write-gate downstream/i, "legacy global depth gate wording should be gone");
 });
 
+test("guided requirements prompt requires milestone-qualified provisional owners", () => {
+  const prompt = readPrompt("guided-discuss-requirements");
+  assert.match(prompt, /M###\/none yet/, "unsliced requirements should retain milestone ownership");
+  assert.match(prompt, /never bare `none yet`/, "prompt should forbid bare provisional ownership");
+  assert.doesNotMatch(prompt, /primary owning slice \(or `none yet`\)/i);
+});
+
+test("guided requirements prompt saves requirement records before final summary write", () => {
+  const prompt = readPrompt("guided-discuss-requirements");
+  const output = prompt.slice(prompt.indexOf("## Output"));
+  const requirementSaveIndex = output.indexOf("gsd_requirement_save");
+  const summarySaveIndex = output.indexOf("gsd_summary_save");
+
+  assert.ok(requirementSaveIndex >= 0, "output instructions should call gsd_requirement_save");
+  assert.ok(summarySaveIndex >= 0, "output instructions should call gsd_summary_save");
+  assert.ok(
+    requirementSaveIndex < summarySaveIndex,
+    "DB-backed requirement records should be saved before writing REQUIREMENTS.md",
+  );
+});
+
+test("guided requirements prompt uses supported summary artifact types", () => {
+  const prompt = readPrompt("guided-discuss-requirements");
+  assert.match(prompt, /artifact_type:\s*"REQUIREMENTS-DRAFT"/);
+  assert.match(prompt, /artifact_type:\s*"REQUIREMENTS"(?!-)/);
+  assert.match(prompt, /omit `milestone_id`/);
+  assert.match(prompt, /Do NOT use `artifact_type: "CONTEXT"` and do NOT pass `milestone_id: "REQUIREMENTS"`/);
+  assert.match(prompt, /depth_verification_requirements_confirm/);
+  assert.doesNotMatch(prompt, /call `gsd_summary_save` with `artifact_type: "CONTEXT"`/);
+});
+
+test("workflow preferences prompt writes defaults without interactive questions", () => {
+  const prompt = readPrompt("guided-workflow-preferences");
+  assert.match(prompt, /default-writing/i);
+  assert.match(prompt, /Do NOT call `ask_user_questions`/);
+  assert.match(prompt, /commit_policy:\s*per-task/);
+  assert.match(prompt, /branch_model:\s*single/);
+  assert.match(prompt, /research:\s*skip/);
+  assert.match(prompt, /"decision": "skip"/);
+  assert.doesNotMatch(prompt, /research:\s*research/);
+  assert.doesNotMatch(prompt, /Ask all three questions/i);
+  assert.doesNotMatch(prompt, /Ask all four questions/i);
+  assert.doesNotMatch(prompt, /Ask all five questions/i);
+});
+
+test("project research prompt dispatches scout agents allowed by planning-dispatch", () => {
+  const prompt = readPrompt("guided-research-project");
+  assert.match(prompt, /agent:\s*"scout"/);
+  assert.match(prompt, /Do not use `agent: "researcher"`/);
+  assert.match(prompt, /runtime clears the dispatch marker/i);
+  assert.doesNotMatch(prompt, /Delete `\.gsd\/runtime\/research-project-inflight`/);
+});
+
+test("slice planning prompts name scout for external research dispatch", () => {
+  const planSlice = readPrompt("plan-slice");
+  const refineSlice = readPrompt("refine-slice");
+  assert.match(planSlice, /dispatch the \*\*scout\*\* agent/);
+  assert.match(refineSlice, /dispatch the \*\*scout\*\* agent/);
+  assert.doesNotMatch(planSlice, /dispatch the \*\*researcher\*\* agent/);
+  assert.doesNotMatch(refineSlice, /dispatch the \*\*researcher\*\* agent/);
+});
+
+test("guided project prompt writes root PROJECT artifact, not PROJECT milestone", () => {
+  const prompt = readPrompt("guided-discuss-project");
+  assert.match(prompt, /artifact_type:\s*"PROJECT"/);
+  assert.match(prompt, /omit `milestone_id`/);
+  assert.match(prompt, /Do NOT use `artifact_type: "CONTEXT"` and do NOT pass `milestone_id: "PROJECT"`/);
+  assert.match(prompt, /single freeform question in plain text, not structured/i);
+  assert.doesNotMatch(prompt, /project_initial_shape/);
+  assert.match(prompt, /depth_verification_project_confirm/);
+});
+
+test("guided research decision prompt keeps exact chat confirmation strings", () => {
+  const prompt = readPrompt("guided-research-decision");
+  assert.match(prompt, /^Research decision: research$/m);
+  assert.match(prompt, /^Research decision recorded\.$/m);
+  assert.match(prompt, /Skip \(Recommended\)/);
+  assert.match(prompt, /"source": "research-decision"/);
+  assert.match(prompt, /Do not change the required confirmation strings/i);
+  assert.doesNotMatch(prompt, /note the inference in the chat confirmation line/i);
+});
+
 test("queue prompt requires waiting for user response between rounds", () => {
   const prompt = readPrompt("queue");
   assert.match(prompt, /Never fabricate or simulate user input during this discussion/i);
@@ -118,16 +200,6 @@ test("execute-task prompt still contains template variables for context", () =>
   assert.match(prompt, /\{\{planPath\}\}/);
 });
 
-test("guided-execute-task prompt references gsd_task_complete tool", () => {
-  const prompt = readPrompt("guided-execute-task");
-  assert.match(prompt, /gsd_task_complete/);
-});
-
-test("guided-execute-task prompt does not instruct manual file write", () => {
-  const prompt = readPrompt("guided-execute-task");
-  assert.doesNotMatch(prompt, /Write `?\{\{taskId\}\}-SUMMARY\.md`?.*mark it done/i);
-});
-
 // ─── Prompt migration: complete-slice → gsd_complete_slice ────────────
 
 test("complete-slice prompt references gsd_complete_slice tool", () => {
@@ -140,11 +212,6 @@ test("complete-slice prompt does not instruct LLM to toggle checkboxes manually"
   assert.doesNotMatch(prompt, /change \[ \] to \[x\]/);
 });
 
-test("guided-complete-slice prompt references gsd_slice_complete tool", () => {
-  const prompt = readPrompt("guided-complete-slice");
-  assert.match(prompt, /gsd_slice_complete/);
-});
-
 test("complete-slice prompt instructs writing summary and UAT files before tool call", () => {
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
@@ -184,12 +251,6 @@ test("plan-milestone prompt references DB-backed planning tool and explicitly fo
   assert.match(prompt, /Do \*\*not\*\* write `?\{\{outputPath\}\}`?, `?ROADMAP\.md`?, or other planning artifacts manually/i);
 });
 
-test("guided-plan-milestone prompt references DB-backed planning tool and explicitly forbids manual roadmap writes", () => {
-  const prompt = readPrompt("guided-plan-milestone");
-  assert.match(prompt, /gsd_plan_milestone/);
-  assert.match(prompt, /Do \*\*not\*\* write `?\{\{milestoneId\}\}-ROADMAP\.md`?, `?ROADMAP\.md`?, or other planning artifacts manually/i);
-});
-
 test("plan-slice prompt no longer frames direct PLAN writes as the source of truth", () => {
   const prompt = readPrompt("plan-slice");
   assert.match(prompt, /Do \*\*not\*\* rely on direct `PLAN\.md` writes as the source of truth/i);

package/src/resources/extensions/gsd/tests/quality-gates.test.ts

@@ -53,31 +53,25 @@ console.log("\n=== Level 2: Prompts reference quality gates ===");
   assertTrue(planSlice.includes("Threat Surface"), "plan-slice.md mentions Threat Surface");
   assertTrue(planSlice.includes("Requirement Impact"), "plan-slice.md mentions Requirement Impact");
   assertTrue(planSlice.toLowerCase().includes("quality gate"), "plan-slice.md mentions quality gate");
-
-  const guidedPlanSlice = loadPrompt("guided-plan-slice");
   assertTrue(
-    guidedPlanSlice.includes("Threat Surface") || guidedPlanSlice.includes("Q3"),
-    "guided-plan-slice.md mentions Threat Surface or Q3"
+    planSlice.includes("Q3") || planSlice.includes("Threat Surface"),
+    "plan-slice.md mentions Threat Surface or Q3"
   );
 
   const executeTask = loadPrompt("execute-task");
   assertTrue(executeTask.includes("Failure Modes"), "execute-task.md mentions Failure Modes");
   assertTrue(executeTask.includes("Load Profile"), "execute-task.md mentions Load Profile");
   assertTrue(executeTask.includes("Negative Tests"), "execute-task.md mentions Negative Tests");
-
-  const guidedExecuteTask = loadPrompt("guided-execute-task");
   assertTrue(
-    guidedExecuteTask.includes("Failure Modes") || guidedExecuteTask.includes("Q5"),
-    "guided-execute-task.md mentions Failure Modes or Q5"
+    executeTask.includes("Q5") || executeTask.includes("Failure Modes"),
+    "execute-task.md mentions Failure Modes or Q5"
   );
 
   const completeSlice = loadPrompt("complete-slice");
   assertTrue(completeSlice.includes("Operational Readiness"), "complete-slice.md mentions Operational Readiness");
-
-  const guidedCompleteSlice = loadPrompt("guided-complete-slice");
   assertTrue(
-    guidedCompleteSlice.includes("Operational Readiness") || guidedCompleteSlice.includes("Q8"),
-    "guided-complete-slice.md mentions Operational Readiness or Q8"
+    completeSlice.includes("Operational Readiness") || completeSlice.includes("Q8"),
+    "complete-slice.md mentions Operational Readiness or Q8"
   );
 
   const completeMilestone = loadPrompt("complete-milestone");
@@ -85,10 +79,7 @@ console.log("\n=== Level 2: Prompts reference quality gates ===");
   assertTrue(completeMilestone.includes("Decision Re-evaluation"), "complete-milestone.md mentions Decision Re-evaluation");
 
   const planMilestone = loadPrompt("plan-milestone");
-  assertTrue(planMilestone.toLowerCase().includes("horizontal checklist"), "plan-milestone.md mentions horizontal checklist");
-
-  const guidedPlanMilestone = loadPrompt("guided-plan-milestone");
-  assertTrue(guidedPlanMilestone.includes("Horizontal Checklist"), "guided-plan-milestone.md mentions Horizontal Checklist");
+  assertTrue(planMilestone.includes("Horizontal Checklist"), "plan-milestone.md mentions Horizontal Checklist");
 
   const reassess = loadPrompt("reassess-roadmap");
   assertTrue(reassess.includes("Threat Surface"), "reassess-roadmap.md mentions Threat Surface");

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

@@ -21,6 +21,7 @@ import {
   maybeHandleEmptyIntentTurn,
   resetEmptyTurnCounter,
 } from "../guided-flow.ts";
+import { drainLogs } from "../workflow-logger.ts";
 
 // ─── Test harness ──────────────────────────────────────────────────────────
 
@@ -177,6 +178,28 @@ describe("#4573 maybeHandleReadyPhraseWithoutFiles", () => {
     }
   });
 
+  test("legacy unprefixed files present → no nudge", () => {
+    const base = mkBase();
+    try {
+      writeFileSync(join(base, ".gsd", "milestones", "M001", "CONTEXT.md"), "# ctx");
+      writeFileSync(join(base, ".gsd", "milestones", "M001", "ROADMAP.md"), "# roadmap");
+      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);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
   test("last message lacks ready phrase → no-op", () => {
     const base = mkBase();
     try {
@@ -197,6 +220,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 {
@@ -285,6 +383,101 @@ describe("#4573 maybeHandleEmptyIntentTurn", () => {
     }
   });
 
+  test("multi-line message with mid-message question → treated as user-handoff (regression: discuss flow)", () => {
+    // Regression for the deep-mode discuss-project case where the LLM asked
+    // a clarifying question mid-message and ended on a closing remark. The
+    // previous heuristic only checked the LAST line for `?` and missed the
+    // earlier question, causing the empty-turn nudge to auto-reply on
+    // behalf of the user.
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const text = [
+        "Let me make sure I understand what you're testing here.",
+        "",
+        "We need something to plan. A few lightweight options:",
+        "- A simple CLI tool",
+        "- A static API",
+        "",
+        "What should the fictional project be?",
+        "",
+        "If you have a preference, say the word and I'll pick one.",
+      ].join("\n");
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg(text)] },
+        false,
+      );
+      assert.equal(handled, false, "any line ending in ? must defer to the user");
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  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 {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      // No question mark anywhere — so the only thing keeping this from
+      // firing the nudge should be the refined commit-intent regex
+      // (dropping "make" from the verb list).
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("Let me make sure I have this right.")] },
+        false,
+      );
+      assert.equal(handled, false, "meta acknowledgments are not action announcements");
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
   test("commit-intent phrase WITHOUT tool call → nudge fires", () => {
     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

@@ -162,3 +162,159 @@ test("register-hooks clears depth gate when remote (Telegram/Slack/Discord) answ
     "remote confirmation must unlock the matching milestone context write",
   );
 });
+
+test("register-hooks returns hard blocker when depth question is cancelled", async (t) => {
+  const dir = makeTempDir("cancelled");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState();
+
+  t.after(() => {
+    resetWriteGateState();
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const questionId = "depth_verification_M003_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Did I capture this correctly?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Needs adjustment" },
+      ],
+    },
+  ];
+
+  for (const handler of handlers.get("tool_call") ?? []) {
+    await handler({ toolName: "ask_user_questions", input: { questions } });
+  }
+  assert.equal(getPendingGate(), questionId);
+
+  let patch: any;
+  for (const handler of handlers.get("tool_result") ?? []) {
+    const result = await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: { cancelled: true, response: null },
+    });
+    if (result) patch = result;
+  }
+
+  assert.equal(getPendingGate(), questionId, "cancelled question must leave gate pending");
+  assert.match(
+    patch?.content?.[0]?.text ?? "",
+    /HARD BLOCK: approval gate "depth_verification_M003_confirm" is still pending/,
+  );
+  assert.match(
+    patch?.content?.[0]?.text ?? "",
+    /Do not infer approval from earlier or prior messages/,
+  );
+});
+
+test("register-hooks gates MCP ask_user_questions cancellation before requirement saves", async (t) => {
+  const dir = makeTempDir("mcp-cancelled");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState();
+
+  t.after(() => {
+    resetWriteGateState();
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const questionId = "depth_verification_requirements_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Are these the right requirements at the right scope?",
+      options: [
+        { label: "Yes, ship it (Recommended)" },
+        { label: "Not quite — let me adjust" },
+      ],
+    },
+  ];
+
+  const askBlocks: any[] = [];
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({
+      toolName: "mcp__gsd-workflow__ask_user_questions",
+      input: { questions },
+    });
+    if (result) askBlocks.push(result);
+  }
+
+  assert.equal(getPendingGate(), questionId, "MCP ask_user_questions should set the pending gate");
+  assert.equal(
+    askBlocks.some((result) => result?.block === true),
+    false,
+    "the gate-setting MCP ask_user_questions call itself should be allowed",
+  );
+
+  let hardBlock: any;
+  for (const handler of handlers.get("tool_result") ?? []) {
+    const result = await handler({
+      toolName: "mcp__gsd-workflow__ask_user_questions",
+      input: { questions },
+      details: { cancelled: true, response: null },
+    });
+    if (result) hardBlock = result;
+  }
+
+  assert.equal(getPendingGate(), questionId, "cancelled MCP question must leave gate pending");
+  assert.match(
+    hardBlock?.content?.[0]?.text ?? "",
+    /approval gate "depth_verification_requirements_confirm" is still pending/,
+  );
+
+  let toolSearchBlock: any;
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({
+      toolName: "ToolSearch",
+      input: { query: "select:mcp__gsd-workflow__gsd_requirement_save", max_results: 2 },
+    });
+    if (result?.block) toolSearchBlock = result;
+  }
+  assert.equal(toolSearchBlock?.block, true, "ToolSearch must not bury a pending approval question");
+
+  let requirementBlock: any;
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({
+      toolName: "mcp__gsd-workflow__gsd_requirement_save",
+      input: {
+        class: "functional",
+        description: "User can add tasks to the todo list",
+        why: "Primary product value",
+        source: "primary-user-loop",
+      },
+    });
+    if (result?.block) requirementBlock = result;
+  }
+
+  assert.equal(requirementBlock?.block, true, "requirement save must be blocked while gate is pending");
+  assert.match(requirementBlock?.reason ?? "", /has not been confirmed/);
+});

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('./'));

package/src/resources/extensions/gsd/tests/rogue-file-detection.test.ts

@@ -149,7 +149,7 @@ test("rogue detection: DB not available → returns empty array (graceful degrad
   }
 });
 
-test("rogue detection: slice summary on disk, no DB row → auto-remediated (not rogue)", () => {
+test("rogue detection: slice summary on disk, no DB completion → detected as rogue without DB import", () => {
   const basePath = createTmpBase();
   const dbPath = join(basePath, ".gsd", "gsd.db");
   mkdirSync(join(basePath, ".gsd"), { recursive: true });
@@ -160,10 +160,9 @@ test("rogue detection: slice summary on disk, no DB row → auto-remediated (not
     const summaryPath = createSliceSummaryOnDisk(basePath, "M001", "S01");
     assert.ok(existsSync(summaryPath), "Slice summary file should exist on disk");
 
-    // Fix #3633: stale slice DB status is auto-remediated via updateSliceStatus()
-    // instead of being reported as rogue, so rogues array should be empty.
     const rogues = detectRogueFileWrites("complete-slice", "M001/S01", basePath);
-    assert.equal(rogues.length, 0, "Should auto-remediate stale slice, not report as rogue");
+    assert.equal(rogues.length, 1, "Should report stale disk summary instead of mutating DB");
+    assert.equal(rogues[0]?.path, summaryPath);
   } finally {
     closeDatabase();
     rmSync(basePath, { recursive: true, force: true });

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

@@ -109,6 +109,42 @@ describe("mergeSliceToMain", () => {
     assert.equal(summary.sliceMergeConflicts, 0);
   });
 
+  test("merges slices to the recorded integration branch", () => {
+    git(["checkout", "-b", "develop"], dir);
+    mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(
+      join(dir, ".gsd", "milestones", "M001", "M001-META.json"),
+      JSON.stringify({ integrationBranch: "develop" }, null, 2) + "\n",
+    );
+
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "develop-only.txt", "slice 1 work\n", "feat: S01 work");
+
+    process.chdir(dir);
+    const result = mergeSliceToMain(dir, "M001", "S01");
+
+    assert.equal(result.mainBranch, "develop");
+    assert.equal(readFileSync(join(dir, "develop-only.txt"), "utf-8"), "slice 1 work\n");
+    assert.equal(git(["rev-parse", "develop"], dir), git(["rev-parse", "milestone/M001"], dir));
+    assert.notEqual(git(["rev-parse", "develop"], dir), git(["rev-parse", "main"], dir));
+  });
+
+  test("advances milestone branch when it is checked out in a worktree", () => {
+    commitFile(dir, ".gitignore", ".gsd/worktrees/\n", "chore: ignore worktrees");
+    const wtPath = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+    git(["worktree", "add", "-b", "milestone/M001", wtPath, "main"], dir);
+    commitFile(wtPath, "worktree-slice.txt", "slice work\n", "feat: S01 worktree");
+
+    process.chdir(wtPath);
+    const result = mergeSliceToMain(dir, "M001", "S01");
+
+    assert.equal(result.skipped, false);
+    assert.equal(git(["rev-parse", "main"], dir), git(["rev-parse", "milestone/M001"], dir));
+    assert.equal(git(["branch", "--show-current"], wtPath), "milestone/M001");
+    assert.equal(readFileSync(join(wtPath, "worktree-slice.txt"), "utf-8"), "slice work\n");
+  });
+
   test("handles sequential slice merges cleanly", () => {
     enterMilestoneBranch(dir, "M001");
     commitFile(dir, "a.txt", "slice 1\n", "feat: S01");