gsd-pi 2.10.12 → 2.12.0

package/src/resources/extensions/gsd/tests/worktree.test.ts

@@ -31,14 +31,14 @@ function run(command: string, cwd: string): string {
 
 const base = mkdtempSync(join(tmpdir(), "gsd-branch-test-"));
 run("git init -b main", base);
-run("git config user.name 'Pi Test'", base);
-run("git config user.email 'pi@example.com'", base);
+run('git config user.name "Pi Test"', base);
+run('git config user.email "pi@example.com"', base);
 mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
 writeFileSync(join(base, "README.md"), "hello\n", "utf-8");
 writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), `# M001: Demo\n\n## Slices\n- [ ] **S01: Slice One** \`risk:low\` \`depends:[]\`\n  > After this: demo works\n`, "utf-8");
 writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"), `# S01: Slice One\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Implement** \`est:10m\`\n  do it\n`, "utf-8");
 run("git add .", base);
-run("git commit -m 'chore: init'", base);
+run('git commit -m "chore: init"', base);
 
 async function main(): Promise<void> {
   console.log("\n=== ensureSliceBranch ===");
@@ -85,7 +85,7 @@ async function main(): Promise<void> {
   ensureSliceBranch(base, "M001", "S01");
   writeFileSync(join(base, "README.md"), "hello from slice\n", "utf-8");
   run("git add README.md", base);
-  run("git commit -m 'feat: slice change'", base);
+  run('git commit -m "feat: slice change"', base);
   switchToMain(base);
 
   const merge = mergeSliceToMain(base, "M001", "S01", "Slice One");
@@ -107,7 +107,7 @@ async function main(): Promise<void> {
     "- [ ] **S02: Slice Two** `risk:low` `depends:[]`", "  > Demo 2",
   ].join("\n") + "\n", "utf-8");
   run("git add .", base);
-  run("git commit -m 'chore: add S02'", base);
+  run('git commit -m "chore: add S02"', base);
 
   ensureSliceBranch(base, "M001", "S02");
   writeFileSync(join(base, "feature.txt"), "new feature\n", "utf-8");
@@ -168,11 +168,11 @@ async function main(): Promise<void> {
   console.log("\n=== ensureSliceBranch from non-main working branch ===");
   const base2 = mkdtempSync(join(tmpdir(), "gsd-branch-base-test-"));
   run("git init -b main", base2);
-  run("git config user.name 'Pi Test'", base2);
-  run("git config user.email 'pi@example.com'", base2);
+  run('git config user.name "Pi Test"', base2);
+  run('git config user.email "pi@example.com"', base2);
   writeFileSync(join(base2, "README.md"), "hello\n", "utf-8");
   run("git add .", base2);
-  run("git commit -m 'chore: init'", base2);
+  run('git commit -m "chore: init"', base2);
 
   // Create a "developer" branch with planning artifacts (like the real scenario)
   run("git checkout -b developer", base2);
@@ -183,7 +183,7 @@ async function main(): Promise<void> {
     "- [ ] **S01: Config Fix** `risk:low` `depends:[]`", "  > Fix config",
   ].join("\n") + "\n", "utf-8");
   run("git add .", base2);
-  run("git commit -m 'docs(M001): context and roadmap'", base2);
+  run('git commit -m "docs(M001): context and roadmap"', base2);
 
   // Verify main does NOT have the artifacts
   const mainRoadmap = run("git show main:.gsd/milestones/M001/M001-ROADMAP.md 2>&1 || echo MISSING", base2);
@@ -211,8 +211,8 @@ async function main(): Promise<void> {
   console.log("\n=== ensureSliceBranch from slice branch falls back to main ===");
   const base3 = mkdtempSync(join(tmpdir(), "gsd-branch-chain-test-"));
   run("git init -b main", base3);
-  run("git config user.name 'Pi Test'", base3);
-  run("git config user.email 'pi@example.com'", base3);
+  run('git config user.name "Pi Test"', base3);
+  run('git config user.email "pi@example.com"', base3);
   mkdirSync(join(base3, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
   mkdirSync(join(base3, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
   writeFileSync(join(base3, "README.md"), "hello\n", "utf-8");
@@ -222,7 +222,7 @@ async function main(): Promise<void> {
     "- [ ] **S02: Second** `risk:low` `depends:[]`", "  > second",
   ].join("\n") + "\n", "utf-8");
   run("git add .", base3);
-  run("git commit -m 'chore: init'", base3);
+  run('git commit -m "chore: init"', base3);
 
   ensureSliceBranch(base3, "M001", "S01");
   assertEq(getCurrentBranch(base3), "gsd/M001/S01", "on S01 slice branch");
@@ -379,7 +379,7 @@ async function main(): Promise<void> {
     // User creates feature branch
     run("git checkout -b feature/big-change", repo);
     writeFileSync(join(repo, "setup.txt"), "feature setup\n");
-    run("git add -A && git commit -m 'feat: initial setup'", repo);
+    run('git add -A && git commit -m "feat: initial setup"', repo);
 
     // auto.ts startup: capture + set milestone
     captureIntegrationBranch(repo, "M001");
@@ -397,7 +397,7 @@ async function main(): Promise<void> {
       "multi: S01 inherited feature branch content");
 
     writeFileSync(join(repo, "s01-work.txt"), "s01 output\n");
-    run("git add -A && git commit -m 'feat(S01): work'", repo);
+    run('git add -A && git commit -m "feat(S01): work"', repo);
 
     switchToMain(repo);
     assertEq(getCurrentBranch(repo), "feature/big-change",
@@ -428,7 +428,7 @@ async function main(): Promise<void> {
       "multi: S02 has S01 output (inherited via feature branch)");
 
     writeFileSync(join(repo, "s02-work.txt"), "s02 output\n");
-    run("git add -A && git commit -m 'feat(S02): work'", repo);
+    run('git add -A && git commit -m "feat(S02): work"', repo);
 
     switchToMain(repo);
     assertEq(getCurrentBranch(repo), "feature/big-change",
@@ -479,7 +479,7 @@ async function main(): Promise<void> {
     // Create a slice and do some work
     ensureSliceBranch(repo, "M001", "S01");
     writeFileSync(join(repo, "work.txt"), "wip\n");
-    run("git add -A && git commit -m 'wip'", repo);
+    run('git add -A && git commit -m "wip"', repo);
 
     // Simulate "restart" — clear milestone ID (fresh service instance)
     setActiveMilestoneId(repo, null);
@@ -530,7 +530,7 @@ async function main(): Promise<void> {
     // Full lifecycle on main still works
     ensureSliceBranch(repo, "M001", "S01");
     writeFileSync(join(repo, "feature.txt"), "new\n");
-    run("git add -A && git commit -m 'feat: work'", repo);
+    run('git add -A && git commit -m "feat: work"', repo);
 
     switchToMain(repo);
     assertEq(getCurrentBranch(repo), "main",
@@ -564,7 +564,7 @@ async function main(): Promise<void> {
 
     run("git checkout -b dev-branch", repo);
     writeFileSync(join(repo, "dev-only.txt"), "from dev\n");
-    run("git add -A && git commit -m 'dev setup'", repo);
+    run('git add -A && git commit -m "dev setup"', repo);
 
     captureIntegrationBranch(repo, "M001");
     setActiveMilestoneId(repo, "M001");
@@ -572,7 +572,7 @@ async function main(): Promise<void> {
     // Create S01 (from dev-branch)
     ensureSliceBranch(repo, "M001", "S01");
     writeFileSync(join(repo, "s01.txt"), "s01\n");
-    run("git add -A && git commit -m 's01 work'", repo);
+    run('git add -A && git commit -m "s01 work"', repo);
 
     // While on S01, create S02 — should fall back to integration branch
     ensureSliceBranch(repo, "M001", "S02");

package/src/resources/extensions/gsd/types.ts

@@ -185,3 +185,112 @@ export interface GSDState {
     tasks?: { done: number; total: number };
   };
 }
+
+// ─── Post-Unit Hook Types ─────────────────────────────────────────────────
+
+export interface PostUnitHookConfig {
+  /** Unique hook identifier — used in idempotency keys and logging. */
+  name: string;
+  /** Unit types that trigger this hook (e.g., ["execute-task"]). */
+  after: string[];
+  /** Prompt sent to the LLM session. Supports {milestoneId}, {sliceId}, {taskId} substitutions. */
+  prompt: string;
+  /** Max times this hook can fire for the same trigger unit. Default 1, max 10. */
+  max_cycles?: number;
+  /** Model override for hook sessions. */
+  model?: string;
+  /** Expected output file name (relative to task/slice dir). Used for idempotency — skip if exists. */
+  artifact?: string;
+  /** If this file is produced instead of artifact, re-run the trigger unit then re-run hooks. */
+  retry_on?: string;
+  /** Agent definition file to use. */
+  agent?: string;
+  /** Set false to disable without removing config. Default true. */
+  enabled?: boolean;
+}
+
+export interface HookExecutionState {
+  /** Hook name. */
+  hookName: string;
+  /** The unit type that triggered this hook. */
+  triggerUnitType: string;
+  /** The unit ID that triggered this hook. */
+  triggerUnitId: string;
+  /** Current cycle (1-based). */
+  cycle: number;
+  /** Whether the hook completed with a retry signal (retry_on artifact found). */
+  pendingRetry: boolean;
+}
+
+export interface HookDispatchResult {
+  /** Hook name for display. */
+  hookName: string;
+  /** The prompt to send. */
+  prompt: string;
+  /** Model override, if configured. */
+  model?: string;
+  /** Synthetic unit type, e.g. "hook/code-review". */
+  unitType: string;
+  /** The trigger unit's ID, reused for the hook. */
+  unitId: string;
+}
+
+// ─── Pre-Dispatch Hook Types ──────────────────────────────────────────────
+
+export interface PreDispatchHookConfig {
+  /** Unique hook identifier. */
+  name: string;
+  /** Unit types this hook intercepts before dispatch (e.g., ["execute-task"]). */
+  before: string[];
+  /** Action to take: "modify" mutates the prompt, "skip" skips the unit, "replace" swaps it. */
+  action: 'modify' | 'skip' | 'replace';
+  /** For "modify": text prepended to the unit prompt. Supports {milestoneId}, {sliceId}, {taskId}. */
+  prepend?: string;
+  /** For "modify": text appended to the unit prompt. Supports {milestoneId}, {sliceId}, {taskId}. */
+  append?: string;
+  /** For "replace": the replacement prompt. Supports {milestoneId}, {sliceId}, {taskId}. */
+  prompt?: string;
+  /** For "replace": override the unit type label. */
+  unit_type?: string;
+  /** For "skip": optional condition file — only skip if this file exists (relative to unit dir). */
+  skip_if?: string;
+  /** Model override when this hook fires. */
+  model?: string;
+  /** Set false to disable without removing config. Default true. */
+  enabled?: boolean;
+}
+
+export interface PreDispatchResult {
+  /** What happened: the unit proceeds with modifications, was skipped, or was replaced. */
+  action: 'proceed' | 'skip' | 'replace';
+  /** Modified/replacement prompt (for "proceed" and "replace"). */
+  prompt?: string;
+  /** Override unit type (for "replace"). */
+  unitType?: string;
+  /** Model override. */
+  model?: string;
+  /** Names of hooks that fired, for logging. */
+  firedHooks: string[];
+}
+
+// ─── Hook State Persistence Types ─────────────────────────────────────────
+
+export interface PersistedHookState {
+  /** Cycle counts keyed as "hookName/triggerUnitType/triggerUnitId". */
+  cycleCounts: Record<string, number>;
+  /** Timestamp of last state save. */
+  savedAt: string;
+}
+
+export interface HookStatusEntry {
+  /** Hook name. */
+  name: string;
+  /** Hook type: "post" or "pre". */
+  type: 'post' | 'pre';
+  /** Whether hook is enabled. */
+  enabled: boolean;
+  /** What unit types it targets. */
+  targets: string[];
+  /** Current cycle counts for active triggers. */
+  activeCycles: Record<string, number>;
+}

package/src/resources/extensions/gsd/worktree-manager.ts

@@ -17,7 +17,7 @@
 
 import { existsSync, mkdirSync, realpathSync } from "node:fs";
 import { execSync } from "node:child_process";
-import { join, relative, resolve } from "node:path";
+import { join, resolve } from "node:path";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
 
@@ -46,13 +46,27 @@ export interface WorktreeDiffSummary {
 
 // ─── Git Helpers ───────────────────────────────────────────────────────────
 
-/** Env overlay that suppresses all interactive git credential prompts. */
+/** Env overlay that suppresses interactive git credential prompts and git-svn noise. */
 const GIT_NO_PROMPT_ENV = {
   ...process.env,
   GIT_TERMINAL_PROMPT: "0",
   GIT_ASKPASS: "",
+  GIT_SVN_ID: "",
 };
 
+/**
+ * Strip git-svn noise from error messages.
+ * Some systems have a buggy git-svn Perl module that emits warnings
+ * on every git invocation. See #404.
+ */
+function filterGitSvnNoise(message: string): string {
+  return message
+    .replace(/Duplicate specification "[^"]*" for option "[^"]*"\n?/g, "")
+    .replace(/Unable to determine upstream SVN information from .*\n?/g, "")
+    .replace(/Perhaps the repository is empty\. at .*git-svn.*\n?/g, "")
+    .trim();
+}
+
 function runGit(cwd: string, args: string[], opts: { allowFailure?: boolean } = {}): string {
   try {
     return execSync(`git ${args.join(" ")}`, {
@@ -64,10 +78,18 @@ function runGit(cwd: string, args: string[], opts: { allowFailure?: boolean } =
   } catch (error) {
     if (opts.allowFailure) return "";
     const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`git ${args.join(" ")} failed in ${cwd}: ${message}`);
+    throw new Error(`git ${args.join(" ")} failed in ${cwd}: ${filterGitSvnNoise(message)}`);
   }
 }
 
+function normalizePathForComparison(path: string): string {
+  const normalized = path
+    .replaceAll("\\", "/")
+    .replace(/^\/\/\?\//, "")
+    .replace(/\/+$/, "");
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+
 export function getMainBranch(basePath: string): string {
   const symbolic = runGit(basePath, ["symbolic-ref", "refs/remotes/origin/HEAD"], { allowFailure: true });
   if (symbolic) {
@@ -156,15 +178,29 @@ export function createWorktree(basePath: string, name: string): WorktreeInfo {
  * Parses `git worktree list` and filters to those under .gsd/worktrees/.
  */
 export function listWorktrees(basePath: string): WorktreeInfo[] {
-  // Resolve real paths to handle symlinks (e.g. /tmp → /private/tmp on macOS)
-  const resolvedBase = existsSync(basePath) ? realpathSync(basePath) : resolve(basePath);
-  const wtDir = join(resolvedBase, ".gsd", "worktrees");
+  const baseVariants = [resolve(basePath)];
+  if (existsSync(basePath)) {
+    baseVariants.push(realpathSync(basePath));
+  }
+  const seenRoots = new Set<string>();
+  const worktreeRoots = baseVariants
+    .map(baseVariant => {
+      const path = join(baseVariant, ".gsd", "worktrees");
+      return {
+        normalized: normalizePathForComparison(path),
+      };
+    })
+    .filter(root => {
+      if (seenRoots.has(root.normalized)) return false;
+      seenRoots.add(root.normalized);
+      return true;
+    });
   const rawList = runGit(basePath, ["worktree", "list", "--porcelain"]);
 
   if (!rawList.trim()) return [];
 
   const worktrees: WorktreeInfo[] = [];
-  const entries = rawList.split("\n\n").filter(Boolean);
+  const entries = rawList.replaceAll("\r\n", "\n").split("\n\n").filter(Boolean);
 
   for (const entry of entries) {
     const lines = entry.split("\n");
@@ -175,19 +211,42 @@ export function listWorktrees(basePath: string): WorktreeInfo[] {
 
     const entryPath = wtLine.replace("worktree ", "");
     const branch = branchLine.replace("branch refs/heads/", "");
+    const branchWorktreeName = branch.startsWith("worktree/") ? branch.slice("worktree/".length) : null;
+    const entryVariants = [resolve(entryPath)];
+    if (existsSync(entryPath)) {
+      entryVariants.push(realpathSync(entryPath));
+    }
+    const normalizedEntryVariants = [...new Set(entryVariants.map(normalizePathForComparison))];
+    const matchedRoot = worktreeRoots.find(root =>
+      normalizedEntryVariants.some(entryVariant => entryVariant.startsWith(`${root.normalized}/`)),
+    );
+    const matchesBranchLeaf = branchWorktreeName
+      ? normalizedEntryVariants.some(entryVariant => entryVariant.split("/").pop() === branchWorktreeName)
+      : false;
 
     // Only include worktrees under .gsd/worktrees/
-    if (!entryPath.startsWith(wtDir)) continue;
+    if (!matchedRoot && !matchesBranchLeaf) continue;
+
+    const matchedEntryPath = normalizedEntryVariants.find(entryVariant =>
+      matchedRoot ? entryVariant.startsWith(`${matchedRoot.normalized}/`) : false,
+    );
+    let name = matchedRoot ? matchedEntryPath?.slice(matchedRoot.normalized.length + 1) ?? "" : "";
+
+    // Git on Windows can report a path form that does not map cleanly back to the
+    // repo root even when the branch naming is still authoritative.
+    if ((!name || name.includes("/")) && branchWorktreeName && matchesBranchLeaf) {
+      name = branchWorktreeName;
+    }
+
+    if (!name || name.includes("/")) continue;
 
-    const name = relative(wtDir, entryPath);
-    // Skip nested paths — only direct children
-    if (name.includes("/") || name.includes("\\")) continue;
+    const resolvedEntryPath = existsSync(entryPath) ? realpathSync(entryPath) : resolve(entryPath);
 
     worktrees.push({
       name,
-      path: entryPath,
+      path: resolvedEntryPath,
       branch,
-      exists: existsSync(entryPath),
+      exists: existsSync(resolvedEntryPath),
     });
   }
 

package/src/resources/extensions/gsd/worktree.ts

@@ -72,11 +72,12 @@ export function captureIntegrationBranch(basePath: string, milestoneId: string):
  * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
  */
 export function detectWorktreeName(basePath: string): string | null {
-  const marker = `${sep}.gsd${sep}worktrees${sep}`;
-  const idx = basePath.indexOf(marker);
+  const normalizedPath = basePath.replaceAll("\\", "/");
+  const marker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(marker);
   if (idx === -1) return null;
-  const afterMarker = basePath.slice(idx + marker.length);
-  const name = afterMarker.split(sep)[0] ?? afterMarker.split("/")[0];
+  const afterMarker = normalizedPath.slice(idx + marker.length);
+  const name = afterMarker.split("/")[0];
   return name || null;
 }
 

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

@@ -13,16 +13,18 @@ import type { AutocompleteItem } from '@gsd/pi-tui'
 import {
   getTavilyApiKey,
   getBraveApiKey,
+  getOllamaApiKey,
   getSearchProviderPreference,
   setSearchProviderPreference,
   resolveSearchProvider,
   type SearchProviderPreference,
 } from './provider.ts'
 
-const VALID_PREFERENCES: SearchProviderPreference[] = ['tavily', 'brave', 'auto']
+const VALID_PREFERENCES: SearchProviderPreference[] = ['tavily', 'brave', 'ollama', 'auto']
 
-function keyStatus(provider: 'tavily' | 'brave'): string {
+function keyStatus(provider: 'tavily' | 'brave' | 'ollama'): string {
   if (provider === 'tavily') return getTavilyApiKey() ? '✓' : '✗'
+  if (provider === 'ollama') return getOllamaApiKey() ? '✓' : '✗'
   return getBraveApiKey() ? '✓' : '✗'
 }
 
@@ -30,6 +32,7 @@ function buildSelectOptions(): string[] {
   return [
     `tavily (key: ${keyStatus('tavily')})`,
     `brave (key: ${keyStatus('brave')})`,
+    `ollama (key: ${keyStatus('ollama')})`,
     `auto`,
   ]
 }
@@ -37,12 +40,13 @@ function buildSelectOptions(): string[] {
 function parseSelectChoice(choice: string): SearchProviderPreference {
   if (choice.startsWith('tavily')) return 'tavily'
   if (choice.startsWith('brave')) return 'brave'
+  if (choice.startsWith('ollama')) return 'ollama'
   return 'auto'
 }
 
 export function registerSearchProviderCommand(pi: ExtensionAPI): void {
   pi.registerCommand('search-provider', {
-    description: 'Switch search provider (tavily, brave, auto)',
+    description: 'Switch search provider (tavily, brave, ollama, auto)',
 
     getArgumentCompletions(prefix: string): AutocompleteItem[] | null {
       const trimmed = prefix.trim().toLowerCase()
@@ -51,7 +55,7 @@ export function registerSearchProviderCommand(pi: ExtensionAPI): void {
         .map((p) => {
           let description: string
           if (p === 'auto') {
-            description = `Auto-select (tavily: ${keyStatus('tavily')}, brave: ${keyStatus('brave')})`
+            description = `Auto-select (tavily: ${keyStatus('tavily')}, brave: ${keyStatus('brave')}, ollama: ${keyStatus('ollama')})`
           } else {
             description = `key: ${keyStatus(p)}`
           }

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

@@ -8,6 +8,9 @@
 /** Tool names for the Brave-backed custom search tools */
 export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
 
+/** All custom search tool names that should be disabled when native search is active */
+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"]);
 
@@ -57,27 +60,30 @@ export function stripThinkingFromHistory(
  */
 export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic: () => boolean } {
   let isAnthropicProvider = false;
+  let modelSelectFired = false;
 
   // Track provider changes via model selection — also handles diagnostics
   // since model_select fires AFTER session_start and knows the provider.
   pi.on("model_select", async (event: any, ctx: any) => {
+    modelSelectFired = true;
     const wasAnthropic = isAnthropicProvider;
     isAnthropicProvider = event.model.provider === "anthropic";
 
     const hasBrave = !!process.env.BRAVE_API_KEY;
 
-    // When Anthropic + no Brave key: disable custom search tools (they'd fail)
-    if (isAnthropicProvider && !hasBrave) {
+    // When Anthropic: disable all custom search tools — native web_search is
+    // server-side and more reliable. Custom tools cause confusion and failures.
+    if (isAnthropicProvider) {
       const active = pi.getActiveTools();
       pi.setActiveTools(
-        active.filter((t: string) => !BRAVE_TOOL_NAMES.includes(t))
+        active.filter((t: string) => !CUSTOM_SEARCH_TOOL_NAMES.includes(t))
       );
-    } else if (!isAnthropicProvider && wasAnthropic && !hasBrave) {
-      // Switching away from Anthropic without Brave — re-enable so the user
-      // sees the "missing key" error rather than tools silently vanishing.
-      // Only add tools not already active to avoid duplicates on repeated toggles.
+    } else if (!isAnthropicProvider && wasAnthropic) {
+      // Switching away from Anthropic — re-enable custom search tools (they
+      // were disabled while native search was active). If keys are missing,
+      // user sees the error rather than tools silently vanishing.
       const active = pi.getActiveTools();
-      const toAdd = BRAVE_TOOL_NAMES.filter((t) => !active.includes(t));
+      const toAdd = CUSTOM_SEARCH_TOOL_NAMES.filter((t) => !active.includes(t));
       if (toAdd.length > 0) {
         pi.setActiveTools([...active, ...toAdd]);
       }
@@ -99,11 +105,17 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
     const payload = event.payload as Record<string, unknown>;
     if (!payload) return;
 
-    // Only inject native web search for confirmed Anthropic provider.
-    // model_select sets isAnthropicProvider via the provider field.
-    // Model name prefix is NOT sufficient — other providers (GitHub Copilot,
-    // AWS Bedrock, etc.) serve claude-* models through non-Anthropic APIs.
-    if (!isAnthropicProvider) return;
+    // Detect Anthropic provider. Prefer the model_select flag when available,
+    // but fall back to checking the model name in the payload. model_select
+    // may not fire when the session restores with the same model already set
+    // (modelsAreEqual guard in the SDK suppresses the event). When model_select
+    // HAS fired and said "not Anthropic" (e.g. Copilot serving claude-*),
+    // respect that — don't override with model name heuristic.
+    const modelName = typeof payload.model === "string" ? payload.model : "";
+    const isAnthropic = modelSelectFired
+      ? isAnthropicProvider
+      : modelName.startsWith("claude-");
+    if (!isAnthropic) return;
 
     // Strip thinking blocks from history to avoid signature validation errors
     // caused by the SDK dropping server_tool_use/web_search_tool_result blocks.
@@ -119,16 +131,13 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
     // Don't double-inject if already present
     if (tools.some((t) => t.type === "web_search_20250305")) return;
 
-    // When no Brave key, remove Brave-based search tool definitions from the
-    // payload so Claude doesn't see (and try to call) broken tools.
-    // This is more reliable than setActiveTools since model_select may not fire.
-    const hasBrave = !!process.env.BRAVE_API_KEY;
-    if (!hasBrave) {
-      tools = tools.filter(
-        (t) => !BRAVE_TOOL_NAMES.includes(t.name as string)
-      );
-      payload.tools = tools;
-    }
+    // Always remove custom search tool definitions from Anthropic requests.
+    // Native web_search is server-side and more reliable — keeping both confuses
+    // the model and causes it to pick custom tools which can fail with network errors.
+    tools = tools.filter(
+      (t) => !CUSTOM_SEARCH_TOOL_NAMES.includes(t.name as string)
+    );
+    payload.tools = tools;
 
     tools.push({
       type: "web_search_20250305",

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

@@ -18,10 +18,10 @@ import { join } from 'path'
 // where the relative import '../../../app-paths.ts' doesn't resolve.
 const authFilePath = join(homedir(), '.gsd', 'agent', 'auth.json')
 
-export type SearchProvider = 'tavily' | 'brave'
+export type SearchProvider = 'tavily' | 'brave' | 'ollama'
 export type SearchProviderPreference = SearchProvider | 'auto'
 
-const VALID_PREFERENCES = new Set<string>(['tavily', 'brave', 'auto'])
+const VALID_PREFERENCES = new Set<string>(['tavily', 'brave', 'ollama', 'auto'])
 const PREFERENCE_KEY = 'search_provider'
 
 /** Returns the Tavily API key from the environment, or empty string if not set. */
@@ -34,6 +34,11 @@ export function getBraveApiKey(): string {
   return process.env.BRAVE_API_KEY || ''
 }
 
+/** Returns the Ollama API key from the environment, or empty string if not set. */
+export function getOllamaApiKey(): string {
+  return process.env.OLLAMA_API_KEY || ''
+}
+
 /**
  * Read the user's search provider preference from auth.json.
  * Returns 'auto' if no preference is stored or the stored value is invalid.
@@ -78,9 +83,11 @@ export function setSearchProviderPreference(pref: SearchProviderPreference, auth
 export function resolveSearchProvider(overridePreference?: string): SearchProvider | null {
   const tavilyKey = getTavilyApiKey()
   const braveKey = getBraveApiKey()
+  const ollamaKey = getOllamaApiKey()
 
   const hasTavily = tavilyKey.length > 0
   const hasBrave = braveKey.length > 0
+  const hasOllama = ollamaKey.length > 0
 
   // Determine effective preference
   let pref: SearchProviderPreference
@@ -100,18 +107,28 @@ export function resolveSearchProvider(overridePreference?: string): SearchProvid
   if (pref === 'auto') {
     if (hasTavily) return 'tavily'
     if (hasBrave) return 'brave'
+    if (hasOllama) return 'ollama'
     return null
   }
 
   if (pref === 'tavily') {
     if (hasTavily) return 'tavily'
     if (hasBrave) return 'brave'
+    if (hasOllama) return 'ollama'
     return null
   }
 
   if (pref === 'brave') {
     if (hasBrave) return 'brave'
     if (hasTavily) return 'tavily'
+    if (hasOllama) return 'ollama'
+    return null
+  }
+
+  if (pref === 'ollama') {
+    if (hasOllama) return 'ollama'
+    if (hasTavily) return 'tavily'
+    if (hasBrave) return 'brave'
     return null
   }