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

package/src/resources/extensions/gsd/tests/prompt-loader-extension-dir.test.ts

@@ -0,0 +1,49 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { join } from "node:path";
+
+import { resolveExtensionDirFromCandidates } from "../prompt-loader.ts";
+
+function makeExists(paths: Set<string>): (path: string) => boolean {
+  return (path: string) => paths.has(path);
+}
+
+test("resolveExtensionDirFromCandidates prefers user-local dir when both trees are valid", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    join(moduleDir, "templates", "task-summary.md"),
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, agentDir);
+});
+
+test("resolveExtensionDirFromCandidates rejects module dir missing task-summary template", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    // Missing module templates/task-summary.md on purpose.
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, agentDir);
+});
+
+test("resolveExtensionDirFromCandidates falls back to prompts-only dir when neither tree is fully valid", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    // Neither side has templates/task-summary.md.
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, moduleDir);
+});

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -45,6 +45,13 @@ test("classifyError treats usage-limit phrasing as transient rate-limit (#4373)"
   assert.equal(result.kind, "rate-limit");
 });
 
+test("classifyError treats extra-usage phrasing as transient rate-limit (#4397)", () => {
+  const result = classifyError("You are out of extra usage. Please wait before retrying.");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 60_000);
+});
+
 test("classifyError treats OpenRouter affordability errors as transient rate-limit class", () => {
   const result = classifyError(
     "402 This request requires more credits, or fewer max_tokens. You requested up to 32000 tokens, but can only afford 329.",
@@ -147,6 +154,49 @@ test("classifyError: rate limit takes precedence over auth keywords", () => {
   assert.ok(isTransient(result));
 });
 
+// ── unsupported-model: account/plan entitlement rejection (#4513) ──────────
+
+test("classifyError: Codex ChatGPT-account entitlement rejection is unsupported-model", () => {
+  const result = classifyError(
+    "The 'gpt-5.1-codex-max' model is not supported when using Codex with a ChatGPT account.",
+  );
+  assert.equal(result.kind, "unsupported-model");
+  assert.ok(!isTransient(result));
+});
+
+test("classifyError: 'model not available for this plan' is unsupported-model", () => {
+  const result = classifyError("This model is not available for your current plan.");
+  assert.equal(result.kind, "unsupported-model");
+});
+
+test("classifyError: 'account does not have access to model' is unsupported-model", () => {
+  const result = classifyError("Your account does not have access to the gpt-5 model.");
+  assert.equal(result.kind, "unsupported-model");
+});
+
+test("classifyError: 'tier does not support deployment' is unsupported-model", () => {
+  const result = classifyError("The free tier does not support this deployment.");
+  assert.equal(result.kind, "unsupported-model");
+});
+
+test("classifyError: 'account suspended' stays permanent (not unsupported-model)", () => {
+  const result = classifyError("Your account has been suspended. Contact support.");
+  assert.equal(result.kind, "permanent");
+});
+
+test("classifyError: 'invalid account' stays permanent", () => {
+  const result = classifyError("invalid account credentials");
+  assert.equal(result.kind, "permanent");
+});
+
+test("classifyError: rate limit on unsupported-model phrasing stays rate-limit", () => {
+  // A throttled account is not an entitlement failure.
+  const result = classifyError(
+    "429 rate limit — model not supported when using your account right now",
+  );
+  assert.equal(result.kind, "rate-limit");
+});
+
 // ── STREAM_RE: V8 JSON parse error variants (#2916) ────────────────────────
 
 test("classifyError: 'Expected comma/brace after property value in JSON' is transient stream", () => {
@@ -630,6 +680,47 @@ test("MAX_TRANSIENT_AUTO_RESUMES is at least 8 for sustained overload resilience
   );
 });
 
+// ── Stream idle timeout / partial response (#4558) ──────────────────────────
+
+test("classifyError: 'Stream idle timeout - partial response received' is transient network", () => {
+  const result = classifyError("API Error: Stream idle timeout - partial response received");
+  assert.ok(isTransient(result), "stream idle timeout must be transient");
+  assert.equal(result.kind, "network");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs > 0);
+});
+
+test("classifyError: 'stream idle timeout' (lowercase) is transient network", () => {
+  const result = classifyError("stream idle timeout");
+  assert.ok(isTransient(result), "lowercase stream idle timeout must be transient");
+  assert.equal(result.kind, "network");
+});
+
+test("classifyError: 'partial response received' alone is transient network", () => {
+  const result = classifyError("partial response received");
+  assert.ok(isTransient(result), "partial response received must be transient");
+  assert.equal(result.kind, "network");
+});
+
+// ── Context overflow / context window exceeded (#4528) ───────────────────────
+
+test("classifyError: MiniMax context window error is transient server", () => {
+  const result = classifyError("400 invalid params, context window exceeds limit (2013)");
+  assert.ok(isTransient(result), "context window exceeded must be transient");
+  assert.equal(result.kind, "server");
+});
+
+test("classifyError: 'context length exceeded' is transient server", () => {
+  const result = classifyError("context length exceeded: max 128000 tokens");
+  assert.ok(isTransient(result), "context length exceeded must be transient");
+  assert.equal(result.kind, "server");
+});
+
+test("classifyError: 'context window' with 'exceed' is transient server", () => {
+  const result = classifyError("context window exceeded for this model");
+  assert.ok(isTransient(result), "context window exceeded must be transient");
+  assert.equal(result.kind, "server");
+});
+
 // ── agent-session retryable regex handles server_error (#1166) ──────────────
 
 test("agent-session retryable error regex matches server_error (underscore)", () => {

package/src/resources/extensions/gsd/tests/save-gate-result-render.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Regression test suite for save_gate_result renderResult.
+ *
+ * Verifies that renderResult does not print "undefined: undefined" when
+ * `details` is empty, and that the error fallback does not produce a
+ * duplicated `Error: Error:` prefix when `content[0].text` already starts
+ * with `Error:`.
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { registerDbTools } from '../bootstrap/db-tools.ts';
+
+function makeMockPi() {
+  const tools: any[] = [];
+  return {
+    registerTool: (tool: any) => tools.push(tool),
+    tools,
+  } as any;
+}
+
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+function getSaveGateResultTool() {
+  const pi = makeMockPi();
+  registerDbTools(pi);
+  const tool = pi.tools.find((t: any) => t.name === 'gsd_save_gate_result');
+  assert.ok(tool, 'gsd_save_gate_result should be registered');
+  return tool;
+}
+
+test('save_gate_result renderResult falls back to content text when details is empty', () => {
+  const tool = getSaveGateResultTool();
+  const result = {
+    content: [{ type: 'text', text: 'Gate Q3 result saved: verdict=pass' }],
+    details: {},
+    isError: false,
+  };
+  const rendered = tool.renderResult(result, {}, fakeTheme);
+  const text = String(rendered.content ?? rendered.text ?? rendered);
+  assert.ok(!text.includes('undefined'), `got: ${text}`);
+  assert.ok(
+    text.includes('Gate Q3') || text.includes('verdict=pass'),
+    `expected content summary — got: ${text}`,
+  );
+});
+
+test('save_gate_result renderResult uses structured details when present', () => {
+  const tool = getSaveGateResultTool();
+  const result = {
+    content: [{ type: 'text', text: 'Gate Q3 result saved: verdict=flag' }],
+    details: { operation: 'save_gate_result', gateId: 'Q3', verdict: 'flag' },
+    isError: false,
+  };
+  const rendered = tool.renderResult(result, {}, fakeTheme);
+  const text = String(rendered.content ?? rendered.text ?? rendered);
+  assert.ok(text.includes('Q3'), `got: ${text}`);
+  assert.ok(text.includes('flag'), `got: ${text}`);
+  assert.ok(!text.includes('undefined'), `got: ${text}`);
+});
+
+test('save_gate_result renderResult shows error from content when details.error is missing', () => {
+  const tool = getSaveGateResultTool();
+  const result = {
+    content: [{ type: 'text', text: 'Error: Invalid gateId "Z1"' }],
+    details: {},
+    isError: true,
+  };
+  const rendered = tool.renderResult(result, {}, fakeTheme);
+  const text = String(rendered.content ?? rendered.text ?? rendered);
+  assert.ok(
+    text.includes('Invalid gateId') || text.includes('Error'),
+    `got: ${text}`,
+  );
+  assert.ok(!text.includes('undefined'), `got: ${text}`);
+});
+
+test('save_gate_result renderResult does not duplicate Error: prefix', () => {
+  const tool = getSaveGateResultTool();
+  const result = {
+    content: [{ type: 'text', text: 'Error: Invalid gateId "Z1"' }],
+    details: {},
+    isError: true,
+  };
+  const rendered = tool.renderResult(result, {}, fakeTheme);
+  const text = String(rendered.content ?? rendered.text ?? rendered);
+  assert.ok(
+    !/Error:\s*Error:/i.test(text),
+    `expected a single Error: prefix — got: ${text}`,
+  );
+  assert.ok(text.includes('Invalid gateId'), `got: ${text}`);
+});

package/src/resources/extensions/gsd/tests/zombie-gsd-state.test.ts

@@ -72,7 +72,9 @@ const autoStartSrc = readFileSync(
 const symlinkIdx = autoStartSrc.indexOf("ensureGsdSymlink(base)");
 assertTrue(symlinkIdx >= 0, "auto-start.ts calls ensureGsdSymlink(base)");
 
-const afterSymlink = symlinkIdx >= 0 ? autoStartSrc.slice(symlinkIdx, symlinkIdx + 800) : "";
+const afterSymlink = symlinkIdx >= 0
+  ? autoStartSrc.slice(symlinkIdx, autoStartSrc.indexOf("Initialize GitServiceImpl", symlinkIdx))
+  : "";
 
 // The milestones bootstrap must check milestones path, not gsdDir
 // Old (dead) code: if (!existsSync(gsdDir)) { mkdirSync(join(gsdDir, "milestones"), ...) }

package/src/resources/extensions/gsd/tools/exec-search-tool.ts

@@ -0,0 +1,81 @@
+// 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, type ExecSearchOptions } from "../exec-history.js";
+
+export interface ExecSearchToolParams {
+  query?: string;
+  runtime?: "bash" | "node" | "python";
+  failing_only?: boolean;
+  limit?: number;
+}
+
+export interface ToolExecutionResult {
+  content: Array<{ type: "text"; text: string }>;
+  details: Record<string, unknown>;
+  isError?: boolean;
+}
+
+export function executeExecSearch(
+  params: ExecSearchToolParams,
+  opts: { baseDir: string },
+): ToolExecutionResult {
+  const searchOpts: ExecSearchOptions = {
+    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: string[] = [`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: { exit_code: number | null; timed_out: boolean; signal: string | null }): string {
+  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/src/resources/extensions/gsd/tools/exec-tool.ts

@@ -0,0 +1,183 @@
+// 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,
+  type ExecSandboxOptions,
+  type ExecSandboxRequest,
+  type ExecSandboxResult,
+} from "../exec-sandbox.js";
+import { isContextModeEnabled, type ContextModeConfig } from "../preferences-types.js";
+
+export interface ExecToolParams {
+  runtime: ExecSandboxRequest["runtime"];
+  script: string;
+  purpose?: string;
+  timeout_ms?: number;
+}
+
+export interface ToolExecutionResult {
+  content: Array<{ type: "text"; text: string }>;
+  details: Record<string, unknown>;
+  isError?: boolean;
+}
+
+export interface ExecToolDeps {
+  baseDir: string;
+  preferences: { context_mode?: ContextModeConfig } | null;
+  /** Optional override for testing. */
+  run?: (req: ExecSandboxRequest, opts: ExecSandboxOptions) => Promise<ExecSandboxResult>;
+  now?: () => Date;
+  generateId?: () => string;
+}
+
+export function buildExecOptions(
+  baseDir: string,
+  cfg: ContextModeConfig | undefined,
+  extras?: Pick<ExecSandboxOptions, "env" | "now" | "generateId">,
+): ExecSandboxOptions {
+  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: unknown, fallback: number, min: number, max: number): number {
+  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: ExecToolDeps["preferences"]): boolean {
+  return isContextModeEnabled(prefs);
+}
+
+function disabledResult(): ToolExecutionResult {
+  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: string): ToolExecutionResult {
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    details: { operation: "gsd_exec", error: "invalid_params", detail: message },
+    isError: true,
+  };
+}
+
+export async function executeGsdExec(
+  params: ExecToolParams,
+  deps: ExecToolDeps,
+): Promise<ToolExecutionResult> {
+  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: ExecSandboxResult): ToolExecutionResult {
+  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: ExecSandboxResult): string {
+  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/src/resources/extensions/gsd/tools/resume-tool.ts

@@ -0,0 +1,40 @@
+// 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 interface ResumeToolParams {
+  /** Ignored — reserved for future variant (e.g. dated snapshots). */
+  _variant?: string;
+}
+
+export interface ToolExecutionResult {
+  content: Array<{ type: "text"; text: string }>;
+  details: Record<string, unknown>;
+  isError?: boolean;
+}
+
+export function executeResume(
+  _params: ResumeToolParams,
+  opts: { baseDir: string },
+): ToolExecutionResult {
+  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/src/resources/extensions/gsd/workflow-logger.ts

@@ -57,7 +57,8 @@ export type LogComponent =
   | "ecosystem"     // GSD ecosystem extension loader and dispatch
   | "memory-embeddings" // Memory layer embedding generation
   | "memory-ingest"     // Memory layer ingestion pipeline
-  | "memory-backfill";  // ADR-013: decisions->memories backfill
+  | "memory-backfill"   // ADR-013: decisions->memories backfill
+  | "context-mode";    // Context-mode exec sandbox and compaction snapshot
 
 export interface LogEntry {
   ts: string;

package/src/resources/extensions/gsd/workflow-mcp.ts

@@ -23,6 +23,9 @@ export interface WorkflowCapabilityOptions {
 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/src/resources/extensions/search-the-web/command-search-provider.ts

@@ -8,7 +8,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 type { ExtensionAPI } from '@gsd/pi-coding-agent'
 import type { AutocompleteItem } from '@gsd/pi-tui'
 import {
@@ -91,9 +91,10 @@ export function registerSearchProviderCommand(pi: ExtensionAPI): void {
 
       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}`,