gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

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

@@ -7,12 +7,12 @@
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
-import { inlineDependencySummaries } from "../auto-prompts.js";
+import { buildExecuteTaskPrompt, buildPlanSlicePrompt, inlineDependencySummaries } from "../auto-prompts.js";
 import { computeBudgets, truncateAtSectionBoundary } from "../context-budget.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -191,13 +191,18 @@ describe("prompt-budget: inlineDependencySummaries truncation", () => {
 // ─── plan-slice template includes executor constraints placeholder ────────────
 
 describe("prompt-budget: plan-slice template", () => {
-  it("contains {{executorContextConstraints}} placeholder", () => {
-    const templatePath = join(__dirname, "..", "prompts", "plan-slice.md");
-    const template = readFileSync(templatePath, "utf-8");
-    assert.ok(
-      template.includes("{{executorContextConstraints}}"),
-      "plan-slice.md should contain {{executorContextConstraints}} placeholder",
-    );
+  it("rendered plan-slice prompt includes executor context constraints", async () => {
+    const base = createFixtureBase();
+    try {
+      setupDependencyFixture(base, "M001", "S01", ["S00"], { S00: "### Results\n\nDone." });
+      const prompt = await buildPlanSlicePrompt("M001", "Milestone", "S01", "Current slice", base, "minimal", {
+        sessionContextWindow: 128_000,
+      });
+      assert.match(prompt, /Executor Context Constraints/);
+      assert.match(prompt, /128K token/);
+    } finally {
+      cleanup(base);
+    }
   });
 });
 
@@ -323,13 +328,25 @@ describe("prompt-budget: different context windows produce different outputs", (
 // ─── execute-task template includes verificationBudget placeholder ─────────
 
 describe("prompt-budget: execute-task template", () => {
-  it("contains {{verificationBudget}} placeholder", () => {
-    const templatePath = join(__dirname, "..", "prompts", "execute-task.md");
-    const template = readFileSync(templatePath, "utf-8");
-    assert.ok(
-      template.includes("{{verificationBudget}}"),
-      "execute-task.md should contain {{verificationBudget}} placeholder",
-    );
+  it("rendered execute-task prompt includes verification budget", async () => {
+    const base = createFixtureBase();
+    try {
+      const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+      const taskDir = join(sliceDir, "tasks");
+      mkdirSync(taskDir, { recursive: true });
+      writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap\n");
+      writeFileSync(join(sliceDir, "S01-PLAN.md"), "# Slice Plan\n");
+      writeFileSync(join(taskDir, "T01-PLAN.md"), "# Task Plan\n");
+
+      const prompt = await buildExecuteTaskPrompt("M001", "S01", "Slice", "T01", "Task", base, {
+        level: "minimal",
+        sessionContextWindow: 128_000,
+      });
+      assert.match(prompt, /verification/i);
+      assert.match(prompt, /~51K chars/);
+    } finally {
+      cleanup(base);
+    }
   });
 
   it("verificationBudget format varies with context window size", () => {
@@ -486,130 +503,51 @@ describe("prompt-budget: execute-task builder truncation pattern", () => {
 });
 
 // ─── Regression: prompt builders must thread modelRegistry + sessionContextWindow (issue #4142) ───
-//
-// `resolveExecutorContextWindow()` resolves the executor context window in 3
-// steps: (1) look up the configured executor model in `modelRegistry`, (2) fall
-// back to `sessionContextWindow`, (3) fall back to `DEFAULT_CONTEXT_WINDOW`
-// (200K). Before this fix, prompt-builder call sites passed `undefined` for
-// both knobs and always landed on Step 3 — even on 1M-token models. These
-// source-level assertions pin the wiring so future refactors cannot regress it.
-
-describe("prompt-budget: modelRegistry + sessionContextWindow wiring", () => {
-  const autoPromptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
-  const autoDispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
-  const autoDirectDispatchSrc = readFileSync(join(__dirname, "..", "auto-direct-dispatch.ts"), "utf-8");
-  const phasesSrc = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
-
-  it("formatExecutorConstraints accepts and forwards both knobs", () => {
-    assert.match(
-      autoPromptsSrc,
-      /function formatExecutorConstraints\([^)]*sessionContextWindow[^)]*modelRegistry[^)]*\)/s,
-      "formatExecutorConstraints must accept sessionContextWindow and modelRegistry",
-    );
-    assert.match(
-      autoPromptsSrc,
-      /resolveExecutorContextWindow\(\s*modelRegistry\s*,\s*prefs\?\.preferences\s*,\s*sessionContextWindow/,
-      "formatExecutorConstraints must forward both to resolveExecutorContextWindow",
-    );
-  });
-
-  it("renderSlicePrompt options declare both knobs and forward to formatExecutorConstraints", () => {
-    assert.match(
-      autoPromptsSrc,
-      /async function renderSlicePrompt\(options:\s*\{[^}]*sessionContextWindow\?[^}]*modelRegistry\?/s,
-      "renderSlicePrompt options must declare both fields",
-    );
-    assert.match(
-      autoPromptsSrc,
-      /formatExecutorConstraints\(sessionContextWindow,\s*modelRegistry(?:,\s*sessionProvider)?\)/,
-      "renderSlicePrompt must forward both to formatExecutorConstraints",
-    );
-  });
-
-  it("buildPlanSlicePrompt options declare both knobs and thread them into renderSlicePrompt", () => {
-    assert.match(
-      autoPromptsSrc,
-      /export async function buildPlanSlicePrompt\([\s\S]*?options\?:\s*\{[^}]*sessionContextWindow\?[^}]*modelRegistry\?/,
-      "buildPlanSlicePrompt options must declare both fields",
-    );
-    assert.match(
-      autoPromptsSrc,
-      /sessionContextWindow:\s*options\?\.sessionContextWindow,\s*modelRegistry:\s*options\?\.modelRegistry/,
-      "buildPlanSlicePrompt must forward both into renderSlicePrompt",
-    );
-  });
 
-  it("ExecuteTaskPromptOptions declares both knobs", () => {
-    assert.match(
-      autoPromptsSrc,
-      /interface ExecuteTaskPromptOptions\s*\{[^}]*sessionContextWindow\?[^}]*modelRegistry\?/s,
-      "ExecuteTaskPromptOptions must declare both fields",
-    );
-  });
-
-  it("buildExecuteTaskPrompt forwards opts.modelRegistry + opts.sessionContextWindow to resolveExecutorContextWindow", () => {
-    assert.match(
-      autoPromptsSrc,
-      /resolveExecutorContextWindow\(\s*opts\.modelRegistry\s*,\s*prefs\?\.preferences\s*,\s*opts\.sessionContextWindow/,
-      "buildExecuteTaskPrompt must forward both into resolveExecutorContextWindow",
-    );
-  });
-
-  it("buildReactiveExecutePrompt accepts opts and forwards to embedded buildExecuteTaskPrompt", () => {
-    assert.match(
-      autoPromptsSrc,
-      /export async function buildReactiveExecutePrompt\([\s\S]*?opts\?:\s*\{[^}]*sessionContextWindow\?[^}]*modelRegistry\?/,
-      "buildReactiveExecutePrompt must accept sessionContextWindow + modelRegistry",
-    );
-    assert.match(
-      autoPromptsSrc,
-      /sessionContextWindow:\s*opts\?\.sessionContextWindow,\s*modelRegistry:\s*opts\?\.modelRegistry/,
-      "buildReactiveExecutePrompt must forward both into the embedded buildExecuteTaskPrompt call",
-    );
-  });
-
-  it("DispatchContext declares both knobs", () => {
-    assert.match(
-      autoDispatchSrc,
-      /interface DispatchContext\s*\{[^}]*sessionContextWindow\?[^}]*modelRegistry\?/s,
-      "DispatchContext must declare both fields so dispatch rules can thread them",
-    );
-  });
-
-  it("DISPATCH_RULES destructure and forward both knobs at every prompt-builder call site", () => {
-    // Every plan-slice / execute-task / reactive-execute rule must destructure
-    // both names from its match context so new call sites can't silently drop them.
-    const matchLines = autoDispatchSrc.match(/match:\s*async\s*\(\{[^}]*sessionContextWindow[^}]*modelRegistry[^}]*\}/g) ?? [];
-    assert.ok(
-      matchLines.length >= 5,
-      `expected ≥5 dispatch rules destructuring both knobs, got ${matchLines.length}`,
-    );
-
-    const forwardCount = (autoDispatchSrc.match(/sessionContextWindow,\s*modelRegistry/g) ?? []).length;
-    assert.ok(
-      forwardCount >= 5,
-      `expected ≥5 forward sites of { sessionContextWindow, modelRegistry }, got ${forwardCount}`,
-    );
-  });
-
-  it("runDispatch populates both knobs from ctx.model / ctx.modelRegistry", () => {
-    assert.match(
-      phasesSrc,
-      /sessionContextWindow:\s*ctx\.model\?\.contextWindow/,
-      "runDispatch must populate sessionContextWindow from ctx.model?.contextWindow",
-    );
-    assert.match(
-      phasesSrc,
-      /modelRegistry:\s*ctx\.modelRegistry/,
-      "runDispatch must populate modelRegistry from ctx.modelRegistry",
-    );
+describe("prompt-budget: modelRegistry + sessionContextWindow behavior", () => {
+  it("buildPlanSlicePrompt output changes when sessionContextWindow changes", async () => {
+    const base = createFixtureBase();
+    try {
+      setupDependencyFixture(base, "M001", "S01", ["S00"], { S00: "### Results\n\nDone." });
+      const small = await buildPlanSlicePrompt("M001", "Milestone", "S01", "Current slice", base, "minimal", {
+        sessionContextWindow: 128_000,
+      });
+      const large = await buildPlanSlicePrompt("M001", "Milestone", "S01", "Current slice", base, "minimal", {
+        sessionContextWindow: 1_000_000,
+      });
+
+      assert.match(small, /128K token/);
+      assert.match(large, /1000K token/);
+      assert.notEqual(small, large);
+    } finally {
+      cleanup(base);
+    }
   });
 
-  it("dispatchDirectPhase forwards both knobs to buildPlanSlicePrompt and buildExecuteTaskPrompt", () => {
-    const passes = (autoDirectDispatchSrc.match(/sessionContextWindow:\s*ctx\.model\?\.contextWindow[\s\S]*?modelRegistry:\s*ctx\.modelRegistry/g) ?? []).length;
-    assert.ok(
-      passes >= 2,
-      `dispatchDirectPhase must forward the pair at both prompt-builder call sites (≥2), got ${passes}`,
-    );
+  it("buildExecuteTaskPrompt output changes when sessionContextWindow changes", async () => {
+    const base = createFixtureBase();
+    try {
+      const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+      const taskDir = join(sliceDir, "tasks");
+      mkdirSync(taskDir, { recursive: true });
+      writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap\n");
+      writeFileSync(join(sliceDir, "S01-PLAN.md"), "# Slice Plan\n");
+      writeFileSync(join(taskDir, "T01-PLAN.md"), "# Task Plan\n");
+
+      const small = await buildExecuteTaskPrompt("M001", "S01", "Slice", "T01", "Task", base, {
+        level: "minimal",
+        sessionContextWindow: 128_000,
+      });
+      const large = await buildExecuteTaskPrompt("M001", "S01", "Slice", "T01", "Task", base, {
+        level: "minimal",
+        sessionContextWindow: 1_000_000,
+      });
+
+      assert.match(small, /~51K chars/);
+      assert.match(large, /~400K chars/);
+      assert.notEqual(small, large);
+    } finally {
+      cleanup(base);
+    }
   });
 });

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

@@ -64,6 +64,16 @@ test("discuss prompt allows implementation questions when they materially matter
   assert.doesNotMatch(prompt, /Questions must be about the experience, not the implementation/i);
 });
 
+test("discuss prompt ends milestone planning with next-step handoff", () => {
+  const prompt = readPrompt("discuss");
+  assert.match(prompt, /Next steps:/);
+  assert.match(prompt, /\/gsd auto/);
+  assert.match(prompt, /\/gsd status/);
+  assert.match(prompt, /\/gsd visualize/);
+  assert.match(prompt, /\/gsd notifications/);
+  assert.doesNotMatch(prompt, /nothing else\. Auto-mode will start automatically/);
+});
+
 test("guided discussion prompts avoid wrap-up prompts after every round", () => {
   const milestonePrompt = readPrompt("guided-discuss-milestone");
   const slicePrompt = readPrompt("guided-discuss-slice");
@@ -217,6 +227,17 @@ test("complete-slice prompt does not instruct LLM to toggle checkboxes manually"
   assert.doesNotMatch(prompt, /change \[ \] to \[x\]/);
 });
 
+test("complete-slice prompt keeps source fixes in execution units", () => {
+  const prompt = readPrompt("complete-slice");
+  assert.match(prompt, /Do not use direct `bash` for verification commands/i);
+  assert.match(prompt, /do \*\*not\*\* edit source files in this unit/i);
+  assert.match(prompt, /do \*\*not\*\* call `gsd_slice_complete`/i);
+  assert.match(prompt, /gsd_task_reopen/);
+  assert.match(prompt, /gsd_replan_slice/);
+  assert.match(prompt, /needs execution follow-up/i);
+  assert.doesNotMatch(prompt, /Fix failures before marking done/i);
+});
+
 test("complete-slice prompt instructs writing summary and UAT files before tool call", () => {
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
@@ -363,7 +384,9 @@ test("execute-task prompt uses camelCase parameter names matching TypeBox schema
 test("complete-slice prompt uses camelCase parameter names matching TypeBox schema", () => {
   const prompt = readPrompt("complete-slice");
   // The gsd_complete_slice tool schema uses camelCase: milestoneId, sliceId
-  const toolCallLine = prompt.split("\n").find((l) => /gsd_complete_slice/.test(l) || /gsd_slice_complete/.test(l));
+  const toolCallLine = prompt.split("\n").find((l) =>
+    (/gsd_complete_slice/.test(l) || /gsd_slice_complete/.test(l)) && /milestoneId/.test(l) && /sliceId/.test(l)
+  );
   assert.ok(toolCallLine, "prompt must contain a gsd_complete_slice or gsd_slice_complete tool call line");
   assert.doesNotMatch(toolCallLine!, /milestone_id/, "must use milestoneId, not milestone_id");
   assert.doesNotMatch(toolCallLine!, /slice_id/, "must use sliceId, not slice_id");

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

@@ -0,0 +1,230 @@
+// Project/App: GSD-2
+// File Purpose: Verifies low-risk auto-prompt duplication cuts render through prompt builders.
+
+import test from "node:test";
+import type { TestContext } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+  upsertMilestonePlanning,
+} from "../gsd-db.ts";
+
+type AutoPromptBuilders = typeof import("../auto-prompts.ts");
+
+function makeBase(prefix: string): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
+
+async function loadAutoPromptBuilders(t: TestContext): Promise<AutoPromptBuilders> {
+  const previousGsdHome = process.env.GSD_HOME;
+  const isolatedHome = mkdtempSync(join(tmpdir(), "gsd-prompt-loader-home-"));
+  process.env.GSD_HOME = isolatedHome;
+  t.after(() => {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(isolatedHome, { recursive: true, force: true });
+  });
+  return import(`../auto-prompts.ts?promptDupCuts=${Date.now()}-${Math.random()}`) as Promise<AutoPromptBuilders>;
+}
+
+function seedDb(base: string, taskStatus = "complete"): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Prompt Cuts", status: "active", depends_on: [] });
+  upsertMilestonePlanning("M001", {
+    title: "Prompt Cuts",
+    status: "active",
+    vision: "Reduce duplicate prompt reads.",
+    successCriteria: ["Prompt builders render compact context."],
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Prompt Slice",
+    status: "active",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task one",
+    status: taskStatus,
+  });
+}
+
+function writeRoadmapAndPlan(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001 Roadmap",
+      "## Slices",
+      "- [ ] **S01: Prompt Slice** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+    [
+      "# S01 Plan",
+      "",
+      "**Goal:** Reduce duplicate prompt reads.",
+      "",
+      "## Tasks",
+      "- [x] **T01: Task one** `est:15m`",
+    ].join("\n"),
+  );
+}
+
+function writeTaskSummary(base: string, options?: { blocker?: boolean; repeatedNarrative?: string }): void {
+  const narrative = options?.repeatedNarrative ?? "This full implementation narrative should stay out of closer prompts.";
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+    [
+      "---",
+      "id: T01",
+      "parent: S01",
+      "milestone: M001",
+      "provides:",
+      "  - prompt context reduction",
+      "key_files:",
+      "  - src/resources/extensions/gsd/auto-prompts.ts",
+      "key_decisions:",
+      "  - use compact excerpts before full reads",
+      "patterns_established:",
+      "  - excerpt-first complete-slice context",
+      "observability_surfaces: []",
+      "duration: 15m",
+      "verification_result: passed",
+      "completed_at: 2026-05-06T12:00:00Z",
+      `blocker_discovered: ${options?.blocker ? "true" : "false"}`,
+      "---",
+      "",
+      "# T01: Task one",
+      "**One-line result.**",
+      "",
+      "## What Happened",
+      narrative,
+      "",
+      "## Verification",
+      "node:test passed.",
+      "",
+      "## Diagnostics",
+      "Prompt size stayed bounded.",
+    ].join("\n"),
+  );
+}
+
+test("execute-task rendering makes memory_query and template disk reads fallback-only", async (t) => {
+  const base = makeBase("gsd-execute-dup-cuts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base, "pending");
+  writeRoadmapAndPlan(base);
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-PLAN.md"),
+    "# T01 Plan\n\nDo the prompt edit.\n",
+  );
+
+  const { buildExecuteTaskPrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildExecuteTaskPrompt("M001", "S01", "Prompt Slice", "T01", "Task one", base);
+
+  assert.match(prompt, /Call `memory_query`.*only when no injected memory block exists or the inlined memory\/context is insufficient/s);
+  assert.doesNotMatch(prompt, /Call `memory_query` with 2-4 keywords from the task title and touched files unless this is purely mechanical/);
+  assert.match(prompt, /Use the inlined Task Summary template below/);
+  assert.match(prompt, /Read `.*task-summary\.md` only if the inlined template is absent or visibly truncated/);
+  assert.doesNotMatch(prompt, /Read the template at `.*task-summary\.md`/);
+  assert.match(prompt, /### Output Template: Task Summary/);
+});
+
+test("complete-slice renders task summary excerpts without full summary bodies", async (t) => {
+  const base = makeBase("gsd-complete-slice-excerpts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base);
+  writeRoadmapAndPlan(base);
+  const repeatedNarrative = "FULL_TASK_BODY_SHOULD_NOT_RENDER ".repeat(40);
+  writeTaskSummary(base, { repeatedNarrative });
+
+  const { buildCompleteSlicePrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildCompleteSlicePrompt("M001", "Prompt Cuts", "S01", "Prompt Slice", base);
+
+  assert.match(prompt, /### Task Summary: T01 \(excerpt\)/);
+  assert.match(prompt, /On-demand.*read `\.gsd\/milestones\/M001\/slices\/S01\/tasks\/T01-SUMMARY\.md` only when this excerpt is absent\/truncated/s);
+  assert.doesNotMatch(prompt, /FULL_TASK_BODY_SHOULD_NOT_RENDER/);
+  assert.match(prompt, /Review the inlined task-summary excerpts/);
+});
+
+test("complete-slice caps malformed task summaries instead of inlining full bodies", async (t) => {
+  const base = makeBase("gsd-complete-slice-malformed-excerpts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base);
+  writeRoadmapAndPlan(base);
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+    [
+      "# Legacy summary without frontmatter id",
+      "LEGACY_FULL_BODY_SHOULD_BE_CAPPED ".repeat(200),
+    ].join("\n"),
+  );
+
+  const { buildCompleteSlicePrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildCompleteSlicePrompt("M001", "Prompt Cuts", "S01", "Prompt Slice", base);
+
+  assert.match(prompt, /Truncated malformed summary/);
+  assert.ok(prompt.length < 20_000);
+  assert.ok((prompt.match(/LEGACY_FULL_BODY_SHOULD_BE_CAPPED/g) ?? []).length < 60);
+});
+
+test("replan-slice renders blocker summary excerpt and tells the agent to read full only on demand", async (t) => {
+  const base = makeBase("gsd-replan-excerpts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base);
+  writeRoadmapAndPlan(base);
+  writeTaskSummary(base, {
+    blocker: true,
+    repeatedNarrative: "FULL_BLOCKER_BODY_SHOULD_NOT_RENDER ".repeat(40),
+  });
+
+  const { buildReplanSlicePrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildReplanSlicePrompt("M001", "Prompt Cuts", "S01", "Prompt Slice", base);
+
+  assert.match(prompt, /### Blocker Task Summary: T01 \(excerpt\)/);
+  assert.match(prompt, /Use the inlined blocker summary excerpt first/);
+  assert.match(prompt, /Read the full blocker task summary only if the excerpt is absent, marked truncated, or lacks the specific blocker evidence needed to replan/);
+  assert.doesNotMatch(prompt, /FULL_BLOCKER_BODY_SHOULD_NOT_RENDER/);
+  assert.doesNotMatch(prompt, /Read the blocker task summary carefully/);
+});

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

@@ -0,0 +1,40 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const promptsDir = join(__dirname, "..", "prompts");
+
+test("prompt templates do not reference legacy milestone-root .gsd paths", () => {
+  const offenders: string[] = [];
+  for (const file of readdirSync(promptsDir)) {
+    if (!file.endsWith(".md")) continue;
+    const content = readFileSync(join(promptsDir, file), "utf-8");
+    const legacyPatterns = [
+      /\.gsd\/\{\{(?:milestoneId|mid)\}\}\//g,
+      /\.gsd\/<milestone-id>\//g,
+      /\.gsd\/<ID>\//g,
+    ];
+    for (const pattern of legacyPatterns) {
+      if (pattern.test(content)) {
+        offenders.push(`${file}: ${pattern.source}`);
+      }
+    }
+  }
+
+  assert.deepEqual(
+    offenders,
+    [],
+    "Milestone artifacts must use .gsd/milestones/<MID>/..., not legacy .gsd/<MID>/...",
+  );
+});
+
+test("quick task prompt delegates commit policy to quick.ts", () => {
+  const content = readFileSync(join(promptsDir, "quick-task.md"), "utf-8");
+  assert.match(content, /\{\{commitInstruction\}\}/);
+  assert.doesNotMatch(content, /Stage only relevant files/);
+});