@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-web-access/index.js

@@ -1,23 +1,19 @@
 import { Box, Text, truncateToWidth } from "@duckmind/dm-tui";
 import { Type } from "typebox";
-import pLimit from "p-limit";
 import { normalizeFetchContentParams } from "./fetch-params.js";
-import { resolveAuthFetchProfile } from "./auth-fetch.js";
-import { findContent } from "./content-find.js";
 import { answerFromPage } from "./page-query.js";
 import { rewriteSearchQuery } from "./query-rewrite.js";
-import { clearCloneCache } from "./github-extract.js";
-import { ALL_SEARCH_PROVIDERS, assertSearchProviderSelectionAllowed, getAllowedSearchProviders, getConfiguredSearchRouting, normalizeSearchProviderSelection, providerLabel, RESOLVED_SEARCH_PROVIDERS, search } from "./gemini-search.js";
-import { formatSeconds, getWebSearchConfigDir, getWebSearchConfigPath, resolveCuratorNetworkConfig, runWithProxy } from "./utils.js";
+import { clearCloneCache, releaseClonesUnusedSince, touchClones } from "./github-extract.js";
+import { ALL_SEARCH_PROVIDERS, getAllowedSearchProviders, getConfiguredSearchRouting, providerLabel, RESOLVED_SEARCH_PROVIDERS, search } from "./gemini-search.js";
+import { formatSeconds, getWebSearchConfigDir, resolveCuratorNetworkConfig, runWithProxy } from "./utils.js";
 import {
-  clearResults,
-  deleteResult,
+  deleteHeldResult,
   generateId,
   getAllResults,
-  getResult,
-  restoreFromSession,
-  storeFetchedContentResult,
-  storeResult
+  holdResults,
+  loadSessionResults,
+  releaseResults,
+  storeFetchedContentResult
 } from "./storage.js";
 import { activityMonitor } from "./activity.js";
 import { startCuratorServer } from "./curator-server.js";
@@ -38,14 +34,16 @@ import { isGeminiApiAvailable } from "./gemini-api.js";
 import { getActiveGoogleEmail, getGeminiWebAvailabilityDiagnostic, getGeminiWebAvailabilityDiagnosticDetails, isGeminiWebAvailable } from "./gemini-web.js";
 import { isBrowserCookieAccessAllowed } from "./gemini-web-config.js";
 import { isBraveAvailable } from "./brave.js";
-import { isCurrentModelHostedSearchEligible, isOpenAISearchAvailable } from "./openai-search.js";
+import { isCurrentModelHostedSearchEligible, isOpenAISearchAvailable, isOpenAISubscriptionModelSelected } from "./openai-search.js";
 import { isParallelAvailable } from "./parallel.js";
 import { isParallelMcpAvailable } from "./parallel-mcp.js";
+import { parseStringifiedArrays } from "./tool-arguments.js";
 import { isTinyFishAvailable } from "./tinyfish.js";
 import { isSearch1APIAvailable } from "./search1api.js";
 import { isSearchinfinityAvailable } from "./searchinfinity.js";
 import { isQueritAvailable } from "./querit.js";
 import { isTavilyAvailable } from "./tavily.js";
+import { isYouAvailable } from "./you.js";
 import { isFirecrawlAvailable } from "./firecrawl.js";
 import { isJinaSearchAvailable } from "./jina-search.js";
 import { isSerpdiveAvailable } from "./serpdive.js";
@@ -53,6 +51,7 @@ import { isKagiAvailable } from "./kagi.js";
 import { isBochaAvailable } from "./bocha.js";
 import { isOllamaAvailable } from "./ollama.js";
 import { isSearXNGAvailable } from "./searxng.js";
+import { isDegoogAvailable } from "./degoog.js";
 import { isDuckDuckGoAvailable } from "./duckduckgo.js";
 import { isAnySearchAvailable } from "./anysearch.js";
 import { isXaiSearchAvailable } from "./xai-search.js";
@@ -63,19 +62,40 @@ import { isSerpBaseAvailable } from "./serpbase.js";
 import { isSerpApiAvailable } from "./serpapi.js";
 import { isSerperAvailable } from "./serper.js";
 import { isSerplyAvailable } from "./serply.js";
+import { isKeenableAvailable } from "./keenable.js";
+import { isCeramicAvailable } from "./ceramic.js";
 import { isBaizhiAvailable } from "./baizhi.js";
+import { isZaiAvailable } from "./zai.js";
 import { isValyuAvailable } from "./valyu.js";
 import { isXcrawlAvailable } from "./xcrawl.js";
 import { buildSearchErrorPlan } from "./render-search-error.js";
-import { findModelWithProviderRouting, loadEnabledModelPatterns, modelMatchesEnabledPatterns, splitThinkingSuffix } from "./summary-model-scope.js";
+import { findModelWithProviderRouting, getDmScopedModels, isModelInScope, splitThinkingSuffix } from "./summary-model-scope.js";
 import { registerCuratorRunLifecycle, resolveWebSearchWorkflow } from "./curator-run.js";
-import {
-  buildResearchArtifact,
-  withClaimAssessment,
-  storeResearchArtifact,
-  getResearchArtifact
-} from "./source-check.js";
 import { registerWebToolActivation } from "./tool-activation.js";
+import {
+  createWebToolCore,
+  DEFAULT_TOOL_NAMES,
+  expandQueryString,
+  fetchAllContent,
+  fetchUncoveredContent,
+  getMaxInlineContentChars,
+  isToolEnabled,
+  loadConfig,
+  markToolError,
+  normalizeProviderInput,
+  normalizeQueryList,
+  normalizeRecencyFilter,
+  parseConfigRoot,
+  registeredFetchToolNames,
+  resolveFetchModeConfig,
+  resolveRequestedProvider,
+  runSearchQueries,
+  storedContentSourceNames,
+  stripThumbnails,
+  toCuratorProvider,
+  WEB_SEARCH_CONFIG_PATH,
+  withRegisteredFetchOptions
+} from "./web-tool-core.js";
 function StringEnum(values, options) {
   return Type.Unsafe({
     type: "string",
@@ -84,22 +104,31 @@ function StringEnum(values, options) {
     ...options?.default && { default: options.default }
   });
 }
-const WEB_SEARCH_CONFIG_PATH = getWebSearchConfigPath();
-let extractModulePromise;
-async function fetchAllContent(urls, signal, options) {
-  const extractModule = await (extractModulePromise ??= import("./extract.js"));
-  return extractModule.fetchAllContent(urls, signal, options);
-}
-function withRegisteredFetchOptions(options, toolNames, proxy) {
-  return {
-    ...options ?? {},
-    toolNames,
-    ...proxy !== undefined ? { proxy } : {}
-  };
-}
-function isAbortError(err) {
-  return (err instanceof Error ? err.message : String(err)).toLowerCase().includes("abort");
-}
+const nullableString = (description) => Type.Union([Type.String(), Type.Null()], { description });
+const webSearchOutputSchema = Type.Object({
+  responseId: Type.String({ description: "Id of the stored search results" }),
+  fetchId: nullableString("Stored page content id when includeContent fetched or started fetching content, else null"),
+  queries: Type.Array(Type.Object({
+    query: Type.String(),
+    answer: Type.String({ description: "Provider answer text, empty when the provider returned only results" }),
+    error: nullableString("Why this query failed, null on success"),
+    provider: Type.Optional(Type.String()),
+    providers: Type.Optional(Type.Array(Type.String())),
+    results: Type.Array(Type.Object({ title: Type.String(), url: Type.String(), snippet: Type.String() }))
+  }))
+});
+const fetchContentOutputSchema = Type.Object({
+  responseId: nullableString("Id of the stored content, null when nothing was stored"),
+  urls: Type.Array(Type.Object({
+    url: Type.String(),
+    title: Type.String(),
+    content: Type.String({ description: "Full extracted content, not limited by the inline character cap" }),
+    error: nullableString("Why this URL failed, null on success"),
+    mimeType: Type.Optional(Type.String()),
+    status: Type.Optional(Type.Number()),
+    duration: Type.Optional(Type.Number())
+  }))
+});
 function renderSearchErrorPlan(plan, expanded, theme) {
   if (expanded) {
     return new Text(plan.expanded.map((l, i) => i === 0 ? theme.fg("error", l) : theme.fg("toolOutput", l)).join(`
@@ -115,24 +144,6 @@ function renderSearchErrorPlan(plan, expanded, theme) {
   }
   return box;
 }
-function parseConfigRoot(raw) {
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to parse ${WEB_SEARCH_CONFIG_PATH}: ${message}`);
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`Invalid config in ${WEB_SEARCH_CONFIG_PATH}: expected a JSON object`);
-  }
-  return parsed;
-}
-function loadConfig() {
-  if (!existsSync(WEB_SEARCH_CONFIG_PATH))
-    return {};
-  return parseConfigRoot(readFileSync(WEB_SEARCH_CONFIG_PATH, "utf-8"));
-}
 function saveConfig(updates) {
   let config = {};
   if (existsSync(WEB_SEARCH_CONFIG_PATH)) {
@@ -145,45 +156,17 @@ function saveConfig(updates) {
   writeFileSync(WEB_SEARCH_CONFIG_PATH, JSON.stringify(config, null, 2) + `
 `);
 }
-const DEFAULT_TOOL_NAMES = {
-  webSearch: "web_search",
-  sourceCheck: "source_check",
-  fetchContent: "fetch_content",
-  getSearchContent: "get_search_content"
-};
 const TOOL_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
 const DEFAULT_SHORTCUTS = { curate: "ctrl+shift+s", activity: "ctrl+shift+w" };
 const DEFAULT_CURATOR_TIMEOUT_SECONDS = 20;
 const DEFAULT_REMOTE_CURATOR_TIMEOUT_SECONDS = 60;
 const MAX_CURATOR_TIMEOUT_SECONDS = 600;
 const MAX_SUMMARY_GENERATION_DEADLINE_MS = 600000;
-const SEARCH_QUERY_CONCURRENCY = 3;
-const FETCH_MODES = ["readable", "raw", "answer"];
 const FETCH_MODE_DESCRIPTIONS = {
   readable: "extract readable content as markdown",
   raw: "return the exact textual body using direct HTTP only",
   answer: "answer a prompt using only fetched content"
 };
-function resolveFetchModeConfig(config) {
-  const configuredModes = config.fetch?.allowedModes ?? FETCH_MODES;
-  if (!Array.isArray(configuredModes) || configuredModes.length === 0 || configuredModes.some((mode) => !FETCH_MODES.includes(mode))) {
-    throw new Error(`fetch.allowedModes in ${WEB_SEARCH_CONFIG_PATH} must be a non-empty array containing only "readable", "raw", or "answer"`);
-  }
-  const allowedModes = configuredModes;
-  const duplicateMode = allowedModes.find((mode, index) => allowedModes.indexOf(mode) !== index);
-  if (duplicateMode) {
-    throw new Error(`fetch.allowedModes in ${WEB_SEARCH_CONFIG_PATH} must not contain duplicates: "${duplicateMode}"`);
-  }
-  const defaultMode = config.fetch?.defaultMode ?? "readable";
-  if (!allowedModes.includes(defaultMode)) {
-    throw new Error(`fetch.defaultMode in ${WEB_SEARCH_CONFIG_PATH} must be one of fetch.allowedModes`);
-  }
-  return { defaultMode, allowedModes };
-}
-function runSearchQueries(queries, run) {
-  const limit = pLimit(SEARCH_QUERY_CONCURRENCY);
-  return Promise.all(queries.map((query, index) => limit(() => run(query, index))));
-}
 function curatorResultIndex(queryIndex, entryIndex, queryCount) {
   return entryIndex * queryCount + queryIndex;
 }
@@ -196,24 +179,9 @@ function searchProviderSchema(description, allowedProviders) {
     Type.Array(StringEnum([...allowedProviders]), { minItems: 1 })
   ], { description });
 }
-function isToolEnabled(config, key) {
-  const override = config.tools?.[key]?.enabled;
-  if (typeof override === "boolean")
-    return override;
-  return key !== "webSearch" && key !== "sourceCheck" || config.webSearch?.enabled !== false;
-}
 function isCommandEnabled(config, name) {
   return config.commands?.[name]?.enabled !== false;
 }
-function joinToolNames(names) {
-  if (names.length === 0)
-    return "stored content";
-  if (names.length === 1)
-    return names[0];
-  if (names.length === 2)
-    return `${names[0]} or ${names[1]}`;
-  return `${names.slice(0, -1).join(", ")}, or ${names[names.length - 1]}`;
-}
 function resolveToolNames(config) {
   if (config.toolNames !== undefined && (!config.toolNames || typeof config.toolNames !== "object" || Array.isArray(config.toolNames))) {
     throw new Error(`toolNames in ${WEB_SEARCH_CONFIG_PATH} must be an object`);
@@ -253,36 +221,12 @@ function loadConfigForExtensionInit() {
     return {};
   }
 }
-function normalizeProviderInput(value, label = "provider") {
-  if (value === undefined)
-    return;
-  return normalizeSearchProviderSelection(value, label);
-}
-function resolveRequestedProvider(requested) {
-  const normalizedRequested = normalizeProviderInput(requested);
-  if (normalizedRequested && normalizedRequested !== "auto") {
-    assertSearchProviderSelectionAllowed(normalizedRequested, "Requested provider");
-    return normalizedRequested;
-  }
-  const config = loadConfig();
-  const provider = normalizeProviderInput(config.searchProvider ?? config.provider, `provider in ${WEB_SEARCH_CONFIG_PATH}`) ?? "auto";
-  assertSearchProviderSelectionAllowed(provider, `configured provider in ${WEB_SEARCH_CONFIG_PATH}`);
-  return provider;
-}
-function toCuratorProvider(provider) {
-  if (Array.isArray(provider))
-    return "all";
-  return provider === "auto" ? undefined : provider;
-}
 function resolveCuratorSearchProvider(requested, current) {
   const normalized = normalizeProviderInput(requested);
   if (!normalized || normalized === "auto")
     return current;
   return normalized === "all" && Array.isArray(current) ? current : normalized;
 }
-function normalizeRecencyFilter(value) {
-  return value === "day" || value === "week" || value === "month" || value === "year" ? value : undefined;
-}
 function normalizeCuratorTimeoutSeconds(value) {
   if (typeof value !== "number" || !Number.isFinite(value))
     return;
@@ -291,31 +235,6 @@ function normalizeCuratorTimeoutSeconds(value) {
     return;
   return Math.min(normalized, MAX_CURATOR_TIMEOUT_SECONDS);
 }
-function normalizeQueryList(queryList) {
-  const normalized = [];
-  for (const query of queryList) {
-    if (typeof query !== "string")
-      continue;
-    const trimmed = query.trim();
-    if (trimmed.length > 0)
-      normalized.push(trimmed);
-  }
-  return normalized;
-}
-function expandQueryString(query) {
-  if (typeof query !== "string")
-    return [];
-  const trimmed = query.trim();
-  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (Array.isArray(parsed) && parsed.every((entry) => typeof entry === "string")) {
-        return parsed.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-      }
-    } catch {}
-  }
-  return [query];
-}
 function getCuratorTimeoutSeconds() {
   const source = loadConfig();
   const explicit = normalizeCuratorTimeoutSeconds(source.curatorTimeoutSeconds);
@@ -330,6 +249,13 @@ export function getSummaryGenerationDeadlineMs() {
   }
   return Math.min(value, MAX_SUMMARY_GENERATION_DEADLINE_MS);
 }
+export function getSummaryInstructions() {
+  const value = loadConfig().summaryInstructions;
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
 function shouldAutoOpenCuratorBrowser(config) {
   if (config.autoOpenBrowser === false)
     return false;
@@ -351,6 +277,7 @@ async function getProviderAvailability(ctx) {
     searchinfinity: allowedProviders.has("searchinfinity") && isSearchinfinityAvailable(),
     querit: allowedProviders.has("querit") && isQueritAvailable(),
     tavily: allowedProviders.has("tavily") && isTavilyAvailable(),
+    you: allowedProviders.has("you") && isYouAvailable(),
     firecrawl: allowedProviders.has("firecrawl") && isFirecrawlAvailable(),
     jina: allowedProviders.has("jina") && isJinaSearchAvailable(),
     serpdive: allowedProviders.has("serpdive") && isSerpdiveAvailable(),
@@ -358,6 +285,7 @@ async function getProviderAvailability(ctx) {
     bocha: allowedProviders.has("bocha") && isBochaAvailable(),
     ollama: allowedProviders.has("ollama") && isOllamaAvailable(),
     searxng: allowedProviders.has("searxng") && isSearXNGAvailable(),
+    degoog: allowedProviders.has("degoog") && isDegoogAvailable(),
     duckduckgo: allowedProviders.has("duckduckgo") && isDuckDuckGoAvailable(),
     perplexity: allowedProviders.has("perplexity") && isPerplexityAvailable(),
     exa: allowedProviders.has("exa") && isExaAvailable(),
@@ -373,7 +301,10 @@ async function getProviderAvailability(ctx) {
     serper: allowedProviders.has("serper") && isSerperAvailable(),
     serply: allowedProviders.has("serply") && isSerplyAvailable(),
     baizhi: allowedProviders.has("baizhi") && isBaizhiAvailable(),
-    valyu: allowedProviders.has("valyu") && isValyuAvailable()
+    zai: allowedProviders.has("zai") && isZaiAvailable(),
+    valyu: allowedProviders.has("valyu") && isValyuAvailable(),
+    keenable: allowedProviders.has("keenable") && isKeenableAvailable(),
+    ceramic: allowedProviders.has("ceramic") && isCeramicAvailable()
   };
   return {
     all: ALL_SEARCH_PROVIDERS.some((provider) => provider === "gemini" ? geminiApiAvail : providers[provider]),
@@ -387,9 +318,6 @@ async function getOptionalGeminiWebAvailability() {
     return null;
   }
 }
-function shouldUseOpenAICodexDefault(ctx) {
-  return ctx?.model?.provider === "openai-codex";
-}
 function shouldPreferOpenAI(options, preferOpenAICodexDefault) {
   if (options?.recencyFilter)
     return false;
@@ -410,7 +338,7 @@ async function loadCuratorBootstrap(requestedProvider, ctx, options) {
   };
 }
 export function resolveCuratorDefaultProvider(provider, available, ctx, options) {
-  return resolveProvider(provider, available, options, shouldUseOpenAICodexDefault(ctx), ctx);
+  return resolveProvider(provider, available, options, isOpenAISubscriptionModelSelected(ctx), ctx);
 }
 function firstAvailableProvider(available, preferOpenAI, fallback) {
   if (available.searxng)
@@ -453,210 +381,11 @@ function resolveProvider(provider, available, options, preferOpenAICodexDefault
   }
   return provider;
 }
-const pendingFetches = new Map;
-let sessionActive = false;
 let widgetVisible = false;
 let widgetUnsubscribe = null;
 const pendingCurates = new Map;
 const activeCurators = new Map;
 const glimpseWins = new Map;
-const DEFAULT_MAX_INLINE_CONTENT_CHARS = 30000;
-const MIN_INLINE_CONTENT_CHARS = 1000;
-const MAX_INLINE_CONTENT_CHARS = 200000;
-function getMaxInlineContentChars(config = loadConfig()) {
-  const value = config.maxInlineContentChars;
-  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < MIN_INLINE_CONTENT_CHARS) {
-    return DEFAULT_MAX_INLINE_CONTENT_CHARS;
-  }
-  return Math.min(value, MAX_INLINE_CONTENT_CHARS);
-}
-function stripThumbnails(results) {
-  return results.map(({ thumbnail, frames, ...rest }) => rest);
-}
-function storeFetchResult(pi, responseId, data, authProfile) {
-  if (authProfile?.cache === "off")
-    return false;
-  pi.appendEntry("web-search-results", storeFetchedContentResult(responseId, data));
-  return true;
-}
-function initialContentSlice(content, maxChars) {
-  let endOffset = Math.min(content.length, maxChars);
-  if (endOffset < content.length) {
-    const lineBreak = content.lastIndexOf(`
-`, endOffset);
-    if (lineBreak >= Math.floor(maxChars * 0.8))
-      endOffset = lineBreak + 1;
-  }
-  const text = content.slice(0, endOffset);
-  return {
-    text,
-    endOffset,
-    totalBytes: Buffer.byteLength(content),
-    totalLines: content.length === 0 ? 0 : content.split(`
-`).length,
-    shownBytes: Buffer.byteLength(text),
-    shownLines: text.length === 0 ? 0 : text.split(`
-`).length
-  };
-}
-function normalizeFindQueries(value) {
-  const queries = (Array.isArray(value) ? value : [value]).map((query) => query.trim()).filter(Boolean);
-  if (queries.length === 0)
-    throw new Error("findText must contain at least one non-empty string");
-  return queries;
-}
-function normalizeFindMode(value) {
-  if (value === undefined)
-    return;
-  if (value === "exact" || value === "case-insensitive" || value === "fuzzy")
-    return value;
-  throw new Error('findMode must be "exact", "case-insensitive", or "fuzzy"');
-}
-function normalizeGetSearchContentParams(params) {
-  const normalized = { ...params, findMode: normalizeFindMode(params.findMode) };
-  if (normalized.query?.trim() === "")
-    delete normalized.query;
-  if (normalized.url?.trim() === "")
-    delete normalized.url;
-  if (normalized.findText !== undefined) {
-    delete normalized.offset;
-    delete normalized.limit;
-  }
-  return normalized;
-}
-function formatInputValue(value) {
-  if (typeof value === "string")
-    return JSON.stringify(value);
-  if (typeof value === "number")
-    return Number.isNaN(value) ? "NaN" : String(value);
-  try {
-    const serialized = JSON.stringify(value);
-    return serialized === undefined ? String(value) : serialized;
-  } catch {
-    return String(value);
-  }
-}
-function formatSearchSummary(results, answer) {
-  if (results.length === 0) {
-    return answer ? `${answer}
-
----
-
-**Sources:**
-No sources returned.` : "No results found.";
-  }
-  let output = answer ? `${answer}
-
----
-
-**Sources:**
-` : "";
-  output += results.map((r, i) => `${i + 1}. ${r.title}
-   ${r.url}`).join(`
-
-`);
-  return output;
-}
-function formatSourceCheckResult(artifact, getSearchContentTool = DEFAULT_TOOL_NAMES.getSearchContent) {
-  const assessment = artifact.claims?.[0];
-  const lines = [`# Source check: ${artifact.query}`, ""];
-  if (assessment) {
-    lines.push(`**Status:** ${assessment.status} (confidence ${assessment.confidence.toFixed(2)})`);
-    lines.push(`**Rationale:** ${assessment.rationale}`);
-    if (assessment.supporting_passages.length > 0)
-      lines.push(`**Supporting passages:** ${assessment.supporting_passages.join(", ")}`);
-    if (assessment.contradicting_passages.length > 0)
-      lines.push(`**Contradicting passages:** ${assessment.contradicting_passages.join(", ")}`);
-    lines.push("");
-  }
-  if (artifact.sources.length > 0) {
-    lines.push("## Sources");
-    for (const source of artifact.sources)
-      lines.push(`${source.rank}. [${source.quality}] ${source.title}
-   ${source.url}`);
-    lines.push("");
-  }
-  if (artifact.errors?.length)
-    lines.push(`Search errors: ${artifact.errors.map((entry) => `${entry.query}: ${entry.error}`).join("; ")}`);
-  lines.push(getSearchContentTool ? `Artifact responseId: ${artifact.id} (retrievable via ${getSearchContentTool}).` : `Artifact responseId: ${artifact.id}. Content retrieval is not registered.`);
-  return lines.join(`
-`);
-}
-function duplicateQuerySet(results) {
-  const counts = new Map;
-  for (const result of results) {
-    counts.set(result.query, (counts.get(result.query) ?? 0) + 1);
-  }
-  const duplicates = new Set;
-  for (const [query, count] of counts) {
-    if (count > 1)
-      duplicates.add(query);
-  }
-  return duplicates;
-}
-function formatQueryHeader(query, provider, duplicateQueries) {
-  const suffix = duplicateQueries.has(query) && provider ? ` (${provider})` : "";
-  return `## Query: "${query}"${suffix}
-
-`;
-}
-function hasFullInlineCoverage(urls, inlineContent) {
-  if (!inlineContent || inlineContent.length === 0)
-    return false;
-  const coveredUrls = new Set(inlineContent.map((c) => c.url));
-  return urls.every((url) => coveredUrls.has(url));
-}
-function formatFullResults(queryData) {
-  let output = `## Results for: "${queryData.query}"
-
-`;
-  const providers = queryData.providers ?? (queryData.provider ? [queryData.provider] : []);
-  if (providers.length > 0)
-    output += `**Provider${providers.length === 1 ? "" : "s"}:** ${providers.join(", ")}
-
-`;
-  if (queryData.answer) {
-    output += `${queryData.answer}
-
----
-
-`;
-  }
-  for (const r of queryData.results) {
-    output += `### ${r.title}
-${r.url}${r.snippet ? `
-
-${r.snippet}` : ""}
-
-`;
-  }
-  return output;
-}
-function boundSearchPresentation(text, guidance, truncationGuidance, maxChars) {
-  const fullText = `${text}${guidance}`;
-  if (fullText.length <= maxChars) {
-    return { text: fullText, truncated: false, originalChars: text.length, returnedChars: text.length, omittedChars: 0 };
-  }
-  const marker = `
-
----
-[Output truncated.]${truncationGuidance}`;
-  const prefixLength = maxChars - marker.length;
-  const bounded = `${text.slice(0, prefixLength)}${marker}`;
-  return {
-    text: bounded,
-    truncated: true,
-    originalChars: text.length,
-    returnedChars: prefixLength,
-    omittedChars: text.length - prefixLength
-  };
-}
-function abortPendingFetches() {
-  for (const controller of pendingFetches.values()) {
-    controller.abort();
-  }
-  pendingFetches.clear();
-}
 function closeCurator(callId) {
   if (callId !== undefined) {
     const win = glimpseWins.get(callId);
@@ -853,12 +582,9 @@ function formatEntryLine(entry, theme) {
   }
   return `${typeStr.padEnd(4)} ${target.padEnd(32)} ${statusStr.padStart(5)} ${duration.padStart(5)} ${indicator}`;
 }
-function handleSessionChange(ctx) {
-  abortPendingFetches();
+const liveInstances = new Map;
+function refreshUi(ctx) {
   closeCurator();
-  clearCloneCache();
-  sessionActive = true;
-  restoreFromSession(ctx);
   widgetUnsubscribe?.();
   widgetUnsubscribe = null;
   activityMonitor.clear();
@@ -870,6 +596,10 @@ function handleSessionChange(ctx) {
 export default function dm_web_access_default(pi) {
   const initConfig = loadConfigForExtensionInit();
   const fetchModeConfig = resolveFetchModeConfig(initConfig);
+  const toolActivation = initConfig.toolActivation ?? "auto";
+  if (toolActivation !== "auto" && toolActivation !== "dynamic" && toolActivation !== "eager") {
+    throw new Error(`toolActivation in ${WEB_SEARCH_CONFIG_PATH} must be "auto", "dynamic", or "eager"`);
+  }
   const allowedSearchProviders = initConfig.webSearch?.allowedProviders === undefined ? RESOLVED_SEARCH_PROVIDERS : getAllowedSearchProviders();
   const allEligibleProviders = allowedSearchProviders.filter((provider) => ALL_SEARCH_PROVIDERS.includes(provider));
   const allExcludedProviders = allowedSearchProviders.filter((provider) => !ALL_SEARCH_PROVIDERS.includes(provider));
@@ -880,27 +610,72 @@ export default function dm_web_access_default(pi) {
   const sourceCheckEnabled = isToolEnabled(initConfig, "sourceCheck");
   const fetchContentEnabled = isToolEnabled(initConfig, "fetchContent");
   const getSearchContentEnabled = isToolEnabled(initConfig, "getSearchContent");
-  const registeredToolNames = {
-    ...webSearchEnabled ? { webSearch: toolNames.webSearch } : {},
-    ...fetchContentEnabled ? { fetchContent: toolNames.fetchContent } : {}
+  const coreSettings = {
+    toolNames,
+    enabledTools: {
+      webSearch: webSearchEnabled,
+      sourceCheck: sourceCheckEnabled,
+      fetchContent: fetchContentEnabled,
+      getSearchContent: getSearchContentEnabled
+    },
+    maxInlineContentChars: getMaxInlineContentChars(initConfig),
+    fetchModes: fetchModeConfig
   };
-  const storedContentSources = joinToolNames([
-    ...webSearchEnabled ? [toolNames.webSearch] : [],
-    ...sourceCheckEnabled ? [toolNames.sourceCheck] : [],
-    ...fetchContentEnabled ? [toolNames.fetchContent] : []
-  ]);
+  const registeredToolNames = registeredFetchToolNames(coreSettings);
+  const storedContentSources = storedContentSourceNames(coreSettings);
   const searchQueryDescription = webSearchEnabled ? `Get content for this query (${toolNames.webSearch})` : "Get content for a stored search query";
   const fetchContentStorageNote = getSearchContentEnabled ? `Full original content is stored for retrieval with ${toolNames.getSearchContent}.` : "Full original content is stored internally, but the retrieval tool is not registered.";
   const fetchModeDescription = fetchModeConfig.allowedModes.map((mode) => `${mode}${mode === fetchModeConfig.defaultMode ? " (default)" : ""}: ${FETCH_MODE_DESCRIPTIONS[mode]}`).join("; ");
   const curateKey = initConfig.shortcuts?.curate || DEFAULT_SHORTCUTS.curate;
   const activityKey = initConfig.shortcuts?.activity || DEFAULT_SHORTCUTS.activity;
-  function startBackgroundFetch(urls, proxy) {
+  const instance = {};
+  const pendingFetches = new Map;
+  let sessionActive = false;
+  const ownedResults = new Set;
+  function abortPendingFetches() {
+    for (const controller of pendingFetches.values()) {
+      controller.abort();
+    }
+    pendingFetches.clear();
+  }
+  function own(id) {
+    if (ownedResults.has(id))
+      return;
+    ownedResults.add(id);
+    holdResults([id]);
+  }
+  function publish(data) {
+    own(data.id);
+    pi.appendEntry("web-search-results", data);
+  }
+  function endSession() {
+    sessionActive = false;
+    abortPendingFetches();
+    releaseResults(ownedResults);
+    ownedResults.clear();
+    liveInstances.delete(instance);
+    if (liveInstances.size === 0)
+      clearCloneCache();
+    else
+      releaseClonesUnusedSince(Math.min(...liveInstances.values()));
+  }
+  function startSession(ctx) {
+    endSession();
+    liveInstances.set(instance, Date.now());
+    sessionActive = true;
+    const restored = loadSessionResults(ctx);
+    for (const data of restored)
+      own(data.id);
+    touchClones(restored.flatMap((data) => data.type === "fetch" ? (data.urls ?? data.urlMetadata ?? []).map((u) => u.url) : []));
+    refreshUi(ctx);
+  }
+  function startBackgroundFetch(urls, proxy, provided) {
     if (urls.length === 0)
       return null;
     const fetchId = generateId();
     const controller = new AbortController;
     pendingFetches.set(fetchId, controller);
-    Promise.resolve().then(() => runWithProxy(proxy, () => fetchAllContent(urls, controller.signal, withRegisteredFetchOptions(undefined, registeredToolNames, proxy)))).then((fetched) => {
+    Promise.resolve().then(() => fetchUncoveredContent(urls, provided, (missing) => runWithProxy(proxy, () => fetchAllContent(missing, controller.signal, withRegisteredFetchOptions(undefined, registeredToolNames, proxy))))).then((fetched) => {
       if (!sessionActive || !pendingFetches.has(fetchId))
         return;
       const data = {
@@ -909,7 +684,7 @@ export default function dm_web_access_default(pi) {
         timestamp: Date.now(),
         urls: stripThumbnails(fetched)
       };
-      pi.appendEntry("web-search-results", storeFetchedContentResult(fetchId, data));
+      publish(storeFetchedContentResult(fetchId, data));
       const ok = fetched.filter((f) => !f.error).length;
       const availability = ok === fetched.length ? "Full page content now available." : ok > 0 ? "Partial page content now available." : "No page content was fetched. Stored fetch diagnostics are available.";
       pi.sendMessage({
@@ -934,18 +709,18 @@ export default function dm_web_access_default(pi) {
     });
     return fetchId;
   }
-  function storeAndPublishSearch(results) {
-    const id = generateId();
-    const data = {
-      id,
-      type: "search",
-      timestamp: Date.now(),
-      queries: results
-    };
-    storeResult(id, data);
-    pi.appendEntry("web-search-results", data);
-    return id;
-  }
+  const core = createWebToolCore({
+    settings: coreSettings,
+    storeFetchedContent(id, data) {
+      publish(storeFetchedContentResult(id, data));
+    },
+    publishResult(data) {
+      publish(data);
+    },
+    startBackgroundFetch,
+    answerFromPage: (request, ctx, signal) => answerFromPage(request, ctx, signal)
+  });
+  const buildSearchReturn = core.buildSearchReturn;
   function normalizeSummaryMeta(meta, summaryText) {
     const normalizedText = summaryText.trim();
     if (!meta) {
@@ -1005,7 +780,7 @@ export default function dm_web_access_default(pi) {
       throw new Error("No selected results available for summary generation");
     }
     try {
-      return await generateSummaryDraft(selectedResults, summaryContext, signal, modelOverride, feedback, undefined, getSummaryGenerationDeadlineMs());
+      return await generateSummaryDraft(selectedResults, summaryContext, signal, modelOverride, feedback, undefined, getSummaryGenerationDeadlineMs(), getSummaryInstructions());
     } catch (err) {
       const isEmptyResponse = err instanceof Error && err.message.includes("Summary model returned empty response");
       if (!isEmptyResponse)
@@ -1031,25 +806,14 @@ export default function dm_web_access_default(pi) {
       seen.add(value);
       summaryModels.push({ value, label: value });
     };
-    let enabledModelPatterns = null;
-    let scopeLoaded = true;
-    try {
-      enabledModelPatterns = loadEnabledModelPatterns(summaryContext);
-      const availableModels = summaryContext.modelRegistry.getAvailable();
-      for (const model of availableModels) {
-        if (!modelMatchesEnabledPatterns(model, enabledModelPatterns))
-          continue;
-        const value = `${model.provider}/${model.id}`;
-        availableValues.add(value);
-        addModel(model.provider, model.id);
-      }
-    } catch (err) {
-      scopeLoaded = false;
-      const message = err instanceof Error ? err.message : String(err);
-      console.error(`Failed to load summary models: ${message}`);
+    for (const model of summaryContext.modelRegistry.getAvailable()) {
+      if (!isModelInScope(model, summaryContext.scopedModels))
+        continue;
+      availableValues.add(`${model.provider}/${model.id}`);
+      addModel(model.provider, model.id);
     }
     const currentModelValue = summaryContext.model ? `${summaryContext.model.provider}/${summaryContext.model.id}` : null;
-    if (scopeLoaded && summaryContext.model && currentModelValue && !seen.has(currentModelValue) && modelMatchesEnabledPatterns(summaryContext.model, enabledModelPatterns)) {
+    if (summaryContext.model && currentModelValue && !seen.has(currentModelValue) && isModelInScope(summaryContext.model, summaryContext.scopedModels)) {
       addModel(summaryContext.model.provider, summaryContext.model.id);
     }
     const config = loadConfig();
@@ -1080,10 +844,10 @@ export default function dm_web_access_default(pi) {
       return selector;
     };
     let defaultSummaryModel = null;
-    if (scopeLoaded && configuredSummaryModel.length > 0) {
+    if (configuredSummaryModel.length > 0) {
       defaultSummaryModel = availableValues.has(configuredSummaryModel) ? configuredSummaryModel : resolveAvailableModelValue(configuredSummaryModel);
     }
-    if (scopeLoaded && !defaultSummaryModel) {
+    if (!defaultSummaryModel) {
       for (const preferred of preferredDefaults) {
         const model = findModelWithProviderRouting(summaryContext.modelRegistry, preferred.provider, preferred.id);
         const value = model ? `${model.provider}/${model.id}` : null;
@@ -1111,130 +875,6 @@ export default function dm_web_access_default(pi) {
       summaryMeta: deterministic.meta
     };
   }
-  function buildSearchReturn(opts) {
-    const sc = opts.results.filter((r) => !r.error).length;
-    const tr = opts.results.reduce((sum, r) => sum + r.results.length, 0);
-    const hasApprovedSummary = typeof opts.approvedSummary === "string" && opts.approvedSummary.trim().length > 0;
-    const maxInlineContentChars = getMaxInlineContentChars(initConfig);
-    let output = "";
-    if (hasApprovedSummary) {
-      output = opts.approvedSummary.trim();
-    } else {
-      if (opts.curated) {
-        output += `[These results were manually curated by the user in the browser. Use them as-is — do not re-search or discard.]
-
-`;
-      }
-      const providerNames = opts.results.map((result) => {
-        const providers = result.providers ?? (result.provider ? [result.provider] : []);
-        return providers.join(", ") || "unknown";
-      });
-      output += opts.results.length === 1 ? `**Provider:** ${providerNames[0]}
-
-` : `**Providers used:** ${providerNames.map((name, index) => `Query ${index + 1}: ${name}`).join("; ")}
-
-`;
-      const duplicateQueries = opts.curated ? duplicateQuerySet(opts.results) : new Set;
-      for (const { query, answer, results, error, provider } of opts.results) {
-        if (opts.queryList.length > 1) {
-          output += opts.curated ? formatQueryHeader(query, provider, duplicateQueries) : `## Query: "${query}"
-
-`;
-        }
-        if (error)
-          output += `Error: ${error}
-
-`;
-        else
-          output += formatSearchSummary(results, answer) + `
-
-`;
-      }
-    }
-    const hasInlineReady = hasFullInlineCoverage(opts.urls, opts.inlineContent);
-    let fetchId = null;
-    if (hasInlineReady && opts.inlineContent) {
-      fetchId = generateId();
-      const data = {
-        id: fetchId,
-        type: "fetch",
-        timestamp: Date.now(),
-        urls: opts.inlineContent
-      };
-      pi.appendEntry("web-search-results", storeFetchedContentResult(fetchId, data));
-    } else if (opts.includeContent) {
-      fetchId = startBackgroundFetch(opts.urls, opts.proxy);
-    }
-    const searchId = storeAndPublishSearch(opts.results);
-    const isBackgroundFetch = fetchId !== null && !hasInlineReady;
-    const unboundedPresentation = output.trim();
-    const buildGuidance = (forTruncation) => {
-      let value = "";
-      if (hasInlineReady && opts.inlineContent && fetchId) {
-        value += `
----
-Full content for ${opts.inlineContent.length} sources is ready as responseId "${fetchId}". `;
-        value += getSearchContentEnabled ? `Use ${toolNames.getSearchContent}({ responseId: "${fetchId}", urlIndex: 0, offset: 0, limit: ${maxInlineContentChars} }) to retrieve the first bounded page.` : forTruncation ? `Enable ${toolNames.getSearchContent} to retrieve the full stored content.` : "";
-      } else if (isBackgroundFetch && fetchId) {
-        value += `
----
-Content fetching in background as responseId "${fetchId}". Will notify when ready.`;
-      }
-      if (getSearchContentEnabled || forTruncation) {
-        value += `
----
-Full search results are stored as responseId "${searchId}". `;
-        value += getSearchContentEnabled ? `Use ${toolNames.getSearchContent}({ responseId: "${searchId}", queryIndex: 0, offset: 0, limit: ${maxInlineContentChars} }) to retrieve the first bounded page${opts.results.length > 1 ? `; repeat with queryIndex 1 through ${opts.results.length - 1}` : ""}.` : `Enable ${toolNames.getSearchContent} to retrieve the full stored results.`;
-      }
-      return value;
-    };
-    const presentation = hasApprovedSummary ? { text: unboundedPresentation, truncated: false, originalChars: unboundedPresentation.length, returnedChars: unboundedPresentation.length, omittedChars: 0 } : boundSearchPresentation(unboundedPresentation, buildGuidance(false), buildGuidance(true), maxInlineContentChars);
-    return {
-      content: [{ type: "text", text: presentation.text }],
-      details: {
-        queries: opts.queryList,
-        queryCount: opts.queryList.length,
-        successfulQueries: sc,
-        totalResults: tr,
-        includeContent: opts.includeContent,
-        fetchId,
-        fetchUrls: isBackgroundFetch ? opts.urls : undefined,
-        searchId,
-        queryProviders: opts.results.map((result) => ({
-          query: result.query,
-          providers: result.providers ?? (result.provider ? [result.provider] : [])
-        })),
-        truncated: presentation.truncated,
-        originalChars: presentation.originalChars,
-        returnedChars: presentation.returnedChars,
-        omittedChars: presentation.omittedChars,
-        ...opts.curated ? {
-          curated: true,
-          curatedFrom: opts.curatedFrom,
-          curatedQueries: opts.results.map((r) => ({
-            query: r.query,
-            provider: r.provider || null,
-            answer: r.answer || null,
-            sources: r.results.map((s) => ({ title: s.title, url: s.url })),
-            error: r.error
-          }))
-        } : {},
-        ...opts.workflow && hasApprovedSummary ? {
-          summary: {
-            text: opts.approvedSummary.trim(),
-            workflow: opts.workflow,
-            model: opts.summaryMeta?.model ?? null,
-            durationMs: opts.summaryMeta?.durationMs ?? 0,
-            tokenEstimate: opts.summaryMeta?.tokenEstimate ?? 0,
-            fallbackUsed: opts.summaryMeta?.fallbackUsed === true,
-            fallbackReason: opts.summaryMeta?.fallbackReason,
-            phase: opts.summaryMeta?.phase,
-            edited: opts.summaryMeta?.edited === true
-          }
-        } : {}
-      }
-    };
-  }
   function filterByQueryIndices(selectedQueryIndices, results) {
     const filteredResults = [];
     const filteredUrls = [];
@@ -1405,6 +1045,7 @@ Open manually: ${handle.url}` }],
               recencyFilter: pc.recencyFilter,
               domainFilter: pc.domainFilter,
               includeContent: pc.includeContent,
+              category: pc.category,
               signal: addSearchSignal,
               extensionContext: ctx
             });
@@ -1524,14 +1165,24 @@ Open manually: ${handle.url}` }],
       }
     }
   });
-  pi.on("session_start", async (_event, ctx) => handleSessionChange(ctx));
-  pi.on("session_tree", async (_event, ctx) => handleSessionChange(ctx));
+  const nestedSearchCallIds = new Set;
+  if (webSearchEnabled)
+    pi.on("tool_call", (event) => {
+      if ("parentToolCallId" in event && event.parentToolCallId && event.toolName === toolNames.webSearch)
+        nestedSearchCallIds.add(event.toolCallId);
+    });
+  pi.on("session_start", async (_event, ctx) => {
+    nestedSearchCallIds.clear();
+    startSession(ctx);
+  });
+  pi.on("session_tree", async (_event, ctx) => {
+    nestedSearchCallIds.clear();
+    startSession(ctx);
+  });
   pi.on("session_shutdown", () => {
-    sessionActive = false;
-    abortPendingFetches();
+    nestedSearchCallIds.clear();
+    endSession();
     closeCurator();
-    clearCloneCache();
-    clearResults();
     widgetUnsubscribe?.();
     widgetUnsubscribe = null;
     activityMonitor.clear();
@@ -1541,7 +1192,8 @@ Open manually: ${handle.url}` }],
     pi.registerTool({
       name: toolNames.webSearch,
       label: "Web Search",
-      description: `Search the web with ${allowedSearchProviders.map(providerLabel).join(", ")}. Provider arrays run simultaneously; ${allPolicyDescription}. The default workflow is none: it returns bounded source-linked search results or provider answers without a curator or generated summary, identifies the providers used, and stores full results for retrieval by responseId. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query. When includeContent is true, full page content is fetched in the background. Set workflow to "summary-review" to open the curator with an auto-generated summary draft or "auto-summary" to generate a summary without the browser curator. The configured provider is used when provider is omitted or set to auto; omit provider unless explicitly overriding it.`,
+      prepareArguments: (args) => parseStringifiedArrays(args, ["provider", "queries", "domainFilter"]),
+      description: `Search the web and return source-linked results or provider answers.${getSearchContentEnabled ? ` Full results are stored for retrieval with ${toolNames.getSearchContent} using the returned responseId.` : ""} For research, prefer queries with 2-4 varied angles over a single query. Omit provider to use the configured default; set it only to override that.`,
       promptSnippet: "Use for web research questions. Prefer {queries:[...]} with 2-4 varied angles over a single query for broader coverage. Omit provider unless explicitly overriding the configured default.",
       parameters: Type.Object({
         query: Type.Optional(Type.String({ description: "Single search query. For research tasks, prefer 'queries' with multiple varied angles instead." })),
@@ -1550,6 +1202,7 @@ Open manually: ${handle.url}` }],
         includeContent: Type.Optional(Type.Boolean({ description: "Fetch full page content (async)" })),
         recencyFilter: Type.Optional(StringEnum(["day", "week", "month", "year"], { description: "Filter by recency" })),
         domainFilter: Type.Optional(Type.Array(Type.String(), { description: "Limit to domains (prefix with - to exclude)" })),
+        category: Type.Optional(Type.String({ description: "Exa only: result category, e.g. news, research paper" })),
         provider: Type.Optional(searchProviderSchema(`Search provider or non-empty list of allowed providers to search simultaneously; ${allPolicyDescription}; omit this field to use the configured provider, or use auto when none is configured`, allowedSearchProviders)),
         workflow: Type.Optional(StringEnum(["none", "summary-review", "auto-summary"], {
           description: "Search workflow mode: none = no curator (default), summary-review = open curator with auto summary draft, auto-summary = generate summary without opening curator"
@@ -1558,12 +1211,14 @@ Open manually: ${handle.url}` }],
           description: "http(s) or socks proxy URL (e.g. http://host:port or socks5h://host:port) used for every outbound request in this call (search APIs and content fetches). Node fetch ignores HTTP(S)_PROXY env vars, so set this (or `proxy` in web-search.json) when direct access is blocked; empty string forces direct access."
         }))
       }),
+      outputSchema: webSearchOutputSchema,
       async execute(callId, params, signal, onUpdate, ctx) {
-        return runWithProxy(typeof params.proxy === "string" ? params.proxy : undefined, async () => {
+        const nested = nestedSearchCallIds.delete(callId);
+        return markToolError(await runWithProxy(typeof params.proxy === "string" ? params.proxy : undefined, async () => {
           const rawQueryList = Array.isArray(params.queries) ? params.queries : params.query !== undefined ? expandQueryString(params.query) : [];
           const queryList = normalizeQueryList(rawQueryList);
           const configWorkflow = loadConfigForExtensionInit().workflow;
-          const workflow = curatorRunState.resolve(params.workflow, configWorkflow, ctx?.hasUI !== false);
+          const workflow = nested && params.workflow === undefined ? "none" : curatorRunState.resolve(params.workflow, configWorkflow, ctx?.hasUI !== false);
           const shouldCurate = workflow === "summary-review";
           const recencyFilter = normalizeRecencyFilter(params.recencyFilter);
           if (queryList.length === 0) {
@@ -1605,8 +1260,7 @@ Open manually: ${handle.url}` }],
               model: ctx.model,
               modelRegistry: ctx.modelRegistry,
               sessionManager: ctx.sessionManager,
-              cwd: ctx.cwd,
-              isProjectTrusted: () => ctx.isProjectTrusted()
+              scopedModels: getDmScopedModels(ctx)
             };
             const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
             const pc = {
@@ -1621,6 +1275,7 @@ Open manually: ${handle.url}` }],
               numResults: params.numResults,
               recencyFilter,
               domainFilter: params.domainFilter,
+              category: params.category,
               availableProviders,
               defaultProvider,
               searchProvider,
@@ -1681,6 +1336,7 @@ Open manually: ${handle.url}` }],
                   recencyFilter,
                   domainFilter: params.domainFilter,
                   includeContent: params.includeContent,
+                  category: params.category,
                   signal: searchSignal,
                   extensionContext: ctx
                 });
@@ -1764,93 +1420,32 @@ Open manually: ${handle.url}` }],
             }
             return promise;
           }
-          let completedSearches = 0;
-          const allUrls = [];
-          const allInlineContent = [];
-          const resolvedProvider = resolveRequestedProvider(params.provider);
-          const queryResponses = await runSearchQueries(queryList, async (query) => {
-            signal?.throwIfAborted();
-            onUpdate?.({
-              content: [{ type: "text", text: `Searching "${query}" (${completedSearches}/${queryList.length} complete)...` }],
-              details: { phase: "search", progress: completedSearches / queryList.length, currentQuery: query }
-            });
-            try {
-              const { answer, results, inlineContent, provider, providerResponses } = await search(query, {
-                provider: resolvedProvider,
-                numResults: params.numResults,
-                recencyFilter,
-                domainFilter: params.domainFilter,
-                includeContent: params.includeContent,
-                signal,
-                extensionContext: ctx
-              });
-              const providers = providerResponses?.map((response) => response.provider) ?? [provider];
-              return { result: { query, answer, results, error: null, provider, providers }, inlineContent };
-            } catch (err) {
-              if (signal?.aborted || isAbortError(err))
-                throw err;
-              const message = err instanceof Error ? err.message : String(err);
-              const requestedProvider = toCuratorProvider(resolvedProvider);
-              return {
-                result: { query, answer: "", results: [], error: message, provider: requestedProvider },
-                inlineContent: undefined
-              };
-            } finally {
-              completedSearches++;
-              if (!signal?.aborted) {
-                onUpdate?.({
-                  content: [{ type: "text", text: `Completed ${completedSearches}/${queryList.length} searches.` }],
-                  details: { phase: "search", progress: completedSearches / queryList.length, currentQuery: query }
-                });
-              }
-            }
-          });
-          const searchResults = queryResponses.map((response) => response.result);
-          for (const response of queryResponses) {
-            for (const result of response.result.results) {
-              if (!allUrls.includes(result.url))
-                allUrls.push(result.url);
-            }
-            if (response.inlineContent)
-              allInlineContent.push(...response.inlineContent);
-          }
-          let approvedSummary;
-          let summaryMeta;
+          let summarize;
           if (workflow === "auto-summary") {
-            if (!ctx) {
-              return {
-                content: [{ type: "text", text: "Error: Auto-summary requires an active extension context." }],
-                details: { error: "Missing extension context" }
+            summarize = async (searchResults) => {
+              if (!ctx) {
+                return {
+                  content: [{ type: "text", text: "Error: Auto-summary requires an active extension context." }],
+                  details: { error: "Missing extension context" }
+                };
+              }
+              onUpdate?.({
+                content: [{ type: "text", text: "Generating summary..." }],
+                details: { phase: "generating-summary", progress: 1 }
+              });
+              const summaryContext = {
+                model: ctx.model,
+                modelRegistry: ctx.modelRegistry,
+                sessionManager: ctx.sessionManager,
+                scopedModels: getDmScopedModels(ctx)
               };
-            }
-            onUpdate?.({
-              content: [{ type: "text", text: "Generating summary..." }],
-              details: { phase: "generating-summary", progress: 1 }
-            });
-            const summaryContext = {
-              model: ctx.model,
-              modelRegistry: ctx.modelRegistry,
-              sessionManager: ctx.sessionManager,
-              cwd: ctx.cwd,
-              isProjectTrusted: () => ctx.isProjectTrusted()
+              const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
+              const generated = await generateSummaryDraft(searchResults, summaryContext, signal, summaryModelChoices.defaultSummaryModel ?? undefined, undefined, undefined, getSummaryGenerationDeadlineMs(), getSummaryInstructions());
+              return { approvedSummary: generated.summary, summaryMeta: generated.meta };
             };
-            const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
-            const generated = await generateSummaryDraft(searchResults, summaryContext, signal, summaryModelChoices.defaultSummaryModel ?? undefined, undefined, undefined, getSummaryGenerationDeadlineMs());
-            approvedSummary = generated.summary;
-            summaryMeta = generated.meta;
           }
-          return buildSearchReturn({
-            queryList,
-            results: searchResults,
-            urls: allUrls,
-            includeContent: params.includeContent ?? false,
-            inlineContent: allInlineContent.length > 0 ? allInlineContent : undefined,
-            workflow: workflow === "auto-summary" ? "auto-summary" : undefined,
-            approvedSummary,
-            summaryMeta,
-            proxy: typeof params.proxy === "string" ? params.proxy : undefined
-          });
-        });
+          return core.webSearch(params, signal, { extensionContext: ctx, onUpdate, summarize, awaitContent: nested });
+        }));
       },
       renderCall(args, theme) {
         const input = args;
@@ -1861,13 +1456,11 @@ Open manually: ${handle.url}` }],
         }
         if (queryList.length === 1) {
           const q = queryList[0];
-          const display = q.length > 60 ? q.slice(0, 57) + "..." : q;
-          return new Text(theme.fg("toolTitle", theme.bold("search ")) + theme.fg("accent", `"${display}"`), 0, 0);
+          return new Text(theme.fg("toolTitle", theme.bold("search ")) + theme.fg("accent", `"${q}"`), 0, 0);
         }
         const lines = [theme.fg("toolTitle", theme.bold("search ")) + theme.fg("accent", `${queryList.length} queries`)];
         for (const q of queryList.slice(0, 5)) {
-          const display = q.length > 50 ? q.slice(0, 47) + "..." : q;
-          lines.push(theme.fg("muted", `  "${display}"`));
+          lines.push(theme.fg("muted", `  "${q}"`));
         }
         if (queryList.length > 5) {
           lines.push(theme.fg("muted", `  ... and ${queryList.length - 5} more`));
@@ -2075,84 +1668,7 @@ Open manually: ${handle.url}` }],
         }))
       }),
       async execute(_callId, params, signal, _onUpdate, ctx) {
-        return runWithProxy(typeof params.proxy === "string" ? params.proxy : undefined, async () => {
-          const claim = typeof params.claim === "string" ? params.claim.trim() : "";
-          if (!claim) {
-            return { content: [{ type: "text", text: "Error: 'claim' is required." }], details: { error: "Missing claim" } };
-          }
-          const requestedQueries = Array.isArray(params.queries) ? params.queries.filter((query) => typeof query === "string").map((query) => query.trim()).filter(Boolean) : [];
-          const queries = (requestedQueries.length > 0 ? requestedQueries : [claim]).slice(0, 8);
-          const numResults = typeof params.numResults === "number" && Number.isFinite(params.numResults) ? Math.min(20, Math.max(1, Math.floor(params.numResults))) : 5;
-          const domainFilter = Array.isArray(params.domainFilter) ? params.domainFilter.filter((domain) => typeof domain === "string") : undefined;
-          const recencyFilter = normalizeRecencyFilter(params.recencyFilter);
-          const resultsByUrl = new Map;
-          const summaries = [];
-          const errors = [];
-          let provider;
-          for (const query of queries) {
-            if (signal?.aborted)
-              break;
-            try {
-              const response = await search(query, {
-                provider: resolveRequestedProvider(params.provider),
-                numResults,
-                recencyFilter,
-                domainFilter,
-                signal,
-                extensionContext: ctx
-              });
-              if (signal?.aborted)
-                break;
-              provider ??= response.provider;
-              if (response.answer)
-                summaries.push(`${query}: ${response.answer}`);
-              for (const result of response.results) {
-                if (!resultsByUrl.has(result.url))
-                  resultsByUrl.set(result.url, result);
-              }
-            } catch (err) {
-              if (signal?.aborted || isAbortError(err))
-                break;
-              errors.push({ query, error: err instanceof Error ? err.message : String(err) });
-            }
-          }
-          const results = [...resultsByUrl.values()].slice(0, 20).map((result, index) => ({ ...result, rank: index + 1 }));
-          let fetched = [];
-          if (params.fetchContent && results.length > 0) {
-            const urls = results.slice(0, 5).map((result) => result.url);
-            try {
-              fetched = await fetchAllContent(urls, signal, withRegisteredFetchOptions(undefined, registeredToolNames, typeof params.proxy === "string" ? params.proxy : undefined));
-            } catch (err) {
-              if (signal?.aborted || isAbortError(err))
-                throw err;
-              fetched = urls.map((url) => ({ url, title: "", content: "", error: err instanceof Error ? err.message : String(err) }));
-            }
-          }
-          const artifact = withClaimAssessment(buildResearchArtifact({
-            query: claim,
-            provider,
-            summary: summaries.length > 0 ? summaries.join(`
-
-`) : undefined,
-            results,
-            fetched,
-            recency: recencyFilter,
-            domainFilter
-          }), [claim]);
-          if (errors.length > 0)
-            artifact.errors = errors;
-          storeResearchArtifact(artifact);
-          pi.appendEntry("web-search-results", {
-            id: artifact.id,
-            type: "research",
-            timestamp: artifact.timestamp,
-            artifact
-          });
-          return {
-            content: [{ type: "text", text: formatSourceCheckResult(artifact, getSearchContentEnabled ? toolNames.getSearchContent : null) }],
-            details: { responseId: artifact.id, artifact, sourceCount: artifact.sources.length, passageCount: artifact.passages.length }
-          };
-        });
+        return markToolError(await core.sourceCheck(params, signal, { extensionContext: ctx }));
       }
     });
   if (fetchContentEnabled)
@@ -2196,170 +1712,9 @@ Open manually: ${handle.url}` }],
           description: "http(s) or socks proxy URL (e.g. http://host:port or socks5h://host:port) used for this fetch. Needed when the target is unreachable directly; localhost and NO_PROXY hosts always bypass the proxy. Empty string forces direct access."
         }))
       }),
+      outputSchema: fetchContentOutputSchema,
       async execute(_toolCallId, params, signal, onUpdate, ctx) {
-        let normalized;
-        try {
-          normalized = normalizeFetchContentParams(params);
-        } catch (err) {
-          const error = err instanceof Error ? err.message : String(err);
-          return { content: [{ type: "text", text: `Error: ${error}` }], details: { error } };
-        }
-        const { urlList, options } = normalized;
-        const mode = options.mode ?? fetchModeConfig.defaultMode;
-        if (!fetchModeConfig.allowedModes.includes(mode)) {
-          const error = `Fetch mode "${mode}" is disabled by fetch.allowedModes.`;
-          return { content: [{ type: "text", text: `Error: ${error}` }], details: { error } };
-        }
-        return runWithProxy(options.proxy, async () => {
-          if (mode === "answer" && !options.prompt) {
-            return { content: [{ type: "text", text: "Error: mode answer requires prompt." }], details: { error: "mode answer requires prompt" } };
-          }
-          if (mode === "raw" && (options.forceClone === true || options.timestamp || options.frames || options.prompt || options.model || options.answerModel)) {
-            return { content: [{ type: "text", text: "Error: mode raw cannot be combined with forceClone, prompt, timestamp, frames, model, or answerModel." }], details: { error: "Incompatible raw mode options" } };
-          }
-          if (mode !== "answer" && options.answerModel) {
-            return { content: [{ type: "text", text: "Error: answerModel requires mode answer." }], details: { error: "answerModel requires mode answer" } };
-          }
-          if (mode === "answer" && options.model) {
-            return { content: [{ type: "text", text: "Error: use answerModel, not model, with mode answer." }], details: { error: "model is incompatible with mode answer" } };
-          }
-          if (mode === "answer" && options.auth !== undefined) {
-            return { content: [{ type: "text", text: "Error: auth cannot be combined with mode answer." }], details: { error: "auth cannot be combined with mode answer" } };
-          }
-          let authFetchProfile;
-          if (options.auth !== undefined) {
-            try {
-              authFetchProfile = resolveAuthFetchProfile(options.auth);
-            } catch (err) {
-              const error = err instanceof Error ? err.message : String(err);
-              return { content: [{ type: "text", text: `Error: ${error}` }], details: { error } };
-            }
-          }
-          if (urlList.length === 0) {
-            return {
-              content: [{ type: "text", text: "Error: No URL provided." }],
-              details: { error: "No URL provided" }
-            };
-          }
-          onUpdate?.({
-            content: [{ type: "text", text: `Fetching ${urlList.length} URL(s)...` }],
-            details: { phase: "fetch", progress: 0 }
-          });
-          const { answerModel: _answerModel, auth: _auth, ...extractionOptions } = { ...options, mode };
-          const { prompt: _prompt, ...answerExtractionOptions } = extractionOptions;
-          const fetchOptions = {
-            ...mode === "answer" ? answerExtractionOptions : extractionOptions,
-            ...authFetchProfile ? { authFetchProfile } : {}
-          };
-          const fetchResults = await fetchAllContent(urlList, signal, withRegisteredFetchOptions(fetchOptions, registeredToolNames, options.proxy));
-          const presentedResults = mode === "answer" ? await Promise.all(fetchResults.map(async (result) => {
-            if (result.error)
-              return result;
-            if (result.thumbnail || result.mimeType?.startsWith("image/")) {
-              return { ...result, error: "Page answer requires textual fetched content" };
-            }
-            try {
-              const answer = await answerFromPage({
-                question: options.prompt,
-                pageText: result.content,
-                sourceUrl: result.url,
-                ...options.answerModel ? { model: options.answerModel } : {}
-              }, ctx, signal);
-              return { ...result, content: answer.text };
-            } catch (err) {
-              return { ...result, error: `Page answer failed: ${err instanceof Error ? err.message : String(err)}` };
-            }
-          })) : fetchResults;
-          const successful = presentedResults.filter((r) => !r.error).length;
-          const totalChars = presentedResults.reduce((sum, r) => sum + r.content.length, 0);
-          const responseId = generateId();
-          const data = {
-            id: responseId,
-            type: "fetch",
-            timestamp: Date.now(),
-            urls: stripThumbnails(fetchResults)
-          };
-          const storedContent = storeFetchResult(pi, responseId, data, authFetchProfile);
-          if (urlList.length === 1) {
-            const result = presentedResults[0];
-            if (result.error) {
-              return {
-                content: [{ type: "text", text: `Error: ${result.error}` }],
-                details: { urls: urlList, urlCount: 1, successful: 0, error: result.error, ...storedContent ? { responseId } : {}, prompt: params.prompt, timestamp: params.timestamp, frames: params.frames }
-              };
-            }
-            const fullLength = result.content.length;
-            const slice = initialContentSlice(result.content, getMaxInlineContentChars());
-            const truncated = slice.endOffset < fullLength;
-            let output = slice.text;
-            if (truncated) {
-              output += `
-
----
-Showing ${slice.endOffset} of ${fullLength} chars, ${slice.shownBytes} of ${slice.totalBytes} bytes, and ${slice.shownLines} of ${slice.totalLines} lines. `;
-              output += storedContent ? getSearchContentEnabled ? `Use ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0, offset: ${slice.endOffset} }) for the next slice.` : "Content retrieval is not registered." : "Authenticated fetch cache is off; repeat the fetch to read more.";
-            }
-            const content = [];
-            if (result.frames?.length) {
-              for (const frame of result.frames) {
-                content.push({ type: "image", data: frame.data, mimeType: frame.mimeType });
-                content.push({ type: "text", text: `Frame at ${frame.timestamp}` });
-              }
-            } else if (result.thumbnail) {
-              content.push({ type: "image", data: result.thumbnail.data, mimeType: result.thumbnail.mimeType });
-            }
-            content.push({ type: "text", text: output });
-            const imageCount = (result.frames?.length ?? 0) + (result.thumbnail ? 1 : 0);
-            return {
-              content,
-              details: {
-                urls: urlList,
-                urlCount: 1,
-                successful: 1,
-                totalChars: fullLength,
-                title: result.title,
-                ...storedContent ? { responseId } : {},
-                truncated,
-                hasImage: imageCount > 0,
-                imageCount,
-                prompt: params.prompt,
-                timestamp: params.timestamp,
-                frames: params.frames,
-                duration: result.duration,
-                mode,
-                mimeType: result.mimeType,
-                status: result.status,
-                totalBytes: slice.totalBytes,
-                totalLines: slice.totalLines,
-                shownBytes: slice.shownBytes,
-                shownLines: slice.shownLines
-              }
-            };
-          }
-          let output = `## Fetched URLs
-
-`;
-          for (const { url, title, content, error } of presentedResults) {
-            if (error) {
-              output += `- ${url}: Error - ${error}
-`;
-            } else {
-              output += `- ${title || url} (${content.length} chars)
-`;
-            }
-          }
-          output += storedContent ? getSearchContentEnabled ? `
----
-Use ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0 }) to retrieve bounded content slices.` : `
----
-Content retrieval is not registered.` : `
----
-Authenticated fetch cache is off; repeat the fetch to read content.`;
-          return {
-            content: [{ type: "text", text: output }],
-            details: { urls: urlList, urlCount: urlList.length, successful, totalChars, ...storedContent ? { responseId } : {} }
-          };
-        });
+        return markToolError(await core.fetchContent(params, signal, { extensionContext: ctx, onUpdate }));
       },
       renderCall(args, theme) {
         let normalized;
@@ -2375,13 +1730,11 @@ Authenticated fetch cache is off; repeat the fetch to read content.`;
         }
         const lines = [];
         if (urlList.length === 1) {
-          const display = urlList[0].length > 60 ? urlList[0].slice(0, 57) + "..." : urlList[0];
-          lines.push(theme.fg("toolTitle", theme.bold("fetch ")) + theme.fg("accent", display));
+          lines.push(theme.fg("toolTitle", theme.bold("fetch ")) + theme.fg("accent", urlList[0]));
         } else {
           lines.push(theme.fg("toolTitle", theme.bold("fetch ")) + theme.fg("accent", `${urlList.length} URLs`));
           for (const u of urlList.slice(0, 5)) {
-            const display = u.length > 60 ? u.slice(0, 57) + "..." : u;
-            lines.push(theme.fg("muted", "  " + display));
+            lines.push(theme.fg("muted", "  " + u));
           }
           if (urlList.length > 5) {
             lines.push(theme.fg("muted", `  ... and ${urlList.length - 5} more`));
@@ -2504,291 +1857,7 @@ Authenticated fetch cache is off; repeat the fetch to read content.`;
         findMode: Type.Optional(StringEnum(["exact", "case-insensitive", "fuzzy"], { description: "Matching mode for findText (default: case-insensitive). Requires findText." }))
       }),
       async execute(_toolCallId, rawParams) {
-        const params = normalizeGetSearchContentParams(rawParams);
-        if (params.findMode !== undefined && params.findText === undefined) {
-          return {
-            content: [{ type: "text", text: `findMode ${formatInputValue(params.findMode)} requires findText; provide findText or omit findMode.` }],
-            details: { error: "findMode requires findText" }
-          };
-        }
-        const data = getResult(params.responseId);
-        if (!data) {
-          return {
-            content: [{ type: "text", text: `Error: No stored results for responseId ${formatInputValue(params.responseId)}. Use a responseId returned by ${storedContentSources}.` }],
-            details: { error: "Not found", responseId: params.responseId }
-          };
-        }
-        if (data.type === "research") {
-          const artifact = getResearchArtifact(params.responseId);
-          if (!artifact) {
-            return {
-              content: [{ type: "text", text: `Error: stored research artifact for responseId ${formatInputValue(params.responseId)} was not found. Use a responseId returned by ${storedContentSources}.` }],
-              details: { error: "Artifact not found", responseId: params.responseId }
-            };
-          }
-          const serialized = JSON.stringify(artifact, null, 2);
-          if (params.findText !== undefined) {
-            try {
-              const found = findContent(serialized, normalizeFindQueries(params.findText), params.findMode ?? "case-insensitive");
-              const { text, ...findDetails } = found;
-              return {
-                content: [{ type: "text", text }],
-                details: { responseId: artifact.id, type: "research", contentLength: serialized.length, findMode: params.findMode ?? "case-insensitive", ...findDetails }
-              };
-            } catch (err) {
-              const error = err instanceof Error ? err.message : String(err);
-              return {
-                content: [{ type: "text", text: `Unable to find ${formatInputValue(params.findText)} in research artifact for responseId ${formatInputValue(params.responseId)}: ${error}. Check findText and use a supported findMode.` }],
-                details: { error, responseId: params.responseId, type: "research" }
-              };
-            }
-          }
-          const offset = params.offset ?? 0;
-          const limit = params.limit ?? maxInlineContentChars;
-          if (!Number.isInteger(offset) || offset < 0) {
-            return {
-              content: [{ type: "text", text: `Invalid offset: received ${formatInputValue(offset)} for responseId ${formatInputValue(params.responseId)}; offset must be a non-negative integer. Use 0 or a larger integer.` }],
-              details: { error: "Invalid offset", offset }
-            };
-          }
-          if (!Number.isInteger(limit) || limit <= 0 || limit > maxInlineContentChars) {
-            return {
-              content: [{ type: "text", text: `Invalid limit: received ${formatInputValue(limit)} for responseId ${formatInputValue(params.responseId)}; limit must be an integer from 1 to ${maxInlineContentChars}. Use a value in that range.` }],
-              details: { error: "Invalid limit", limit, maxLimit: maxInlineContentChars }
-            };
-          }
-          if (offset > serialized.length) {
-            return {
-              content: [{ type: "text", text: `Offset ${offset} is out of range for responseId ${formatInputValue(params.responseId)}. Received offset ${offset}; valid range is 0-${serialized.length}. Use an offset within that range.` }],
-              details: { error: "Offset out of range", offset, contentLength: serialized.length }
-            };
-          }
-          const endOffset = Math.min(offset + limit, serialized.length);
-          const artifactSlice = serialized.slice(offset, endOffset);
-          const hasMore = endOffset < serialized.length;
-          return {
-            content: [{ type: "text", text: artifactSlice }],
-            details: { responseId: artifact.id, type: "research", contentLength: serialized.length, offset, limit, returnedChars: artifactSlice.length, nextOffset: hasMore ? endOffset : null, truncated: hasMore }
-          };
-        }
-        if (data.type === "search" && data.queries) {
-          let queryData;
-          if (params.query !== undefined) {
-            queryData = data.queries.find((q) => q.query === params.query);
-            if (!queryData) {
-              const available = data.queries.map((q) => `"${q.query}"`).join(", ");
-              return {
-                content: [{ type: "text", text: `Query ${formatInputValue(params.query)} was not found for responseId ${formatInputValue(params.responseId)}. Received query=${formatInputValue(params.query)}. Available queries: ${available || "none"}. Use one of the available queries or queryIndex.` }],
-                details: { error: "Query not found" }
-              };
-            }
-          } else if (params.queryIndex !== undefined) {
-            queryData = data.queries[params.queryIndex];
-            if (!queryData) {
-              const available = data.queries.map((q, i) => `${i}: "${q.query}"`).join(", ");
-              return {
-                content: [{ type: "text", text: `Query index ${formatInputValue(params.queryIndex)} is out of range for responseId ${formatInputValue(params.responseId)}. Received queryIndex=${formatInputValue(params.queryIndex)}; valid indexes are 0-${data.queries.length - 1}. Available queries: ${available || "none"}. Use one of the available indexes.` }],
-                details: { error: "Index out of range" }
-              };
-            }
-          } else {
-            const available = data.queries.map((q, i) => `${i}: "${q.query}"`).join(", ");
-            return {
-              content: [{ type: "text", text: `Specify query or queryIndex for responseId ${formatInputValue(params.responseId)}. Available queries: ${available || "none"}.` }],
-              details: { error: "No query specified" }
-            };
-          }
-          if (queryData.error) {
-            return {
-              content: [{ type: "text", text: `Error retrieving query ${formatInputValue(queryData.query)} from responseId ${formatInputValue(params.responseId)}: ${queryData.error}. Check the stored search result and retry with another query or queryIndex if needed.` }],
-              details: { error: queryData.error, query: queryData.query }
-            };
-          }
-          const fullResults = formatFullResults(queryData);
-          if (params.findText !== undefined) {
-            try {
-              const found = findContent(fullResults, normalizeFindQueries(params.findText), params.findMode ?? "case-insensitive");
-              const { text, ...findDetails } = found;
-              return {
-                content: [{ type: "text", text }],
-                details: { responseId: params.responseId, query: queryData.query, resultCount: queryData.results.length, contentLength: fullResults.length, findMode: params.findMode ?? "case-insensitive", ...findDetails }
-              };
-            } catch (err) {
-              const error = err instanceof Error ? err.message : String(err);
-              return {
-                content: [{ type: "text", text: `Unable to find ${formatInputValue(params.findText)} in query ${formatInputValue(queryData.query)} for responseId ${formatInputValue(params.responseId)}: ${error}. Check findText and use a supported findMode.` }],
-                details: { error, query: queryData.query }
-              };
-            }
-          }
-          const offset = params.offset ?? 0;
-          const limit = params.limit ?? maxInlineContentChars;
-          if (!Number.isInteger(offset) || offset < 0) {
-            return {
-              content: [{ type: "text", text: `Invalid offset: received ${formatInputValue(offset)} for query ${formatInputValue(queryData.query)}; offset must be a non-negative integer. Use 0 or a larger integer.` }],
-              details: { error: "Invalid offset", offset }
-            };
-          }
-          if (!Number.isInteger(limit) || limit <= 0 || limit > maxInlineContentChars) {
-            return {
-              content: [{ type: "text", text: `Invalid limit: received ${formatInputValue(limit)} for query ${formatInputValue(queryData.query)}; limit must be an integer from 1 to ${maxInlineContentChars}. Use a value in that range.` }],
-              details: { error: "Invalid limit", limit, maxLimit: maxInlineContentChars }
-            };
-          }
-          if (offset > fullResults.length) {
-            return {
-              content: [{ type: "text", text: `Offset ${offset} is out of range for query ${formatInputValue(queryData.query)} in responseId ${formatInputValue(params.responseId)}. Received offset ${offset}; valid range is 0-${fullResults.length}. Use an offset within that range.` }],
-              details: { error: "Offset out of range", offset, contentLength: fullResults.length }
-            };
-          }
-          const queryIndex = data.queries.indexOf(queryData);
-          let returnedChars = Math.min(limit, fullResults.length - offset);
-          let endOffset = offset + returnedChars;
-          let continuation = "";
-          while (endOffset < fullResults.length) {
-            continuation = `
-
----
-Showing chars ${offset}-${endOffset} of ${fullResults.length}. Use ${toolNames.getSearchContent}({ responseId: "${params.responseId}", queryIndex: ${queryIndex}, offset: ${endOffset}, limit: ${limit} }) for the next slice.`;
-            const overflow = returnedChars + continuation.length - maxInlineContentChars;
-            if (overflow <= 0)
-              break;
-            returnedChars -= overflow;
-            endOffset = offset + returnedChars;
-          }
-          const resultSlice = fullResults.slice(offset, endOffset);
-          const hasMore = endOffset < fullResults.length;
-          const text = `${resultSlice}${hasMore ? continuation : ""}`;
-          return {
-            content: [{ type: "text", text }],
-            details: {
-              responseId: params.responseId,
-              query: queryData.query,
-              resultCount: queryData.results.length,
-              contentLength: fullResults.length,
-              offset,
-              limit,
-              returnedChars,
-              nextOffset: hasMore ? endOffset : null,
-              truncated: hasMore
-            }
-          };
-        }
-        if (data.type === "fetch" && data.urls) {
-          let urlData;
-          let selectedUrlIndex = -1;
-          if (params.url !== undefined) {
-            selectedUrlIndex = data.urls.findIndex((u) => u.url === params.url);
-            urlData = data.urls[selectedUrlIndex];
-            if (!urlData) {
-              const available = data.urls.map((u) => u.url).join(`
-  `);
-              return {
-                content: [{ type: "text", text: `URL ${formatInputValue(params.url)} was not found for responseId ${formatInputValue(params.responseId)}. Received url=${formatInputValue(params.url)}. Available URLs:
-  ${available || "  none"}
-Use one of the available URLs or urlIndex.` }],
-                details: { error: "URL not found" }
-              };
-            }
-          } else if (params.urlIndex !== undefined) {
-            selectedUrlIndex = params.urlIndex;
-            urlData = data.urls[selectedUrlIndex];
-            if (!urlData) {
-              const available = data.urls.map((u, i) => `${i}: ${u.url}`).join(`
-  `);
-              return {
-                content: [{ type: "text", text: `URL index ${formatInputValue(params.urlIndex)} is out of range for responseId ${formatInputValue(params.responseId)}. Received urlIndex=${formatInputValue(params.urlIndex)}; valid indexes are 0-${data.urls.length - 1}. Available URLs:
-  ${available || "  none"}
-Use one of the available indexes.` }],
-                details: { error: "Index out of range" }
-              };
-            }
-          } else {
-            const available = data.urls.map((u, i) => `${i}: ${u.url}`).join(`
-  `);
-            return {
-              content: [{ type: "text", text: `Specify url or urlIndex for responseId ${formatInputValue(params.responseId)}. Available URLs:
-  ${available || "  none"}` }],
-              details: { error: "No URL specified" }
-            };
-          }
-          if (urlData.error) {
-            return {
-              content: [{ type: "text", text: `Error retrieving URL ${formatInputValue(urlData.url)} from responseId ${formatInputValue(params.responseId)}: ${urlData.error}. Check the stored fetch result and retry with another URL or urlIndex if needed.` }],
-              details: { error: urlData.error, url: urlData.url }
-            };
-          }
-          if (params.findText !== undefined) {
-            try {
-              const found = findContent(urlData.content, normalizeFindQueries(params.findText), params.findMode ?? "case-insensitive");
-              const { text, ...findDetails } = found;
-              return {
-                content: [{ type: "text", text: `# ${urlData.title || urlData.url}
-
-${text}` }],
-                details: { url: urlData.url, title: urlData.title, contentLength: urlData.content.length, findMode: params.findMode ?? "case-insensitive", ...findDetails }
-              };
-            } catch (err) {
-              const error = err instanceof Error ? err.message : String(err);
-              return {
-                content: [{ type: "text", text: `Unable to find ${formatInputValue(params.findText)} in URL ${formatInputValue(urlData.url)} for responseId ${formatInputValue(params.responseId)}: ${error}. Check findText and use a supported findMode.` }],
-                details: { error, url: urlData.url }
-              };
-            }
-          }
-          const offset = params.offset ?? 0;
-          const limit = params.limit ?? maxInlineContentChars;
-          if (!Number.isInteger(offset) || offset < 0) {
-            return {
-              content: [{ type: "text", text: `Invalid offset: received ${formatInputValue(offset)} for URL ${formatInputValue(urlData.url)}; offset must be a non-negative integer. Use 0 or a larger integer.` }],
-              details: { error: "Invalid offset", offset }
-            };
-          }
-          if (!Number.isInteger(limit) || limit <= 0 || limit > maxInlineContentChars) {
-            return {
-              content: [{ type: "text", text: `Invalid limit: received ${formatInputValue(limit)} for URL ${formatInputValue(urlData.url)}; limit must be an integer from 1 to ${maxInlineContentChars}. Use a value in that range.` }],
-              details: { error: "Invalid limit", limit, maxLimit: maxInlineContentChars }
-            };
-          }
-          if (offset > urlData.content.length) {
-            return {
-              content: [{ type: "text", text: `Offset ${offset} is out of range for URL ${formatInputValue(urlData.url)} in responseId ${formatInputValue(params.responseId)}. Received offset ${offset}; valid range is 0-${urlData.content.length}. Use an offset within that range.` }],
-              details: { error: "Offset out of range", offset, contentLength: urlData.content.length }
-            };
-          }
-          const endOffset = Math.min(offset + limit, urlData.content.length);
-          const contentSlice = urlData.content.slice(offset, endOffset);
-          const hasMore = endOffset < urlData.content.length;
-          let text = `# ${urlData.title || urlData.url}
-
-${contentSlice}`;
-          if (hasMore || offset > 0) {
-            text += `
-
----
-Showing chars ${offset}-${endOffset} of ${urlData.content.length}.`;
-            if (hasMore) {
-              text += ` Use ${toolNames.getSearchContent}({ responseId: "${params.responseId}", urlIndex: ${selectedUrlIndex}, offset: ${endOffset}, limit: ${limit} }) for the next slice.`;
-            }
-          }
-          return {
-            content: [{ type: "text", text }],
-            details: {
-              url: urlData.url,
-              title: urlData.title,
-              contentLength: urlData.content.length,
-              offset,
-              limit,
-              returnedChars: contentSlice.length,
-              nextOffset: hasMore ? endOffset : null,
-              truncated: hasMore
-            }
-          };
-        }
-        return {
-          content: [{ type: "text", text: `Invalid stored data for responseId ${formatInputValue(params.responseId)}: received type ${formatInputValue(data.type)}. Use a responseId returned by ${storedContentSources}.` }],
-          details: { error: "Invalid data" }
-        };
+        return markToolError(await core.getSearchContent(rawParams));
       },
       renderCall(args, theme) {
         const { responseId, query, queryIndex, url, urlIndex, offset, findText } = args;
@@ -2846,13 +1915,13 @@ Showing chars ${offset}-${endOffset} of ${urlData.content.length}.`;
       }
     });
   }
-  const activationTools = [
-    ...webSearchEnabled ? [{ name: toolNames.webSearch, capability: "search" }] : [],
-    ...sourceCheckEnabled ? [{ name: toolNames.sourceCheck, capability: "source-check" }] : [],
-    ...fetchContentEnabled ? [{ name: toolNames.fetchContent, capability: "fetch" }] : [],
-    ...getSearchContentEnabled ? [{ name: toolNames.getSearchContent, capability: "stored-content" }] : []
-  ];
-  registerWebToolActivation(pi, activationTools);
+  if (toolActivation !== "eager")
+    registerWebToolActivation(pi, [
+      ...webSearchEnabled ? [{ name: toolNames.webSearch, capability: "search" }] : [],
+      ...sourceCheckEnabled ? [{ name: toolNames.sourceCheck, capability: "source-check" }] : [],
+      ...fetchContentEnabled ? [{ name: toolNames.fetchContent, capability: "fetch" }] : [],
+      ...getSearchContentEnabled ? [{ name: toolNames.getSearchContent, capability: "stored-content" }] : []
+    ], toolActivation);
   if (isCommandEnabled(initConfig, "websearch"))
     pi.registerCommand("websearch", {
       description: "Open web search curator",
@@ -2881,8 +1950,7 @@ Showing chars ${offset}-${endOffset} of ${urlData.content.length}.`;
           model: ctx.model,
           modelRegistry: ctx.modelRegistry,
           sessionManager: ctx.sessionManager,
-          cwd: ctx.cwd,
-          isProjectTrusted: () => ctx.isProjectTrusted()
+          scopedModels: getDmScopedModels(ctx)
         };
         const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
         ctx.ui.notify("Opening web search curator...", "info");
@@ -3179,7 +2247,7 @@ Showing chars ${offset}-${endOffset} of ${urlData.content.length}.`;
     pi.registerCommand("search", {
       description: "Browse stored web search results",
       handler: async (_args, ctx) => {
-        const results = getAllResults();
+        const results = getAllResults().filter((r) => ownedResults.has(r.id));
         if (results.length === 0) {
           ctx.ui.notify("No stored search results", "info");
           return;
@@ -3208,7 +2276,8 @@ Showing chars ${offset}-${endOffset} of ${urlData.content.length}.`;
         const actions = ["View details", "Delete"];
         const action = await ctx.ui.select(`Result ${selected.id.slice(0, 6)}`, actions);
         if (action === "Delete") {
-          deleteResult(selected.id);
+          deleteHeldResult(selected.id);
+          ownedResults.delete(selected.id);
           ctx.ui.notify(`Deleted ${selected.id.slice(0, 6)}`, "info");
         } else if (action === "View details") {
           let info = `ID: ${selected.id}