gsd-pi 2.76.0-dev.b072ebb73 → 2.76.0-dev.fe143342a

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -660,6 +660,55 @@ export function validatePreferences(preferences) {
             errors.push("context_management must be an object");
         }
     }
+    // ─── Context Mode (gsd_exec sandbox) ────────────────────────────────────
+    if (preferences.context_mode !== undefined) {
+        if (typeof preferences.context_mode === "object" && preferences.context_mode !== null) {
+            const cmode = preferences.context_mode;
+            const validCmode = {};
+            if (cmode.enabled !== undefined) {
+                if (typeof cmode.enabled === "boolean")
+                    validCmode.enabled = cmode.enabled;
+                else
+                    errors.push("context_mode.enabled must be a boolean");
+            }
+            if (cmode.exec_timeout_ms !== undefined) {
+                const t = cmode.exec_timeout_ms;
+                if (typeof t === "number" && t >= 1000 && t <= 600_000)
+                    validCmode.exec_timeout_ms = Math.floor(t);
+                else
+                    errors.push("context_mode.exec_timeout_ms must be a number between 1000 and 600000");
+            }
+            if (cmode.exec_stdout_cap_bytes !== undefined) {
+                const b = cmode.exec_stdout_cap_bytes;
+                if (typeof b === "number" && b >= 4096 && b <= 16_777_216)
+                    validCmode.exec_stdout_cap_bytes = Math.floor(b);
+                else
+                    errors.push("context_mode.exec_stdout_cap_bytes must be a number between 4096 and 16777216");
+            }
+            if (cmode.exec_digest_chars !== undefined) {
+                const c = cmode.exec_digest_chars;
+                if (typeof c === "number" && c >= 0 && c <= 4000)
+                    validCmode.exec_digest_chars = Math.floor(c);
+                else
+                    errors.push("context_mode.exec_digest_chars must be a number between 0 and 4000");
+            }
+            if (cmode.exec_env_allowlist !== undefined) {
+                if (Array.isArray(cmode.exec_env_allowlist) &&
+                    cmode.exec_env_allowlist.every((v) => typeof v === "string" && /^[A-Z_][A-Z0-9_]*$/i.test(v))) {
+                    validCmode.exec_env_allowlist = cmode.exec_env_allowlist;
+                }
+                else {
+                    errors.push("context_mode.exec_env_allowlist must be an array of valid env var names");
+                }
+            }
+            if (Object.keys(validCmode).length > 0) {
+                validated.context_mode = validCmode;
+            }
+        }
+        else {
+            errors.push("context_mode must be an object");
+        }
+    }
     // ─── Parallel Config ────────────────────────────────────────────────────
     if (preferences.parallel && typeof preferences.parallel === "object") {
         const p = preferences.parallel;
@@ -716,6 +765,40 @@ export function validatePreferences(preferences) {
             validated.parallel = parallel;
         }
     }
+    // ─── Slice Parallel Config ───────────────────────────────────────────────
+    if (preferences.slice_parallel !== undefined) {
+        if (typeof preferences.slice_parallel === "object" && preferences.slice_parallel !== null) {
+            const sp = preferences.slice_parallel;
+            const validSp = {};
+            if (sp.enabled !== undefined) {
+                if (typeof sp.enabled === "boolean")
+                    validSp.enabled = sp.enabled;
+                else
+                    errors.push("slice_parallel.enabled must be a boolean");
+            }
+            if (sp.max_workers !== undefined) {
+                const maxWorkers = typeof sp.max_workers === "number" ? sp.max_workers : Number(sp.max_workers);
+                if (Number.isFinite(maxWorkers) && maxWorkers >= 1 && maxWorkers <= 8) {
+                    validSp.max_workers = Math.floor(maxWorkers);
+                }
+                else {
+                    errors.push("slice_parallel.max_workers must be a number between 1 and 8");
+                }
+            }
+            const knownSliceParallelKeys = new Set(["enabled", "max_workers"]);
+            for (const key of Object.keys(sp)) {
+                if (!knownSliceParallelKeys.has(key)) {
+                    warnings.push(`unknown slice_parallel key "${key}" — ignored`);
+                }
+            }
+            if (Object.keys(validSp).length > 0) {
+                validated.slice_parallel = validSp;
+            }
+        }
+        else {
+            errors.push("slice_parallel must be an object");
+        }
+    }
     // ─── Reactive Execution ─────────────────────────────────────────────────
     if (preferences.reactive_execution !== undefined) {
         if (typeof preferences.reactive_execution === "object" && preferences.reactive_execution !== null) {

package/dist/resources/extensions/gsd/preferences.js

@@ -26,12 +26,12 @@ export { resolveAllSkillReferences } from "./preferences-skills.js";
 // These lived in preferences-skills.ts but imported loadEffectiveGSDPreferences
 // back from this file, creating a circular dependency. Moved here since they
 // are trivial wrappers over loadEffectiveGSDPreferences.
-export function resolveSkillDiscoveryMode() {
-    const prefs = loadEffectiveGSDPreferences();
+export function resolveSkillDiscoveryMode(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath);
     return prefs?.preferences.skill_discovery ?? "suggest";
 }
-export function resolveSkillStalenessDays() {
-    const prefs = loadEffectiveGSDPreferences();
+export function resolveSkillStalenessDays(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath);
     return prefs?.preferences.skill_staleness_days ?? 60;
 }
 // ─── Re-exports: models ─────────────────────────────────────────────────────
@@ -46,16 +46,16 @@ function globalPreferencesPath() {
 function legacyGlobalPreferencesPath() {
     return join(homedir(), ".pi", "agent", "gsd-preferences.md");
 }
-function projectPreferencesPath() {
-    return join(gsdRoot(process.cwd()), "PREFERENCES.md");
+function projectPreferencesPath(basePath = process.cwd()) {
+    return join(gsdRoot(basePath), "PREFERENCES.md");
 }
 // Legacy lowercase files can still exist in older projects. Keep them as a
 // compatibility-only fallback, but route new reads/writes through PREFERENCES.md.
 function legacyGlobalPreferencesPathLowercase() {
     return join(gsdHome(), "preferences.md");
 }
-function legacyProjectPreferencesPathLowercase() {
-    return join(gsdRoot(process.cwd()), "preferences.md");
+function legacyProjectPreferencesPathLowercase(basePath = process.cwd()) {
+    return join(gsdRoot(basePath), "preferences.md");
 }
 export function getGlobalGSDPreferencesPath() {
     return globalPreferencesPath();
@@ -63,8 +63,8 @@ export function getGlobalGSDPreferencesPath() {
 export function getLegacyGlobalGSDPreferencesPath() {
     return legacyGlobalPreferencesPath();
 }
-export function getProjectGSDPreferencesPath() {
-    return projectPreferencesPath();
+export function getProjectGSDPreferencesPath(basePath) {
+    return projectPreferencesPath(basePath);
 }
 // ─── Loading ────────────────────────────────────────────────────────────────
 export function loadGlobalGSDPreferences() {
@@ -72,13 +72,13 @@ export function loadGlobalGSDPreferences() {
         ?? loadPreferencesFile(legacyGlobalPreferencesPathLowercase(), "global")
         ?? loadPreferencesFile(legacyGlobalPreferencesPath(), "global");
 }
-export function loadProjectGSDPreferences() {
-    return loadPreferencesFile(projectPreferencesPath(), "project")
-        ?? loadPreferencesFile(legacyProjectPreferencesPathLowercase(), "project");
+export function loadProjectGSDPreferences(basePath) {
+    return loadPreferencesFile(projectPreferencesPath(basePath), "project")
+        ?? loadPreferencesFile(legacyProjectPreferencesPathLowercase(basePath), "project");
 }
-export function loadEffectiveGSDPreferences() {
+export function loadEffectiveGSDPreferences(basePath) {
     const globalPreferences = loadGlobalGSDPreferences();
-    const projectPreferences = loadProjectGSDPreferences();
+    const projectPreferences = loadProjectGSDPreferences(basePath);
     if (!globalPreferences && !projectPreferences)
         return null;
     let result;
@@ -489,8 +489,8 @@ export function resolvePreDispatchHooks() {
  * Worktree isolation requires explicit opt-in because it depends on git
  * branch infrastructure that must be set up before use.
  */
-export function getIsolationMode() {
-    const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
+export function getIsolationMode(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath)?.preferences?.git;
     if (prefs?.isolation === "worktree")
         return "worktree";
     if (prefs?.isolation === "branch")

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -22,6 +22,27 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { logWarning } from "./workflow-logger.js";
+function hasRequiredExtensionAssets(rootDir, exists = existsSync) {
+    return (exists(join(rootDir, "prompts")) &&
+        exists(join(rootDir, "templates", "task-summary.md")));
+}
+export function resolveExtensionDirFromCandidates(moduleDir, agentGsdDir, exists = existsSync) {
+    const moduleUsable = hasRequiredExtensionAssets(moduleDir, exists);
+    const agentUsable = hasRequiredExtensionAssets(agentGsdDir, exists);
+    // Prefer the user-local extension tree when both are valid. This avoids
+    // leaking npm/global-install paths into prompts on Windows.
+    if (agentUsable)
+        return agentGsdDir;
+    if (moduleUsable)
+        return moduleDir;
+    // Degraded fallback: if required template is missing in both locations,
+    // keep previous behavior and prefer whichever still has prompts/.
+    if (exists(join(moduleDir, "prompts")))
+        return moduleDir;
+    if (exists(join(agentGsdDir, "prompts")))
+        return agentGsdDir;
+    return moduleDir;
+}
 /**
  * Resolve the GSD extension directory.
  *
@@ -34,15 +55,9 @@ import { logWarning } from "./workflow-logger.js";
  */
 function resolveExtensionDir() {
     const moduleDir = dirname(fileURLToPath(import.meta.url));
-    if (existsSync(join(moduleDir, "prompts")))
-        return moduleDir;
-    // Fallback: user-local agent directory
     const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
     const agentGsdDir = join(gsdHome, "agent", "extensions", "gsd");
-    if (existsSync(join(agentGsdDir, "prompts")))
-        return agentGsdDir;
-    // Last resort: return the module dir (warmCache will silently handle the miss)
-    return moduleDir;
+    return resolveExtensionDirFromCandidates(moduleDir, agentGsdDir);
 }
 const __extensionDir = resolveExtensionDir();
 const promptsDir = join(__extensionDir, "prompts");

package/dist/resources/extensions/gsd/safety/file-change-validator.js

@@ -62,7 +62,7 @@ export function validateFileChanges(basePath, expectedOutput, plannedFiles) {
 // ─── Internals ──────────────────────────────────────────────────────────────
 function getChangedFilesFromLastCommit(basePath) {
     try {
-        const result = execFileSync("git", ["diff", "--name-only", "HEAD~1", "HEAD"], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+        const result = execFileSync("git", ["diff-tree", "--root", "--no-commit-id", "-r", "--name-only", "HEAD"], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
         return result ? result.split("\n").filter(Boolean) : [];
     }
     catch (e) {

package/dist/resources/extensions/gsd/tools/exec-search-tool.js

@@ -0,0 +1,59 @@
+// GSD Exec Search Tool — lists and filters prior gsd_exec runs.
+//
+// Scans .gsd/exec/*.meta.json and returns a ranked summary so agents can
+// re-discover past runs without re-executing. Read-only; no DB writes.
+import { searchExecHistory } from "../exec-history.js";
+export function executeExecSearch(params, opts) {
+    const searchOpts = {
+        query: typeof params.query === "string" ? params.query : undefined,
+        runtime: params.runtime,
+        failing_only: params.failing_only === true,
+        limit: typeof params.limit === "number" ? params.limit : undefined,
+    };
+    const hits = searchExecHistory(opts.baseDir, searchOpts);
+    if (hits.length === 0) {
+        return {
+            content: [{ type: "text", text: "No prior gsd_exec runs match those filters." }],
+            details: { operation: "gsd_exec_search", matches: 0 },
+        };
+    }
+    const lines = [`Found ${hits.length} exec run(s), most recent first:`];
+    for (const hit of hits) {
+        const e = hit.entry;
+        const status = formatStatus(e);
+        const purpose = e.purpose ? ` — ${e.purpose}` : "";
+        const truncated = e.stdout_truncated ? " (stdout truncated)" : "";
+        lines.push(`- [${e.id}] ${e.runtime} ${status} ${e.duration_ms}ms${truncated}${purpose}`, `    stdout: ${e.stdout_path}`);
+        if (hit.digest_preview) {
+            const preview = hit.digest_preview.replace(/\n/g, "\n      ");
+            lines.push(`    preview:\n      ${preview}`);
+        }
+    }
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: {
+            operation: "gsd_exec_search",
+            matches: hits.length,
+            results: hits.map((hit) => ({
+                id: hit.entry.id,
+                runtime: hit.entry.runtime,
+                exit_code: hit.entry.exit_code,
+                timed_out: hit.entry.timed_out,
+                duration_ms: hit.entry.duration_ms,
+                purpose: hit.entry.purpose,
+                stdout_path: hit.entry.stdout_path,
+                stderr_path: hit.entry.stderr_path,
+                meta_path: hit.entry.meta_path,
+            })),
+        },
+    };
+}
+function formatStatus(entry) {
+    if (entry.timed_out)
+        return "timeout";
+    if (entry.signal)
+        return `signal:${entry.signal}`;
+    if (entry.exit_code === null)
+        return "exit:null";
+    return `exit:${entry.exit_code}`;
+}

package/dist/resources/extensions/gsd/tools/exec-tool.js

@@ -0,0 +1,126 @@
+// GSD Exec Tool — executor for the gsd_exec MCP tool.
+//
+// Thin wrapper around exec-sandbox.ts that reads effective options from
+// the project preferences (context_mode block) and formats the result
+// for MCP return.
+import { EXEC_DEFAULTS, runExecSandbox, } from "../exec-sandbox.js";
+import { isContextModeEnabled } from "../preferences-types.js";
+export function buildExecOptions(baseDir, cfg, extras) {
+    const allowlist = Array.isArray(cfg?.exec_env_allowlist) ? cfg.exec_env_allowlist : EXEC_DEFAULTS.envAllowlist;
+    const stdoutCap = clampNumber(cfg?.exec_stdout_cap_bytes, EXEC_DEFAULTS.stdoutCapBytes, 4_096, 16_777_216);
+    const defaultTimeout = clampNumber(cfg?.exec_timeout_ms, EXEC_DEFAULTS.defaultTimeoutMs, 1_000, EXEC_DEFAULTS.clampTimeoutMs);
+    const digestChars = clampNumber(cfg?.exec_digest_chars, EXEC_DEFAULTS.digestChars, 0, 4_000);
+    return {
+        baseDir,
+        clamp_timeout_ms: EXEC_DEFAULTS.clampTimeoutMs,
+        default_timeout_ms: defaultTimeout,
+        stdout_cap_bytes: stdoutCap,
+        stderr_cap_bytes: EXEC_DEFAULTS.stderrCapBytes,
+        digest_chars: digestChars,
+        env_allowlist: allowlist,
+        ...extras,
+    };
+}
+function clampNumber(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return Math.floor(value);
+}
+function isEnabled(prefs) {
+    return isContextModeEnabled(prefs);
+}
+function disabledResult() {
+    return {
+        content: [
+            {
+                type: "text",
+                text: "gsd_exec is disabled by `context_mode.enabled: false` in preferences. Remove that " +
+                    "override (or set it to true) to re-enable sandboxed tool-output execution.",
+            },
+        ],
+        details: { operation: "gsd_exec", error: "context_mode_disabled" },
+        isError: true,
+    };
+}
+function paramError(message) {
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        details: { operation: "gsd_exec", error: "invalid_params", detail: message },
+        isError: true,
+    };
+}
+export async function executeGsdExec(params, deps) {
+    if (!isEnabled(deps.preferences))
+        return disabledResult();
+    const runtime = params.runtime;
+    if (runtime !== "bash" && runtime !== "node" && runtime !== "python") {
+        return paramError(`invalid runtime "${String(runtime)}" — must be bash | node | python`);
+    }
+    const script = typeof params.script === "string" ? params.script : "";
+    if (script.trim().length === 0) {
+        return paramError("script is required and must be a non-empty string");
+    }
+    if (Buffer.byteLength(script, "utf8") > 200_000) {
+        return paramError("script exceeds the 200 KB length limit");
+    }
+    const opts = buildExecOptions(deps.baseDir, deps.preferences?.context_mode, { now: deps.now, generateId: deps.generateId });
+    const run = deps.run ?? runExecSandbox;
+    try {
+        const result = await run({
+            runtime,
+            script,
+            ...(typeof params.purpose === "string" ? { purpose: params.purpose } : {}),
+            ...(typeof params.timeout_ms === "number" ? { timeout_ms: params.timeout_ms } : {}),
+        }, opts);
+        return formatResult(result);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: `Error: gsd_exec failed — ${message}` }],
+            details: { operation: "gsd_exec", error: message },
+            isError: true,
+        };
+    }
+}
+function formatResult(result) {
+    const headerLines = [
+        `gsd_exec[${result.id}] runtime=${result.runtime} exit=${formatExit(result)} duration=${result.duration_ms}ms`,
+        `  stdout: ${result.stdout_bytes}B${result.stdout_truncated ? " (truncated)" : ""} → ${result.stdout_path}`,
+        `  stderr: ${result.stderr_bytes}B${result.stderr_truncated ? " (truncated)" : ""} → ${result.stderr_path}`,
+    ];
+    const summary = `${headerLines.join("\n")}\n--- digest ---\n${result.digest}`.trimEnd();
+    return {
+        content: [{ type: "text", text: summary }],
+        details: {
+            operation: "gsd_exec",
+            id: result.id,
+            runtime: result.runtime,
+            exit_code: result.exit_code,
+            signal: result.signal,
+            timed_out: result.timed_out,
+            duration_ms: result.duration_ms,
+            stdout_bytes: result.stdout_bytes,
+            stderr_bytes: result.stderr_bytes,
+            stdout_truncated: result.stdout_truncated,
+            stderr_truncated: result.stderr_truncated,
+            stdout_path: result.stdout_path,
+            stderr_path: result.stderr_path,
+            meta_path: result.meta_path,
+        },
+        isError: result.timed_out || result.signal !== null || result.exit_code !== 0,
+    };
+}
+function formatExit(result) {
+    if (result.timed_out)
+        return "timeout";
+    if (result.signal)
+        return `signal:${result.signal}`;
+    if (result.exit_code === null)
+        return "null";
+    return String(result.exit_code);
+}

package/dist/resources/extensions/gsd/tools/resume-tool.js

@@ -0,0 +1,23 @@
+// GSD Resume Tool — returns the contents of .gsd/last-snapshot.md so
+// agents can re-orient after compaction or session resume without
+// re-deriving project memory state.
+import { readCompactionSnapshot } from "../compaction-snapshot.js";
+export function executeResume(_params, opts) {
+    const snapshot = readCompactionSnapshot(opts.baseDir);
+    if (snapshot == null) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No snapshot found at .gsd/last-snapshot.md. The snapshot is written automatically " +
+                        "on session_before_compact (enabled by default; set context_mode.enabled=false to opt out).",
+                },
+            ],
+            details: { operation: "gsd_resume", found: false },
+        };
+    }
+    return {
+        content: [{ type: "text", text: snapshot }],
+        details: { operation: "gsd_resume", found: true, bytes: Buffer.byteLength(snapshot, "utf-8") },
+    };
+}

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -5,6 +5,9 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 const MCP_WORKFLOW_TOOL_SURFACE = new Set([
     "ask_user_questions",
     "gsd_decision_save",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
     "gsd_complete_milestone",
     "gsd_complete_task",
     "gsd_complete_slice",

package/dist/resources/extensions/search-the-web/command-search-provider.js

@@ -7,7 +7,7 @@
  *
  * All provider logic lives in provider.ts (S01) — this is pure UI wiring.
  */
-import { isAnthropicApi } from '@gsd/pi-ai';
+import { supportsNativeWebSearch } from './native-search.js';
 import { getTavilyApiKey, getBraveApiKey, getOllamaApiKey, getSearchProviderPreference, setSearchProviderPreference, resolveSearchProvider, } from './provider.js';
 const VALID_PREFERENCES = ['tavily', 'brave', 'ollama', 'auto'];
 function keyStatus(provider) {
@@ -72,9 +72,10 @@ export function registerSearchProviderCommand(pi) {
             }
             setSearchProviderPreference(chosen);
             const effective = resolveSearchProvider();
-            // 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);
+            // Gate on api shape + provider allowlist: the info note must match the
+            // actual runtime behavior in native-search.ts. Claude served via copilot
+            // / minimax / kimi is anthropic-shaped but does NOT run native search.
+            const isAnthropic = supportsNativeWebSearch(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

@@ -12,6 +12,38 @@ export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
 export const CUSTOM_SEARCH_TOOL_NAMES = ["search-the-web", "search_and_read", "google_search"];
 /** Thinking block types that require signature validation by the API */
 const THINKING_TYPES = new Set(["thinking", "redacted_thinking"]);
+/**
+ * Providers whose Anthropic-Messages endpoint is known to accept the native
+ * `web_search_20250305` server tool. Anthropic-shaped transports NOT in this
+ * set (github-copilot, minimax, kimi-coding, opencode, vercel-ai-gateway,
+ * etc.) route Claude or Claude-compatible models through the Messages API
+ * but do NOT expose the server-side search tool — injecting it yields a
+ * 400 "unsupported_value" from their endpoints (regression from #4492).
+ *
+ * Keep this allowlist tight — err on the side of custom/Brave search rather
+ * than a runtime 400. Add a provider here only after confirming its endpoint
+ * accepts the tool type.
+ */
+const NATIVE_WEB_SEARCH_PROVIDERS = new Set([
+    "anthropic",
+    "claude-code",
+    "anthropic-vertex",
+    "vercel-ai-gateway",
+]);
+/**
+ * True when the model is an Anthropic-shaped transport AND the provider is
+ * known to accept the native `web_search_20250305` tool. Gate both on api
+ * shape (#4478 / ADR-012) and on provider identity (#444 regression guard
+ * and #4492 scope correction) — provider-level discrimination is legitimate
+ * per ADR-012 for credential/behavior differences that api shape can't
+ * express.
+ */
+export function supportsNativeWebSearch(model) {
+    if (!isAnthropicApi(model))
+        return false;
+    const provider = model?.provider;
+    return typeof provider === "string" && NATIVE_WEB_SEARCH_PROVIDERS.has(provider);
+}
 /**
  * Maximum number of native web searches allowed per session (agent unit).
  * The Anthropic API's `max_uses` is per-request — it resets on each API call.
@@ -76,10 +108,11 @@ export function registerNativeSearchHooks(pi) {
     pi.on("model_select", async (event, ctx) => {
         modelSelectFired = true;
         const wasAnthropic = isAnthropicProvider;
-        // 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);
+        // Gate on api shape AND provider allowlist: direct Anthropic, claude-code
+        // OAuth, and anthropic-vertex accept `web_search_20250305`; copilot /
+        // minimax / kimi / opencode route Claude-compat models through the same
+        // wire protocol but reject the server-side tool (#4492 regression).
+        isAnthropicProvider = supportsNativeWebSearch(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.
@@ -120,20 +153,19 @@ export function registerNativeSearchHooks(pi) {
         // modelsAreEqual suppresses model_select AND the SDK doesn't pass model.
         const eventModel = event.model;
         let isAnthropic;
-        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";
+        if (eventModel?.api || eventModel?.provider) {
+            // Preferred path: gate on api shape + provider allowlist. Both fields
+            // are authoritative when present — do NOT fall back to the model-name
+            // heuristic, which would misclassify copilot-served Claude as Anthropic
+            // (#444 regression) or minimax-served Claude-compat as Anthropic (#4492).
+            isAnthropic = supportsNativeWebSearch(eventModel);
         }
         else if (modelSelectFired) {
             isAnthropic = isAnthropicProvider;
         }
         else {
+            // Last resort: session-restore paths where the SDK doesn't pass model.
+            // The model-name prefix is best-effort and assumes direct Anthropic.
             const modelName = typeof payload.model === "string" ? payload.model : "";
             isAnthropic = modelName.startsWith("claude-");
         }