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

package/src/resources/extensions/gsd/tests/integration/doctor-git-symlink-cwd.test.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import { execSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import { runGSDDoctor } from "../../doctor.ts";
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createRepoWithCompletedMilestone(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-symlink-cwd-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  const milestoneDir = join(dir, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, "ROADMAP.md"), `---
+id: M001
+title: "Test Milestone"
+---
+
+# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- Done
+
+## Slices
+- [x] **S01: Test slice** \`risk:low\` \`depends:[]\`
+  > After this: done
+
+## Boundary Map
+_None_
+`);
+
+  run("git add -A", dir);
+  run("git commit -m \"add milestone\"", dir);
+
+  return dir;
+}
+
+test("doctor removes orphaned milestone worktree when cwd uses a symlink alias", { skip: process.platform === "win32" }, async (t) => {
+  const previousCwd = process.cwd();
+  const dir = createRepoWithCompletedMilestone();
+  const alias = join(tmpdir(), `doc-git-alias-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+
+  t.after(() => {
+    try { process.chdir(previousCwd); } catch { process.chdir(tmpdir()); }
+    rmSync(alias, { recursive: true, force: true });
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+  run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+  symlinkSync(dir, alias);
+  process.chdir(join(alias, ".gsd", "worktrees", "M001"));
+
+  const fixed = await runGSDDoctor(dir, { fix: true, isolationMode: "worktree" });
+  assert.ok(
+    fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")),
+    `removes orphaned worktree even when cwd uses a symlink alias (got: ${JSON.stringify(fixed.fixesApplied)})`,
+  );
+
+  const wtList = run("git worktree list", dir);
+  assert.ok(!wtList.includes("milestone/M001"), "worktree removed after symlink-cwd fix");
+});

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -1579,3 +1579,69 @@ describe("checkTaskOrdering directory inputs (#4446)", () => {
     );
   });
 });
+
+describe("checkFilePathConsistency self-referential inputs (#4459)", () => {
+  test("input that is also in the same task's expected_output is not blocking when missing on disk", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-self-output-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T02",
+        sequence: 0,
+        inputs: ["src/components/email/SnoozePopover.jsx"],
+        expected_output: ["src/components/email/SnoozePopover.jsx"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.deepEqual(
+      results,
+      [],
+      "File declared as both input and expected_output of the same task should not block — the task itself produces it",
+    );
+  });
+
+  test("input missing from disk, missing from prior outputs, and missing from own expected_output still blocks", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-self-output-missing-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T02",
+        sequence: 0,
+        inputs: ["src/components/email/SnoozePopover.jsx"],
+        expected_output: ["src/other/unrelated.jsx"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(results.length, 1, "Genuinely missing input should still be reported");
+    assert.equal(results[0].blocking, true);
+    assert.equal(results[0].target, "src/components/email/SnoozePopover.jsx");
+  });
+
+  test("self-output exemption matches across path normalization (./ prefix)", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-self-output-norm-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T02",
+        sequence: 0,
+        inputs: ["./src/generated.ts"],
+        expected_output: ["src/generated.ts"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.deepEqual(
+      results,
+      [],
+      "./src/generated.ts and src/generated.ts should compare equal after normalization",
+    );
+  });
+});

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

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

@@ -10,6 +10,8 @@ import {
 } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { saveArtifactToDb } from "../db-writer.js";
+import { resolveMilestoneFile, resolveSliceFile } from "../paths.js";
+import { unlinkSync } from "node:fs";
 import type { CompleteMilestoneParams } from "./complete-milestone.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
 import { handleCompleteTask } from "./complete-task.js";
@@ -103,6 +105,18 @@ export async function executeSummarySave(
       },
       basePath,
     );
+
+    if (params.artifact_type === "CONTEXT" && !params.task_id) {
+      try {
+        const draftFile = params.slice_id
+          ? resolveSliceFile(basePath, params.milestone_id, params.slice_id, "CONTEXT-DRAFT")
+          : resolveMilestoneFile(basePath, params.milestone_id, "CONTEXT-DRAFT");
+        if (draftFile) unlinkSync(draftFile);
+      } catch (e) {
+        logWarning("tool", `CONTEXT-DRAFT.md unlink failed: ${(e as Error).message}`);
+      }
+    }
+
     return {
       content: [{ type: "text", text: `Saved ${params.artifact_type} artifact to ${relativePath}` }],
       details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type },

package/src/resources/extensions/search-the-web/command-search-provider.ts

@@ -8,6 +8,7 @@
  * All provider logic lives in provider.ts (S01) — this is pure UI wiring.
  */
 
+import { isAnthropicApi } from '@gsd/pi-ai'
 import type { ExtensionAPI } from '@gsd/pi-coding-agent'
 import type { AutocompleteItem } from '@gsd/pi-tui'
 import {
@@ -90,7 +91,9 @@ export function registerSearchProviderCommand(pi: ExtensionAPI): void {
 
       setSearchProviderPreference(chosen)
       const effective = resolveSearchProvider()
-      const isAnthropic = ctx.model?.provider === 'anthropic'
+      // Gate on api (#4478 / ADR-012): covers claude-code, anthropic-vertex, and
+      // other Anthropic-fronting transports — not just the plain `anthropic` provider.
+      const isAnthropic = isAnthropicApi(ctx.model)
       const nativeNote = isAnthropic ? '\nNote: Native Anthropic web search is also active (automatic, no API key needed).' : ''
       ctx.ui.notify(
         `Search provider set to ${chosen}. Effective provider: ${effective ?? 'none (no API keys)'}${nativeNote}`,

package/src/resources/extensions/search-the-web/native-search.ts

@@ -5,6 +5,7 @@
  * the heavy tool-registration modules.
  */
 
+import { isAnthropicApi } from "@gsd/pi-ai";
 import { resolveSearchProviderFromPreferences } from "../gsd/preferences.js";
 
 /** Tool names for the Brave-backed custom search tools */
@@ -94,7 +95,10 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
   pi.on("model_select", async (event: any, ctx: any) => {
     modelSelectFired = true;
     const wasAnthropic = isAnthropicProvider;
-    isAnthropicProvider = event.model.provider === "anthropic";
+    // Gate on `api` not `provider` (#4478 / ADR-012): covers claude-code OAuth,
+    // anthropic-vertex, and Vercel-gateway-hosted Anthropic — all serve the
+    // Messages API and accept the native web_search tool.
+    isAnthropicProvider = isAnthropicApi(event.model);
 
     const hasBrave = !!process.env.BRAVE_API_KEY;
 
@@ -139,9 +143,15 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
     // the model_select flag, then to the model name heuristic (last resort).
     // The model name heuristic is needed for session restores where
     // modelsAreEqual suppresses model_select AND the SDK doesn't pass model.
-    const eventModel = event.model as { provider: string } | undefined;
+    const eventModel = event.model as { provider?: string; api?: string } | undefined;
     let isAnthropic: boolean;
-    if (eventModel?.provider) {
+    if (eventModel?.api) {
+      // Preferred path: gate on wire protocol (#4478 / ADR-012).
+      isAnthropic = isAnthropicApi(eventModel);
+    } else if (eventModel?.provider) {
+      // Fallback for event shapes that carry provider but not api — only plain
+      // `anthropic` maps unambiguously without the api field. Other Anthropic
+      // transports will arrive via the modelSelectFired or model-name branch.
       isAnthropic = eventModel.provider === "anthropic";
     } else if (modelSelectFired) {
       isAnthropic = isAnthropicProvider;