gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

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

@@ -1,45 +1,143 @@
-// Guard test — every key in KNOWN_PREFERENCE_KEYS must be reachable from the
-// /gsd prefs wizard.  Without this guard, a new preference can be added to the
-// schema without anyone wiring it into the TUI, silently re-creating the gap
-// this test exists to prevent.
+// GSD-2 + prefs-wizard-coverage.test.ts - Behavioral coverage for preferences wizard persistence.
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
+import { buildCategorySummaries, handlePrefsWizard } from "../commands-prefs-wizard.ts";
 import { KNOWN_PREFERENCE_KEYS } from "../preferences-types.ts";
 
-// Keys exposed via a dedicated command rather than the wizard.  They're still
-// reachable by the user, just not inside the category menu flow.  If you add a
-// new key here, add a comment explaining where it lives.
-const EXPOSED_OUTSIDE_WIZARD = new Set<string>([
-  "version",          // auto-managed by writePreferencesFile
-  "modelOverrides",   // advanced routing — edit PREFERENCES.md directly (not in KNOWN_PREFERENCE_KEYS)
-  "context_mode",     // advanced sandbox config (gsd_exec + compaction) — enabled by default; edit PREFERENCES.md directly to tune timeouts/caps. Wizard coverage tracked separately.
-  "planning_depth",   // exposed through /gsd new-project --deep and /gsd new-milestone --deep
-]);
+const PREF_SAMPLE_VALUES: Record<string, unknown> = {
+  version: 1,
+  mode: "team",
+  always_use_skills: ["debug-like-expert"],
+  prefer_skills: ["typescript-expert"],
+  avoid_skills: ["slow-skill"],
+  skill_rules: [{ when: "unit:execute-task", use: ["test-writer-fixer"] }],
+  custom_instructions: ["Keep changes focused."],
+  models: { execution: "openai/gpt-5" },
+  skill_discovery: "auto",
+  skill_staleness_days: 7,
+  auto_supervisor: { soft_timeout_minutes: 20, idle_timeout_minutes: 10, hard_timeout_minutes: 30 },
+  uat_dispatch: true,
+  unique_milestone_ids: true,
+  budget_ceiling: 12.5,
+  budget_enforcement: "warn",
+  context_pause_threshold: 0.8,
+  notifications: {
+    enabled: true,
+    on_complete: true,
+    on_error: true,
+    on_budget: true,
+    on_milestone: true,
+    on_attention: true,
+  },
+  cmux: { enabled: true },
+  remote_questions: { provider: "slack", channel: "C123" },
+  git: {
+    auto_push: false,
+    push_branches: true,
+    pre_merge_check: true,
+    merge_strategy: "squash",
+    isolation: "worktree",
+    main_branch: "main",
+    absorb_snapshot_commits: true,
+  },
+  post_unit_hooks: [{ command: "npm test" }],
+  pre_dispatch_hooks: [{ command: "npm run lint" }],
+  dynamic_routing: { enabled: true },
+  disabled_model_providers: ["slow-provider"],
+  uok: { enabled: true },
+  token_profile: "standard",
+  phases: { progressive_planning: true },
+  auto_visualize: true,
+  auto_report: true,
+  parallel: { enabled: true, max_workers: 2 },
+  verification_commands: ["npm test"],
+  verification_auto_fix: true,
+  verification_max_retries: 1,
+  search_provider: "web",
+  context_selection: "auto",
+  widget_mode: "small",
+  reactive_execution: { enabled: true },
+  gate_evaluation: { enabled: true },
+  github: { enabled: true },
+  service_tier: "default",
+  forensics_dedup: true,
+  show_token_cost: true,
+  min_request_interval_ms: 250,
+  stale_commit_threshold_minutes: 15,
+  context_management: { enabled: true },
+  experimental: { rtk: true },
+  codebase: { indexing: "auto" },
+  slice_parallel: { enabled: true, max_workers: 2 },
+  safety_harness: { enabled: true },
+  enhanced_verification: true,
+  enhanced_verification_pre: true,
+  enhanced_verification_post: true,
+  enhanced_verification_strict: false,
+  discuss_preparation: true,
+  discuss_web_research: true,
+  discuss_depth: "standard",
+  flat_rate_providers: ["openai"],
+  language: "en",
+  context_window_override: 128000,
+  context_mode: { enabled: true },
+  planning_depth: "deep",
+};
 
-test("every KNOWN_PREFERENCE_KEYS entry is reachable from the wizard source", () => {
-  const src = readFileSync(
-    new URL("../commands-prefs-wizard.ts", import.meta.url),
-    "utf-8",
-  );
+test("prefs wizard save path preserves every known preference key", async () => {
+  const missingSamples = [...KNOWN_PREFERENCE_KEYS].filter((key) => !(key in PREF_SAMPLE_VALUES));
+  assert.deepEqual(missingSamples, [], "test fixture must cover every known preference key");
+
+  const dir = mkdtempSync(join(tmpdir(), "gsd-prefs-wizard-"));
+  const prefsPath = join(dir, "PREFERENCES.md");
+  const choices = ["── Save & Exit ──"];
+  const ctx = {
+    ui: {
+      notify() {},
+      select: async () => choices.shift(),
+    },
+    waitForIdle: async () => {},
+    reload: async () => {},
+  } as any;
 
-  const missing: string[] = [];
-  for (const key of KNOWN_PREFERENCE_KEYS) {
-    if (EXPOSED_OUTSIDE_WIZARD.has(key)) continue;
-    // The key must appear somewhere in the wizard — either as a direct
-    // prefs[...] / pref reference, or in the orderedKeys serialization list.
-    // A plain substring match is enough because all prefs-wizard references
-    // use the exact key name.
-    if (!src.includes(`"${key}"`) && !src.includes(`.${key}`)) {
-      missing.push(key);
-    }
+  try {
+    await handlePrefsWizard(ctx, "project", PREF_SAMPLE_VALUES, { pathOverride: prefsPath });
+    const saved = readFileSync(prefsPath, "utf-8");
+    const missingPersisted = [...KNOWN_PREFERENCE_KEYS].filter((key) => !saved.includes(`${key}:`));
+    assert.deepEqual(missingPersisted, []);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
   }
+});
 
+test("category summaries expose the wizard menu surface for configured prefs", () => {
+  const summaries = buildCategorySummaries(PREF_SAMPLE_VALUES);
   assert.deepEqual(
-    missing,
-    [],
-    `These preference keys are in KNOWN_PREFERENCE_KEYS but are not referenced anywhere in the /gsd prefs wizard — they cannot be configured through the UI. Either add wizard coverage or add them to EXPOSED_OUTSIDE_WIZARD with an explanatory comment:\n${missing.join("\n")}`,
+    Object.keys(summaries).sort(),
+    [
+      "advanced",
+      "budget",
+      "context",
+      "discuss",
+      "git",
+      "hooks",
+      "integrations",
+      "mode",
+      "models",
+      "notifications",
+      "parallelism",
+      "phases",
+      "skills",
+      "timeouts",
+      "uok",
+      "verification",
+    ],
   );
+  assert.match(summaries.models, /phase/);
+  assert.match(summaries.integrations, /remote: C123/);
+  assert.match(summaries.verification, /1 cmd/);
 });

package/src/resources/extensions/gsd/tests/project-root-cwd-crash.test.ts

@@ -8,46 +8,28 @@
  * Also verifies #3589 — nativeBranchExists validation for prefs.main_branch
  * in auto-worktree.ts to prevent merge failures with stale preferences.
  *
- * Structural verification test — reads source to confirm the guards exist.
+ * Behavior verification test — exercises the exported projectRoot helper
+ * without reading command source.
  */
 
-import { describe, test } from 'node:test';
+import { describe, test, mock } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const contextSource = readFileSync(join(__dirname, '..', 'commands', 'context.ts'), 'utf-8');
-const worktreeSource = readFileSync(join(__dirname, '..', 'auto-worktree.ts'), 'utf-8');
+import { GSDNoProjectError, projectRoot } from '../commands/context.ts';
 
 describe('projectRoot cwd crash guard (#3598)', () => {
-  test('projectRoot wraps process.cwd() in try/catch', () => {
-    assert.match(contextSource, /try\s*\{[\s\S]*?process\.cwd\(\)/,
-      'process.cwd() should be inside a try block');
-  });
-
-  test('catch block falls back to homedir()', () => {
-    assert.match(contextSource, /catch[\s\S]*?homedir\(\)/,
-      'catch block should fall back to homedir()');
-  });
-
-  test('projectRoot function is exported', () => {
-    assert.match(contextSource, /export function projectRoot\(\)/,
-      'projectRoot should be an exported function');
-  });
-});
-
-describe('main_branch nativeBranchExists validation (#3589)', () => {
-  test('prefs.main_branch is validated with nativeBranchExists', () => {
-    assert.match(worktreeSource, /nativeBranchExists\(.*prefs\.main_branch\)/,
-      'nativeBranchExists should validate prefs.main_branch');
-  });
-
-  test('validatedPrefBranch falls back to undefined when branch missing', () => {
-    assert.match(worktreeSource, /validatedPrefBranch[\s\S]*?:\s*undefined/,
-      'validatedPrefBranch should fall back to undefined');
+  test('reports the home-directory guard instead of leaking cwd ENOENT', () => {
+    const cwd = mock.method(process, 'cwd', () => {
+      const err = new Error('ENOENT: current working directory was removed') as NodeJS.ErrnoException;
+      err.code = 'ENOENT';
+      throw err;
+    });
+    try {
+      assert.throws(
+        () => projectRoot(),
+        (err) => err instanceof GSDNoProjectError && !String(err.message).includes('ENOENT'),
+      );
+    } finally {
+      cwd.mock.restore();
+    }
   });
 });

package/src/resources/extensions/gsd/tests/projection-no-plan-overwrite.test.ts

@@ -13,80 +13,42 @@
 
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-// Use process.cwd() based resolution instead of import.meta.url
-// to avoid tsx test runner path resolution issues
-const src = readFileSync(
-  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'workflow-projections.ts'),
-  'utf-8',
-)
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from '../gsd-db.ts'
+import { renderAllProjections } from '../workflow-projections.ts'
 
 describe('renderAllProjections must not overwrite PLAN.md (#3651)', () => {
-  it('renderAllProjections function body does NOT invoke renderPlanProjection', () => {
-    // Extract the renderAllProjections function body
-    const fnStart = src.indexOf('export async function renderAllProjections(')
-    assert.ok(fnStart !== -1, 'renderAllProjections function must exist')
-
-    // Find the for-loop over sliceRows inside renderAllProjections
-    const loopStart = src.indexOf('for (const slice of sliceRows)', fnStart)
-    assert.ok(loopStart !== -1, 'slice loop must exist in renderAllProjections')
-
-    // Find the closing of renderAllProjections (next section marker)
-    const fnEnd = src.indexOf('\n// ─── ', fnStart + 1)
-    assert.ok(fnEnd !== -1, 'section delimiter after renderAllProjections must exist')
-
-    const fnBody = src.slice(loopStart, fnEnd)
-
-    // The fix: renderPlanProjection must NOT appear as a function call.
-    // Strip comment lines before checking (comments may mention the function name).
-    const codeOnly = fnBody
-      .split('\n')
-      .filter(line => !line.trim().startsWith('//'))
-      .join('\n')
-
-    const hasPlanCall = /renderPlanProjection\s*\(/.test(codeOnly)
-    assert.equal(
-      hasPlanCall,
-      false,
-      'renderPlanProjection must not be called inside the renderAllProjections slice loop — ' +
-        'authoritative PLAN.md is rendered only by plan-slice/replan-slice tools',
-    )
-  })
-
-  it('renderPlanProjection is still defined (available for regenerateIfMissing)', () => {
-    assert.ok(
-      src.includes('function renderPlanProjection('),
-      'renderPlanProjection function definition must still exist for on-demand recovery',
-    )
-  })
-
-  it('renderAllProjections still renders ROADMAP, SUMMARY, and STATE projections', () => {
-    const fnStart = src.indexOf('export async function renderAllProjections(')
-    const fnEnd = src.indexOf('\n// ─── ', fnStart + 1)
-    const fnBody = src.slice(fnStart, fnEnd)
-
-    // #4402: ROADMAP.md is now rendered by the authoritative renderer
-    // (renderRoadmapFromDb) to preserve ## Boundary Map and other sections
-    // that the reduced renderRoadmapProjection would strip.
-    assert.ok(
-      fnBody.includes('renderRoadmapFromDb('),
-      'renderRoadmapFromDb must be called (authoritative roadmap renderer)',
-    )
-    assert.ok(
-      !/renderRoadmapProjection\s*\(/.test(
-        fnBody.split('\n').filter(l => !l.trim().startsWith('//')).join('\n'),
-      ),
-      'renderRoadmapProjection must NOT be called — it clobbers Boundary Map (#4402)',
-    )
-    assert.ok(
-      fnBody.includes('renderSummaryProjection('),
-      'renderSummaryProjection must still be called',
-    )
-    assert.ok(
-      fnBody.includes('renderStateProjection('),
-      'renderStateProjection must still be called',
-    )
+  it('preserves authoritative PLAN.md while rendering other projections', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-projection-plan-'))
+    const msDir = join(base, '.gsd', 'milestones', 'M001')
+    const sliceDir = join(msDir, 'slices', 'S01')
+    const planPath = join(sliceDir, 'S01-PLAN.md')
+    const planContent = [
+      '# S01 Plan',
+      '',
+      '## Must-Haves',
+      '',
+      '- preserve this authoritative section',
+      '',
+    ].join('\n')
+
+    try {
+      mkdirSync(sliceDir, { recursive: true })
+      writeFileSync(join(msDir, 'M001-ROADMAP.md'), '# Roadmap\n\n## Slices\n\n- [ ] **S01: Slice** `risk:low` `depends:[]`\n')
+      writeFileSync(planPath, planContent)
+      openDatabase(join(base, '.gsd', 'gsd.db'))
+      insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' })
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice', status: 'pending' })
+
+      await renderAllProjections(base, 'M001')
+
+      assert.equal(readFileSync(planPath, 'utf-8'), planContent)
+      assert.ok(readFileSync(join(base, '.gsd', 'STATE.md'), 'utf-8').includes('M001'))
+    } finally {
+      closeDatabase()
+      rmSync(base, { recursive: true, force: true })
+    }
   })
 })

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);
+    }
   });
 });