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

package/dist/resources/extensions/gsd/auto/phases.js

@@ -607,6 +607,8 @@ export async function runDispatch(ic, preData, loopState) {
         prefs,
         session: s,
         structuredQuestionsAvailable,
+        sessionContextWindow: ctx.model?.contextWindow,
+        modelRegistry: ctx.modelRegistry,
     });
     if (dispatchResult.action === "stop") {
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-stop", rule: dispatchResult.matchedRule, data: { reason: dispatchResult.reason } });

package/dist/resources/extensions/gsd/auto-dashboard.js

@@ -9,6 +9,7 @@ import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
+import { nativeIsRepo } from "./native-git-bridge.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
@@ -256,6 +257,10 @@ let cachedLastCommit = null;
 let lastCommitFetchedAt = 0;
 function refreshLastCommit(basePath) {
     try {
+        if (!nativeIsRepo(basePath)) {
+            cachedLastCommit = null;
+            return;
+        }
         const raw = execFileSync("git", ["log", "-1", "--format=%cr|%s"], {
             cwd: basePath,
             encoding: "utf-8",
@@ -269,12 +274,15 @@ function refreshLastCommit(basePath) {
                 message: raw.slice(sep + 1),
             };
         }
-        lastCommitFetchedAt = Date.now();
     }
     catch (err) {
         // Non-fatal — just skip last commit display
+        cachedLastCommit = null;
         logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
+    finally {
+        lastCommitFetchedAt = Date.now();
+    }
 }
 function getLastCommit(basePath) {
     // Refresh at most every 15 seconds
@@ -283,6 +291,19 @@ function getLastCommit(basePath) {
     }
     return cachedLastCommit;
 }
+export function _resetLastCommitCacheForTests() {
+    cachedLastCommit = null;
+    lastCommitFetchedAt = 0;
+}
+export function _refreshLastCommitForTests(basePath) {
+    refreshLastCommit(basePath);
+}
+export function _getLastCommitForTests(basePath) {
+    return getLastCommit(basePath);
+}
+export function _getLastCommitFetchedAtForTests() {
+    return lastCommitFetchedAt;
+}
 // ─── Footer Factory ───────────────────────────────────────────────────────────
 /**
  * Footer factory used by auto-mode.

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -68,7 +68,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 unitType = "plan-slice";
                 unitId = `${mid}/${sid}`;
-                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base);
+                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base, undefined, {
+                    sessionContextWindow: ctx.model?.contextWindow,
+                    modelRegistry: ctx.modelRegistry,
+                });
             }
             else {
                 unitType = "plan-milestone";
@@ -93,7 +96,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             unitType = "execute-task";
             unitId = `${mid}/${sid}/${tid}`;
-            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base);
+            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, {
+                sessionContextWindow: ctx.model?.contextWindow,
+                modelRegistry: ctx.modelRegistry,
+            });
             break;
         }
         case "complete":

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -412,7 +412,7 @@ export const DISPATCH_RULES = [
         // auto-heal without either adding an explicit `setSliceSketchFlag(..., false)`
         // call here or doing so inside the plan-slice tool handler.
         name: "refining → refine-slice",
-        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "refining")
                 return null;
             if (!state.activeSlice)
@@ -438,20 +438,20 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "plan-slice",
                     unitId: `${mid}/${sid}`,
-                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, softScopeHint ? { softScopeHint } : undefined),
+                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { ...(softScopeHint ? { softScopeHint } : {}), sessionContextWindow, modelRegistry }),
                 };
             }
             return {
                 action: "dispatch",
                 unitType: "refine-slice",
                 unitId: `${mid}/${sid}`,
-                prompt: await buildRefineSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+                prompt: await buildRefineSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
             };
         },
     },
     {
         name: "planning → plan-slice",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "planning")
                 return null;
             if (!state.activeSlice)
@@ -462,7 +462,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "plan-slice",
                 unitId: `${mid}/${sid}`,
-                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
             };
         },
     },
@@ -511,7 +511,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → reactive-execute (parallel dispatch)",
-        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -574,7 +574,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "reactive-execute",
                     unitId: `${mid}/${sid}/reactive+${batchSuffix}`,
-                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel),
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel, { sessionContextWindow, modelRegistry }),
                 };
             }
             catch (err) {
@@ -586,7 +586,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → execute-task (recover missing task plan → plan-slice)",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -605,7 +605,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "plan-slice",
                     unitId: `${mid}/${sid}`,
-                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
                 };
             }
             return null;
@@ -613,7 +613,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → execute-task",
-        match: async ({ state, mid, basePath }) => {
+        match: async ({ state, mid, basePath, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -626,7 +626,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "execute-task",
                 unitId: `${mid}/${sid}/${tid}`,
-                prompt: await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, basePath),
+                prompt: await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, basePath, { sessionContextWindow, modelRegistry }),
             };
         },
     },

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -382,7 +382,9 @@ export function resolveModelId(modelId, availableModels, currentProvider) {
         if (providerMatch)
             return providerMatch;
     }
-    // Prefer "anthropic" as the canonical provider for Anthropic models
+    // Prefer "anthropic" as the canonical provider for Anthropic models.
+    // Transport-specific tiebreaker (ADR-012): intentionally keys on provider,
+    // not api — we want the plain Anthropic transport when multiple are available.
     const anthropicMatch = candidates.find(m => m.provider === "anthropic");
     if (anthropicMatch)
         return anthropicMatch;

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -75,15 +75,17 @@ function capPreamble(preamble) {
  * Uses the budget engine to compute task count ranges and inline context budgets
  * based on the configured executor model's context window.
  */
-function formatExecutorConstraints() {
+function formatExecutorConstraints(sessionContextWindow, modelRegistry) {
     let windowTokens;
     try {
         const prefs = loadEffectiveGSDPreferences();
-        windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences);
+        windowTokens = resolveExecutorContextWindow(modelRegistry, prefs?.preferences, sessionContextWindow);
     }
     catch (e) {
         logWarning("prompt", `resolveExecutorContextWindow failed: ${e.message}`);
-        windowTokens = 200_000; // safe default
+        // Delegate to the budget engine without prefs (the path that just threw)
+        // so DEFAULT_CONTEXT_WINDOW stays the single source of truth.
+        windowTokens = resolveExecutorContextWindow(undefined, undefined, sessionContextWindow);
     }
     const budgets = computeBudgets(windowTokens);
     const { min, max } = budgets.taskCountRange;
@@ -1136,7 +1138,7 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
  * sketch-scope constraint).
  */
 async function renderSlicePrompt(options) {
-    const { mid, sid, sTitle, base, level, promptTemplate, prependBlocks = [], extraVars = {} } = options;
+    const { mid, sid, sTitle, base, level, promptTemplate, prependBlocks = [], extraVars = {}, sessionContextWindow, modelRegistry, } = options;
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const researchPath = resolveSliceFile(base, mid, sid, "RESEARCH");
@@ -1186,7 +1188,7 @@ async function renderSlicePrompt(options) {
     if (overridesInline)
         inlined.unshift(overridesInline);
     const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
-    const executorContextConstraints = formatExecutorConstraints();
+    const executorContextConstraints = formatExecutorConstraints(sessionContextWindow, modelRegistry);
     const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
     const commitInstruction = "Do not commit — .gsd/ planning docs are managed externally and not tracked in git.";
     return loadPrompt(promptTemplate, {
@@ -1226,6 +1228,8 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
         level: level ?? resolveInlineLevel(),
         promptTemplate: "plan-slice",
         prependBlocks,
+        sessionContextWindow: options?.sessionContextWindow,
+        modelRegistry: options?.modelRegistry,
     });
 }
 /**
@@ -1235,7 +1239,7 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
  * blank-sheet planning pass. Reuses inlineDependencySummaries for prior
  * slice SUMMARY and inlines the stored sketch_scope as a hard constraint.
  */
-export async function buildRefineSlicePrompt(mid, _midTitle, sid, sTitle, base, level) {
+export async function buildRefineSlicePrompt(mid, _midTitle, sid, sTitle, base, level, options) {
     // Pull the stored sketch scope from the DB — the hard constraint we plan within.
     let sketchScope = "";
     try {
@@ -1258,6 +1262,8 @@ export async function buildRefineSlicePrompt(mid, _midTitle, sid, sTitle, base,
         promptTemplate: "refine-slice",
         prependBlocks,
         extraVars: { sketchScope },
+        sessionContextWindow: options?.sessionContextWindow,
+        modelRegistry: options?.modelRegistry,
     });
 }
 export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, level) {
@@ -1323,7 +1329,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const overridesSection = formatOverridesSection(activeOverrides);
     // Compute verification budget for the executor's context window (issue #707)
     const prefs = loadEffectiveGSDPreferences();
-    const contextWindow = resolveExecutorContextWindow(undefined, prefs?.preferences);
+    const contextWindow = resolveExecutorContextWindow(opts.modelRegistry, prefs?.preferences, opts.sessionContextWindow);
     const budgets = computeBudgets(contextWindow);
     const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
     // Truncate carry-forward section when it exceeds 40% of inline context budget.
@@ -1858,7 +1864,7 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
     });
 }
 // ─── Reactive Execute Prompt ──────────────────────────────────────────────
-export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base, subagentModel) {
+export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base, subagentModel, opts) {
     const { loadSliceTaskIO, deriveTaskGraph, graphMetrics } = await import("./reactive-graph.js");
     // Build graph for context
     const taskIO = await loadSliceTaskIO(base, mid, sid);
@@ -1889,7 +1895,11 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
         // Build dependency-scoped carry-forward paths for this task
         const depPaths = await getDependencyTaskSummaryPaths(mid, sid, tid, node?.dependsOn ?? [], base);
         // Build a full execute-task prompt with dependency-based carry-forward
-        const taskPrompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, { carryForwardPaths: depPaths });
+        const taskPrompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, {
+            carryForwardPaths: depPaths,
+            sessionContextWindow: opts?.sessionContextWindow,
+            modelRegistry: opts?.modelRegistry,
+        });
         const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
             `### ${tid}: ${tTitle}`,

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -180,6 +180,14 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
         }
     }
 }
+function isProjectGsdSymlink(basePath) {
+    try {
+        return lstatSyncFn(join(basePath, ".gsd")).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
 // ─── Build Artifact Auto-Resolve ─────────────────────────────────────────────
 /** Patterns for machine-generated build artifacts that can be safely
  * auto-resolved by accepting --theirs during merge. These files are
@@ -1440,10 +1448,17 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             // CONTEXT files into the stash. If stash pop later fails, those files
             // are permanently trapped in the stash entry and lost on the next
             // stash push or drop.
+            //
+            // When `.gsd` itself is a symlink, Git rejects pathspecs below it
+            // ("beyond a symbolic link"). In that layout, exclude the whole symlink
+            // and keep stashing real project files that could block the merge.
+            const stashPathspecs = isProjectGsdSymlink(originalBasePath_)
+                ? [".", ":(exclude).gsd"]
+                : [":(exclude).gsd/milestones"];
             execFileSync("git", [
                 "stash", "push", "--include-untracked",
                 "-m", `gsd: pre-merge stash for ${milestoneId}`,
-                "--", ":(exclude).gsd/milestones",
+                "--", ...stashPathspecs,
             ], { cwd: originalBasePath_, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
             stashed = true;
         }

package/dist/resources/extensions/gsd/doctor-git-checks.js

@@ -34,6 +34,20 @@ function isDoctorArtifactOnly(dirPath) {
         return false;
     }
 }
+function normalizePathForComparison(path) {
+    const resolved = existsSync(path) ? realpathSync(path) : path;
+    const normalized = resolved
+        .replaceAll("\\", "/")
+        .replace(/^\/\/\?\//, "")
+        .replace(/\/+$/, "");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isSameOrNestedPath(candidate, container) {
+    const normalizedCandidate = normalizePathForComparison(candidate);
+    const normalizedContainer = normalizePathForComparison(container);
+    return normalizedCandidate === normalizedContainer ||
+        normalizedCandidate.startsWith(`${normalizedContainer}/`);
+}
 export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "none") {
     // Degrade gracefully if not a git repo
     if (!nativeIsRepo(basePath)) {
@@ -84,8 +98,14 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                         // pattern in removeWorktree() (#1946). Without this, git cannot
                         // remove the worktree and the doctor enters a deadlock where it
                         // detects the orphan every run but never cleans it up.
-                        const cwd = process.cwd();
-                        if (wt.path === cwd || cwd.startsWith(wt.path + sep)) {
+                        let cwd = basePath;
+                        try {
+                            cwd = process.cwd();
+                        }
+                        catch {
+                            cwd = basePath;
+                        }
+                        if (isSameOrNestedPath(cwd, wt.path)) {
                             try {
                                 process.chdir(basePath);
                             }

package/dist/resources/extensions/gsd/pre-execution-checks.js

@@ -347,10 +347,13 @@ function getExpectedOutputsUpTo(tasks, taskIndex) {
 /**
  * Check that all files referenced in task.inputs either:
  *   1. Exist on disk, OR
- *   2. Are in a prior task's expected_output
+ *   2. Are in a prior task's expected_output, OR
+ *   3. Are in the current task's own expected_output — the task produces them,
+ *      so they don't need to pre-exist (#4459, mirroring the exemption #3626
+ *      introduced for task.files).
  *
- * task.files ("files likely touched") is excluded — it intentionally includes
- * files the task will create, so they don't need to pre-exist (#3626).
+ * task.files ("files likely touched") is excluded entirely from this check —
+ * it intentionally includes files the task will create (#3626).
  *
  * All paths are normalized before comparison to ensure ./src/a.ts matches src/a.ts.
  */
@@ -359,6 +362,7 @@ export function checkFilePathConsistency(tasks, basePath) {
     for (let i = 0; i < tasks.length; i++) {
         const task = tasks[i];
         const priorOutputs = getExpectedOutputsUpTo(tasks, i);
+        const ownOutputs = new Set(task.expected_output.map(normalizeFilePath));
         const filesToCheck = [...task.inputs];
         for (const file of filesToCheck) {
             // Skip empty strings
@@ -375,21 +379,21 @@ export function checkFilePathConsistency(tasks, basePath) {
             const existsOnDisk = existsSync(absolutePath);
             // Check if file is in prior expected outputs (priorOutputs already normalized)
             const inPriorOutputs = priorOutputs.has(normalizedFile);
+            const inOwnOutputs = ownOutputs.has(normalizedFile);
             // Directory inputs are satisfied when something produces a file beneath
             // them — either a prior task or the current task itself.
             let directorySatisfied = false;
-            if (!existsOnDisk && !inPriorOutputs && isDirectoryReference(file)) {
-                const sameTaskOutputs = task.expected_output.map(normalizeFilePath);
+            if (!existsOnDisk && !inPriorOutputs && !inOwnOutputs && isDirectoryReference(file)) {
                 directorySatisfied =
                     anyOutputUnderDirectory(normalizedFile, priorOutputs) ||
-                        anyOutputUnderDirectory(normalizedFile, sameTaskOutputs);
+                        anyOutputUnderDirectory(normalizedFile, ownOutputs);
             }
-            if (!existsOnDisk && !inPriorOutputs && !directorySatisfied) {
+            if (!existsOnDisk && !inPriorOutputs && !inOwnOutputs && !directorySatisfied) {
                 results.push({
                     category: "file",
                     target: file,
                     passed: false,
-                    message: `Task ${task.id} references '${file}' which doesn't exist and isn't created by prior tasks`,
+                    message: `Task ${task.id} references '${file}' which doesn't exist and isn't created by prior or same-task outputs`,
                     blocking: true,
                 });
             }

package/dist/resources/extensions/gsd/prompts/add-tests.md

@@ -31,5 +31,6 @@ You are generating tests for recently completed GSD work.
 - Do NOT modify implementation files — only create or update test files
 - Name test files consistently with the project's conventions
 - Keep tests focused and readable
+- Tests must only reference files that are tracked in git. Do NOT import, read, or depend on paths listed in `.gitignore` — in particular GSD-local state such as `.gsd/`, `.planning/`, and `.audits/`. If a test seems to need one of those files, replace it with an inline fixture or a tracked sample; otherwise the test will fail for everyone but the author.
 
 {{skillActivation}}

package/dist/resources/extensions/gsd/prompts/execute-task.md

@@ -36,7 +36,7 @@ Then:
 2. Execute the steps in the inlined task plan, adapting minor local mismatches when the surrounding code differs from the planner's snapshot
 3. Before any `Write` that creates an artifact or output file, check whether that path already exists. If it does, read it first and decide whether the work is already done, should be extended, or truly needs replacement. "Create" in the plan does **not** mean the file is missing — a prior session may already have started it.
 4. Build the real thing. If the task plan says "create login endpoint", build an endpoint that actually authenticates against a real store, not one that returns a hardcoded success response. If the task plan says "create dashboard page", build a page that renders real data from the API, not a component with hardcoded props. Stubs and mocks are for tests, not for the shipped feature.
-5. Write or update tests as part of execution — tests are verification, not an afterthought. If the slice plan defines test files in its Verification section and this is the first task, create them (they should initially fail).
+5. Write or update tests as part of execution — tests are verification, not an afterthought. If the slice plan defines test files in its Verification section and this is the first task, create them (they should initially fail). Tests must only reference files tracked in git; never import, read, or assert on paths listed in `.gitignore` (e.g. `.gsd/`, `.planning/`, `.audits/`) — those files are local-only and the test will fail for anyone else. Use inline fixtures or tracked samples instead.
 6. When implementing non-trivial runtime behavior (async flows, API boundaries, background processes, error paths), add or preserve agent-usable observability. Skip this for simple changes where it doesn't apply.
 
    **Background process rule:** Never use bare `command &` to run background processes. The shell's `&` operator leaves stdout/stderr attached to the parent, which causes the Bash tool to hang indefinitely waiting for those streams to close. Always redirect output before backgrounding:

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -53,6 +53,7 @@ Then:
    - For simple slices: executable commands or script assertions are fine.
    - If the project is non-trivial and has no test framework, the first task should set one up.
    - If this slice establishes a boundary contract, verification must exercise that contract.
+   - Planned test files must only read from or import paths that are tracked in git. Do NOT plan tests whose inputs or fixtures are paths listed in `.gitignore` (e.g. `.gsd/`, `.planning/`, `.audits/`). If the scenario seems to require such a file, plan an inline fixture or a tracked sample instead.
 4. **For non-trivial slices only** — plan observability, proof level, and integration closure:
    - Include `Observability / Diagnostics` for backend, integration, async, stateful, or UI slices where failure diagnosis matters.
    - Fill `Proof Level` and `Integration Closure` when the slice crosses runtime boundaries or has meaningful integration concerns.

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -4,6 +4,8 @@ import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot } from
 import { getMilestone, getSliceStatusSummary, getSliceTaskCounts, readTransaction, saveGateResult, } 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 { handleCompleteMilestone } from "./complete-milestone.js";
 import { handleCompleteTask } from "./complete-task.js";
 import { handleCompleteSlice } from "./complete-slice.js";
@@ -61,6 +63,18 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
             slice_id: params.slice_id,
             task_id: params.task_id,
         }, 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.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/dist/resources/extensions/search-the-web/command-search-provider.js

@@ -7,6 +7,7 @@
  *
  * All provider logic lives in provider.ts (S01) — this is pure UI wiring.
  */
+import { isAnthropicApi } from '@gsd/pi-ai';
 import { getTavilyApiKey, getBraveApiKey, getOllamaApiKey, getSearchProviderPreference, setSearchProviderPreference, resolveSearchProvider, } from './provider.js';
 const VALID_PREFERENCES = ['tavily', 'brave', 'ollama', 'auto'];
 function keyStatus(provider) {
@@ -71,7 +72,9 @@ export function registerSearchProviderCommand(pi) {
             }
             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}`, 'info');
         },

package/dist/resources/extensions/search-the-web/native-search.js

@@ -4,6 +4,7 @@
  * Extracted from index.ts so it can be unit-tested without importing
  * 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 */
 export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
@@ -75,7 +76,10 @@ export function registerNativeSearchHooks(pi) {
     pi.on("model_select", async (event, ctx) => {
         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;
         // When Anthropic (and not preferring Brave): disable custom search tools —
         // native web_search is server-side and more reliable.
@@ -116,7 +120,14 @@ export function registerNativeSearchHooks(pi) {
         // modelsAreEqual suppresses model_select AND the SDK doesn't pass model.
         const eventModel = event.model;
         let isAnthropic;
-        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) {