@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.16-dev.9.1

package/dist/node-runtime/pi-web-access-DPGAVKOA.js

@@ -0,0 +1,1864 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  runSessionCleanups
+} from "./chunk-AUXVGBO4.js";
+import {
+  isBrowserCookieAccessAllowed
+} from "./chunk-DMMTJQMQ.js";
+import {
+  loadBrave,
+  loadCuratorServer,
+  loadExa,
+  loadExtract,
+  loadGeminiApi,
+  loadGeminiSearch,
+  loadGeminiWeb,
+  loadOpenAISearch,
+  loadParallel,
+  loadPerplexity,
+  loadSummaryReview,
+  loadTavily
+} from "./chunk-7NBZ5P7I.js";
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import {
+  getWebSearchConfigDir,
+  getWebSearchConfigPath
+} from "./chunk-VRB2IYGG.js";
+import {
+  loadEnabledModelPatterns,
+  modelMatchesEnabledPatterns
+} from "./chunk-4ZWGEEAS.js";
+import {
+  formatGroupedCall,
+  toolGroupTree,
+  toolStatusDotFromContext
+} from "./chunk-GZQHMEWL.js";
+import "./chunk-ZCHMJ34K.js";
+import "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/index.js
+import { Box, Text, truncateToWidth } from "@ashx-j/lunr-tui";
+import { Type } from "typebox";
+import { StringEnum, complete } from "@ashx-j/lunr-ai/compat";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/fetch-params.js
+function normalizeFetchContentParams(params) {
+  let normalizedUrls = uniqueUrls(normalizeUrlArray(params.urls)), urlList = normalizedUrls.length > 0 ? normalizedUrls : normalizeSingleUrl(params.url), prompt = normalizeOptionalString(params.prompt), timestamp = normalizeOptionalString(params.timestamp), frames = normalizeOptionalInteger(params.frames), shouldIncludeFrames = frames !== void 0 && (timestamp !== void 0 || frames > 1);
+  return {
+    urlList,
+    options: {
+      forceClone: typeof params.forceClone == "boolean" ? params.forceClone : void 0,
+      prompt,
+      timestamp,
+      frames: shouldIncludeFrames ? frames : void 0,
+      model: normalizeOptionalString(params.model)
+    }
+  };
+}
+function normalizeUrlArray(value) {
+  return Array.isArray(value) ? value.flatMap(normalizeSingleUrl) : [];
+}
+function normalizeSingleUrl(value) {
+  if (typeof value != "string")
+    return [];
+  let trimmed = value.trim();
+  return trimmed ? [trimmed] : [];
+}
+function normalizeOptionalString(value) {
+  return typeof value != "string" ? void 0 : value.trim() || void 0;
+}
+function normalizeOptionalInteger(value) {
+  if (!(typeof value != "number" || !Number.isInteger(value) || value < 1))
+    return value;
+}
+function uniqueUrls(urls) {
+  return [...new Set(urls)];
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/storage.js
+var storedResults = /* @__PURE__ */ new Map();
+function generateId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+function storeResult(id, data) {
+  storedResults.set(id, data);
+}
+function getResult(id) {
+  return storedResults.get(id) ?? null;
+}
+function getAllResults() {
+  return Array.from(storedResults.values());
+}
+function deleteResult(id) {
+  return storedResults.delete(id);
+}
+function clearResults() {
+  storedResults.clear();
+}
+function isValidStoredData(data) {
+  if (!data || typeof data != "object")
+    return !1;
+  let d = data;
+  return !(typeof d.id != "string" || !d.id || d.type !== "search" && d.type !== "fetch" || typeof d.timestamp != "number" || d.type === "search" && !Array.isArray(d.queries) || d.type === "fetch" && !Array.isArray(d.urls));
+}
+function restoreFromSession(ctx2) {
+  storedResults.clear();
+  let now = Date.now();
+  for (let entry of ctx2.sessionManager.getBranch())
+    if (entry.type === "custom" && entry.customType === "web-search-results") {
+      let data = entry.data;
+      isValidStoredData(data) && now - data.timestamp < 36e5 && storedResults.set(data.id, data);
+    }
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/index.js
+import { randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { platform } from "node:os";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/render-search-error.js
+function truncate(text, max) {
+  return text.length > max ? text.slice(0, max - 1) + "\u2026" : text;
+}
+function buildSearchErrorPlan(details) {
+  if (!details || !details.error && !details.cancelled)
+    return null;
+  let headline = details.error ?? "Search cancelled.", queries = details.cancelledQueries ?? [], queryCount = typeof details.queryCount == "number" && details.queryCount > 0 ? details.queryCount : queries.length, done = queries.length, errored = queries.filter((q) => q.error).length, extras = details.extraLines ?? [];
+  if (!(details.cancelled === !0 || queries.length > 0 || extras.length > 0))
+    return { expanded: [headline], collapsed: [], expandHint: null };
+  let expanded = [headline, ""];
+  if (details.cancelled === !0 || queries.length > 0) {
+    let diag = [];
+    details.cancelled && diag.push(`cancel reason   : ${details.cancelReason ?? "unknown"}`);
+    let browserLabel = details.browserConnected === void 0 ? "unknown" : details.browserConnected ? "connected" : "never connected";
+    diag.push(`browser         : ${browserLabel}`), typeof details.lastHeartbeatAgeMs == "number" && Number.isFinite(details.lastHeartbeatAgeMs) && diag.push(`last heartbeat  : ${Math.round(details.lastHeartbeatAgeMs / 1e3)}s ago`), queryCount > 0 && (diag.push(`queries started : ${queryCount}`), diag.push(`queries done    : ${done}`), errored > 0 && diag.push(`queries errored : ${errored}`)), expanded.push("Diagnostics:");
+    for (let line of diag)
+      expanded.push(`  ${line}`);
+  }
+  if (queries.length > 0) {
+    expanded.push(""), expanded.push("Per-query results (gathered before cancel):");
+    for (let q of queries) {
+      let dq = truncate(q.query, 52), tag = q.error ? "[err] " : "[ok]  ", provider = q.provider ? ` (${q.provider})` : "", tail = q.error ? `\u2014 ${truncate(q.error, 60)}` : `\u2014 ${q.resultCount} source${q.resultCount === 1 ? "" : "s"}`;
+      expanded.push(`  ${tag}"${dq}"${provider} ${tail}`);
+    }
+  }
+  if (extras.length > 0) {
+    expanded.push(""), expanded.push("Details:");
+    for (let e of extras)
+      expanded.push(`  ${e}`);
+  }
+  let collapsed = [], parts = [];
+  if (queryCount > 0 && parts.push(`${done}/${queryCount} queries completed`), errored > 0 && parts.push(`${errored} errored`), details.browserConnected === !1 ? parts.push("browser never connected") : details.cancelReason && parts.push(`reason: ${details.cancelReason}`), parts.length > 0 && collapsed.push(parts.join("; ") + "."), collapsed.length === 0 && extras.length > 0)
+    for (let e of extras.slice(0, 2))
+      collapsed.push(truncate(e, 100));
+  let hiddenLines = Math.max(0, expanded.length - (1 + collapsed.length)), expandHint = hiddenLines > 0 ? `... (${hiddenLines} more lines, ${expanded.length} total)` : null;
+  return { expanded, collapsed, expandHint };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/render-search-chrome.js
+function normalizeSearchQueryList(queryList) {
+  let normalized = [];
+  for (let query of queryList) {
+    if (typeof query != "string")
+      continue;
+    let trimmed = query.trim();
+    trimmed.length > 0 && normalized.push(trimmed);
+  }
+  return normalized;
+}
+function collectSearchQueries(args) {
+  let input = args ?? {}, rawQueryList = Array.isArray(input.queries) ? input.queries : input.query !== void 0 ? [input.query] : [];
+  return normalizeSearchQueryList(rawQueryList);
+}
+function collectFetchUrls(args) {
+  let input = args ?? {};
+  return Array.isArray(input.urls) ? input.urls.filter((url) => typeof url == "string" && url.length > 0) : typeof input.url == "string" && input.url.length > 0 ? [input.url] : [];
+}
+function formatSearchCallTitle(queries) {
+  if (queries.length === 0)
+    return { title: "search (no query)", empty: !0 };
+  if (queries.length === 1) {
+    let q = queries[0];
+    return { title: `search "${q.length > 60 ? `${q.slice(0, 57)}...` : q}"`, empty: !1 };
+  }
+  return { title: `search ${queries.length} queries`, empty: !1 };
+}
+function formatFetchCallTitle(urls) {
+  return urls.length === 0 ? { title: "fetch (no URL)", empty: !0 } : urls.length === 1 ? { title: `fetch ${urls[0].length > 60 ? `${urls[0].slice(0, 57)}...` : urls[0]}`, empty: !1 } : { title: `fetch ${urls.length} URLs`, empty: !1 };
+}
+function formatSearchStatusLine(details) {
+  let statusLine = `${details?.queryCount === 1 ? "" : `${details?.successfulQueries}/${details?.queryCount} queries, `}${details?.totalResults ?? 0} sources`;
+  return details?.curated && details?.curatedFrom && (statusLine += ` (${details.queryCount}/${details.curatedFrom} queries curated)`), details?.fetchId && details?.fetchUrls ? statusLine += ` (fetching ${details.fetchUrls.length} URLs)` : details?.fetchId && (statusLine += " (content ready)"), statusLine;
+}
+function formatFetchStatusLine(details) {
+  let urlCount = details?.urlCount ?? 0;
+  return `${details?.successful ?? (urlCount === 1 ? 1 : 0)}/${urlCount} URLs`;
+}
+function formatSearchDetail(queries, details) {
+  let rest = formatSearchCallTitle(queries).title.replace(/^search\s+/, ""), status = details ? formatSearchStatusLine(details) : "";
+  return status ? `${rest} \xB7 ${status}` : rest;
+}
+function formatFetchDetail(urls, details) {
+  let rest = formatFetchCallTitle(urls).title.replace(/^fetch\s+/, ""), status = details ? formatFetchStatusLine(details) : "";
+  return status ? `${rest} \xB7 ${status}` : rest;
+}
+function formatSearchChrome(options) {
+  let call = formatSearchCallTitle(options.queries);
+  if (options.expanded)
+    return { call: call.title, result: options.queries.slice() };
+  let status = options.details ? formatSearchStatusLine(options.details) : "";
+  return { call: status ? `${call.title} \xB7 ${status}` : call.title, result: [] };
+}
+function formatFetchChrome(options) {
+  let call = formatFetchCallTitle(options.urls);
+  if (options.expanded)
+    return { call: call.title, result: options.urls.slice() };
+  let status = options.details ? formatFetchStatusLine(options.details) : "";
+  return { call: status ? `${call.title} \xB7 ${status}` : call.title, result: [] };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/index.js
+var __rewriteRelativeImportExtension = function(path, preserveJsx) {
+  return typeof path == "string" && /^\.\.?\//.test(path) ? path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+    return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+  }) : path;
+}, WEB_SEARCH_CONFIG_PATH = getWebSearchConfigPath();
+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(`
+`), 0, 0);
+  let box = new Box(1, 0, (t) => theme.bg("toolErrorBg", t));
+  box.addChild(new Text(theme.fg("error", plan.expanded[0]), 0, 0));
+  for (let line of plan.collapsed)
+    box.addChild(new Text(theme.fg("dim", line), 0, 0));
+  return plan.expandHint && box.addChild(new Text(theme.fg("muted", plan.expandHint), 0, 0)), box;
+}
+function loadConfig() {
+  if (!existsSync(WEB_SEARCH_CONFIG_PATH))
+    return {};
+  let raw = readFileSync(WEB_SEARCH_CONFIG_PATH, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${WEB_SEARCH_CONFIG_PATH}: ${message}`);
+  }
+}
+function saveConfig(updates) {
+  let config = {};
+  if (existsSync(WEB_SEARCH_CONFIG_PATH)) {
+    let raw = readFileSync(WEB_SEARCH_CONFIG_PATH, "utf-8");
+    try {
+      config = JSON.parse(raw);
+    } catch (err) {
+      let message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to parse ${WEB_SEARCH_CONFIG_PATH}: ${message}`);
+    }
+  }
+  Object.assign(config, updates);
+  let dir = getWebSearchConfigDir();
+  existsSync(dir) || mkdirSync(dir, { recursive: !0 }), writeFileSync(WEB_SEARCH_CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`);
+}
+var DEFAULT_SHORTCUTS = { curate: "ctrl+shift+s", activity: "ctrl+shift+w" }, DEFAULT_CURATOR_TIMEOUT_SECONDS = 20, MAX_CURATOR_TIMEOUT_SECONDS = 600;
+function loadConfigForExtensionInit() {
+  try {
+    return loadConfig();
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    return console.error(`[pi-web-access] ${message}`), {};
+  }
+}
+function normalizeProviderInput(value) {
+  if (value === void 0)
+    return;
+  if (typeof value != "string")
+    return "auto";
+  let normalized = value.trim().toLowerCase();
+  return ["auto", "openai", "brave", "parallel", "tavily", "exa", "perplexity", "gemini"].includes(normalized) ? normalized : "auto";
+}
+function normalizeCuratorTimeoutSeconds(value) {
+  if (typeof value != "number" || !Number.isFinite(value))
+    return;
+  let normalized = Math.floor(value);
+  if (!(normalized < 1))
+    return Math.min(normalized, MAX_CURATOR_TIMEOUT_SECONDS);
+}
+function resolveWorkflow(input, hasUI) {
+  let normalized = typeof input == "string" ? input.trim().toLowerCase() : "";
+  return normalized === "auto-summary" ? "auto-summary" : !hasUI || normalized === "none" ? "none" : "summary-review";
+}
+function normalizeQueryList(queryList) {
+  return collectSearchQueries({ queries: queryList });
+}
+function getCuratorTimeoutSeconds() {
+  let source = loadConfig();
+  return normalizeCuratorTimeoutSeconds(source.curatorTimeoutSeconds) ?? DEFAULT_CURATOR_TIMEOUT_SECONDS;
+}
+async function getProviderAvailability(ctx2) {
+  let [openaiMod, braveMod, parallelMod, tavilyMod, perplexityMod, exaMod, geminiApiMod] = await Promise.all([
+    loadOpenAISearch(),
+    loadBrave(),
+    loadParallel(),
+    loadTavily(),
+    loadPerplexity(),
+    loadExa(),
+    loadGeminiApi()
+  ]), geminiWebAvail = null;
+  return isBrowserCookieAccessAllowed() && (geminiWebAvail = await (await loadGeminiWeb()).isGeminiWebAvailable()), {
+    openai: await openaiMod.isOpenAISearchAvailable(ctx2),
+    brave: braveMod.isBraveAvailable(),
+    parallel: parallelMod.isParallelAvailable(),
+    tavily: tavilyMod.isTavilyAvailable(),
+    perplexity: perplexityMod.isPerplexityAvailable(),
+    exa: exaMod.isExaAvailable(),
+    gemini: geminiApiMod.isGeminiApiAvailable() || !!geminiWebAvail
+  };
+}
+function shouldPreferOpenAI(options) {
+  return options ? !(options.recencyFilter || typeof options.numResults == "number" && Number.isFinite(options.numResults) && Math.floor(options.numResults) !== 5) : !0;
+}
+async function loadCuratorBootstrap(requestedProvider, ctx2, options) {
+  let availableProviders = await getProviderAvailability(ctx2);
+  return {
+    availableProviders,
+    defaultProvider: resolveProvider(requestedProvider, availableProviders, options),
+    timeoutSeconds: getCuratorTimeoutSeconds()
+  };
+}
+function firstAvailableProvider(available, preferOpenAI, fallback) {
+  return preferOpenAI && available.openai ? "openai" : available.exa ? "exa" : available.brave ? "brave" : available.parallel ? "parallel" : available.tavily ? "tavily" : available.perplexity ? "perplexity" : available.gemini ? "gemini" : fallback;
+}
+function resolveProvider(requested, available, options) {
+  let provider = normalizeProviderInput(requested ?? loadConfig().provider ?? "auto") ?? "auto", preferOpenAI = shouldPreferOpenAI(options);
+  return provider === "auto" ? firstAvailableProvider(available, preferOpenAI, "exa") : provider === "openai" && !available.openai ? firstAvailableProvider(available, !1, "openai") : provider === "brave" && !available.brave ? firstAvailableProvider(available, preferOpenAI, "brave") : provider === "parallel" && !available.parallel ? firstAvailableProvider(available, preferOpenAI, "parallel") : provider === "tavily" && !available.tavily ? firstAvailableProvider(available, preferOpenAI, "tavily") : provider === "exa" && !available.exa ? firstAvailableProvider(available, preferOpenAI, "exa") : provider === "perplexity" && !available.perplexity ? firstAvailableProvider(available, preferOpenAI, "perplexity") : provider === "gemini" && !available.gemini ? firstAvailableProvider(available, preferOpenAI, "gemini") : provider;
+}
+var pendingFetches = /* @__PURE__ */ new Map(), sessionActive = !1, sessionGeneration = 0, sessionAbort = new AbortController();
+function assertActiveRequest(generation, signal) {
+  if (signal?.throwIfAborted(), generation !== sessionGeneration)
+    throw new Error("Web request cancelled: session changed");
+}
+var widgetVisible = !1, widgetUnsubscribe = null, pendingCurates = /* @__PURE__ */ new Map(), activeCurators = /* @__PURE__ */ new Map(), glimpseWins = /* @__PURE__ */ new Map(), MAX_INLINE_CONTENT = 3e4;
+function stripThumbnails(results) {
+  return results.map(({ thumbnail, frames, ...rest }) => rest);
+}
+function formatSearchSummary(results, answer) {
+  let output = answer ? `${answer}
+
+---
+
+**Sources:**
+` : "";
+  return output += results.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}`).join(`
+
+`), output;
+}
+function duplicateQuerySet(results) {
+  let counts = /* @__PURE__ */ new Map();
+  for (let result of results)
+    counts.set(result.query, (counts.get(result.query) ?? 0) + 1);
+  let duplicates = /* @__PURE__ */ new Set();
+  for (let [query, count] of counts)
+    count > 1 && duplicates.add(query);
+  return duplicates;
+}
+function formatQueryHeader(query, provider, duplicateQueries) {
+  let suffix = duplicateQueries.has(query) && provider ? ` (${provider})` : "";
+  return `## Query: "${query}"${suffix}
+
+`;
+}
+function hasFullInlineCoverage(urls, inlineContent) {
+  if (!inlineContent || inlineContent.length === 0)
+    return !1;
+  let coveredUrls = new Set(inlineContent.map((c) => c.url));
+  return urls.every((url) => coveredUrls.has(url));
+}
+function formatFullResults(queryData) {
+  let output = `## Results for: "${queryData.query}"
+
+`;
+  queryData.answer && (output += `${queryData.answer}
+
+---
+
+`);
+  for (let r of queryData.results)
+    output += `### ${r.title}
+${r.url}
+
+`;
+  return output;
+}
+function abortPendingFetches() {
+  for (let controller of pendingFetches.values())
+    controller.abort();
+  pendingFetches.clear();
+}
+function closeCurator(callId) {
+  if (callId !== void 0) {
+    let win = glimpseWins.get(callId);
+    glimpseWins.delete(callId);
+    try {
+      win?.close();
+    } catch {
+    }
+    pendingCurates.get(callId)?.cancel("stale"), pendingCurates.delete(callId);
+    let curator = activeCurators.get(callId);
+    activeCurators.delete(callId);
+    try {
+      curator?.close();
+    } catch {
+    }
+    return;
+  }
+  for (let win of glimpseWins.values())
+    try {
+      win.close();
+    } catch {
+    }
+  glimpseWins.clear();
+  for (let pc of pendingCurates.values())
+    try {
+      pc.cancel("stale");
+    } catch {
+    }
+  pendingCurates.clear();
+  for (let curator of activeCurators.values())
+    try {
+      curator.close();
+    } catch {
+    }
+  activeCurators.clear();
+}
+async function openInBrowser(pi, url) {
+  let plat = platform(), result = plat === "darwin" ? await pi.exec("open", [url]) : plat === "win32" ? await pi.exec("cmd", ["/c", "start", "", url]) : await pi.exec("xdg-open", [url]);
+  if (result.code !== 0)
+    throw new Error(result.stderr || `Failed to open browser (exit code ${result.code})`);
+}
+var glimpseOpen;
+function findGlimpseMjs() {
+  try {
+    return createRequire(new URL("../builtin-extensions/pi-web-access/index.js", import.meta.url).href).resolve("glimpseui");
+  } catch {
+  }
+  try {
+    let globalRoot = execFileSync("npm", ["root", "-g"], { encoding: "utf-8" }).trim(), entry = join(globalRoot, "glimpseui", "src", "glimpse.mjs");
+    if (existsSync(entry))
+      return entry;
+  } catch {
+  }
+  return null;
+}
+async function getGlimpseOpen() {
+  if (glimpseOpen !== void 0)
+    return glimpseOpen;
+  let resolved = findGlimpseMjs();
+  if (resolved)
+    try {
+      return glimpseOpen = (await import(__rewriteRelativeImportExtension(resolved))).open, glimpseOpen;
+    } catch {
+    }
+  return glimpseOpen = null, glimpseOpen;
+}
+function openInGlimpse(open, url, title) {
+  let shellHTML = `<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"><title>${title}</title></head>
+<body style="margin:0; background:#1a1a2e;">
+  <script>window.location.replace(${JSON.stringify(url)});</script>
+</body>
+</html>`, win = open(shellHTML, {
+    width: 800,
+    height: 900,
+    title
+  }), maxHeight = 1200;
+  return win.on("ready", (info) => {
+    let visibleHeight = info?.screen?.visibleHeight;
+    typeof visibleHeight == "number" && visibleHeight > 0 && (maxHeight = Math.floor(visibleHeight * 0.85));
+  }), win.on("message", (data) => {
+    if (!data || typeof data != "object")
+      return;
+    let msg = data;
+    if (msg.type !== "resize" || typeof msg.height != "number")
+      return;
+    let clamped = Math.max(400, Math.min(Math.round(msg.height), maxHeight));
+    win._write({ type: "resize", width: 800, height: clamped });
+  }), win;
+}
+function extractDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+}
+function updateWidget(ctx2) {
+  let theme = ctx2.ui.theme, entries = activityMonitor.getEntries(), lines = [];
+  if (lines.push(theme.fg("accent", "\u2500\u2500\u2500 Web Search Activity " + "\u2500".repeat(36))), entries.length === 0)
+    lines.push(theme.fg("muted", "  No activity yet"));
+  else
+    for (let e of entries)
+      lines.push("  " + formatEntryLine(e, theme));
+  lines.push(theme.fg("accent", "\u2500".repeat(60)));
+  let rateInfo = activityMonitor.getRateLimitInfo(), resetMs = rateInfo.oldestTimestamp ? Math.max(0, rateInfo.oldestTimestamp + rateInfo.windowMs - Date.now()) : 0, resetSec = Math.ceil(resetMs / 1e3);
+  lines.push(theme.fg("muted", `Rate: ${rateInfo.used}/${rateInfo.max}`) + (resetMs > 0 ? theme.fg("dim", ` (resets in ${resetSec}s)`) : "")), ctx2.ui.setWidget("web-activity", new Text(lines.join(`
+`), 0, 0));
+}
+function formatEntryLine(entry, theme) {
+  let typeStr = entry.type === "api" ? "API" : "GET", target = entry.type === "api" ? `"${truncateToWidth(entry.query || "", 28, "")}"` : truncateToWidth(entry.url?.replace(/^https?:\/\//, "") || "", 30, ""), duration = entry.endTime ? `${((entry.endTime - entry.startTime) / 1e3).toFixed(1)}s` : `${((Date.now() - entry.startTime) / 1e3).toFixed(1)}s`, statusStr, indicator;
+  return entry.error ? (statusStr = "err", indicator = theme.fg("error", "\u2717")) : entry.status === null ? (statusStr = "...", indicator = theme.fg("warning", "\u22EF")) : entry.status === 0 ? (statusStr = "abort", indicator = theme.fg("muted", "\u25CB")) : (statusStr = String(entry.status), indicator = entry.status >= 200 && entry.status < 300 ? theme.fg("success", "\u2713") : theme.fg("error", "\u2717")), `${typeStr.padEnd(4)} ${target.padEnd(32)} ${statusStr.padStart(5)} ${duration.padStart(5)} ${indicator}`;
+}
+function handleSessionChange(ctx2) {
+  sessionGeneration++, sessionAbort.abort(), sessionAbort = new AbortController(), abortPendingFetches(), closeCurator(), runSessionCleanups(), sessionActive = !0, restoreFromSession(ctx2), widgetUnsubscribe?.(), widgetUnsubscribe = null, activityMonitor.clear(), widgetVisible && (widgetUnsubscribe = activityMonitor.onUpdate(() => updateWidget(ctx2)), updateWidget(ctx2));
+}
+function pi_web_access_default(pi) {
+  let initConfig = loadConfigForExtensionInit(), curateKey = initConfig.shortcuts?.curate || DEFAULT_SHORTCUTS.curate, activityKey = initConfig.shortcuts?.activity || DEFAULT_SHORTCUTS.activity, warmSummaryReview = null;
+  async function ensureSummaryReview() {
+    return warmSummaryReview || (warmSummaryReview = await loadSummaryReview()), warmSummaryReview;
+  }
+  async function runSearch(query, options) {
+    let { search } = await loadGeminiSearch();
+    return search(query, options);
+  }
+  globalThis[/* @__PURE__ */ Symbol.for("@lunr/search-curator")] = {
+    getWorkflow() {
+      return resolveWorkflow(loadConfigForExtensionInit().workflow, !0);
+    },
+    setWorkflow(workflow) {
+      saveConfig({ workflow });
+    }
+  };
+  function startBackgroundFetch(urls) {
+    if (urls.length === 0)
+      return null;
+    let fetchId = generateId(), controller = new AbortController();
+    return pendingFetches.set(fetchId, controller), (async () => {
+      try {
+        let { fetchAllContent } = await loadExtract();
+        if (!sessionActive || !pendingFetches.has(fetchId))
+          return;
+        let fetched = await fetchAllContent(urls, controller.signal);
+        if (!sessionActive || !pendingFetches.has(fetchId))
+          return;
+        let data = {
+          id: fetchId,
+          type: "fetch",
+          timestamp: Date.now(),
+          urls: stripThumbnails(fetched)
+        };
+        storeResult(fetchId, data), pi.appendEntry("web-search-results", data);
+        let ok = fetched.filter((f) => !f.error).length;
+        pi.sendMessage({
+          customType: "web-search-content-ready",
+          content: `Content fetched for ${ok}/${fetched.length} URLs [${fetchId}]. Full page content now available.`,
+          display: !0
+        }, { triggerTurn: !0 });
+      } catch (err) {
+        if (!sessionActive || !pendingFetches.has(fetchId))
+          return;
+        let message = err instanceof Error ? err.message : String(err);
+        err instanceof Error && err.name === "AbortError" || message.toLowerCase().includes("abort") || pi.sendMessage({
+          customType: "web-search-error",
+          content: `Content fetch failed [${fetchId}]: ${message}`,
+          display: !0
+        }, { triggerTurn: !1 });
+      } finally {
+        pendingFetches.delete(fetchId);
+      }
+    })(), fetchId;
+  }
+  function storeAndPublishSearch(results) {
+    let id = generateId(), data = {
+      id,
+      type: "search",
+      timestamp: Date.now(),
+      queries: results
+    };
+    return storeResult(id, data), pi.appendEntry("web-search-results", data), id;
+  }
+  function normalizeSummaryMeta(meta, summaryText) {
+    let normalizedText = summaryText.trim();
+    return meta ? {
+      model: meta.model,
+      durationMs: Number.isFinite(meta.durationMs) && meta.durationMs >= 0 ? meta.durationMs : 0,
+      tokenEstimate: Number.isFinite(meta.tokenEstimate) && meta.tokenEstimate >= 0 ? meta.tokenEstimate : normalizedText.length > 0 ? Math.max(1, Math.ceil(normalizedText.length / 4)) : 0,
+      fallbackUsed: meta.fallbackUsed === !0,
+      fallbackReason: meta.fallbackReason,
+      edited: meta.edited === !0
+    } : {
+      model: null,
+      durationMs: 0,
+      tokenEstimate: normalizedText.length > 0 ? Math.max(1, Math.ceil(normalizedText.length / 4)) : 0,
+      fallbackUsed: !1,
+      edited: !1
+    };
+  }
+  function buildCurationCancelledReturn(reason, partial) {
+    let message = `Search curation cancelled (${reason}).`, cancelledQueries = partial?.queries?.length ? partial.queries.map((q) => ({
+      query: q.query,
+      provider: q.provider ?? null,
+      error: q.error,
+      resultCount: q.results?.length ?? 0
+    })) : void 0, extraLines = [];
+    return partial?.curatorUrl && extraLines.push(`curator: ${partial.curatorUrl}`), partial?.browserOpenError && extraLines.push(`browser open error: ${partial.browserOpenError}`), {
+      content: [{ type: "text", text: message }],
+      details: {
+        error: message,
+        cancelled: !0,
+        cancelReason: reason,
+        browserConnected: partial?.browserConnected,
+        lastHeartbeatAgeMs: partial?.lastHeartbeatAgeMs,
+        queryCount: partial?.queryCount,
+        cancelledQueries,
+        extraLines: extraLines.length > 0 ? extraLines : void 0
+      }
+    };
+  }
+  async function resolveFirstAvailableModel(ctx2, candidates) {
+    let enabledModelPatterns = loadEnabledModelPatterns(ctx2);
+    for (let { provider, id } of candidates) {
+      let model = ctx2.modelRegistry.find(provider, id);
+      if (!model || !modelMatchesEnabledPatterns(model, enabledModelPatterns))
+        continue;
+      let auth = await ctx2.modelRegistry.getApiKeyAndHeaders(model);
+      if (auth.ok && auth.apiKey)
+        return { model, apiKey: auth.apiKey, headers: auth.headers };
+    }
+    throw new Error(`No enabled model available: ${candidates.map((c) => `${c.provider}/${c.id}`).join(", ")}`);
+  }
+  async function rewriteSearchQuery(query, ctx2, signal) {
+    let { model, apiKey, headers } = await resolveFirstAvailableModel(ctx2, [
+      { provider: "anthropic", id: "claude-haiku-4-5" },
+      { provider: "google", id: "gemini-2.5-flash" },
+      { provider: "openai", id: "gpt-4.1-mini" }
+    ]), response = await complete(model, {
+      messages: [{
+        role: "user",
+        content: [{ type: "text", text: `Rewrite this web search query to get better, more specific results. Add relevant year qualifiers, precise technical terms, and specificity. Return ONLY the improved query text, nothing else.
+
+Query: ${query}` }],
+        timestamp: Date.now()
+      }]
+    }, { apiKey, headers, signal });
+    if (response.stopReason === "aborted")
+      throw new Error("Aborted");
+    let text = (Array.isArray(response.content) ? response.content : []).map((p) => {
+      if (!p || typeof p != "object")
+        return "";
+      let part = p;
+      return typeof part.text == "string" ? part.text : "";
+    }).join("").trim();
+    if (!text)
+      throw new Error("Rewrite returned empty response");
+    return text;
+  }
+  async function generateSummaryForSelectedIndices(selectedQueryIndices, resultsByIndex, summaryContext, signal, modelOverride, feedback) {
+    let selectedResults = [];
+    for (let qi of selectedQueryIndices) {
+      let result = resultsByIndex.get(qi);
+      result && selectedResults.push(result);
+    }
+    if (selectedResults.length === 0)
+      throw new Error("No selected results available for summary generation");
+    let summaryReview = await ensureSummaryReview();
+    try {
+      return await summaryReview.generateSummaryDraft(selectedResults, summaryContext, signal, modelOverride, feedback);
+    } catch (err) {
+      if (!(err instanceof Error && err.message.includes("Summary model returned empty response")))
+        throw err;
+      let deterministic = summaryReview.buildDeterministicSummary(selectedResults);
+      return {
+        summary: deterministic.summary,
+        meta: {
+          ...deterministic.meta,
+          fallbackReason: "summary-model-empty-response"
+        }
+      };
+    }
+  }
+  async function loadSummaryModelChoices(summaryContext) {
+    let summaryModels = [], seen = /* @__PURE__ */ new Set(), availableValues = /* @__PURE__ */ new Set(), addModel = (provider, id) => {
+      let value = `${provider}/${id}`;
+      seen.has(value) || (seen.add(value), summaryModels.push({ value, label: value }));
+    }, enabledModelPatterns = null, scopeLoaded = !0;
+    try {
+      enabledModelPatterns = loadEnabledModelPatterns(summaryContext);
+      let availableModels = summaryContext.modelRegistry.getAvailable();
+      for (let model of availableModels) {
+        if (!modelMatchesEnabledPatterns(model, enabledModelPatterns))
+          continue;
+        let value = `${model.provider}/${model.id}`;
+        availableValues.add(value), addModel(model.provider, model.id);
+      }
+    } catch (err) {
+      scopeLoaded = !1;
+      let message = err instanceof Error ? err.message : String(err);
+      console.error(`Failed to load summary models: ${message}`);
+    }
+    let currentModelValue = summaryContext.model ? `${summaryContext.model.provider}/${summaryContext.model.id}` : null;
+    scopeLoaded && summaryContext.model && currentModelValue && !seen.has(currentModelValue) && modelMatchesEnabledPatterns(summaryContext.model, enabledModelPatterns) && addModel(summaryContext.model.provider, summaryContext.model.id);
+    let config = loadConfig(), configuredSummaryModel = typeof config.summaryModel == "string" ? config.summaryModel.trim() : "", preferredDefaults = [
+      "anthropic/claude-haiku-4-5",
+      "openai-codex/gpt-5.3-codex-spark"
+    ], defaultSummaryModel = null;
+    if (configuredSummaryModel.length > 0 && availableValues.has(configuredSummaryModel) && (defaultSummaryModel = configuredSummaryModel), !defaultSummaryModel) {
+      for (let preferred of preferredDefaults)
+        if (availableValues.has(preferred)) {
+          defaultSummaryModel = preferred;
+          break;
+        }
+    }
+    return { summaryModels, defaultSummaryModel };
+  }
+  function resolveSummaryForSubmit(payload, resultsByIndex) {
+    let submittedSummary = typeof payload.summary == "string" ? payload.summary.trim() : "";
+    if (submittedSummary.length > 0)
+      return {
+        approvedSummary: submittedSummary,
+        summaryMeta: normalizeSummaryMeta(payload.summaryMeta, submittedSummary)
+      };
+    let selected = filterByQueryIndices(payload.selectedQueryIndices, resultsByIndex).results, fallbackResults = selected.length > 0 ? selected : [...resultsByIndex.values()];
+    if (!warmSummaryReview)
+      throw new Error("Summary review module is not loaded");
+    let deterministic = warmSummaryReview.buildDeterministicSummary(fallbackResults);
+    return {
+      approvedSummary: deterministic.summary,
+      summaryMeta: deterministic.meta
+    };
+  }
+  function buildSearchReturn(opts) {
+    let sc = opts.results.filter((r) => !r.error).length, tr = opts.results.reduce((sum, r) => sum + r.results.length, 0), hasApprovedSummary = typeof opts.approvedSummary == "string" && opts.approvedSummary.trim().length > 0, output = "";
+    if (hasApprovedSummary)
+      output = opts.approvedSummary.trim();
+    else {
+      opts.curated && (output += `[These results were manually curated by the user in the browser. Use them as-is \u2014 do not re-search or discard.]
+
+`);
+      let duplicateQueries = opts.curated ? duplicateQuerySet(opts.results) : /* @__PURE__ */ new Set();
+      for (let { query, answer, results, error, provider } of opts.results)
+        opts.queryList.length > 1 && (output += opts.curated ? formatQueryHeader(query, provider, duplicateQueries) : `## Query: "${query}"
+
+`), error ? output += `Error: ${error}
+
+` : results.length === 0 ? output += `No results found.
+
+` : output += formatSearchSummary(results, answer) + `
+
+`;
+    }
+    let hasInlineReady = hasFullInlineCoverage(opts.urls, opts.inlineContent), fetchId = null;
+    if (hasInlineReady && opts.inlineContent) {
+      fetchId = generateId();
+      let data = {
+        id: fetchId,
+        type: "fetch",
+        timestamp: Date.now(),
+        urls: opts.inlineContent
+      };
+      storeResult(fetchId, data), pi.appendEntry("web-search-results", data), hasApprovedSummary || (output += `---
+Full content for ${opts.inlineContent.length} sources available [${fetchId}].`);
+    } else opts.includeContent && (fetchId = startBackgroundFetch(opts.urls), fetchId && !hasApprovedSummary && (output += `---
+Content fetching in background [${fetchId}]. Will notify when ready.`));
+    let searchId = storeAndPublishSearch(opts.results), isBackgroundFetch = fetchId !== null && !hasInlineReady;
+    return {
+      content: [{ type: "text", text: output.trim() }],
+      details: {
+        queries: opts.queryList,
+        queryCount: opts.queryList.length,
+        successfulQueries: sc,
+        totalResults: tr,
+        includeContent: opts.includeContent,
+        fetchId,
+        fetchUrls: isBackgroundFetch ? opts.urls : void 0,
+        searchId,
+        ...opts.curated ? {
+          curated: !0,
+          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 === !0,
+            fallbackReason: opts.summaryMeta?.fallbackReason,
+            edited: opts.summaryMeta?.edited === !0
+          }
+        } : {}
+      }
+    };
+  }
+  function filterByQueryIndices(selectedQueryIndices, results) {
+    let filteredResults = [], filteredUrls = [];
+    for (let qi of selectedQueryIndices) {
+      let r = results.get(qi);
+      if (r) {
+        filteredResults.push(r);
+        for (let res of r.results)
+          filteredUrls.includes(res.url) || filteredUrls.push(res.url);
+      }
+    }
+    return { results: filteredResults, urls: filteredUrls };
+  }
+  function collectAllResultsAndUrls(resultsByIndex) {
+    let results = [...resultsByIndex.values()], urls = [];
+    for (let result of results)
+      for (let source of result.results)
+        urls.includes(source.url) || urls.push(source.url);
+    return { results, urls };
+  }
+  async function openCuratorBrowser(callId, pc, searchesComplete = !0) {
+    if (pendingCurates.get(callId) !== pc)
+      return;
+    let handle = null;
+    try {
+      pc.phase = "curating";
+      let searchAbort = new AbortController(), addSearchSignal = pc.signal ? AbortSignal.any([pc.signal, searchAbort.signal]) : searchAbort.signal, sessionToken = randomUUID(), [{ startCuratorServer }] = await Promise.all([
+        loadCuratorServer(),
+        ensureSummaryReview()
+      ]);
+      if (pendingCurates.get(callId) !== pc)
+        return;
+      if (handle = await startCuratorServer({
+        queries: pc.queryList,
+        sessionToken,
+        timeout: pc.timeoutSeconds,
+        availableProviders: pc.availableProviders,
+        defaultProvider: pc.defaultProvider,
+        searchProvider: pc.searchProvider,
+        summaryModels: pc.summaryModels,
+        defaultSummaryModel: pc.defaultSummaryModel
+      }, {
+        async onSummarize(selectedQueryIndices, summarizeSignal, model, feedback) {
+          if (pendingCurates.get(callId) !== pc)
+            throw new Error("Curator session is no longer active.");
+          pc.onUpdate?.({
+            content: [{ type: "text", text: "Generating summary draft..." }],
+            details: { phase: "generating-summary", progress: 0.9, curatorUrl: pc.curatorUrl, timeoutSeconds: pc.timeoutSeconds, shortcut: curateKey }
+          });
+          let draft = await generateSummaryForSelectedIndices(selectedQueryIndices, pc.searchResults, pc.summaryContext, summarizeSignal, model, feedback);
+          if (pendingCurates.get(callId) !== pc)
+            throw new Error("Curator session is no longer active.");
+          return pc.onUpdate?.({
+            content: [{ type: "text", text: "Summary draft ready \u2014 waiting for approval..." }],
+            details: { phase: "waiting-for-approval", progress: 1, curatorUrl: pc.curatorUrl, timeoutSeconds: pc.timeoutSeconds, shortcut: curateKey }
+          }), draft;
+        },
+        onSubmit(payload) {
+          if (pendingCurates.get(callId) !== pc)
+            return;
+          searchAbort.abort();
+          let filtered = payload.selectedQueryIndices.length > 0 ? filterByQueryIndices(payload.selectedQueryIndices, pc.searchResults) : collectAllResultsAndUrls(pc.searchResults), filteredInline = pc.allInlineContent.filter((c) => filtered.urls.includes(c.url)), base = {
+            queryList: filtered.results.map((r) => r.query),
+            results: filtered.results,
+            urls: filtered.urls,
+            includeContent: pc.includeContent,
+            inlineContent: filteredInline.length > 0 ? filteredInline : void 0,
+            curated: !0,
+            curatedFrom: pc.searchResults.size
+          };
+          if (!payload.rawResults) {
+            let resolvedSummary = resolveSummaryForSubmit(payload, pc.searchResults);
+            base.workflow = pc.workflow, base.approvedSummary = resolvedSummary.approvedSummary, base.summaryMeta = resolvedSummary.summaryMeta;
+          }
+          pc.finish(buildSearchReturn(base)), closeCurator(callId);
+        },
+        onCancel(reason) {
+          if (pendingCurates.get(callId) === pc) {
+            if (searchAbort.abort(), reason === "timeout") {
+              let resolvedSummary = resolveSummaryForSubmit({ selectedQueryIndices: [], summary: void 0, summaryMeta: void 0 }, pc.searchResults), all = collectAllResultsAndUrls(pc.searchResults), filteredInline = pc.allInlineContent.filter((c) => all.urls.includes(c.url));
+              pc.finish(buildSearchReturn({
+                queryList: all.results.map((r) => r.query),
+                results: all.results,
+                urls: all.urls,
+                includeContent: pc.includeContent,
+                inlineContent: filteredInline.length > 0 ? filteredInline : void 0,
+                curated: !0,
+                curatedFrom: pc.searchResults.size,
+                workflow: pc.workflow,
+                approvedSummary: resolvedSummary.approvedSummary,
+                summaryMeta: resolvedSummary.summaryMeta
+              }));
+            } else {
+              let conn = activeCurators.get(callId)?.getConnectionState();
+              pc.finish(buildCurationCancelledReturn(reason, {
+                queries: Array.from(pc.searchResults.values()),
+                queryCount: pc.queryList.length,
+                browserConnected: conn?.browserConnected,
+                lastHeartbeatAgeMs: conn?.lastHeartbeatAgeMs,
+                curatorUrl: pc.curatorUrl,
+                browserOpenError: pc.browserOpenError
+              }));
+            }
+            closeCurator(callId);
+          }
+        },
+        onProviderChange(provider) {
+          if (pendingCurates.get(callId) !== pc)
+            return;
+          let normalized = normalizeProviderInput(provider);
+          if (!(!normalized || normalized === "auto")) {
+            pc.defaultProvider = normalized, pc.searchProvider = normalized;
+            try {
+              saveConfig({ provider: normalized });
+            } catch (err) {
+              let message = err instanceof Error ? err.message : String(err);
+              console.error(`Failed to persist default provider: ${message}`);
+            }
+          }
+        },
+        async onAddSearch(query, queryIndex, provider) {
+          if (pendingCurates.get(callId) !== pc)
+            throw new Error("Curator session is no longer active.");
+          let normalizedProvider = normalizeProviderInput(provider), requestedProvider = !normalizedProvider || normalizedProvider === "auto" ? pc.searchProvider : normalizedProvider;
+          try {
+            let { answer, results, inlineContent, provider: actualProvider } = await runSearch(query, {
+              provider: requestedProvider,
+              numResults: pc.numResults,
+              recencyFilter: pc.recencyFilter,
+              domainFilter: pc.domainFilter,
+              includeContent: pc.includeContent,
+              signal: addSearchSignal,
+              extensionContext: ctx
+            });
+            if (pendingCurates.get(callId) !== pc)
+              throw new Error("Curator session is no longer active.");
+            return pc.searchResults.set(queryIndex, { query, answer, results, error: null, provider: actualProvider }), inlineContent && pc.allInlineContent.push(...inlineContent), {
+              answer,
+              results: results.map((r) => ({ title: r.title, url: r.url, domain: extractDomain(r.url) })),
+              provider: actualProvider
+            };
+          } catch (err) {
+            let message = err instanceof Error ? err.message : String(err);
+            throw pendingCurates.get(callId) === pc && pc.searchResults.set(queryIndex, { query, answer: "", results: [], error: message, provider: requestedProvider }), err;
+          }
+        },
+        async onRewriteQuery(query, rewriteSignal) {
+          if (pendingCurates.get(callId) !== pc)
+            throw new Error("Curator session is no longer active.");
+          return rewriteSearchQuery(query, pc.summaryContext, rewriteSignal);
+        }
+      }), pendingCurates.get(callId) !== pc) {
+        handle.close();
+        return;
+      }
+      activeCurators.set(callId, handle), pc.curatorUrl = handle.url;
+      for (let [qi, data] of pc.searchResults)
+        data.error ? handle.pushError(qi, data.error, data.provider) : handle.pushResult(qi, {
+          answer: data.answer,
+          results: data.results.map((r) => ({ title: r.title, url: r.url, domain: extractDomain(r.url) })),
+          provider: data.provider || pc.defaultProvider
+        });
+      searchesComplete && handle.searchesDone();
+      let sendCuratorFallbackUpdate2 = (message) => {
+        pc.onUpdate?.({
+          content: [{ type: "text", text: `${message}
+Open manually: ${handle.url}` }],
+          details: {
+            phase: "curator-fallback",
+            progress: searchesComplete ? 1 : 0.5,
+            curatorUrl: handle.url,
+            timeoutSeconds: pc.timeoutSeconds,
+            shortcut: curateKey,
+            browserOpenError: pc.browserOpenError
+          }
+        });
+      };
+      pc.onUpdate?.({
+        content: [{ type: "text", text: searchesComplete ? "Waiting for summary approval in browser..." : "Searches streaming to browser..." }],
+        details: {
+          phase: "curating",
+          progress: searchesComplete ? 1 : 0.5,
+          curatorUrl: handle.url,
+          timeoutSeconds: pc.timeoutSeconds,
+          shortcut: curateKey
+        }
+      });
+      let open = platform() === "darwin" ? await getGlimpseOpen() : null;
+      if (open)
+        try {
+          let win = openInGlimpse(open, handle.url, "Search Curator");
+          glimpseWins.set(callId, win), win.on("closed", () => {
+            glimpseWins.get(callId) === win && (glimpseWins.delete(callId), closeCurator(callId));
+          });
+          return;
+        } catch (err) {
+          let message = err instanceof Error ? err.message : String(err);
+          console.error(`Failed to open Glimpse curator window: ${message}`), glimpseWins.delete(callId);
+        }
+      await openInBrowser(pi, handle.url);
+    } catch (err) {
+      let message = err instanceof Error ? err.message : String(err);
+      console.error(`Failed to open curator UI: ${message}`), handle && activeCurators.get(callId) === handle && pendingCurates.get(callId) === pc ? (pc.browserOpenError = message, sendCuratorFallbackUpdate("Search curator is running, but the browser did not open automatically.")) : (pendingCurates.get(callId) === pc || handle && activeCurators.get(callId) === handle) && closeCurator(callId);
+    }
+  }
+  pi.registerShortcut(curateKey, {
+    description: "Review search results",
+    handler: async (ctx2) => {
+      let entries = [...pendingCurates.entries()];
+      if (entries.length === 0)
+        return;
+      let [callId, pc] = entries[entries.length - 1];
+      if (pc.phase === "searching") {
+        pc.browserPromise = openCuratorBrowser(callId, pc, !1), ctx2.ui.notify("Opening curator \u2014 remaining searches will stream in", "info");
+        return;
+      }
+    }
+  }), pi.registerShortcut(activityKey, {
+    description: "Toggle web search activity",
+    handler: async (ctx2) => {
+      widgetVisible = !widgetVisible, widgetVisible ? (widgetUnsubscribe = activityMonitor.onUpdate(() => updateWidget(ctx2)), updateWidget(ctx2)) : (widgetUnsubscribe?.(), widgetUnsubscribe = null, ctx2.ui.setWidget("web-activity", void 0));
+    }
+  }), pi.on("session_start", async (_event, ctx2) => handleSessionChange(ctx2)), pi.on("session_tree", async (_event, ctx2) => handleSessionChange(ctx2)), pi.on("session_shutdown", () => {
+    sessionGeneration++, sessionAbort.abort(), sessionActive = !1, abortPendingFetches(), closeCurator(), runSessionCleanups(), clearResults(), widgetUnsubscribe?.(), widgetUnsubscribe = null, activityMonitor.clear(), widgetVisible = !1;
+  }), initConfig.webSearch?.enabled !== !1 && pi.registerTool({
+    name: "web_search",
+    label: "Web Search",
+    description: 'Search the web using OpenAI, Brave, Parallel, Tavily, Exa, Perplexity, or Gemini. Returns an AI-synthesized answer with source citations. OpenAI web_search uses a Codex subscription or OpenAI API key. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query \u2014 each query gets its own synthesized answer, so varying phrasing and scope gives much broader coverage. When includeContent is true, full page content is fetched in the background. Searches auto-open the interactive browser curator and stream results live; set workflow to "none" to skip curation or "auto-summary" for a model-generated summary without the browser curator. Provider auto-selects: OpenAI when suitable and available, then Exa, Brave, Parallel, Tavily, Perplexity, Gemini API, then Gemini Web.',
+    promptSnippet: "Use for web research questions. Prefer {queries:[...]} with 2-4 varied angles over a single query for broader coverage.",
+    parameters: Type.Object({
+      query: Type.Optional(Type.String({ description: "Single search query. For research tasks, prefer 'queries' with multiple varied angles instead." })),
+      queries: Type.Optional(Type.Array(Type.String(), { description: "Multiple queries searched in sequence, each returning its own synthesized answer. Prefer this for research \u2014 vary phrasing, scope, and angle across 2-4 queries to maximize coverage. Good: ['React vs Vue performance benchmarks 2026', 'React vs Vue developer experience comparison', 'React ecosystem size vs Vue ecosystem']. Bad: ['React vs Vue', 'React vs Vue comparison', 'React vs Vue review'] (too similar, redundant results)." })),
+      numResults: Type.Optional(Type.Number({ description: "Results per query (default: 5, max: 20)" })),
+      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)" })),
+      provider: Type.Optional(StringEnum(["auto", "openai", "brave", "parallel", "tavily", "exa", "perplexity", "gemini"], { description: "Search provider (default: auto)" })),
+      workflow: Type.Optional(StringEnum(["none", "summary-review", "auto-summary"], {
+        description: "Search workflow mode: none = no curator, summary-review = open curator with auto summary draft (default), auto-summary = generate summary without opening curator"
+      }))
+    }),
+    async execute(callId, params, incomingSignal, onUpdate, ctx2) {
+      let generation = sessionGeneration, signal = incomingSignal ? AbortSignal.any([incomingSignal, sessionAbort.signal]) : sessionAbort.signal;
+      assertActiveRequest(generation, signal);
+      let rawQueryList = Array.isArray(params.queries) ? params.queries : params.query !== void 0 ? [params.query] : [], queryList = normalizeQueryList(rawQueryList), configWorkflow = loadConfigForExtensionInit().workflow, workflow = resolveWorkflow(params.workflow ?? configWorkflow, ctx2?.hasUI !== !1), shouldCurate = workflow === "summary-review";
+      if (queryList.length === 0)
+        return {
+          content: [{ type: "text", text: "Error: No query provided. Use 'query' or 'queries' parameter." }],
+          details: { error: "No query provided" }
+        };
+      if (shouldCurate && !ctx2)
+        return {
+          content: [{ type: "text", text: "Error: Curation requires an active extension context." }],
+          details: { error: "Missing extension context" }
+        };
+      if (shouldCurate) {
+        closeCurator(callId);
+        let resolvePromise = () => {
+        }, promise = new Promise((resolve) => {
+          resolvePromise = resolve;
+        }), includeContent = params.includeContent ?? !1, searchResults2 = /* @__PURE__ */ new Map(), allInlineContent2 = [], searchAbort = new AbortController(), searchSignal = signal ? AbortSignal.any([signal, searchAbort.signal]) : searchAbort.signal, cancelled = !1, bootstrap = await loadCuratorBootstrap(params.provider, ctx2, {
+          numResults: params.numResults,
+          recencyFilter: params.recencyFilter
+        });
+        assertActiveRequest(generation, signal);
+        let availableProviders = bootstrap.availableProviders, defaultProvider = bootstrap.defaultProvider, searchProvider = (normalizeProviderInput(params.provider ?? loadConfig().provider ?? "auto") ?? "auto") === "auto" ? "auto" : defaultProvider, curatorTimeoutSeconds = bootstrap.timeoutSeconds, curatorWorkflow = "summary-review", summaryContext = {
+          model: ctx2.model,
+          modelRegistry: ctx2.modelRegistry,
+          cwd: ctx2.cwd,
+          isProjectTrusted: () => ctx2.isProjectTrusted()
+        }, summaryModelChoices = await loadSummaryModelChoices(summaryContext);
+        assertActiveRequest(generation, signal);
+        let pc = {
+          phase: "searching",
+          workflow: curatorWorkflow,
+          summaryContext,
+          searchResults: searchResults2,
+          allInlineContent: allInlineContent2,
+          queryList,
+          includeContent,
+          numResults: params.numResults,
+          recencyFilter: params.recencyFilter,
+          domainFilter: params.domainFilter,
+          availableProviders,
+          defaultProvider,
+          searchProvider,
+          summaryModels: summaryModelChoices.summaryModels,
+          defaultSummaryModel: summaryModelChoices.defaultSummaryModel,
+          timeoutSeconds: curatorTimeoutSeconds,
+          onUpdate,
+          signal,
+          abortSearches: () => {
+            searchAbort.signal.aborted || searchAbort.abort();
+          },
+          finish: () => {
+          },
+          cancel: () => {
+          }
+        }, finish = (value) => {
+          cancelled || (cancelled = !0, pc.abortSearches(), signal?.removeEventListener("abort", onAbort), pendingCurates.delete(callId), resolvePromise(value));
+        }, cancel = (reason = "stale") => {
+          if (cancelled)
+            return;
+          let conn = activeCurators.get(callId)?.getConnectionState();
+          finish(buildCurationCancelledReturn(reason, {
+            queries: Array.from(searchResults2.values()),
+            queryCount: queryList.length,
+            browserConnected: conn?.browserConnected,
+            lastHeartbeatAgeMs: conn?.lastHeartbeatAgeMs,
+            curatorUrl: pc.curatorUrl,
+            browserOpenError: pc.browserOpenError
+          }));
+        };
+        pc.finish = finish, pc.cancel = cancel;
+        let onAbort = () => closeCurator(callId);
+        pendingCurates.set(callId, pc), signal?.addEventListener("abort", onAbort, { once: !0 }), pc.browserPromise = openCuratorBrowser(callId, pc, !1);
+        for (let qi = 0; qi < queryList.length && !(signal?.aborted || cancelled || searchAbort.signal.aborted); qi++) {
+          onUpdate?.({
+            content: [{ type: "text", text: `Searching ${qi + 1}/${queryList.length}: "${queryList[qi]}"...` }],
+            details: { phase: "searching", progress: qi / queryList.length, currentQuery: queryList[qi] }
+          });
+          let requestedProvider = pc.searchProvider;
+          try {
+            let { answer, results, inlineContent, provider } = await runSearch(queryList[qi], {
+              provider: requestedProvider,
+              numResults: params.numResults,
+              recencyFilter: params.recencyFilter,
+              domainFilter: params.domainFilter,
+              includeContent: params.includeContent,
+              signal: searchSignal,
+              extensionContext: ctx2
+            });
+            if (signal?.aborted || cancelled || searchAbort.signal.aborted)
+              break;
+            searchResults2.set(qi, { query: queryList[qi], answer, results, error: null, provider }), inlineContent && allInlineContent2.push(...inlineContent);
+            let curator2 = activeCurators.get(callId);
+            curator2 && curator2.pushResult(qi, {
+              answer,
+              results: results.map((r) => ({ title: r.title, url: r.url, domain: extractDomain(r.url) })),
+              provider
+            });
+          } catch (err) {
+            if (signal?.aborted || cancelled || searchAbort.signal.aborted)
+              break;
+            let message = err instanceof Error ? err.message : String(err);
+            searchResults2.set(qi, { query: queryList[qi], answer: "", results: [], error: message, provider: requestedProvider });
+            let curator2 = activeCurators.get(callId);
+            curator2 && curator2.pushError(qi, message, requestedProvider);
+          }
+        }
+        if (signal?.aborted || cancelled || searchAbort.signal.aborted)
+          return cancel(), promise;
+        await pc.browserPromise;
+        let curator = activeCurators.get(callId);
+        return curator && !cancelled && (curator.searchesDone(), pc.browserOpenError ? pc.onUpdate?.({
+          content: [{ type: "text", text: `All searches complete. Open the curator manually: ${pc.curatorUrl}` }],
+          details: {
+            phase: "curator-fallback",
+            progress: 1,
+            curatorUrl: pc.curatorUrl,
+            timeoutSeconds: pc.timeoutSeconds,
+            shortcut: curateKey,
+            browserOpenError: pc.browserOpenError
+          }
+        }) : pc.onUpdate?.({
+          content: [{ type: "text", text: "All searches complete \u2014 waiting for summary approval in browser..." }],
+          details: {
+            phase: "curating",
+            progress: 1,
+            curatorUrl: pc.curatorUrl,
+            timeoutSeconds: pc.timeoutSeconds,
+            shortcut: curateKey
+          }
+        })), promise;
+      }
+      let searchResults = [], allUrls = [], allInlineContent = [], resolvedProvider = normalizeProviderInput(params.provider ?? loadConfig().provider);
+      for (let i = 0; i < queryList.length; i++) {
+        assertActiveRequest(generation, signal);
+        let query = queryList[i];
+        onUpdate?.({
+          content: [{ type: "text", text: `Searching ${i + 1}/${queryList.length}: "${query}"...` }],
+          details: { phase: "search", progress: i / queryList.length, currentQuery: query }
+        });
+        try {
+          let { answer, results, inlineContent, provider } = await runSearch(query, {
+            provider: resolvedProvider,
+            numResults: params.numResults,
+            recencyFilter: params.recencyFilter,
+            domainFilter: params.domainFilter,
+            includeContent: params.includeContent,
+            signal,
+            extensionContext: ctx2
+          });
+          assertActiveRequest(generation, signal), searchResults.push({ query, answer, results, error: null, provider });
+          for (let r of results)
+            allUrls.includes(r.url) || allUrls.push(r.url);
+          inlineContent && allInlineContent.push(...inlineContent);
+        } catch (err) {
+          assertActiveRequest(generation, signal);
+          let message = err instanceof Error ? err.message : String(err), requestedProvider = typeof resolvedProvider == "string" && resolvedProvider !== "auto" ? resolvedProvider : void 0;
+          searchResults.push({ query, answer: "", results: [], error: message, provider: requestedProvider });
+        }
+      }
+      let approvedSummary, summaryMeta;
+      if (workflow === "auto-summary") {
+        if (!ctx2)
+          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 }
+        });
+        let summaryContext = {
+          model: ctx2.model,
+          modelRegistry: ctx2.modelRegistry,
+          cwd: ctx2.cwd,
+          isProjectTrusted: () => ctx2.isProjectTrusted()
+        }, summaryModelChoices = await loadSummaryModelChoices(summaryContext), generated = await (await ensureSummaryReview()).generateSummaryDraft(searchResults, summaryContext, signal, summaryModelChoices.defaultSummaryModel ?? void 0);
+        approvedSummary = generated.summary, summaryMeta = generated.meta;
+      }
+      return assertActiveRequest(generation, signal), buildSearchReturn({
+        queryList,
+        results: searchResults,
+        urls: allUrls,
+        includeContent: params.includeContent ?? !1,
+        inlineContent: allInlineContent.length > 0 ? allInlineContent : void 0,
+        workflow: workflow === "auto-summary" ? "auto-summary" : void 0,
+        approvedSummary,
+        summaryMeta
+      });
+    },
+    renderCall(args, theme, context) {
+      let queryList = collectSearchQueries(args), compact = !!(context && !context.isPartial && !context.expanded && !context.isError);
+      if (formatSearchCallTitle(queryList).empty)
+        return new Text(theme.fg("toolTitle", theme.bold("search ")) + theme.fg("error", "(no query)"), 0, 0);
+      let detail = formatSearchDetail(queryList, compact ? context?.result?.details : void 0);
+      return new Text(formatGroupedCall({
+        role: context?.groupRole ?? "singleton",
+        compact,
+        tree: context ? toolGroupTree(context) : !1,
+        dot: context ? toolStatusDotFromContext(context, theme) : theme.fg("success", "\u25CF"),
+        title: theme.fg("toolTitle", theme.bold("search")),
+        detail: theme.fg("accent", detail)
+      }), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme, context) {
+      let details = result.details;
+      if (isPartial) {
+        if (details?.phase === "curator-fallback") {
+          let lines = [theme.fg("warning", "Open the search curator manually:")];
+          details?.curatorUrl && lines.push(theme.fg("muted", `  ${details.curatorUrl}`)), details?.browserOpenError && lines.push(theme.fg("dim", `  auto-open failed: ${details.browserOpenError}`));
+          let timeout = typeof details?.timeoutSeconds == "number" ? details.timeoutSeconds : void 0, shortcut = typeof details?.shortcut == "string" ? details.shortcut : curateKey;
+          return lines.push(theme.fg("dim", timeout ? `  auto-submits after ${timeout}s idle; ${shortcut} reopens` : `  ${shortcut} reopens`)), new Text(lines.join(`
+`), 0, 0);
+        }
+        if (details?.phase === "curating" || details?.phase === "waiting-for-approval" || details?.phase === "generating-summary") {
+          let phaseText = details?.phase === "generating-summary" ? "generating summary draft..." : details?.phase === "waiting-for-approval" ? "summary draft ready; approve in browser..." : "waiting for summary approval in browser...", lines = [theme.fg("accent", phaseText)];
+          details?.curatorUrl && lines.push(theme.fg("muted", `  ${details.curatorUrl}`));
+          let timeout = typeof details?.timeoutSeconds == "number" ? details.timeoutSeconds : void 0, shortcut = typeof details?.shortcut == "string" ? details.shortcut : curateKey;
+          return timeout ? lines.push(theme.fg("dim", `  auto-submits after ${timeout}s idle; ${shortcut} reopens`)) : lines.push(theme.fg("dim", `  ${shortcut} reopens`)), new Text(lines.join(`
+`), 0, 0);
+        }
+        if (details?.phase === "searching") {
+          let progress2 = details?.progress ?? 0, bar2 = "\u2588".repeat(Math.floor(progress2 * 10)) + "\u2591".repeat(10 - Math.floor(progress2 * 10)), query = details?.currentQuery || "", display = query.length > 40 ? query.slice(0, 37) + "..." : query;
+          return new Text(theme.fg("accent", `[${bar2}] ${display}`), 0, 0);
+        }
+        let progress = details?.progress ?? 0, bar = "\u2588".repeat(Math.floor(progress * 10)) + "\u2591".repeat(10 - Math.floor(progress * 10));
+        return new Text(theme.fg("accent", `[${bar}] ${details?.phase || "searching"}`), 0, 0);
+      }
+      if (details?.error) {
+        let plan = buildSearchErrorPlan(details);
+        return plan ? renderSearchErrorPlan(plan, expanded, theme) : new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+      }
+      let queryList = collectSearchQueries(context?.args), fallbackQueries = (details?.curatedQueries ?? []).map((cq) => cq.query).filter(Boolean), chrome = formatSearchChrome({
+        queries: queryList.length > 0 ? queryList : fallbackQueries,
+        details,
+        expanded
+      }), statusColor = expanded ? "accent" : "success";
+      return new Text(chrome.result.map((line) => theme.fg(statusColor, line)).join(`
+`), 0, 0);
+    }
+  }), pi.registerTool({
+    name: "fetch_content",
+    label: "Fetch Content",
+    description: "Fetch URL(s) and extract readable content as markdown. Supports YouTube video transcripts (with thumbnail), GitHub repository contents, and local video files (with frame thumbnail). Video frames can be extracted via timestamp/range or sampled across the entire video with frames alone. Falls back to Gemini for pages that block bots or fail Readability extraction. For YouTube and video files: ALWAYS pass the user's specific question via the prompt parameter \u2014 this directs the AI to focus on that aspect of the video, producing much better results than a generic extraction. Content is always stored and can be retrieved with get_search_content.",
+    promptSnippet: "Use to extract readable content from URL(s), YouTube, GitHub repos, or local videos. For video questions, pass the user's exact question in prompt.",
+    parameters: Type.Object({
+      url: Type.Optional(Type.String({ description: "Single URL to fetch" })),
+      urls: Type.Optional(Type.Array(Type.String(), { description: "Multiple URLs (parallel)" })),
+      forceClone: Type.Optional(Type.Boolean({
+        description: "Force cloning large GitHub repositories that exceed the size threshold"
+      })),
+      prompt: Type.Optional(Type.String({
+        description: "Question or instruction for video analysis (YouTube and video files). Pass the user's specific question here \u2014 e.g. 'describe the book shown at the advice for beginners section'. Without this, a generic transcript extraction is used which may miss what the user is asking about."
+      })),
+      timestamp: Type.Optional(Type.String({
+        description: "Extract video frame(s) at a timestamp or time range. Single: '1:23:45', '23:45', or '85' (seconds). Range: '23:41-25:00' extracts evenly-spaced frames across that span (default 6). Use frames with ranges to control density; single+frames uses a fixed 5s interval. YouTube requires yt-dlp + ffmpeg; local videos require ffmpeg. Use a range when you know the approximate area but not the exact moment \u2014 you'll get a contact sheet to visually identify the right frame."
+      })),
+      frames: Type.Optional(Type.Integer({
+        minimum: 1,
+        maximum: 12,
+        description: "Number of frames to extract. Use with timestamp range for custom density, with single timestamp to get N frames at 5s intervals, or alone to sample across the entire video. Requires yt-dlp + ffmpeg for YouTube, ffmpeg for local video."
+      })),
+      model: Type.Optional(Type.String({
+        description: "Override the Gemini model for video/YouTube analysis (e.g. 'gemini-2.5-flash', 'gemini-3-flash-preview'). Defaults to config or gemini-3-flash-preview."
+      }))
+    }),
+    async execute(_toolCallId, params, incomingSignal, onUpdate) {
+      let generation = sessionGeneration, signal = incomingSignal ? AbortSignal.any([incomingSignal, sessionAbort.signal]) : sessionAbort.signal;
+      assertActiveRequest(generation, signal);
+      let { urlList, options } = normalizeFetchContentParams(params);
+      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 }
+      });
+      let { fetchAllContent } = await loadExtract();
+      if (signal?.aborted)
+        return {
+          content: [{ type: "text", text: "Error: Aborted" }],
+          details: { error: "Aborted", urls: urlList, urlCount: urlList.length, successful: 0 }
+        };
+      let fetchResults = await fetchAllContent(urlList, signal, options);
+      assertActiveRequest(generation, signal);
+      let successful = fetchResults.filter((r) => !r.error).length, totalChars = fetchResults.reduce((sum, r) => sum + r.content.length, 0), responseId = generateId(), data = {
+        id: responseId,
+        type: "fetch",
+        timestamp: Date.now(),
+        urls: stripThumbnails(fetchResults)
+      };
+      if (storeResult(responseId, data), pi.appendEntry("web-search-results", data), urlList.length === 1) {
+        let result = fetchResults[0];
+        if (result.error)
+          return {
+            content: [{ type: "text", text: `Error: ${result.error}` }],
+            details: { urls: urlList, urlCount: 1, successful: 0, error: result.error, responseId, prompt: params.prompt, timestamp: params.timestamp, frames: params.frames }
+          };
+        let fullLength = result.content.length, truncated = fullLength > MAX_INLINE_CONTENT, output2 = truncated ? result.content.slice(0, MAX_INLINE_CONTENT) + `
+
+[Content truncated...]` : result.content;
+        truncated && (output2 += `
+
+---
+Showing ${MAX_INLINE_CONTENT} of ${fullLength} chars. Use get_search_content({ responseId: "${responseId}", urlIndex: 0 }) for full content.`);
+        let content = [];
+        if (result.frames?.length)
+          for (let frame of result.frames)
+            content.push({ type: "image", data: frame.data, mimeType: frame.mimeType }), content.push({ type: "text", text: `Frame at ${frame.timestamp}` });
+        else result.thumbnail && content.push({ type: "image", data: result.thumbnail.data, mimeType: result.thumbnail.mimeType });
+        content.push({ type: "text", text: output2 });
+        let imageCount = (result.frames?.length ?? 0) + (result.thumbnail ? 1 : 0);
+        return {
+          content,
+          details: {
+            urls: urlList,
+            urlCount: 1,
+            successful: 1,
+            totalChars: fullLength,
+            title: result.title,
+            responseId,
+            truncated,
+            hasImage: imageCount > 0,
+            imageCount,
+            prompt: params.prompt,
+            timestamp: params.timestamp,
+            frames: params.frames,
+            duration: result.duration
+          }
+        };
+      }
+      let output = `## Fetched URLs
+
+`;
+      for (let { url, title, content, error } of fetchResults)
+        error ? output += `- ${url}: Error - ${error}
+` : output += `- ${title || url} (${content.length} chars)
+`;
+      return output += `
+---
+Use get_search_content({ responseId: "${responseId}", urlIndex: 0 }) to retrieve full content.`, {
+        content: [{ type: "text", text: output }],
+        details: { urls: urlList, urlCount: urlList.length, successful, totalChars, responseId }
+      };
+    },
+    renderCall(args, theme, context) {
+      let urlList = collectFetchUrls(args), compact = !!(context && !context.isPartial && !context.expanded && !context.isError);
+      if (formatFetchCallTitle(urlList).empty)
+        return new Text(theme.fg("toolTitle", theme.bold("fetch ")) + theme.fg("error", "(no URL)"), 0, 0);
+      let detail = formatFetchDetail(urlList, compact ? context?.result?.details : void 0);
+      return new Text(formatGroupedCall({
+        role: context?.groupRole ?? "singleton",
+        compact,
+        tree: context ? toolGroupTree(context) : !1,
+        dot: context ? toolStatusDotFromContext(context, theme) : theme.fg("success", "\u25CF"),
+        title: theme.fg("toolTitle", theme.bold("fetch")),
+        detail: theme.fg("accent", detail)
+      }), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme, context) {
+      let details = result.details;
+      if (isPartial) {
+        let progress = details?.progress ?? 0, bar = "\u2588".repeat(Math.floor(progress * 10)) + "\u2591".repeat(10 - Math.floor(progress * 10));
+        return new Text(theme.fg("accent", `[${bar}] ${details?.phase || "fetching"}`), 0, 0);
+      }
+      if (details?.error) {
+        let fd = details, extras = [];
+        if ((typeof fd.urlCount == "number" || typeof fd.successful == "number") && extras.push(`urls: ${fd.successful ?? 0}/${fd.urlCount ?? 0} succeeded`), fd.responseId && extras.push(`response id: ${fd.responseId}`), fd.urls && fd.urls.length > 0) {
+          for (let u of fd.urls.slice(0, 8))
+            extras.push(`  \u25B8 ${u}`);
+          fd.urls.length > 8 && extras.push(`  ... and ${fd.urls.length - 8} more`);
+        }
+        let plan = buildSearchErrorPlan({ error: details.error, extraLines: extras });
+        return plan ? renderSearchErrorPlan(plan, expanded, theme) : new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+      }
+      let urlList = collectFetchUrls(context?.args), fallbackUrls = Array.isArray(details?.urls) ? details.urls : [], chrome = formatFetchChrome({
+        urls: urlList.length > 0 ? urlList : fallbackUrls,
+        details,
+        expanded
+      }), statusColor = expanded ? "accent" : (details?.successful ?? 0) > 0 || details?.urlCount === 1 ? "success" : "error";
+      return new Text(chrome.result.map((line) => theme.fg(statusColor, line)).join(`
+`), 0, 0);
+    }
+  }), pi.registerTool({
+    name: "get_search_content",
+    label: "Get Search Content",
+    description: "Retrieve full content from a previous web_search or fetch_content call.",
+    promptSnippet: "Use after web_search/fetch_content when full stored content is needed via responseId plus query/url selectors.",
+    parameters: Type.Object({
+      responseId: Type.String({ description: "The responseId from web_search or fetch_content" }),
+      query: Type.Optional(Type.String({ description: "Get content for this query (web_search)" })),
+      queryIndex: Type.Optional(Type.Number({ description: "Get content for query at index" })),
+      url: Type.Optional(Type.String({ description: "Get content for this URL" })),
+      urlIndex: Type.Optional(Type.Number({ description: "Get content for URL at index" }))
+    }),
+    async execute(_toolCallId, params) {
+      let data = getResult(params.responseId);
+      if (!data)
+        return {
+          content: [{ type: "text", text: `Error: No stored results for "${params.responseId}"` }],
+          details: { error: "Not found", responseId: params.responseId }
+        };
+      if (data.type === "search" && data.queries) {
+        let queryData;
+        if (params.query !== void 0) {
+          if (queryData = data.queries.find((q) => q.query === params.query), !queryData) {
+            let available = data.queries.map((q) => `"${q.query}"`).join(", ");
+            return {
+              content: [{ type: "text", text: `Query "${params.query}" not found. Available: ${available}` }],
+              details: { error: "Query not found" }
+            };
+          }
+        } else if (params.queryIndex !== void 0) {
+          if (queryData = data.queries[params.queryIndex], !queryData)
+            return {
+              content: [{ type: "text", text: `Index ${params.queryIndex} out of range (0-${data.queries.length - 1})` }],
+              details: { error: "Index out of range" }
+            };
+        } else
+          return {
+            content: [{ type: "text", text: `Specify query or queryIndex. Available: ${data.queries.map((q, i) => `${i}: "${q.query}"`).join(", ")}` }],
+            details: { error: "No query specified" }
+          };
+        return queryData.error ? {
+          content: [{ type: "text", text: `Error for "${queryData.query}": ${queryData.error}` }],
+          details: { error: queryData.error, query: queryData.query }
+        } : {
+          content: [{ type: "text", text: formatFullResults(queryData) }],
+          details: { query: queryData.query, resultCount: queryData.results.length }
+        };
+      }
+      if (data.type === "fetch" && data.urls) {
+        let urlData;
+        if (params.url !== void 0) {
+          if (urlData = data.urls.find((u) => u.url === params.url), !urlData)
+            return {
+              content: [{ type: "text", text: `URL not found. Available:
+  ${data.urls.map((u) => u.url).join(`
+  `)}` }],
+              details: { error: "URL not found" }
+            };
+        } else if (params.urlIndex !== void 0) {
+          if (urlData = data.urls[params.urlIndex], !urlData)
+            return {
+              content: [{ type: "text", text: `Index ${params.urlIndex} out of range (0-${data.urls.length - 1})` }],
+              details: { error: "Index out of range" }
+            };
+        } else
+          return {
+            content: [{ type: "text", text: `Specify url or urlIndex. Available:
+  ${data.urls.map((u, i) => `${i}: ${u.url}`).join(`
+  `)}` }],
+            details: { error: "No URL specified" }
+          };
+        return urlData.error ? {
+          content: [{ type: "text", text: `Error for ${urlData.url}: ${urlData.error}` }],
+          details: { error: urlData.error, url: urlData.url }
+        } : {
+          content: [{ type: "text", text: `# ${urlData.title}
+
+${urlData.content}` }],
+          details: { url: urlData.url, title: urlData.title, contentLength: urlData.content.length }
+        };
+      }
+      return {
+        content: [{ type: "text", text: "Invalid stored data format" }],
+        details: { error: "Invalid data" }
+      };
+    },
+    renderCall(args, theme) {
+      let { responseId, query, queryIndex, url, urlIndex } = args, target = "";
+      return query ? target = `query="${query}"` : queryIndex !== void 0 ? target = `queryIndex=${queryIndex}` : url ? target = url.length > 30 ? url.slice(0, 27) + "..." : url : urlIndex !== void 0 && (target = `urlIndex=${urlIndex}`), new Text(theme.fg("toolTitle", theme.bold("get_content ")) + theme.fg("accent", target || responseId.slice(0, 8)), 0, 0);
+    },
+    renderResult(result, { expanded }, theme) {
+      let details = result.details;
+      if (details?.error) {
+        let extras = [];
+        details.query && extras.push(`query: ${details.query}`), details.url ? extras.push(`url: ${details.url}`) : details.title && extras.push(`resource: ${details.title}`);
+        let plan = buildSearchErrorPlan({ error: details.error, extraLines: extras });
+        return plan ? renderSearchErrorPlan(plan, expanded, theme) : new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+      }
+      let statusLine;
+      if (details?.query ? statusLine = theme.fg("success", `"${details.query}"`) + theme.fg("muted", ` (${details.resultCount} results)`) : statusLine = theme.fg("success", details?.title || "Content") + theme.fg("muted", ` (${details?.contentLength ?? 0} chars)`), !expanded)
+        return new Text(statusLine, 0, 0);
+      let textContent = result.content.find((c) => c.type === "text")?.text || "", preview = textContent.length > 500 ? textContent.slice(0, 500) + "..." : textContent;
+      return new Text(statusLine + `
+` + theme.fg("dim", preview), 0, 0);
+    }
+  }), pi.registerCommand("websearch", {
+    description: "Open web search curator",
+    handler: async (args, ctx2) => {
+      let generation = sessionGeneration, sessionSignal = sessionAbort.signal, sessionToken = randomUUID(), commandCallId = `cmd:${sessionToken}`;
+      closeCurator(commandCallId);
+      let raw = args.trim(), queries = raw.length > 0 ? normalizeQueryList(raw.split(",")) : [], bootstrap;
+      try {
+        bootstrap = await loadCuratorBootstrap(void 0, ctx2);
+      } catch (err) {
+        if (generation !== sessionGeneration)
+          return;
+        let message = err instanceof Error ? err.message : String(err);
+        ctx2.ui.notify(`Failed to load web search config: ${message}`, "error");
+        return;
+      }
+      if (generation !== sessionGeneration)
+        return;
+      let availableProviders = bootstrap.availableProviders, initialProvider = bootstrap.defaultProvider, curatorTimeoutSeconds = bootstrap.timeoutSeconds, currentProvider = initialProvider, currentSearchProvider = (normalizeProviderInput(loadConfig().provider ?? "auto") ?? "auto") === "auto" ? "auto" : initialProvider, summaryContext = {
+        model: ctx2.model,
+        modelRegistry: ctx2.modelRegistry,
+        cwd: ctx2.cwd,
+        isProjectTrusted: () => ctx2.isProjectTrusted()
+      }, summaryModelChoices = await loadSummaryModelChoices(summaryContext);
+      if (generation !== sessionGeneration)
+        return;
+      ctx2.ui.notify("Opening web search curator...", "info");
+      let collected = /* @__PURE__ */ new Map(), searchAbort = new AbortController(), searchSignal = AbortSignal.any([searchAbort.signal, sessionSignal]), aborted = !1, commandHandle = null, isCommandActive = () => generation === sessionGeneration && (commandHandle === null || activeCurators.get(commandCallId) === commandHandle);
+      function sendFollowUpFromReturn(payload) {
+        pi.sendMessage({
+          customType: "web-search-results",
+          content: payload.content,
+          display: !0,
+          details: payload.details
+        }, { triggerTurn: !0, deliverAs: "followUp" });
+      }
+      try {
+        let [{ startCuratorServer }] = await Promise.all([
+          loadCuratorServer(),
+          ensureSummaryReview()
+        ]);
+        if (!isCommandActive())
+          return;
+        let handle = await startCuratorServer({
+          queries,
+          sessionToken,
+          timeout: curatorTimeoutSeconds,
+          availableProviders,
+          defaultProvider: initialProvider,
+          searchProvider: currentSearchProvider,
+          summaryModels: summaryModelChoices.summaryModels,
+          defaultSummaryModel: summaryModelChoices.defaultSummaryModel
+        }, {
+          async onSummarize(selectedQueryIndices, summarizeSignal, model, feedback) {
+            if (!isCommandActive())
+              throw new Error("Curator session is no longer active.");
+            return generateSummaryForSelectedIndices(selectedQueryIndices, collected, summaryContext, summarizeSignal, model, feedback);
+          },
+          onSubmit(payload) {
+            if (!isCommandActive())
+              return;
+            aborted = !0, searchAbort.abort();
+            let filtered = payload.selectedQueryIndices.length > 0 ? filterByQueryIndices(payload.selectedQueryIndices, collected) : collectAllResultsAndUrls(collected), base = {
+              queryList: filtered.results.map((r) => r.query),
+              results: filtered.results,
+              urls: filtered.urls,
+              includeContent: !1,
+              curated: !0,
+              curatedFrom: collected.size
+            };
+            if (!payload.rawResults) {
+              let resolvedSummary = resolveSummaryForSubmit(payload, collected);
+              base.workflow = "summary-review", base.approvedSummary = resolvedSummary.approvedSummary, base.summaryMeta = resolvedSummary.summaryMeta;
+            }
+            sendFollowUpFromReturn(buildSearchReturn(base)), closeCurator(commandCallId);
+          },
+          onCancel(reason) {
+            if (isCommandActive()) {
+              if (aborted = !0, searchAbort.abort(), reason === "timeout") {
+                let all = collectAllResultsAndUrls(collected), resolvedSummary = resolveSummaryForSubmit({ selectedQueryIndices: [], summary: void 0, summaryMeta: void 0 }, collected);
+                sendFollowUpFromReturn(buildSearchReturn({
+                  queryList: all.results.map((r) => r.query),
+                  results: all.results,
+                  urls: all.urls,
+                  includeContent: !1,
+                  curated: !0,
+                  curatedFrom: collected.size,
+                  workflow: "summary-review",
+                  approvedSummary: resolvedSummary.approvedSummary,
+                  summaryMeta: resolvedSummary.summaryMeta
+                }));
+              }
+              closeCurator(commandCallId);
+            }
+          },
+          onProviderChange(provider) {
+            if (!isCommandActive())
+              return;
+            let normalized = normalizeProviderInput(provider);
+            if (!(!normalized || normalized === "auto")) {
+              currentProvider = normalized, currentSearchProvider = normalized;
+              try {
+                saveConfig({ provider: normalized });
+              } catch (err) {
+                let message = err instanceof Error ? err.message : String(err);
+                console.error(`Failed to persist default provider: ${message}`);
+              }
+            }
+          },
+          async onAddSearch(query, queryIndex, provider) {
+            if (!isCommandActive())
+              throw new Error("Curator session is no longer active.");
+            let normalizedProvider = normalizeProviderInput(provider), requestedProvider = !normalizedProvider || normalizedProvider === "auto" ? currentSearchProvider : normalizedProvider;
+            try {
+              let { answer, results, provider: actualProvider } = await runSearch(query, {
+                provider: requestedProvider,
+                signal: searchSignal,
+                extensionContext: ctx2
+              });
+              if (!isCommandActive())
+                throw new Error("Curator session is no longer active.");
+              return collected.set(queryIndex, { query, answer, results, error: null, provider: actualProvider }), {
+                answer,
+                results: results.map((r) => ({ title: r.title, url: r.url, domain: extractDomain(r.url) })),
+                provider: actualProvider
+              };
+            } catch (err) {
+              let message = err instanceof Error ? err.message : String(err);
+              throw isCommandActive() && collected.set(queryIndex, { query, answer: "", results: [], error: message, provider: requestedProvider }), err;
+            }
+          },
+          async onRewriteQuery(query, rewriteSignal) {
+            if (!isCommandActive())
+              throw new Error("Curator session is no longer active.");
+            return rewriteSearchQuery(query, summaryContext, rewriteSignal);
+          }
+        });
+        if (!isCommandActive()) {
+          handle.close();
+          return;
+        }
+        commandHandle = handle, activeCurators.set(commandCallId, handle);
+        let open = platform() === "darwin" ? await getGlimpseOpen() : null;
+        if (!isCommandActive())
+          return;
+        let browserOpenError = null;
+        if (open)
+          try {
+            let win = openInGlimpse(open, handle.url, "Search Curator");
+            glimpseWins.set(commandCallId, win), win.on("closed", () => {
+              glimpseWins.get(commandCallId) === win && (glimpseWins.delete(commandCallId), closeCurator(commandCallId));
+            });
+          } catch (err) {
+            let message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to open Glimpse curator window: ${message}`), glimpseWins.delete(commandCallId);
+            try {
+              await openInBrowser(pi, handle.url);
+            } catch (browserErr) {
+              browserOpenError = browserErr instanceof Error ? browserErr.message : String(browserErr);
+            }
+          }
+        else
+          try {
+            await openInBrowser(pi, handle.url);
+          } catch (browserErr) {
+            browserOpenError = browserErr instanceof Error ? browserErr.message : String(browserErr);
+          }
+        if (!isCommandActive())
+          return;
+        browserOpenError && (console.error(`Failed to open curator UI: ${browserOpenError}`), ctx2.ui.notify(`Search curator is running, but the browser did not open automatically. Open manually: ${handle.url}`, "info")), queries.length > 0 ? (async () => {
+          for (let qi = 0; qi < queries.length && !(aborted || !isCommandActive()); qi++) {
+            let requestedProvider = currentSearchProvider;
+            try {
+              let { answer, results, provider } = await runSearch(queries[qi], {
+                provider: requestedProvider,
+                signal: searchSignal,
+                extensionContext: ctx2
+              });
+              if (aborted || !isCommandActive())
+                break;
+              handle.pushResult(qi, {
+                answer,
+                results: results.map((r) => ({ title: r.title, url: r.url, domain: extractDomain(r.url) })),
+                provider
+              }), collected.set(qi, { query: queries[qi], answer, results, error: null, provider });
+            } catch (err) {
+              if (aborted || !isCommandActive())
+                break;
+              let message = err instanceof Error ? err.message : String(err);
+              handle.pushError(qi, message, requestedProvider), collected.set(qi, { query: queries[qi], answer: "", results: [], error: message, provider: requestedProvider });
+            }
+          }
+          !aborted && isCommandActive() && handle.searchesDone();
+        })() : isCommandActive() && handle.searchesDone();
+      } catch (err) {
+        if (closeCurator(commandCallId), generation !== sessionGeneration)
+          return;
+        let message = err instanceof Error ? err.message : String(err);
+        ctx2.ui.notify(`Failed to open curator: ${message}`, "error");
+      }
+    }
+  }), pi.registerCommand("curator", {
+    description: "Toggle or configure the search curator workflow",
+    handler: async (args, ctx2) => {
+      let arg = args.trim().toLowerCase(), newWorkflow;
+      if (arg.length === 0)
+        newWorkflow = resolveWorkflow(loadConfigForExtensionInit().workflow, !0) === "none" ? "summary-review" : "none";
+      else if (arg === "on")
+        newWorkflow = "summary-review";
+      else if (arg === "off")
+        newWorkflow = "none";
+      else if (arg === "none" || arg === "summary-review" || arg === "auto-summary")
+        newWorkflow = arg;
+      else {
+        ctx2.ui.notify(`Unknown option: ${arg}. Use on, off, summary-review, or auto-summary.`, "error");
+        return;
+      }
+      try {
+        saveConfig({ workflow: newWorkflow });
+      } catch (err) {
+        let message = err instanceof Error ? err.message : String(err);
+        ctx2.ui.notify(`Failed to save config: ${message}`, "error");
+        return;
+      }
+      let label = newWorkflow === "none" ? "Curator disabled \u2014 web_search will return raw results" : newWorkflow === "auto-summary" ? "Auto-summary enabled \u2014 web_search will generate a summary without opening the curator" : "Curator enabled \u2014 web_search will open curator and auto-generate a summary draft";
+      pi.sendMessage({
+        customType: "curator-config",
+        content: [{ type: "text", text: label }],
+        display: !0,
+        details: { workflow: newWorkflow }
+      }, { triggerTurn: !1, deliverAs: "followUp" });
+    }
+  }), pi.registerCommand("google-account", {
+    description: "Show the active Google account for Gemini Web",
+    handler: async () => {
+      if (!isBrowserCookieAccessAllowed()) {
+        pi.sendMessage({
+          customType: "google-account",
+          content: [{ type: "text", text: `Gemini Web browser cookie access is disabled. Set allowBrowserCookies: true in ${WEB_SEARCH_CONFIG_PATH} to enable it.` }],
+          display: !0,
+          details: { available: !1, cookieAccessAllowed: !1 }
+        }, { triggerTurn: !0, deliverAs: "followUp" });
+        return;
+      }
+      let geminiWeb = await loadGeminiWeb(), cookies = await geminiWeb.isGeminiWebAvailable();
+      if (!cookies) {
+        pi.sendMessage({
+          customType: "google-account",
+          content: [{ type: "text", text: "Gemini Web is unavailable. Sign into gemini.google.com in a supported Chromium-based browser." }],
+          display: !0,
+          details: { available: !1, cookieAccessAllowed: !0 }
+        }, { triggerTurn: !0, deliverAs: "followUp" });
+        return;
+      }
+      let email = await geminiWeb.getActiveGoogleEmail(cookies), text = email ? `Active Google account: ${email}` : "Gemini Web is available, but the active Google account could not be determined.";
+      pi.sendMessage({
+        customType: "google-account",
+        content: [{ type: "text", text }],
+        display: !0,
+        details: { available: !0, email: email ?? null }
+      }, { triggerTurn: !0, deliverAs: "followUp" });
+    }
+  }), pi.registerCommand("search", {
+    description: "Browse stored web search results",
+    handler: async (_args, ctx2) => {
+      let results = getAllResults();
+      if (results.length === 0) {
+        ctx2.ui.notify("No stored search results", "info");
+        return;
+      }
+      let options = results.map((r) => {
+        let age = Math.floor((Date.now() - r.timestamp) / 6e4), ageStr = age < 60 ? `${age}m ago` : `${Math.floor(age / 60)}h ago`;
+        if (r.type === "search" && r.queries) {
+          let query = r.queries[0]?.query || "unknown";
+          return `[${r.id.slice(0, 6)}] "${query}" (${r.queries.length} queries) - ${ageStr}`;
+        }
+        return r.type === "fetch" && r.urls ? `[${r.id.slice(0, 6)}] ${r.urls.length} URLs fetched - ${ageStr}` : `[${r.id.slice(0, 6)}] ${r.type} - ${ageStr}`;
+      }), choice = await ctx2.ui.select("Stored Search Results", options);
+      if (!choice)
+        return;
+      let match = choice.match(/^\[([a-z0-9]+)\]/);
+      if (!match)
+        return;
+      let selected = results.find((r) => r.id.startsWith(match[1]));
+      if (!selected)
+        return;
+      let actions = ["View details", "Delete"], action = await ctx2.ui.select(`Result ${selected.id.slice(0, 6)}`, actions);
+      if (action === "Delete")
+        deleteResult(selected.id), ctx2.ui.notify(`Deleted ${selected.id.slice(0, 6)}`, "info");
+      else if (action === "View details") {
+        let info = `ID: ${selected.id}
+Type: ${selected.type}
+Age: ${Math.floor((Date.now() - selected.timestamp) / 6e4)}m
+
+`;
+        if (selected.type === "search" && selected.queries) {
+          info += `Queries:
+`;
+          let queries = selected.queries.slice(0, 10);
+          for (let q of queries)
+            info += `- "${q.query}" (${q.results.length} results)
+`;
+          selected.queries.length > 10 && (info += `... and ${selected.queries.length - 10} more
+`);
+        }
+        if (selected.type === "fetch" && selected.urls) {
+          info += `URLs:
+`;
+          let urls = selected.urls.slice(0, 10);
+          for (let u of urls) {
+            let urlDisplay = u.url.length > 50 ? u.url.slice(0, 47) + "..." : u.url;
+            info += `- ${urlDisplay} (${u.error || `${u.content.length} chars`})
+`;
+          }
+          selected.urls.length > 10 && (info += `... and ${selected.urls.length - 10} more
+`);
+        }
+        ctx2.ui.notify(info, "info");
+      }
+    }
+  });
+}
+export {
+  pi_web_access_default as default
+};