@opengsd/gsd-pi 1.9.0 → 1.10.0-dev.a5e42e99

package/src/resources/extensions/gsd/tests/markdown-renderer.test.ts

@@ -824,9 +824,9 @@ test('── markdown-renderer: renderTaskSummary round-trip ──', async () =
 
     // Verify file exists on disk
     const summaryPath = path.join(
-      tmpDir, '.gsd', 'phases', '01-test', 'T01-SUMMARY.md',
+      tmpDir, '.gsd', 'phases', '01-test', 'S01-T01-SUMMARY.md',
     );
-    assert.ok(fs.existsSync(summaryPath), 'T01-SUMMARY.md written to disk');
+    assert.ok(fs.existsSync(summaryPath), 'S01-T01-SUMMARY.md written to disk');
 
     // Parse and verify
     const rendered = fs.readFileSync(summaryPath, 'utf-8');
@@ -1020,7 +1020,7 @@ test('── markdown-renderer: renderAllFromDb produces all files ──', asyn
 
     // Verify task summary written
     const taskSummaryPath = path.join(
-      tmpDir, '.gsd', 'phases', '01-test', 'T01-SUMMARY.md',
+      tmpDir, '.gsd', 'phases', '01-test', 'S01-T01-SUMMARY.md',
     );
     assert.ok(fs.existsSync(taskSummaryPath), 'T01 summary written by renderAll');
   } finally {
@@ -1546,9 +1546,9 @@ test('── markdown-renderer: repairStaleRenders writes missing task summary
 
     // Verify file written
     const summaryPath = path.join(
-      tmpDir, '.gsd', 'phases', '01-test', 'T01-SUMMARY.md',
+      tmpDir, '.gsd', 'phases', '01-test', 'S01-T01-SUMMARY.md',
     );
-    assert.ok(fs.existsSync(summaryPath), 'T01-SUMMARY.md should exist after repair');
+    assert.ok(fs.existsSync(summaryPath), 'S01-T01-SUMMARY.md should exist after repair');
 
     // Second detect should be empty
     clearAllCaches();

package/src/resources/extensions/gsd/tests/model-cost-table.test.ts

@@ -75,6 +75,7 @@ test("#2885: cost table includes openai-codex provider models", () => {
   const codexModels = [
     "gpt-5.1", "gpt-5.1-codex-max", "gpt-5.1-codex-mini",
     "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5",
+    "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna",
   ];
   for (const model of codexModels) {
     assert.ok(ids.includes(model), `cost table should include openai-codex model "${model}"`);
@@ -109,3 +110,25 @@ test("gpt-5.5 uses official OpenAI list pricing", () => {
   assert.equal(entry.outputPer1k, 0.03);
   assert.equal(entry.updatedAt, "2026-04-23");
 });
+
+test("gpt-5.6 bare alias is not treated as a real cost-table model", () => {
+  assert.equal(lookupModelCost("gpt-5.6"), undefined);
+});
+
+test("gpt-5.6 variants use published pricing", () => {
+  const sol = lookupModelCost("openai-codex/gpt-5.6-sol");
+  assert.ok(sol, "lookupModelCost should find gpt-5.6-sol");
+  assert.equal(sol.inputPer1k, 0.005);
+  assert.equal(sol.outputPer1k, 0.03);
+  assert.deepEqual(sol.tiers?.[0], { inputTokensAbove: 272000, inputPer1k: 0.01, outputPer1k: 0.045 });
+
+  const terra = lookupModelCost("gpt-5.6-terra");
+  assert.ok(terra, "lookupModelCost should find gpt-5.6-terra");
+  assert.equal(terra.inputPer1k, 0.0025);
+  assert.equal(terra.outputPer1k, 0.015);
+
+  const luna = lookupModelCost("gpt-5.6-luna");
+  assert.ok(luna, "lookupModelCost should find gpt-5.6-luna");
+  assert.equal(luna.inputPer1k, 0.001);
+  assert.equal(luna.outputPer1k, 0.006);
+});

package/src/resources/extensions/gsd/tests/model-isolation.test.ts

@@ -10,6 +10,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { isCustomProvider } from "../preferences-models.ts";
 
 // ─── Test helpers ─────────────────────────────────────────────────────────────
 
@@ -303,3 +304,57 @@ describe("custom provider session model overrides PREFERENCES.md (#4122)", () =>
   });
 });
 
+describe("custom provider detection (#801)", () => {
+  let originalGsdHome: string | undefined;
+  let tmpGsdHome: string;
+
+  beforeEach(() => {
+    originalGsdHome = process.env.GSD_HOME;
+    tmpGsdHome = makeTmpDir("gsd-home");
+    process.env.GSD_HOME = tmpGsdHome;
+  });
+
+  afterEach(() => {
+    if (originalGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = originalGsdHome;
+    }
+    try { rmSync(tmpGsdHome, { recursive: true, force: true }); } catch {}
+  });
+
+  it("detects extension-registered providers that are not declared in models.json", () => {
+    const registry = {
+      getAllWithDiscovered: () => [
+        { provider: "pi-llama-cpp" },
+      ],
+    };
+
+    assert.equal(isCustomProvider("pi-llama-cpp", registry), true,
+      "runtime providers outside the built-in catalog should count as custom");
+  });
+
+  it("does not treat built-in providers as custom just because they are in the registry", () => {
+    const registry = {
+      getAll: () => [
+        { provider: "claude-code" },
+      ],
+    };
+
+    assert.equal(isCustomProvider("claude-code", registry), false,
+      "built-in providers must still defer to PREFERENCES.md");
+  });
+
+  it("does not treat bundled external-CLI providers as custom", () => {
+    // claude-code/cursor-agent/google-gemini-cli/google-antigravity register at
+    // runtime (so they are absent from the generated @gsd/pi-ai catalog), but
+    // they are first-party built-ins that PREFERENCES.md can route to. They must
+    // never be classified as custom, otherwise auto-mode silently ignores
+    // PREFERENCES.md for the default provider.
+    for (const provider of ["cursor-agent", "google-gemini-cli", "google-antigravity"]) {
+      const registry = { getAll: () => [{ provider }] };
+      assert.equal(isCustomProvider(provider, registry), false,
+        `${provider} is a built-in CLI provider and must defer to PREFERENCES.md`);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/model-router.test.ts

@@ -900,7 +900,7 @@ test("#2885: openai-codex standard-tier models are recognized", () => {
 
 test("#2885: openai-codex heavy-tier models are recognized", () => {
   const config = { ...defaultRoutingConfig(), enabled: true };
-  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "gpt-5.5", "o4-mini", "o4-mini-deep-research"];
+  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "gpt-5.5", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "o4-mini", "o4-mini-deep-research"];
   for (const model of heavyModels) {
     const result = resolveModelForComplexity(
       makeClassification("heavy"),

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

@@ -29,12 +29,14 @@ import {
 
 const SKILL_NAME = "testskill";
 const COMPLETE_SLICE_SKILL_NAME = "complete-slice-policies";
-const SKILL_ACTIVATION_SUBSTRING = `Read the installed '${SKILL_NAME}' skill file from <available_skills>`;
-const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Read the installed '${COMPLETE_SLICE_SKILL_NAME}' skill file from <available_skills>`;
 
 const tmpDirs: string[] = [];
 let savedCwd: string | undefined;
 
+function expectedSkillRead(base: string, name: string): string {
+  return `Read the skill file at \`${join(base, ".agents", "skills", name, "SKILL.md")}\``;
+}
+
 function setupProjectWithSkill(options: {
   skillName?: string;
   preferencesLines?: string[];
@@ -139,7 +141,7 @@ test("worker prompt (buildResearchSlicePrompt) includes <skill_activation> from
     "research-slice prompt should contain a <skill_activation> block",
   );
   assert.ok(
-    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, SKILL_NAME)),
     `research-slice prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
 });
@@ -164,7 +166,7 @@ test("complete-slice prompt includes <skill_activation> from unit-specific skill
     "complete-slice prompt should contain a <skill_activation> block",
   );
   assert.ok(
-    prompt.includes(COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, COMPLETE_SLICE_SKILL_NAME)),
     `complete-slice prompt should reference the skill-rule skill '${COMPLETE_SLICE_SKILL_NAME}'`,
   );
 });
@@ -192,7 +194,7 @@ test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skil
     `expected at least 2 <skill_activation> blocks (one per slice), got ${blockCount}`,
   );
   assert.ok(
-    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, SKILL_NAME)),
     `parallel-research-slices prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
   assert.ok(

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

@@ -104,6 +104,30 @@ test('handlePlanSlice writes slice/task planning state and renders plan artifact
   }
 });
 
+test('handlePlanSlice re-dispatch preserves completed task checkboxes', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+
+    const first = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
+
+    updateTaskStatus('M001', 'S02', 'T01', 'complete', '2026-07-11T00:00:00.000Z');
+
+    const second = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in second), `unexpected error: ${'error' in second ? second.error : ''}`);
+
+    const planPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    const parsedPlan = parsePlan(readFileSync(planPath, 'utf-8'));
+    assert.equal(parsedPlan.tasks.find((task) => task.id === 'T01')?.done, true);
+    assert.equal(parsedPlan.tasks.find((task) => task.id === 'T02')?.done, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice persists explicit slice/task target repositories', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -11,7 +11,7 @@
 import { describe, test, mock, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { tmpdir } from "node:os";
-import { mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 
 import { runPostUnitVerification, type VerificationContext } from "../auto-verification.ts";
@@ -113,6 +113,15 @@ ${yamlLines.join("\n")}
   _clearGsdRootCache();
 }
 
+function useFlatPhaseLayout(): string {
+  rmSync(join(tempDir, ".gsd", "milestones"), { recursive: true, force: true });
+  const phaseDir = join(tempDir, ".gsd", "phases", "01-m001");
+  mkdirSync(phaseDir, { recursive: true });
+  invalidateAllCaches();
+  _clearGsdRootCache();
+  return phaseDir;
+}
+
 /**
  * Create a task in DB that will pass basic verification but allows us to test the flow.
  */
@@ -461,6 +470,34 @@ describe("Post-execution blocking failure retry bypass", () => {
     );
   });
 
+  test("flat-phase post-unit evidence writes slice-task VERIFY.json at phase level", async () => {
+    const phaseDir = useFlatPhaseLayout();
+    createPostExecFailureTask();
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      verification_auto_fix: true,
+      verification_max_retries: 3,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+
+    const result = await runPostUnitVerification({ s, ctx, pi }, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    const evidencePath = join(phaseDir, "S01-T01-VERIFY.json");
+    const legacyEvidencePath = join(phaseDir, "tasks", "T01-VERIFY.json");
+    assert.ok(existsSync(evidencePath), "flat-phase evidence should be written at phase level");
+    assert.equal(existsSync(legacyEvidencePath), false, "flat-phase evidence should not create legacy tasks/ path");
+
+    const evidence = JSON.parse(readFileSync(evidencePath, "utf-8"));
+    assert.equal(evidence.passed, false);
+    assert.ok(Array.isArray(evidence.postExecutionChecks), "post-execution checks should be included in rewritten evidence");
+  });
+
   test("strict post-exec warning pause includes warning details", async () => {
     createPostExecWarningTask();
     writePreferences({

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -823,6 +823,157 @@ test("pre-dispatch hook action validation via validatePreferences", () => {
   assert.ok(e3.some(e => e.includes("invalid action")));
 });
 
+test("planning_subagents validation accepts configured read-only planning specialists", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagents: {
+      "plan-milestone": { allowed: ["security", "reviewer"] },
+      "plan-slice": { allowed: ["scout", "security", "security"] },
+    },
+  } as any);
+
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.planning_subagents?.["plan-milestone"]?.allowed, ["security", "reviewer"]);
+  assert.deepEqual(preferences.planning_subagents?.["plan-slice"]?.allowed, ["scout", "security"]);
+});
+
+test("planning_subagents validation accepts custom agents registered as read-only planning specialists", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagent_registry: {
+      "my-custom-planner": { read_only_specialist: true },
+    },
+    planning_subagents: {
+      "plan-milestone": { allowed: ["planner", "my-custom-planner"] },
+      "plan-slice": { allowed: ["scout", "my-custom-planner"] },
+    },
+  } as any);
+
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.planning_subagent_registry?.["my-custom-planner"], {
+    read_only_specialist: true,
+  });
+  assert.deepEqual(preferences.planning_subagents?.["plan-milestone"]?.allowed, [
+    "planner",
+    "my-custom-planner",
+  ]);
+  assert.deepEqual(preferences.planning_subagents?.["plan-slice"]?.allowed, [
+    "scout",
+    "my-custom-planner",
+  ]);
+});
+
+test("planning_subagents validation rejects unsupported units and unsafe agents", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagents: {
+      "execute-task": { allowed: ["security"] },
+      "plan-slice": { allowed: ["worker"] },
+    },
+  } as any);
+
+  assert.equal(preferences.planning_subagents, undefined);
+  assert.ok(errors.some(e => e.includes("unsupported unit \"execute-task\"")));
+  assert.ok(errors.some(e => e.includes("\"worker\"") && e.includes("read-only planning specialist")));
+});
+
+test("planning_subagents validation explains how to register custom planning agents", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagents: {
+      "plan-slice": { allowed: ["my-custom-planner"] },
+    },
+  } as any);
+
+  assert.equal(preferences.planning_subagents, undefined);
+  assert.ok(errors.some(e =>
+    e.includes("my-custom-planner") &&
+    e.includes("planning_subagent_registry.my-custom-planner.read_only_specialist: true")
+  ));
+});
+
+test("planning_subagent_registry validation requires explicit read_only_specialist true", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagent_registry: {
+      "write-capable-agent": { read_only_specialist: false },
+    },
+  } as any);
+
+  assert.equal(preferences.planning_subagent_registry, undefined);
+  assert.ok(errors.some(e =>
+    e.includes("planning_subagent_registry.write-capable-agent.read_only_specialist must be true")
+  ));
+});
+
+test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-planning-subagents-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-planning-subagents-home-"));
+
+  t.after(() => {
+    clearGSDPreferencesCache();
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+  clearGSDPreferencesCache();
+
+  writeFileSync(
+    getGlobalGSDPreferencesPath(),
+    [
+      "---",
+      "version: 1",
+      "planning_subagent_registry:",
+      "  global-custom-planner:",
+      "    read_only_specialist: true",
+      "planning_subagents:",
+      "  plan-slice:",
+      "    allowed: [scout, reviewer, global-custom-planner]",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  writeFileSync(
+    getProjectGSDPreferencesPath(tempProject),
+    [
+      "---",
+      "version: 1",
+      "planning_subagent_registry:",
+      "  project-custom-planner:",
+      "    read_only_specialist: true",
+      "planning_subagents:",
+      "  plan-slice:",
+      "    allowed: [security, project-custom-planner]",
+      "  plan-milestone:",
+      "    allowed: [planner, project-custom-planner]",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.deepEqual(loaded?.preferences.planning_subagent_registry, {
+    "global-custom-planner": { read_only_specialist: true },
+    "project-custom-planner": { read_only_specialist: true },
+  });
+  assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-slice"]?.allowed, [
+    "scout",
+    "reviewer",
+    "global-custom-planner",
+    "security",
+    "project-custom-planner",
+  ]);
+  assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-milestone"]?.allowed, [
+    "planner",
+    "project-custom-planner",
+  ]);
+});
+
 // ── Model config parsing ─────────────────────────────────────────────────────
 
 test("parses OpenRouter model config with org/model IDs and fallbacks", () => {

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -54,6 +54,13 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   },
   post_unit_hooks: [{ command: "npm test" }],
   pre_dispatch_hooks: [{ command: "npm run lint" }],
+  planning_subagent_registry: {
+    "custom-planner": { read_only_specialist: true },
+  },
+  planning_subagents: {
+    "plan-milestone": { allowed: ["scout", "planner"] },
+    "plan-slice": { allowed: ["scout"] },
+  },
   dynamic_routing: { enabled: true },
   disabled_model_providers: ["slow-provider"],
   uok: { enabled: true },

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

@@ -13,6 +13,7 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 import { buildExecuteTaskPrompt, buildPlanSlicePrompt, buildReactiveExecutePrompt, buildResearchSlicePrompt, inlineDependencySummaries } from "../auto-prompts.js";
+import { buildDiscussSlicePrompt } from "../guided-flow.js";
 import { computeBudgets, truncateAtSectionBoundary } from "../context-budget.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -735,3 +736,89 @@ describe("prompt-budget: modelRegistry + sessionContextWindow behavior", () => {
     }
   });
 });
+
+// ─── execute-task + discuss-slice inline caps (plan 039) ──────────────────────
+
+describe("prompt-budget: execute-task inline cap (039)", () => {
+  it("keeps the authoritative task plan whole but drops trailing templates when the plan alone exceeds the inline 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");
+      // Oversized task plan (~60K) — well past the 20K inline ceiling.
+      const bigPlan = "# Task Plan\n\nMARKER_TASKPLAN_HEAD\n\n" + Array.from({ length: 30 }, (_, i) =>
+        `### Step ${i}\n\n${"Implementation detail. ".repeat(90)}`
+      ).join("\n\n");
+      writeFileSync(join(taskDir, "T01-PLAN.md"), bigPlan);
+
+      const prompt = await buildExecuteTaskPrompt("M001", "S01", "Slice", "T01", "Task", base, {
+        level: "standard",
+        sessionContextWindow: 32_000,
+      });
+
+      // The task plan is the authoritative execution contract — never truncated;
+      // its content survives whole even when it alone exceeds the inline budget.
+      assert.match(prompt, /MARKER_TASKPLAN_HEAD/);
+      assert.match(prompt, /### Step 29/);
+      // Trailing lower-priority templates are dropped — the on-demand decisions
+      // template that "standard" normally inlines is gone because the task plan
+      // consumed the entire inline budget. (Baseline: the tiny-plan test above
+      // asserts this block IS present.)
+      assert.doesNotMatch(prompt, /### On-demand Decisions Template/);
+    } finally {
+      cleanup(base);
+    }
+  });
+});
+
+describe("prompt-budget: discuss-slice inline cap (039)", () => {
+  it("prepends the configured response language", async () => {
+    const base = createFixtureBase();
+    const gsdHome = mkdtempSync(join(tmpdir(), "gsd-discuss-slice-language-home-"));
+    const previousGsdHome = process.env.GSD_HOME;
+    process.env.GSD_HOME = gsdHome;
+
+    try {
+      writeFileSync(join(gsdHome, "PREFERENCES.md"), "---\nversion: 1\nlanguage: 中文\n---\n", "utf-8");
+      mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+
+      const prompt = await buildDiscussSlicePrompt("M001", "S01", "Current", base);
+
+      assert.match(prompt, /^## Response Language\n\nAlways respond in 中文/);
+    } finally {
+      if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+      else process.env.GSD_HOME = previousGsdHome;
+      cleanup(base);
+      cleanup(gsdHome);
+    }
+  });
+
+  it("caps the inlined block — roadmap survives first, the trailing decisions register truncates", async () => {
+    const base = createFixtureBase();
+    try {
+      const msDir = join(base, ".gsd", "milestones", "M001");
+      mkdirSync(join(msDir, "slices", "S01"), { recursive: true });
+      writeFileSync(join(msDir, "M001-ROADMAP.md"), "# Roadmap\n\nMARKER_ROADMAP\n\n- [ ] **S01: Current** `risk:low`\n");
+      writeFileSync(join(msDir, "M001-CONTEXT.md"), "# Context\n\nMARKER_CONTEXT\n");
+      // Huge decisions register (~60K) — the unbounded-growth surface the cap bounds.
+      const bigDecisions = "# Decisions\n\n" + Array.from({ length: 40 }, (_, i) =>
+        `### D${String(i).padStart(3, "0")}\n\n${"Decision rationale detail. ".repeat(60)}`
+      ).join("\n\n");
+      writeFileSync(join(base, ".gsd", "DECISIONS.md"), bigDecisions);
+
+      const prompt = await buildDiscussSlicePrompt("M001", "S01", "Current", base);
+
+      // Roadmap is first in the inlined block → survives the cap.
+      assert.match(prompt, /MARKER_ROADMAP/);
+      // The cap fired (capPreamble ceiling is 20K; the block is ~60K).
+      assert.match(prompt, /\[\.\.\.truncated/);
+      // The last decision (trailing content) is dropped.
+      assert.doesNotMatch(prompt, /### D039/);
+    } finally {
+      cleanup(base);
+    }
+  });
+});