gsd-pi 2.75.0-dev.b6ad8c5f7 → 2.75.0-dev.e41b70b10

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

@@ -1,13 +1,8 @@
 /**
  * Prompt budget enforcement tests — verifies that budget-aware prompt builders
- * truncate content at section boundaries and that plan-slice includes executor
- * context constraints.
- *
- * Tests:
- *   1. inlineDependencySummaries() truncates when budget is small, passes through when large
- *   2. plan-slice.md template includes {{executorContextConstraints}} placeholder
- *   3. Executor constraints formatting varies with context window size
- *   4. Different context windows produce different budget-constrained outputs
+ * truncate content at section boundaries, that plan-slice includes executor
+ * context constraints, and that prompt builders thread the real executor
+ * context window through to the budget engine (issue #4142).
  */
 
 import { describe, it, beforeEach, afterEach } from "node:test";
@@ -488,4 +483,133 @@ describe("prompt-budget: execute-task builder truncation pattern", () => {
       assert.ok(result.droppedSections > 0, "should report dropped sections");
     }
   });
+});
+
+// ─── 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\)/,
+      "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",
+    );
+  });
+
+  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}`,
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/prompts-no-gitignored-test-refs.test.ts

@@ -0,0 +1,56 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const promptsDir = join(__dirname, "..", "prompts");
+
+function readPrompt(name: string): string {
+  return readFileSync(join(promptsDir, name), "utf-8");
+}
+
+test("add-tests prompt forbids referencing gitignored paths", () => {
+  const prompt = readPrompt("add-tests.md");
+
+  assert.match(
+    prompt,
+    /gitignore/i,
+    "add-tests prompt should mention .gitignore to rule out referencing local-only files",
+  );
+  assert.match(prompt, /\.gsd\//, "add-tests prompt should name .gsd/ as off-limits for tests");
+  assert.match(prompt, /\.planning\//, "add-tests prompt should name .planning/ as off-limits for tests");
+  assert.match(prompt, /\.audits\//, "add-tests prompt should name .audits/ as off-limits for tests");
+  assert.match(
+    prompt,
+    /tracked/i,
+    "add-tests prompt should frame the rule in terms of tracked files",
+  );
+});
+
+test("plan-slice prompt warns against planning tests that depend on gitignored files", () => {
+  const prompt = readPrompt("plan-slice.md");
+
+  assert.match(
+    prompt,
+    /gitignore/i,
+    "plan-slice prompt should warn against planning tests that depend on .gitignore paths",
+  );
+  assert.match(prompt, /\.gsd\//, "plan-slice prompt should name .gsd/ as off-limits for planned tests");
+  assert.match(prompt, /\.planning\//, "plan-slice prompt should name .planning/ as off-limits for planned tests");
+  assert.match(prompt, /\.audits\//, "plan-slice prompt should name .audits/ as off-limits for planned tests");
+});
+
+test("execute-task prompt forbids tests that reference gitignored paths", () => {
+  const prompt = readPrompt("execute-task.md");
+
+  assert.match(
+    prompt,
+    /gitignore/i,
+    "execute-task prompt should forbid referencing gitignored paths from tests",
+  );
+  assert.match(prompt, /\.gsd\//, "execute-task prompt should name .gsd/ as off-limits for tests");
+  assert.match(prompt, /\.planning\//, "execute-task prompt should name .planning/ as off-limits for tests");
+  assert.match(prompt, /\.audits\//, "execute-task prompt should name .audits/ as off-limits for tests");
+});

package/src/resources/extensions/gsd/tests/stash-queued-context-files.test.ts

@@ -21,6 +21,8 @@ import {
   existsSync,
   readFileSync,
   realpathSync,
+  symlinkSync,
+  lstatSync,
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -76,6 +78,20 @@ function createTempRepo(): string {
   return dir;
 }
 
+function createTempRepoWithSymlinkedGsd(): { repo: string; stateDir: string } {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "wt-symlink-stash-test-")));
+  const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "wt-symlink-state-")));
+  run("git init", repo);
+  run("git config user.email test@test.com", repo);
+  run("git config user.name Test", repo);
+  writeFileSync(join(repo, "README.md"), "# test\n");
+  symlinkSync(stateDir, join(repo, ".gsd"));
+  run("git add README.md", repo);
+  run("git commit -m init", repo);
+  run("git branch -M main", repo);
+  return { repo, stateDir };
+}
+
 function makeRoadmap(
   milestoneId: string,
   title: string,
@@ -259,6 +275,44 @@ test("#2505: mergeMilestoneToMain preserves queued CONTEXT files (not swept into
   }
 });
 
+test("#2505: pre-merge stash handles symlinked .gsd without traversing it", () => {
+  const { repo, stateDir } = createTempRepoWithSymlinkedGsd();
+  try {
+    const wtPath = createAutoWorktree(repo, "M016");
+    const normalizedPath = wtPath.replaceAll("\\", "/");
+    const worktreeName = normalizedPath.split("/").pop() || "M016";
+    const sliceBranch = `slice/${worktreeName}/S01`;
+    run(`git checkout -b "${sliceBranch}"`, wtPath);
+    writeFileSync(join(wtPath, "app.ts"), "export const app = true;\n");
+    run("git add app.ts", wtPath);
+    run('git commit -m "add app feature"', wtPath);
+    run("git checkout milestone/M016", wtPath);
+    run(`git merge --no-ff "${sliceBranch}" -m "merge S01"`, wtPath);
+
+    const queuedDir = join(stateDir, "milestones", "M017");
+    mkdirSync(queuedDir, { recursive: true });
+    writeFileSync(join(queuedDir, "M017-CONTEXT.md"), "# M017: Queued\n");
+
+    // Trigger the pre-merge stash with both tracked and untracked project files.
+    writeFileSync(join(repo, "README.md"), "# test\n\nDirty change.\n");
+    writeFileSync(join(repo, "local-note.txt"), "local scratch\n");
+
+    const result = mergeMilestoneToMain(repo, "M016", makeRoadmap("M016", "App Feature", [
+      { id: "S01", title: "Feature" },
+    ]));
+
+    assert.ok(result.commitMessage.includes("GSD-Milestone: M016"), "merge should succeed");
+    assert.ok(existsSync(join(repo, "app.ts")), "milestone code merged to main");
+    assert.equal(lstatSync(join(repo, ".gsd")).isSymbolicLink(), true, ".gsd symlink remains in place");
+    assert.ok(existsSync(join(queuedDir, "M017-CONTEXT.md")), "queued context remains in external state");
+    assert.equal(readFileSync(join(repo, "README.md"), "utf-8").replace(/\r\n/g, "\n"), "# test\n\nDirty change.\n");
+    assert.equal(readFileSync(join(repo, "local-note.txt"), "utf-8"), "local scratch\n");
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+    rmSync(stateDir, { recursive: true, force: true });
+  }
+});
+
 test("#2505: back-to-back merges preserve queued CONTEXT files", () => {
   const repo = createTempRepo();
   try {

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -11,6 +11,7 @@ import {
   _getAdapter,
   insertGateRow,
 } from "../gsd-db.ts";
+import { markDepthVerified, clearDiscussionFlowState } from "../bootstrap/write-gate.ts";
 import {
   executeCompleteMilestone,
   executePlanMilestone,
@@ -645,3 +646,99 @@ test("executeReplanSlice rewrites pending tasks and renders replan artifacts", a
     cleanup(base);
   }
 });
+
+test("executeSummarySave removes sibling CONTEXT-DRAFT when writing milestone CONTEXT (#4442)", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    markDepthVerified("M001", base);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    const draftPath = join(milestoneDir, "M001-CONTEXT-DRAFT.md");
+    writeFileSync(draftPath, "# Draft\n\nincremental notes");
+    assert.ok(existsSync(draftPath), "precondition: draft exists");
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      milestone_id: "M001",
+      artifact_type: "CONTEXT",
+      content: "# Context\n\nfinal discussion output",
+    }, base));
+
+    assert.equal(result.details.operation, "save_summary");
+    assert.equal(result.details.artifact_type, "CONTEXT");
+
+    const contextPath = join(milestoneDir, "M001-CONTEXT.md");
+    assert.ok(existsSync(contextPath), "CONTEXT.md should be written");
+    assert.equal(
+      existsSync(draftPath),
+      false,
+      "CONTEXT-DRAFT.md should be removed after final CONTEXT.md is written",
+    );
+  } finally {
+    clearDiscussionFlowState();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave removes sibling CONTEXT-DRAFT when writing slice CONTEXT (#4442)", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    const draftPath = join(sliceDir, "S01-CONTEXT-DRAFT.md");
+    writeFileSync(draftPath, "# Slice Draft\n\nincremental slice notes");
+    assert.ok(existsSync(draftPath), "precondition: slice draft exists");
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      milestone_id: "M001",
+      slice_id: "S01",
+      artifact_type: "CONTEXT",
+      content: "# Slice Context\n\nfinal slice output",
+    }, base));
+
+    assert.equal(result.details.operation, "save_summary");
+    assert.equal(result.details.artifact_type, "CONTEXT");
+
+    const contextPath = join(sliceDir, "S01-CONTEXT.md");
+    assert.ok(existsSync(contextPath), "slice CONTEXT.md should be written");
+    assert.equal(
+      existsSync(draftPath),
+      false,
+      "slice CONTEXT-DRAFT.md should be removed after final CONTEXT.md is written",
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave leaves sibling CONTEXT-DRAFT intact for non-CONTEXT artifacts (#4442)", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    const draftPath = join(milestoneDir, "M001-CONTEXT-DRAFT.md");
+    writeFileSync(draftPath, "# Draft\n\nstill in progress");
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      milestone_id: "M001",
+      artifact_type: "RESEARCH",
+      content: "# Research\n\nresearch notes",
+    }, base));
+
+    assert.equal(result.details.artifact_type, "RESEARCH");
+    assert.ok(
+      existsSync(draftPath),
+      "CONTEXT-DRAFT.md must survive RESEARCH/SUMMARY/ASSESSMENT writes",
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});