pi-web-providers 3.3.0 → 3.4.0

package/dist/index.js

@@ -1,25 +1,25 @@
 // src/index.ts
-import { randomUUID } from "node:crypto";
-import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename, dirname as dirname2, join as join2, relative } from "node:path";
+import { basename, join as join3 } from "node:path";
 import {
+  copyToClipboard,
   DEFAULT_MAX_BYTES,
   DEFAULT_MAX_LINES,
   formatSize as formatSize2,
-  getMarkdownTheme,
+  getMarkdownTheme as getMarkdownTheme2,
   truncateHead
 } from "@earendil-works/pi-coding-agent";
 import {
   Box,
   Editor,
-  getKeybindings,
-  Key,
-  Markdown,
-  matchesKey,
+  getKeybindings as getKeybindings2,
+  Key as Key2,
+  Markdown as Markdown2,
+  matchesKey as matchesKey2,
   Text,
-  truncateToWidth,
-  visibleWidth,
+  truncateToWidth as truncateToWidth2,
+  visibleWidth as visibleWidth2,
   wrapTextWithAnsi
 } from "@earendil-works/pi-tui";
 import { Type as Type16 } from "typebox";
@@ -2454,39 +2454,39 @@ function createDefaultExecutionSettings(overrides = {}) {
 function normalizeDiagnosticDetail(detail) {
   return detail.trim().replace(/[.\s]+$/u, "");
 }
-function startsWithProviderLabel(providerLabel, detail) {
-  return detail.toLowerCase().startsWith(providerLabel.toLowerCase());
+function startsWithProviderLabel(providerLabel2, detail) {
+  return detail.toLowerCase().startsWith(providerLabel2.toLowerCase());
 }
 function readsLikeProviderClause(detail) {
   return /^(is|has|was|returned|did|does|could|cannot|must|should|search\b|contents\b|answer\b|research\b|output\b|response\b|result\b|query\b|no\b|missing\b|deep research\b)/iu.test(
     detail
   );
 }
-function formatProviderDiagnostic(providerLabel, detail) {
+function formatProviderDiagnostic(providerLabel2, detail) {
   const normalized = normalizeDiagnosticDetail(detail);
   if (!normalized) {
-    return `${providerLabel} failed.`;
+    return `${providerLabel2} failed.`;
   }
-  if (startsWithProviderLabel(providerLabel, normalized)) {
+  if (startsWithProviderLabel(providerLabel2, normalized)) {
     return `${normalized}.`;
   }
   if (readsLikeProviderClause(normalized)) {
-    return `${providerLabel} ${normalized}.`;
+    return `${providerLabel2} ${normalized}.`;
   }
-  return `${providerLabel}: ${normalized}.`;
+  return `${providerLabel2}: ${normalized}.`;
 }
-function formatResearchTerminalDiagnostic(providerLabel, status, detail) {
+function formatResearchTerminalDiagnostic(providerLabel2, status, detail) {
   const normalized = detail ? normalizeDiagnosticDetail(detail) : "";
   if (!normalized) {
-    return status === "cancelled" ? `${providerLabel} research was canceled.` : `${providerLabel} research failed.`;
+    return status === "cancelled" ? `${providerLabel2} research was canceled.` : `${providerLabel2} research failed.`;
   }
-  if (startsWithProviderLabel(providerLabel, normalized)) {
+  if (startsWithProviderLabel(providerLabel2, normalized)) {
     return `${normalized}.`;
   }
   if (/^research\b/iu.test(normalized)) {
-    return `${providerLabel} ${normalized}.`;
+    return `${providerLabel2} ${normalized}.`;
   }
-  return status === "cancelled" ? `${providerLabel} research was canceled: ${normalized}.` : `${providerLabel} research failed: ${normalized}.`;
+  return status === "cancelled" ? `${providerLabel2} research was canceled: ${normalized}.` : `${providerLabel2} research failed: ${normalized}.`;
 }
 
 // src/execution-policy.ts
@@ -2532,7 +2532,7 @@ async function runWithExecutionPolicy(label, operation, settings, context) {
   throw new Error(`${label} failed.`);
 }
 async function executeAsyncResearch({
-  providerLabel,
+  providerLabel: providerLabel2,
   providerId,
   context,
   pollIntervalMs = DEFAULT_RESEARCH_POLL_INTERVAL_MS,
@@ -2541,7 +2541,7 @@ async function executeAsyncResearch({
   start,
   poll
 }) {
-  const timeoutMessage = `${providerLabel} research exceeded ${formatDuration(timeoutMs)}.`;
+  const timeoutMessage = `${providerLabel2} research exceeded ${formatDuration(timeoutMs)}.`;
   const deadline = createDeadlineSignal(
     context.signal,
     timeoutMs,
@@ -2555,7 +2555,7 @@ async function executeAsyncResearch({
   let lastProgressStatus;
   const startedAt = Date.now();
   try {
-    researchContext.onProgress?.(`Starting research via ${providerLabel}`);
+    researchContext.onProgress?.(`Starting research via ${providerLabel2}`);
     const job = await withAbortAndOptionalTimeout(
       start(researchContext),
       void 0,
@@ -2564,14 +2564,14 @@ async function executeAsyncResearch({
     );
     const jobId = job.id;
     if (!jobId) {
-      throw new Error(`${providerLabel} research did not return a job id.`);
+      throw new Error(`${providerLabel2} research did not return a job id.`);
     }
-    researchContext.onProgress?.(`${providerLabel} research started: ${jobId}`);
+    researchContext.onProgress?.(`${providerLabel2} research started: ${jobId}`);
     let consecutivePollErrors = 0;
     while (true) {
       throwIfAborted(
         researchContext.signal,
-        `${providerLabel} research aborted.`
+        `${providerLabel2} research aborted.`
       );
       try {
         const result = await withAbortAndOptionalTimeout(
@@ -2584,7 +2584,7 @@ async function executeAsyncResearch({
         const progressStatus = result.statusText ?? result.status;
         if (result.status !== lastStatus || progressStatus !== lastProgressStatus) {
           researchContext.onProgress?.(
-            `Research via ${providerLabel}: ${progressStatus} (${formatElapsed(Date.now() - startedAt)} elapsed)`
+            `Research via ${providerLabel2}: ${progressStatus} (${formatElapsed(Date.now() - startedAt)} elapsed)`
           );
           lastStatus = result.status;
           lastProgressStatus = progressStatus;
@@ -2592,13 +2592,13 @@ async function executeAsyncResearch({
         if (result.status === "completed") {
           return result.output ?? {
             provider: providerId,
-            text: `${providerLabel} research completed without textual output.`
+            text: `${providerLabel2} research completed without textual output.`
           };
         }
         if (result.status === "failed" || result.status === "cancelled") {
           throw new Error(
             formatResearchTerminalDiagnostic(
-              providerLabel,
+              providerLabel2,
               result.status,
               result.error
             )
@@ -2614,11 +2614,11 @@ async function executeAsyncResearch({
         consecutivePollErrors += 1;
         if (consecutivePollErrors >= maxConsecutivePollErrors) {
           throw new Error(
-            `${providerLabel} research polling failed too many times in a row: ${formatErrorMessage(error)}`
+            `${providerLabel2} research polling failed too many times in a row: ${formatErrorMessage(error)}`
           );
         }
         researchContext.onProgress?.(
-          `${providerLabel} research poll is still retrying after transient errors (${consecutivePollErrors}/${maxConsecutivePollErrors} consecutive poll failures). Background job id: ${jobId}`
+          `${providerLabel2} research poll is still retrying after transient errors (${consecutivePollErrors}/${maxConsecutivePollErrors} consecutive poll failures). Background job id: ${jobId}`
         );
       }
       await sleep(pollIntervalMs, researchContext.signal);
@@ -2626,11 +2626,11 @@ async function executeAsyncResearch({
   } catch (error) {
     if (isAbortErrorFromSignal(researchContext.signal, error)) {
       throw new Error(
-        formatProviderDiagnostic(providerLabel, formatErrorMessage(error))
+        formatProviderDiagnostic(providerLabel2, formatErrorMessage(error))
       );
     }
     throw new Error(
-      formatProviderDiagnostic(providerLabel, formatErrorMessage(error))
+      formatProviderDiagnostic(providerLabel2, formatErrorMessage(error))
     );
   } finally {
     deadline.cleanup();
@@ -3713,7 +3713,7 @@ var geminiImplementation = {
       context.signal
     );
     const results = await Promise.all(
-      extractGoogleSearchResults(interaction.outputs).slice(0, maxResults).map(async (result) => {
+      extractGoogleSearchResults(readInteractionSteps(interaction)).slice(0, maxResults).map(async (result) => {
         const resolvedUrl = await resolveGoogleSearchUrl(
           result.url,
           context.signal
@@ -3800,7 +3800,7 @@ var geminiImplementation = {
     );
     const status = readNonEmptyString3(interaction.status) ?? "unknown";
     if (status === "completed") {
-      const text = formatInteractionOutputs(interaction.outputs);
+      const text = formatInteractionSteps(readInteractionSteps(interaction));
       return {
         status: "completed",
         output: {
@@ -3830,7 +3830,7 @@ var geminiImplementation = {
     if (status === "requires_action") {
       return {
         status: "failed",
-        error: describeGeminiRequiredAction(interaction.outputs)
+        error: describeGeminiRequiredAction(readInteractionSteps(interaction))
       };
     }
     return status === "in_progress" ? { status: "in_progress" } : { status: "in_progress", statusText: status };
@@ -3864,17 +3864,20 @@ function addAbortSignalToGeminiConfig(config, signal) {
     abortSignal: signal
   };
 }
-function extractGoogleSearchResults(outputs) {
+function readInteractionSteps(interaction) {
+  return typeof interaction === "object" && interaction !== null ? interaction.steps : void 0;
+}
+function extractGoogleSearchResults(steps) {
   const seen = /* @__PURE__ */ new Set();
   const results = [];
-  if (!Array.isArray(outputs)) {
+  if (!Array.isArray(steps)) {
     return results;
   }
-  for (const output of outputs) {
-    if (typeof output !== "object" || output === null) {
+  for (const step of steps) {
+    if (typeof step !== "object" || step === null) {
       continue;
     }
-    const content = output;
+    const content = step;
     if (content.type !== "google_search_result") {
       continue;
     }
@@ -4040,16 +4043,21 @@ function extractGroundingSources(chunks) {
   }
   return sources;
 }
-function formatInteractionOutputs(outputs) {
+function formatInteractionSteps(steps) {
   const lines = [];
-  if (!Array.isArray(outputs)) {
+  if (!Array.isArray(steps)) {
     return "";
   }
-  for (const output of outputs) {
-    if (typeof output === "object" && output !== null && "type" in output && output.type === "text" && "text" in output && typeof output.text === "string") {
-      const text = output.text.trim();
-      if (text) {
-        lines.push(text);
+  for (const step of steps) {
+    if (typeof step !== "object" || step === null || !("type" in step) || step.type !== "model_output" || !("content" in step) || !Array.isArray(step.content)) {
+      continue;
+    }
+    for (const part of step.content) {
+      if (typeof part === "object" && part !== null && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string") {
+        const text = part.text.trim();
+        if (text) {
+          lines.push(text);
+        }
       }
     }
   }
@@ -4244,14 +4252,12 @@ function buildGeminiGenerateContentRequest({
     }
   };
 }
-function describeGeminiRequiredAction(outputs) {
-  if (!Array.isArray(outputs) || outputs.length === 0) {
+function describeGeminiRequiredAction(steps) {
+  if (!Array.isArray(steps) || steps.length === 0) {
     return "research requires additional action";
   }
-  const firstOutput = outputs.find(
-    (value) => typeof value === "object" && value !== null
-  );
-  const type = readNonEmptyString3(firstOutput?.type);
+  const lastStep = [...steps].reverse().find((value) => typeof value === "object" && value !== null);
+  const type = readNonEmptyString3(lastStep?.type);
   if (!type) {
     return "research requires additional action";
   }
@@ -7849,45 +7855,6 @@ ${JSON.stringify(value, null, 2).trim()}
 \`\`\``;
 }
 
-// src/options.ts
-function buildToolOptionsSchema(_capability, providerSchema) {
-  if (!providerSchema || Object.keys(providerSchema.properties).length === 0) {
-    return void 0;
-  }
-  return closeObjectSchemas(providerSchema);
-}
-function closeObjectSchemas(schema) {
-  if (!isSchemaRecord(schema)) {
-    return schema;
-  }
-  const properties = isSchemaRecord(schema.properties) ? Object.fromEntries(
-    Object.entries(schema.properties).map(([key, value]) => [
-      key,
-      closeObjectSchemas(value)
-    ])
-  ) : schema.properties;
-  const items = isSchemaRecord(schema.items) ? closeObjectSchemas(schema.items) : Array.isArray(schema.items) ? schema.items.map((item) => closeObjectSchemas(item)) : schema.items;
-  return {
-    ...schema,
-    ...properties ? { properties } : {},
-    ...items ? { items } : {},
-    ...mapSchemaArray(schema, "anyOf"),
-    ...mapSchemaArray(schema, "oneOf"),
-    ...mapSchemaArray(schema, "allOf"),
-    ...schema.type === "object" && isSchemaRecord(schema.properties) ? { additionalProperties: false } : {}
-  };
-}
-function mapSchemaArray(schema, key) {
-  const value = schema[key];
-  return Array.isArray(value) ? { [key]: value.map((entry) => closeObjectSchemas(entry)) } : {};
-}
-function isSchemaRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/prefetch-manager.ts
-import { createHash } from "node:crypto";
-
 // src/provider-resolution.ts
 function supportsTool2(provider, tool) {
   return provider.capabilities[tool] !== void 0;
@@ -8029,6 +7996,140 @@ function resolveProviderForTool(config, cwd, tool, explicit) {
   return provider;
 }
 
+// src/managed-tools.ts
+var CAPABILITY_TOOL_NAMES = {
+  search: "web_search",
+  contents: "web_contents",
+  answer: "web_answer",
+  research: "web_research"
+};
+var MANAGED_TOOL_NAMES = Object.values(CAPABILITY_TOOL_NAMES);
+function getAvailableProviderIdsForCapability(config, cwd, capability) {
+  const providerId = getMappedProviderIdForTool(config, capability);
+  if (!providerId) {
+    return [];
+  }
+  const provider = PROVIDERS_BY_ID[providerId];
+  if (!supportsTool2(provider, capability)) {
+    return [];
+  }
+  const status = getProviderCapabilityStatus(
+    config,
+    cwd,
+    providerId,
+    capability,
+    {
+      resolveSecrets: false
+    }
+  );
+  return isProviderCapabilityExposable(status) ? [providerId] : [];
+}
+function getProviderStatusForTool(config, cwd, providerId, capability) {
+  return getProviderCapabilityStatus(config, cwd, providerId, capability);
+}
+function getAvailableManagedToolNames(config, cwd) {
+  return Object.keys(CAPABILITY_TOOL_NAMES).filter(
+    (capability) => getAvailableProviderIdsForCapability(config, cwd, capability).length > 0
+  ).map((capability) => CAPABILITY_TOOL_NAMES[capability]);
+}
+function getSyncedActiveTools(config, cwd, activeToolNames, options) {
+  const availableToolNames = new Set(getAvailableManagedToolNames(config, cwd));
+  const nextActiveTools = new Set(activeToolNames);
+  for (const toolName of MANAGED_TOOL_NAMES) {
+    if (availableToolNames.has(toolName)) {
+      if (options.addAvailable) {
+        nextActiveTools.add(toolName);
+      }
+      continue;
+    }
+    nextActiveTools.delete(toolName);
+  }
+  return nextActiveTools;
+}
+async function refreshManagedTools(pi, registerManagedTools2, cwd, options) {
+  const config = await loadConfig();
+  const nextActiveTools = getSyncedActiveTools(
+    config,
+    cwd,
+    pi.getActiveTools(),
+    options
+  );
+  registerManagedTools2({
+    search: getAvailableProviderIdsForCapability(config, cwd, "search"),
+    contents: getAvailableProviderIdsForCapability(config, cwd, "contents"),
+    answer: getAvailableProviderIdsForCapability(config, cwd, "answer"),
+    research: getAvailableProviderIdsForCapability(config, cwd, "research")
+  });
+  await syncManagedToolAvailability(pi, nextActiveTools);
+}
+async function refreshManagedToolsOnStartup(pi, registerManagedTools2, cwd, options) {
+  try {
+    await refreshManagedTools(pi, registerManagedTools2, cwd, options);
+  } catch (error) {
+    pi.sendMessage({
+      customType: "web-providers-config-error",
+      content: formatStartupConfigError(error),
+      display: true
+    });
+    await syncManagedToolAvailability(
+      pi,
+      new Set(
+        pi.getActiveTools().filter((toolName) => !MANAGED_TOOL_NAMES.includes(toolName))
+      )
+    );
+  }
+}
+function formatStartupConfigError(error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  return `web-providers config error: ${detail.replace(getConfigPath(), "~/.pi/agent/web-providers.json")}`;
+}
+async function syncManagedToolAvailability(pi, nextActiveTools) {
+  const activeTools = pi.getActiveTools();
+  const changed = activeTools.length !== nextActiveTools.size || activeTools.some((toolName) => !nextActiveTools.has(toolName));
+  if (changed) {
+    pi.setActiveTools(Array.from(nextActiveTools));
+  }
+}
+
+// src/options.ts
+function buildToolOptionsSchema(_capability, providerSchema) {
+  if (!providerSchema || Object.keys(providerSchema.properties).length === 0) {
+    return void 0;
+  }
+  return closeObjectSchemas(providerSchema);
+}
+function closeObjectSchemas(schema) {
+  if (!isSchemaRecord(schema)) {
+    return schema;
+  }
+  const properties = isSchemaRecord(schema.properties) ? Object.fromEntries(
+    Object.entries(schema.properties).map(([key, value]) => [
+      key,
+      closeObjectSchemas(value)
+    ])
+  ) : schema.properties;
+  const items = isSchemaRecord(schema.items) ? closeObjectSchemas(schema.items) : Array.isArray(schema.items) ? schema.items.map((item) => closeObjectSchemas(item)) : schema.items;
+  return {
+    ...schema,
+    ...properties ? { properties } : {},
+    ...items ? { items } : {},
+    ...mapSchemaArray(schema, "anyOf"),
+    ...mapSchemaArray(schema, "oneOf"),
+    ...mapSchemaArray(schema, "allOf"),
+    ...schema.type === "object" && isSchemaRecord(schema.properties) ? { additionalProperties: false } : {}
+  };
+}
+function mapSchemaArray(schema, key) {
+  const value = schema[key];
+  return Array.isArray(value) ? { [key]: value.map((entry) => closeObjectSchemas(entry)) } : {};
+}
+function isSchemaRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/prefetch-manager.ts
+import { createHash } from "node:crypto";
+
 // src/provider-runtime.ts
 async function executeProviderRequest(provider, config, request, context) {
   return await executeProviderExecution(
@@ -8122,7 +8223,7 @@ function resolveExecutionPolicy(defaults) {
     retryDelayMs: defaults?.retryDelayMs ?? 2e3
   };
 }
-function createResearchDeadlineSignal(signal, providerLabel, timeoutMs) {
+function createResearchDeadlineSignal(signal, providerLabel2, timeoutMs) {
   if (timeoutMs === void 0) {
     return void 0;
   }
@@ -8137,7 +8238,7 @@ function createResearchDeadlineSignal(signal, providerLabel, timeoutMs) {
   const timer = setTimeout(() => {
     controller.abort(
       new Error(
-        `${providerLabel} research exceeded ${formatDuration(timeoutMs)}.`
+        `${providerLabel2} research exceeded ${formatDuration(timeoutMs)}.`
       )
     );
   }, timeoutMs);
@@ -9792,51 +9893,1001 @@ function getFirstLine(text) {
   return text?.split("\n").map((line) => line.trim()).find((line) => line.length > 0);
 }
 
-// src/index.ts
-var DEFAULT_MAX_RESULTS = 5;
-var MAX_ALLOWED_RESULTS = 20;
-var MAX_SEARCH_QUERIES = 10;
-var RESEARCH_HEARTBEAT_MS = 15e3;
-var WEB_RESEARCH_RESULT_MESSAGE_TYPE = "web-research-result";
-var WEB_RESEARCH_WIDGET_KEY = "web-research-jobs";
+// src/web-research-lifecycle.ts
+import { randomUUID } from "node:crypto";
+import { mkdir as mkdir2, readdir, readFile as readFile2, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
 var RESEARCH_ARTIFACTS_DIR = join2(".pi", "artifacts", "research");
+var MAX_RESEARCH_HISTORY_ITEMS = 20;
+var RESEARCH_PREVIEW_MAX_BYTES = 5e4;
+var RESEARCH_REPORT_MAX_BYTES = 2e5;
 var pendingResearchTasks = /* @__PURE__ */ new Set();
-var CAPABILITY_TOOL_NAMES = {
-  search: "web_search",
-  contents: "web_contents",
-  answer: "web_answer",
-  research: "web_research"
-};
-var MANAGED_TOOL_NAMES = Object.values(CAPABILITY_TOOL_NAMES);
-var DEFAULT_SUMMARY_SYMBOLS = {
-  success: "\u2714",
-  failure: "\u2718"
-};
-function webProvidersExtension(pi) {
-  const activeWebResearchRequests = /* @__PURE__ */ new Map();
-  let latestWidgetContext;
-  let webResearchWidgetTimer;
-  const stopWebResearchWidgetTimer = () => {
-    if (webResearchWidgetTimer) {
-      clearInterval(webResearchWidgetTimer);
-      webResearchWidgetTimer = void 0;
-    }
-  };
-  const ensureWebResearchWidgetTimer = () => {
-    if (webResearchWidgetTimer || activeWebResearchRequests.size === 0) {
-      return;
+async function dispatchWebResearch({
+  activeWebResearchRequests,
+  config,
+  explicitProvider,
+  ctx,
+  options,
+  input,
+  executionOverride,
+  executeResearch,
+  deliverResult,
+  onJobsChanged,
+  resultMessageType
+}) {
+  await cleanupContentStore();
+  const provider = resolveProviderForTool(
+    config,
+    ctx.cwd,
+    "research",
+    explicitProvider
+  );
+  const request = createWebResearchRequest(ctx.cwd, provider.id, input);
+  const abortController = new AbortController();
+  const task = { request, abortController };
+  const providerConfig = getEffectiveProviderConfig(config, provider.id);
+  activeWebResearchRequests.set(request.id, task);
+  onJobsChanged();
+  trackPendingResearchTask(
+    runDispatchedWebResearch({
+      activeWebResearchRequests,
+      task,
+      config,
+      provider,
+      providerConfig,
+      ctx,
+      options,
+      executionOverride,
+      executeResearch,
+      deliverResult,
+      onJobsChanged,
+      resultMessageType
+    })
+  );
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Started web research via ${provider.label}.`
+      }
+    ],
+    details: request,
+    display: {
+      provider: { id: provider.id, label: provider.label },
+      outcome: { success: "started" }
     }
-    webResearchWidgetTimer = setInterval(() => {
-      updateWebResearchWidget();
-    }, 1e3);
   };
-  const updateWebResearchWidget = (ctx) => {
-    const widgetContext = ctx ?? latestWidgetContext;
-    if (!widgetContext) {
-      return;
-    }
-    latestWidgetContext = widgetContext;
-    if (!widgetContext.hasUI) {
+}
+async function runDispatchedWebResearch({
+  activeWebResearchRequests,
+  task,
+  config,
+  provider,
+  providerConfig,
+  ctx,
+  options,
+  executionOverride,
+  executeResearch,
+  deliverResult,
+  onJobsChanged,
+  resultMessageType
+}) {
+  const { request, abortController } = task;
+  let result;
+  let reportText = "";
+  try {
+    const response = await executeResearch({
+      config,
+      provider,
+      providerConfig,
+      ctx,
+      signal: abortController.signal,
+      options,
+      input: request.input,
+      onProgress: (message) => {
+        request.progress = summarizeWebResearchProgress(
+          message,
+          provider.label
+        );
+        onJobsChanged();
+      },
+      executionOverride
+    });
+    result = buildWebResearchResult(request, abortController, task, response);
+    if (result.status === "completed") {
+      reportText = response.text;
+    }
+  } catch (error) {
+    result = buildFailedWebResearchResult(
+      request,
+      abortController,
+      task,
+      error
+    );
+  }
+  try {
+    await writeWebResearchArtifact(result, reportText);
+    deliverResult({
+      customType: resultMessageType,
+      content: formatWebResearchResultMessage(result, reportText),
+      display: true,
+      details: result
+    });
+  } finally {
+    activeWebResearchRequests.delete(request.id);
+    onJobsChanged();
+  }
+}
+function buildWebResearchResult(request, abortController, task, response) {
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (abortController.signal.aborted && task.cancelRequestedAt !== void 0) {
+    return {
+      ...request,
+      status: "cancelled",
+      completedAt,
+      elapsedMs: elapsedMs(request.startedAt, completedAt),
+      error: "web research was cancelled by the user."
+    };
+  }
+  return {
+    ...request,
+    status: "completed",
+    completedAt,
+    elapsedMs: elapsedMs(request.startedAt, completedAt),
+    itemCount: response.itemCount
+  };
+}
+function buildFailedWebResearchResult(request, abortController, task, error) {
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const cancelled = abortController.signal.aborted && task.cancelRequestedAt !== void 0;
+  return {
+    ...request,
+    status: cancelled ? "cancelled" : "failed",
+    completedAt,
+    elapsedMs: elapsedMs(request.startedAt, completedAt),
+    error: cancelled ? "web research was cancelled by the user." : formatErrorMessage(error)
+  };
+}
+function elapsedMs(startedAt, completedAt) {
+  return Math.max(0, Date.parse(completedAt) - Date.parse(startedAt));
+}
+function getActiveWebResearchRequests(tasks) {
+  return [...tasks.values()].map((task) => task.request);
+}
+function getWebResearchTaskSnapshots(tasks) {
+  return [...tasks.values()].map((task) => ({
+    request: task.request,
+    cancelRequestedAt: task.cancelRequestedAt
+  }));
+}
+function cancelWebResearchTask(tasks, id) {
+  const task = tasks.get(id);
+  if (!task || task.abortController.signal.aborted) return false;
+  task.cancelRequestedAt = (/* @__PURE__ */ new Date()).toISOString();
+  task.request.progress = "cancelling";
+  task.abortController.abort(
+    new Error("web research was cancelled by the user.")
+  );
+  return true;
+}
+function createWebResearchRequest(cwd, provider, input) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    tool: "web_research",
+    id: randomUUID(),
+    provider,
+    input,
+    outputPath: buildWebResearchArtifactPath(cwd, input, startedAt),
+    startedAt
+  };
+}
+function buildWebResearchArtifactPath(cwd, input, startedAt) {
+  const timestamp = startedAt.replaceAll(":", "-").replace(".", "-");
+  const slug = slugifyWebResearchInput(input);
+  return join2(cwd, RESEARCH_ARTIFACTS_DIR, `${timestamp}-${slug}.md`);
+}
+function slugifyWebResearchInput(input) {
+  const slug = input.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "");
+  return slug.length > 0 ? slug : "research";
+}
+function getWebResearchProgressIcon(request) {
+  if (request.progress === "poll retrying after transient errors") {
+    return "\u27F3";
+  }
+  if (request.progress === "queued" || request.progress === "cancelling") {
+    return "\u25CC";
+  }
+  if (request.progress === "starting") {
+    return "\u25D4";
+  }
+  if (request.progress?.startsWith("started:")) {
+    return "\u25D1";
+  }
+  return "\u25CF";
+}
+function summarizeWebResearchProgress(message, providerLabel2) {
+  const startingMessage = `Starting research via ${providerLabel2}`;
+  if (message === startingMessage) {
+    return "starting";
+  }
+  const startedPrefix = `${providerLabel2} research started: `;
+  if (message.startsWith(startedPrefix)) {
+    return `started: ${message.slice(startedPrefix.length)}`;
+  }
+  const statusPrefix = `Research via ${providerLabel2}: `;
+  if (message.startsWith(statusPrefix)) {
+    return message.slice(statusPrefix.length).replace(/\s+\([^)]* elapsed\)$/u, "").trim();
+  }
+  const retryPrefix = `${providerLabel2} research poll is still retrying after transient errors`;
+  if (message.startsWith(retryPrefix)) {
+    return "poll retrying after transient errors";
+  }
+  return message.trim();
+}
+function formatWebResearchResultMessage(result, reportText) {
+  const text = reportText.trim();
+  if (text.length > 0) {
+    return `${text}
+`;
+  }
+  if (result.error) {
+    return `${result.error}
+`;
+  }
+  return "";
+}
+async function writeWebResearchArtifact(result, reportText) {
+  await mkdir2(dirname2(result.outputPath), { recursive: true });
+  await writeFile2(
+    result.outputPath,
+    formatWebResearchArtifact(result, reportText),
+    "utf-8"
+  );
+}
+function formatWebResearchArtifact(result, reportText) {
+  const providerLabel2 = PROVIDERS_BY_ID[result.provider]?.label ?? result.provider;
+  const metadata = {
+    query: result.input,
+    provider: providerLabel2,
+    providerId: result.provider,
+    status: result.status,
+    startedAt: result.startedAt,
+    completedAt: result.completedAt,
+    elapsedMs: result.elapsedMs,
+    itemCount: result.itemCount,
+    error: result.error
+  };
+  const lines = [
+    "---",
+    ...Object.entries(metadata).flatMap(
+      ([key, value]) => value === void 0 ? [] : [`${key}: ${formatYamlScalar(value)}`]
+    ),
+    "---",
+    "",
+    "# Web research report"
+  ];
+  if (reportText) {
+    lines.push("", reportText);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatYamlScalar(value) {
+  if (typeof value === "number") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+async function loadWebResearchHistory(cwd, maxItems = MAX_RESEARCH_HISTORY_ITEMS) {
+  const dir = join2(cwd, RESEARCH_ARTIFACTS_DIR);
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const markdown = entries.filter((name) => name.endsWith(".md"));
+  const withStats = await Promise.all(
+    markdown.map(async (fileName) => {
+      const outputPath = join2(dir, fileName);
+      try {
+        return { fileName, outputPath, stat: await stat(outputPath) };
+      } catch {
+        return void 0;
+      }
+    })
+  );
+  const newest = withStats.filter((item) => item !== void 0).sort((left, right) => right.stat.mtimeMs - left.stat.mtimeMs).slice(0, maxItems);
+  return Promise.all(
+    newest.map(async ({ fileName, outputPath, stat: stat2 }) => {
+      let content = "";
+      try {
+        content = await readFile2(outputPath, "utf-8");
+      } catch {
+      }
+      const metadata = parseWebResearchArtifactMetadata(content);
+      return {
+        outputPath,
+        fileName,
+        query: metadata.query ?? "",
+        title: deriveWebResearchTitle(content, metadata.query ?? ""),
+        provider: metadata.provider ?? "",
+        status: metadata.status ?? "unknown",
+        startedAt: metadata.startedAt ?? "",
+        completedAt: metadata.completedAt ?? "",
+        elapsedMs: computeHistoryElapsedMs(metadata),
+        mtimeMs: stat2.mtimeMs
+      };
+    })
+  );
+}
+function parseWebResearchArtifactMetadata(content) {
+  return parseWebResearchFrontmatter(content) ?? parseLegacyWebResearchArtifactMetadata(content);
+}
+function parseWebResearchFrontmatter(content) {
+  if (!content.startsWith("---\n")) {
+    return void 0;
+  }
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) {
+    return void 0;
+  }
+  const result = {};
+  const frontmatter = content.slice(4, end);
+  for (const line of frontmatter.split(/\r?\n/u)) {
+    const match = /^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/u.exec(line);
+    if (!match) {
+      continue;
+    }
+    result[match[1] ?? ""] = parseYamlScalar(match[2] ?? "");
+  }
+  return result;
+}
+function parseYamlScalar(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return typeof parsed === "string" ? parsed : String(parsed);
+    } catch {
+    }
+  }
+  return trimmed;
+}
+function parseLegacyWebResearchArtifactMetadata(content) {
+  const result = {};
+  const metadataHeadings = /* @__PURE__ */ new Map([
+    ["Query", "query"],
+    ["Provider", "provider"],
+    ["Status", "status"],
+    ["Started", "startedAt"],
+    ["Completed", "completedAt"]
+  ]);
+  const artifactBodyHeadings = /* @__PURE__ */ new Set(["Elapsed", "Items", "Error", "Report"]);
+  const lines = content.split(/\r?\n/u);
+  for (let index = 0; index < lines.length; index++) {
+    const match = /^##\s+(.+)$/u.exec(lines[index] ?? "");
+    if (!match) continue;
+    const heading = match[1] ?? "";
+    if (artifactBodyHeadings.has(heading)) break;
+    const key = metadataHeadings.get(heading);
+    if (key === void 0 || result[key] !== void 0) continue;
+    const values = [];
+    for (let next = index + 1; next < lines.length; next++) {
+      if (/^##\s+/u.test(lines[next] ?? "")) break;
+      if ((lines[next] ?? "").trim() || values.length > 0)
+        values.push(lines[next] ?? "");
+    }
+    result[key] = values.join("\n").trim();
+  }
+  return result;
+}
+var RESEARCH_TITLE_MAX_LENGTH = 80;
+var NON_TITLE_HEADINGS = /* @__PURE__ */ new Set([
+  "Web research report",
+  "Query",
+  "Provider",
+  "Status",
+  "Started",
+  "Completed",
+  "Elapsed",
+  "Items",
+  "Error",
+  "Report"
+]);
+function deriveWebResearchTitle(content, query2) {
+  const body = getWebResearchBody(content);
+  for (const line of body.split(/\r?\n/u)) {
+    const match = /^#{1,2}\s+(.+?)\s*$/u.exec(line);
+    if (!match) continue;
+    const heading = (match[1] ?? "").trim();
+    if (heading.length > 0 && !NON_TITLE_HEADINGS.has(heading)) {
+      return heading;
+    }
+  }
+  const fallback = query2.replace(/\s+/g, " ").trim();
+  if (fallback.length <= RESEARCH_TITLE_MAX_LENGTH) {
+    return fallback;
+  }
+  return `${fallback.slice(0, RESEARCH_TITLE_MAX_LENGTH - 1)}\u2026`;
+}
+function computeHistoryElapsedMs(metadata) {
+  if (metadata.elapsedMs !== void 0) {
+    const parsed = Number(metadata.elapsedMs);
+    if (Number.isFinite(parsed) && parsed >= 0) {
+      return parsed;
+    }
+  }
+  const started = Date.parse(metadata.startedAt ?? "");
+  const completed = Date.parse(metadata.completedAt ?? "");
+  if (Number.isFinite(started) && Number.isFinite(completed)) {
+    return Math.max(0, completed - started);
+  }
+  return void 0;
+}
+function getWebResearchBody(content) {
+  if (!content.startsWith("---\n")) {
+    return content;
+  }
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) {
+    return content;
+  }
+  const afterClose = content.indexOf("\n", end + 4);
+  return afterClose === -1 ? "" : content.slice(afterClose + 1);
+}
+async function loadWebResearchReport(outputPath) {
+  const buffer = await readFile2(outputPath);
+  const truncated = buffer.byteLength > RESEARCH_REPORT_MAX_BYTES;
+  const content = buffer.subarray(0, RESEARCH_REPORT_MAX_BYTES).toString("utf-8");
+  return {
+    body: getWebResearchBody(content).trim(),
+    metadata: parseWebResearchArtifactMetadata(content),
+    truncated
+  };
+}
+async function loadWebResearchPreview(outputPath) {
+  const buffer = await readFile2(outputPath);
+  const truncated = buffer.byteLength > RESEARCH_PREVIEW_MAX_BYTES;
+  const text = buffer.subarray(0, RESEARCH_PREVIEW_MAX_BYTES).toString("utf-8");
+  return truncated ? `${text}
+
+---
+Preview truncated. Open the full report at \`${outputPath}\`.` : `${text}
+
+---
+Full report: \`${outputPath}\``;
+}
+function trackPendingResearchTask(task) {
+  const tracked = task.catch(() => {
+  }).finally(() => {
+    pendingResearchTasks.delete(tracked);
+  });
+  pendingResearchTasks.add(tracked);
+}
+async function waitForPendingResearchTasks() {
+  await Promise.all([...pendingResearchTasks]);
+}
+
+// src/web-research-view.ts
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import {
+  getKeybindings,
+  Key,
+  Markdown,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth
+} from "@earendil-works/pi-tui";
+var STATUS_MESSAGE_TTL_MS = 1500;
+var PAGE_JUMP = 10;
+var WebResearchManagerView = class {
+  constructor(tui, theme, done, cwd, tasks, onChange, actions, loadHistory = loadWebResearchHistory) {
+    this.tui = tui;
+    this.theme = theme;
+    this.done = done;
+    this.cwd = cwd;
+    this.tasks = tasks;
+    this.onChange = onChange;
+    this.actions = actions;
+    this.loadHistory = loadHistory;
+    void this.reloadHistory();
+  }
+  tui;
+  theme;
+  done;
+  cwd;
+  tasks;
+  onChange;
+  actions;
+  loadHistory;
+  selectedIndex = 0;
+  history = [];
+  confirmCancelId;
+  open;
+  scrollOffset = 0;
+  statusMessage;
+  statusMessageTimer;
+  isReportOpen() {
+    return this.open !== void 0;
+  }
+  render(width) {
+    if (this.open?.kind === "report") {
+      return this.renderReport(this.open, width);
+    }
+    if (this.open?.kind === "detail") {
+      const snapshot = this.findSnapshot(this.open.taskId);
+      if (snapshot) return this.renderDetail(snapshot, width);
+      this.open = void 0;
+    }
+    return this.renderTable(width);
+  }
+  invalidate() {
+  }
+  dispose() {
+    if (this.statusMessageTimer) clearTimeout(this.statusMessageTimer);
+  }
+  handleInput(data) {
+    if (this.open) {
+      this.handleOpenInput(data);
+    } else {
+      this.handleTableInput(data);
+    }
+    this.tui.requestRender();
+  }
+  refresh() {
+    if (this.open?.kind === "detail" && !this.findSnapshot(this.open.taskId)) {
+      this.open = void 0;
+      this.confirmCancelId = void 0;
+    }
+    void this.reloadHistory();
+    this.tui.requestRender();
+  }
+  // --- table mode ---
+  getRows() {
+    const snapshots = getWebResearchTaskSnapshots(this.tasks).sort(
+      (a, b) => a.request.startedAt.localeCompare(b.request.startedAt)
+    );
+    const runningPaths = new Set(
+      snapshots.map((snapshot) => snapshot.request.outputPath)
+    );
+    const rows = snapshots.map((snapshot) => ({
+      kind: "running",
+      snapshot
+    }));
+    for (const item of this.history) {
+      if (runningPaths.has(item.outputPath)) continue;
+      rows.push({ kind: "history", item });
+    }
+    return rows;
+  }
+  border(width) {
+    return this.theme.fg("border", "\u2500".repeat(Math.max(1, width)));
+  }
+  renderTable(width) {
+    const rows = this.getRows();
+    this.selectedIndex = clamp2(this.selectedIndex, 0, rows.length - 1);
+    const lines = [
+      this.border(width),
+      this.theme.fg("accent", " Web research"),
+      ""
+    ];
+    if (rows.length === 0) {
+      lines.push(this.theme.fg("muted", "  No research jobs or reports"));
+    } else {
+      const layout = computeTableLayout(rows, width);
+      const now = Date.now();
+      rows.forEach((row, index) => {
+        lines.push(
+          formatResearchTableRow(
+            row,
+            layout,
+            this.theme,
+            index === this.selectedIndex,
+            now
+          )
+        );
+        if (row.kind === "running" && this.confirmCancelId === row.snapshot.request.id) {
+          lines.push(
+            this.theme.fg(
+              "warning",
+              truncateToWidth(
+                `     Press c again to cancel this ${providerLabel(row.snapshot.request.provider)} research`,
+                width
+              )
+            )
+          );
+        }
+      });
+    }
+    lines.push("");
+    if (this.statusMessage) {
+      lines.push(this.theme.fg("accent", ` ${this.statusMessage}`));
+    }
+    lines.push(
+      this.theme.fg(
+        "dim",
+        " \u2191\u2193 move \xB7 Enter open \xB7 c cancel running \xB7 Esc close"
+      ),
+      this.border(width)
+    );
+    return lines;
+  }
+  handleTableInput(data) {
+    const kb = getKeybindings();
+    const rows = this.getRows();
+    if (kb.matches(data, "tui.select.up")) this.move(rows.length, -1);
+    else if (kb.matches(data, "tui.select.down")) this.move(rows.length, 1);
+    else if (kb.matches(data, "tui.select.pageUp"))
+      this.move(rows.length, -PAGE_JUMP, false);
+    else if (kb.matches(data, "tui.select.pageDown"))
+      this.move(rows.length, PAGE_JUMP, false);
+    else if (kb.matches(data, "tui.select.confirm"))
+      void this.openRow(rows[this.selectedIndex]);
+    else if (data === "c") this.cancelRow(rows[this.selectedIndex]);
+    else if (kb.matches(data, "tui.select.cancel")) {
+      if (this.confirmCancelId) this.confirmCancelId = void 0;
+      else this.done(void 0);
+    }
+  }
+  move(count, delta, wrap = true) {
+    this.confirmCancelId = void 0;
+    if (count === 0) return;
+    const next = this.selectedIndex + delta;
+    this.selectedIndex = wrap ? (next + count) % count : clamp2(next, 0, count - 1);
+  }
+  async openRow(row) {
+    if (!row) return;
+    this.confirmCancelId = void 0;
+    if (row.kind === "running") {
+      this.open = { kind: "detail", taskId: row.snapshot.request.id };
+      this.scrollOffset = 0;
+      return;
+    }
+    try {
+      const report = await loadWebResearchReport(row.item.outputPath);
+      this.open = {
+        kind: "report",
+        title: row.item.title || row.item.query,
+        body: report.body,
+        truncated: report.truncated,
+        item: row.item,
+        markdown: new Markdown(report.body, 1, 0, getMarkdownTheme())
+      };
+      this.scrollOffset = 0;
+    } catch (error) {
+      this.showStatusMessage(
+        `Failed to read ${row.item.outputPath}: ${formatErrorMessage(error)}`
+      );
+    }
+    this.tui.requestRender();
+  }
+  cancelRow(row) {
+    if (!row || row.kind !== "running") return;
+    const id = row.snapshot.request.id;
+    if (this.confirmCancelId !== id) {
+      this.confirmCancelId = id;
+      return;
+    }
+    cancelWebResearchTask(this.tasks, id);
+    this.confirmCancelId = void 0;
+    this.onChange();
+  }
+  // --- report / detail mode ---
+  renderReport(open, width) {
+    const lines = [
+      this.border(width),
+      this.theme.fg("accent", truncateToWidth(` ${open.title}`, width)),
+      this.theme.fg(
+        "dim",
+        " c copy markdown \xB7 i inject into context \xB7 \u2191\u2193/PgUp/PgDn scroll \xB7 Esc back"
+      ),
+      this.border(width),
+      ""
+    ];
+    let body;
+    try {
+      body = open.markdown.render(Math.max(20, width - 2));
+    } catch {
+      body = open.body.split("\n").map((line) => truncateToWidth(line, width));
+    }
+    const viewport = this.viewportHeight();
+    const maxOffset = Math.max(0, body.length - viewport);
+    this.scrollOffset = clamp2(this.scrollOffset, 0, maxOffset);
+    lines.push(...body.slice(this.scrollOffset, this.scrollOffset + viewport));
+    lines.push("");
+    const footer = [];
+    if (body.length > viewport) {
+      const end = Math.min(body.length, this.scrollOffset + viewport);
+      footer.push(`lines ${this.scrollOffset + 1}\u2013${end} of ${body.length}`);
+    }
+    if (open.truncated) {
+      footer.push(`report truncated \xB7 full text: ${open.item.outputPath}`);
+    }
+    if (this.statusMessage) {
+      lines.push(this.theme.fg("accent", ` ${this.statusMessage}`));
+    }
+    if (footer.length > 0) {
+      lines.push(
+        this.theme.fg("dim", truncateToWidth(` ${footer.join(" \xB7 ")}`, width))
+      );
+    }
+    lines.push(this.border(width));
+    return lines;
+  }
+  renderDetail(snapshot, width) {
+    const request = snapshot.request;
+    const elapsed = formatCompactElapsed(
+      Date.now() - Date.parse(request.startedAt)
+    );
+    const progress = snapshot.cancelRequestedAt ? "cancelling" : request.progress ?? "running";
+    const lines = [
+      this.border(width),
+      this.theme.fg(
+        "accent",
+        truncateToWidth(
+          ` Running research via ${providerLabel(request.provider)}`,
+          width
+        )
+      ),
+      this.theme.fg("dim", " c cancel \xB7 Esc back"),
+      this.border(width),
+      "",
+      truncateToWidth(` Status: ${progress} (${elapsed} elapsed)`, width),
+      truncateToWidth(` Report path: ${request.outputPath}`, width),
+      "",
+      this.theme.fg("accent", " Research brief"),
+      ""
+    ];
+    for (const line of request.input.split("\n").slice(0, 100)) {
+      lines.push(truncateToWidth(` ${line}`, width));
+    }
+    if (this.confirmCancelId === request.id) {
+      lines.push(
+        "",
+        this.theme.fg("warning", " Press c again to cancel this research")
+      );
+    }
+    if (this.statusMessage) {
+      lines.push("", this.theme.fg("accent", ` ${this.statusMessage}`));
+    }
+    lines.push(this.border(width));
+    return lines;
+  }
+  handleOpenInput(data) {
+    const kb = getKeybindings();
+    const open = this.open;
+    if (!open) return;
+    if (kb.matches(data, "tui.select.cancel")) {
+      if (this.confirmCancelId) {
+        this.confirmCancelId = void 0;
+        return;
+      }
+      this.open = void 0;
+      this.scrollOffset = 0;
+      return;
+    }
+    if (open.kind === "detail") {
+      if (data === "c") {
+        const snapshot = this.findSnapshot(open.taskId);
+        if (!snapshot) return;
+        if (this.confirmCancelId !== open.taskId) {
+          this.confirmCancelId = open.taskId;
+          return;
+        }
+        cancelWebResearchTask(this.tasks, open.taskId);
+        this.confirmCancelId = void 0;
+        this.onChange();
+        this.showStatusMessage("Cancellation requested");
+      }
+      return;
+    }
+    if (kb.matches(data, "tui.select.up")) this.scrollOffset -= 1;
+    else if (kb.matches(data, "tui.select.down")) this.scrollOffset += 1;
+    else if (kb.matches(data, "tui.select.pageUp"))
+      this.scrollOffset -= this.viewportHeight();
+    else if (kb.matches(data, "tui.select.pageDown"))
+      this.scrollOffset += this.viewportHeight();
+    else if (matchesKey(data, Key.home)) this.scrollOffset = 0;
+    else if (matchesKey(data, Key.end))
+      this.scrollOffset = Number.MAX_SAFE_INTEGER;
+    else if (data === "c") {
+      void this.actions.copyToClipboard(open.body).then(() => this.showStatusMessage("Copied report to clipboard")).catch((error) => {
+        const message = `Copy failed: ${formatErrorMessage(error)}`;
+        this.showStatusMessage(message);
+        this.actions.notify(message, "error");
+      });
+    } else if (data === "i") {
+      this.actions.injectReport({
+        title: open.title,
+        body: open.body,
+        item: open.item
+      });
+      this.showStatusMessage("Report added to conversation context");
+    }
+  }
+  viewportHeight() {
+    return Math.max(5, Math.floor(this.tui.terminal.rows * 0.85) - 6);
+  }
+  showStatusMessage(message) {
+    this.statusMessage = message;
+    if (this.statusMessageTimer) clearTimeout(this.statusMessageTimer);
+    this.statusMessageTimer = setTimeout(() => {
+      this.statusMessage = void 0;
+      this.statusMessageTimer = void 0;
+      this.tui.requestRender();
+    }, STATUS_MESSAGE_TTL_MS);
+  }
+  findSnapshot(taskId) {
+    return getWebResearchTaskSnapshots(this.tasks).find(
+      (snapshot) => snapshot.request.id === taskId
+    );
+  }
+  async reloadHistory() {
+    this.history = await this.loadHistory(this.cwd);
+    this.tui.requestRender();
+  }
+};
+function computeTableLayout(rows, width) {
+  const providerWidth = clamp2(
+    Math.max(0, ...rows.map((row) => visibleWidth(rowProvider(row)))),
+    4,
+    12
+  );
+  const date = 10;
+  const duration = 7;
+  const fixed = 2 + 2 + date + 1 + providerWidth + 1 + duration + 1;
+  return {
+    date,
+    provider: providerWidth,
+    duration,
+    title: Math.max(10, width - fixed)
+  };
+}
+function formatResearchTableRow(row, layout, theme, selected, now = Date.now()) {
+  const cursor = selected ? "\u203A " : "  ";
+  const glyph = statusGlyph(row, theme);
+  const date = padCell(
+    formatRelativeDate(rowTimestampMs(row), now),
+    layout.date
+  );
+  const provider = padCell(
+    truncateToWidth(rowProvider(row), layout.provider),
+    layout.provider
+  );
+  const duration = padCell(rowDuration(row, now), layout.duration, "right");
+  const title = truncateToWidth(rowTitle(row), layout.title);
+  const dim = (text) => row.kind === "history" ? text : theme.fg("dim", text);
+  return `${cursor}${glyph} ${dim(date)} ${provider} ${theme.fg("muted", duration)} ${title}`;
+}
+function statusGlyph(row, theme) {
+  if (row.kind === "running") {
+    const icon = row.snapshot.cancelRequestedAt ? "\u25CC" : getWebResearchProgressIcon(row.snapshot.request);
+    return theme.fg("accent", icon);
+  }
+  switch (row.item.status) {
+    case "completed":
+      return theme.fg("success", "\u2714");
+    case "failed":
+      return theme.fg("error", "\u2718");
+    case "cancelled":
+      return theme.fg("warning", "\u2718");
+    default:
+      return theme.fg("dim", "?");
+  }
+}
+function rowProvider(row) {
+  return row.kind === "running" ? providerLabel(row.snapshot.request.provider) : row.item.provider || "?";
+}
+function rowTimestampMs(row) {
+  if (row.kind === "running") {
+    return Date.parse(row.snapshot.request.startedAt);
+  }
+  const completed = Date.parse(row.item.completedAt);
+  if (Number.isFinite(completed)) return completed;
+  const started = Date.parse(row.item.startedAt);
+  if (Number.isFinite(started)) return started;
+  return row.item.mtimeMs;
+}
+function rowDuration(row, now) {
+  if (row.kind === "running") {
+    return formatCompactElapsed(
+      now - Date.parse(row.snapshot.request.startedAt)
+    );
+  }
+  return row.item.elapsedMs === void 0 ? "\u2014" : formatCompactElapsed(row.item.elapsedMs);
+}
+var REDUNDANT_PROGRESS = /* @__PURE__ */ new Set([
+  "in_progress",
+  "running",
+  "starting",
+  "queued",
+  "cancelling"
+]);
+function rowTitle(row) {
+  if (row.kind === "running") {
+    const request = row.snapshot.request;
+    const progress = row.snapshot.cancelRequestedAt ? void 0 : request.progress;
+    const prefix = progress && !REDUNDANT_PROGRESS.has(progress) ? `${progress} \u2014 ` : "";
+    return `${prefix}${cleanSingleLine(request.input)}`;
+  }
+  return row.item.title || cleanSingleLine(row.item.query);
+}
+function formatRelativeDate(timestampMs, now) {
+  if (!Number.isFinite(timestampMs)) return "?";
+  const diff = Math.max(0, now - timestampMs);
+  if (diff < 6e4) return "now";
+  if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+  if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
+  if (diff < 7 * 864e5) return `${Math.floor(diff / 864e5)}d ago`;
+  const date = new Date(timestampMs);
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  if (date.getFullYear() === new Date(now).getFullYear()) {
+    return `${month}-${day}`;
+  }
+  return `${date.getFullYear()}-${month}-${day}`;
+}
+function providerLabel(providerId) {
+  return PROVIDERS_BY_ID[providerId]?.label ?? providerId;
+}
+function padCell(text, width, align = "left") {
+  const pad = " ".repeat(Math.max(0, width - visibleWidth(text)));
+  return align === "left" ? `${text}${pad}` : `${pad}${text}`;
+}
+function clamp2(value, min, max) {
+  return Math.min(Math.max(value, min), Math.max(min, max));
+}
+function formatCompactElapsed(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes > 0) {
+    return `${minutes}m${seconds}s`;
+  }
+  return `${totalSeconds}s`;
+}
+function cleanSingleLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+// src/index.ts
+var DEFAULT_MAX_RESULTS = 5;
+var MAX_ALLOWED_RESULTS = 20;
+var MAX_SEARCH_QUERIES = 10;
+var RESEARCH_HEARTBEAT_MS = 15e3;
+var WEB_RESEARCH_RESULT_MESSAGE_TYPE = "web-research-result";
+var WEB_RESEARCH_REPORT_MESSAGE_TYPE = "web-research-report";
+var WEB_RESEARCH_WIDGET_KEY = "web-research-jobs";
+var DEFAULT_SUMMARY_SYMBOLS = {
+  success: "\u2714",
+  failure: "\u2718"
+};
+function webProvidersExtension(pi) {
+  const activeWebResearchRequests = /* @__PURE__ */ new Map();
+  let latestWidgetContext;
+  let webResearchWidgetTimer;
+  const stopWebResearchWidgetTimer = () => {
+    if (webResearchWidgetTimer) {
+      clearInterval(webResearchWidgetTimer);
+      webResearchWidgetTimer = void 0;
+    }
+  };
+  const ensureWebResearchWidgetTimer = () => {
+    if (webResearchWidgetTimer || activeWebResearchRequests.size === 0) {
+      return;
+    }
+    webResearchWidgetTimer = setInterval(() => {
+      updateWebResearchWidget();
+    }, 1e3);
+  };
+  const updateWebResearchWidget = (ctx) => {
+    const widgetContext = ctx ?? latestWidgetContext;
+    if (!widgetContext) {
+      return;
+    }
+    latestWidgetContext = widgetContext;
+    if (!widgetContext.hasUI) {
       stopWebResearchWidgetTimer();
       return;
     }
@@ -9849,7 +10900,7 @@ function webProvidersExtension(pi) {
     widgetContext.ui.setWidget(
       WEB_RESEARCH_WIDGET_KEY,
       buildWebResearchWidgetLines(
-        [...activeWebResearchRequests.values()],
+        getActiveWebResearchRequests(activeWebResearchRequests),
         widgetContext.ui.theme
       )
     );
@@ -9859,6 +10910,10 @@ function webProvidersExtension(pi) {
       WEB_RESEARCH_RESULT_MESSAGE_TYPE,
       (message, state, theme) => renderWebResearchResultMessage(message, state, theme)
     );
+    pi.registerMessageRenderer(
+      WEB_RESEARCH_REPORT_MESSAGE_TYPE,
+      (message, state, theme) => renderWebResearchReportMessage(message, state, theme)
+    );
   }
   pi.registerCommand("web-providers", {
     description: "Configure web search providers",
@@ -9874,11 +10929,71 @@ function webProvidersExtension(pi) {
       );
     }
   });
+  pi.registerCommand("web-research", {
+    description: "Browse, inspect, and manage web researches",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("web-research requires interactive mode", "error");
+        return;
+      }
+      const actions = {
+        copyToClipboard,
+        injectReport: ({ title, body, item }) => {
+          pi.sendMessage(
+            {
+              customType: WEB_RESEARCH_REPORT_MESSAGE_TYPE,
+              content: formatWebResearchReportMessage(title, body, item),
+              display: true,
+              details: {
+                title,
+                outputPath: item.outputPath,
+                provider: item.provider,
+                query: item.query,
+                status: item.status
+              }
+            },
+            { triggerTurn: false }
+          );
+        },
+        notify: (message, type) => ctx.ui.notify(message, type ?? "info")
+      };
+      let timer;
+      let view;
+      try {
+        await ctx.ui.custom(
+          (tui, theme, _keybindings, done) => {
+            view = new WebResearchManagerView(
+              tui,
+              theme,
+              done,
+              ctx.cwd,
+              activeWebResearchRequests,
+              () => updateWebResearchWidget(ctx),
+              actions
+            );
+            timer = setInterval(() => view?.refresh(), 1e3);
+            return view;
+          },
+          {
+            overlay: true,
+            overlayOptions: () => view?.isReportOpen() ? { anchor: "center", width: "85%", maxHeight: "85%" } : {
+              anchor: "center",
+              width: "75%",
+              maxHeight: "60%",
+              minWidth: 60
+            }
+          }
+        );
+      } finally {
+        if (timer) clearInterval(timer);
+      }
+    }
+  });
   pi.on("session_start", async (_event, ctx) => {
     latestWidgetContext = ctx;
     resetContentStore();
     updateWebResearchWidget(ctx);
-    await refreshManagedToolsOnStartup(
+    await refreshManagedToolsOnStartup2(
       pi,
       { activeWebResearchRequests, updateWebResearchWidget },
       ctx.cwd,
@@ -9889,7 +11004,7 @@ function webProvidersExtension(pi) {
     latestWidgetContext = ctx;
     await cleanupContentStore();
     updateWebResearchWidget(ctx);
-    await refreshManagedToolsOnStartup(
+    await refreshManagedToolsOnStartup2(
       pi,
       { activeWebResearchRequests, updateWebResearchWidget },
       ctx.cwd,
@@ -10112,7 +11227,7 @@ function registerWebResearchTool(pi, webResearchLifecycle, providerIds) {
       "Do not expect the final report in the same turn; tell the user that web research has started and wait for the completion message with the saved report path."
     ]),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      return dispatchWebResearch({
+      return dispatchWebResearch2({
         pi,
         activeWebResearchRequests: webResearchLifecycle.activeWebResearchRequests,
         updateWebResearchWidget: webResearchLifecycle.updateWebResearchWidget,
@@ -10137,109 +11252,38 @@ function registerWebResearchTool(pi, webResearchLifecycle, providerIds) {
     }
   });
 }
-async function runWebProvidersConfig(pi, webResearchLifecycle, ctx) {
-  const config = await loadConfig();
-  const activeProvider = getInitialProviderSelection(config);
-  await ctx.ui.custom(
-    (tui, theme, _keybindings, done) => new WebProvidersSettingsView(
-      tui,
-      theme,
-      done,
-      ctx,
-      config,
-      activeProvider
-    )
-  );
-  await refreshManagedTools(pi, webResearchLifecycle, ctx.cwd, {
-    addAvailable: true
-  });
-}
-function formatStartupConfigError(error) {
-  const detail = error instanceof Error ? error.message : String(error);
-  return `web-providers config error: ${detail.replace(getConfigPath(), "~/.pi/agent/web-providers.json")}`;
-}
-function getAvailableProviderIdsForCapability(config, cwd, capability) {
-  const providerId = getMappedProviderIdForTool(config, capability);
-  if (!providerId) {
-    return [];
-  }
-  const provider = PROVIDERS_BY_ID[providerId];
-  if (!supportsTool2(provider, capability)) {
-    return [];
-  }
-  const status = getProviderCapabilityStatus(
-    config,
-    cwd,
-    providerId,
-    capability,
-    {
-      resolveSecrets: false
-    }
-  );
-  return isProviderCapabilityExposable(status) ? [providerId] : [];
-}
-function getProviderStatusForTool(config, cwd, providerId, capability) {
-  return getProviderCapabilityStatus(config, cwd, providerId, capability);
-}
-function getAvailableManagedToolNames(config, cwd) {
-  return Object.keys(CAPABILITY_TOOL_NAMES).filter(
-    (capability) => getAvailableProviderIdsForCapability(config, cwd, capability).length > 0
-  ).map((capability) => CAPABILITY_TOOL_NAMES[capability]);
-}
-function getSyncedActiveTools(config, cwd, activeToolNames, options) {
-  const availableToolNames = new Set(getAvailableManagedToolNames(config, cwd));
-  const nextActiveTools = new Set(activeToolNames);
-  for (const toolName of MANAGED_TOOL_NAMES) {
-    if (availableToolNames.has(toolName)) {
-      if (options.addAvailable) {
-        nextActiveTools.add(toolName);
-      }
-      continue;
-    }
-    nextActiveTools.delete(toolName);
-  }
-  return nextActiveTools;
-}
-async function refreshManagedTools(pi, webResearchLifecycle, cwd, options) {
+async function runWebProvidersConfig(pi, webResearchLifecycle, ctx) {
   const config = await loadConfig();
-  const nextActiveTools = getSyncedActiveTools(
-    config,
-    cwd,
-    pi.getActiveTools(),
-    options
+  const activeProvider = getInitialProviderSelection(config);
+  await ctx.ui.custom(
+    (tui, theme, _keybindings, done) => new WebProvidersSettingsView(
+      tui,
+      theme,
+      done,
+      ctx,
+      config,
+      activeProvider
+    )
   );
-  registerManagedTools(pi, webResearchLifecycle, {
-    search: getAvailableProviderIdsForCapability(config, cwd, "search"),
-    contents: getAvailableProviderIdsForCapability(config, cwd, "contents"),
-    answer: getAvailableProviderIdsForCapability(config, cwd, "answer"),
-    research: getAvailableProviderIdsForCapability(config, cwd, "research")
+  await refreshManagedTools2(pi, webResearchLifecycle, ctx.cwd, {
+    addAvailable: true
   });
-  await syncManagedToolAvailability(pi, nextActiveTools);
 }
-async function refreshManagedToolsOnStartup(pi, webResearchLifecycle, cwd, options) {
-  try {
-    await refreshManagedTools(pi, webResearchLifecycle, cwd, options);
-  } catch (error) {
-    const message = formatStartupConfigError(error);
-    pi.sendMessage({
-      customType: "web-providers-config-error",
-      content: message,
-      display: true
-    });
-    await syncManagedToolAvailability(
-      pi,
-      new Set(
-        pi.getActiveTools().filter((toolName) => !MANAGED_TOOL_NAMES.includes(toolName))
-      )
-    );
-  }
+async function refreshManagedTools2(pi, webResearchLifecycle, cwd, options) {
+  await refreshManagedTools(
+    pi,
+    (providerIdsByCapability) => registerManagedTools(pi, webResearchLifecycle, providerIdsByCapability),
+    cwd,
+    options
+  );
 }
-async function syncManagedToolAvailability(pi, nextActiveTools) {
-  const activeTools = pi.getActiveTools();
-  const changed = activeTools.length !== nextActiveTools.size || activeTools.some((toolName) => !nextActiveTools.has(toolName));
-  if (changed) {
-    pi.setActiveTools(Array.from(nextActiveTools));
-  }
+async function refreshManagedToolsOnStartup2(pi, webResearchLifecycle, cwd, options) {
+  await refreshManagedToolsOnStartup(
+    pi,
+    (providerIdsByCapability) => registerManagedTools(pi, webResearchLifecycle, providerIdsByCapability),
+    cwd,
+    options
+  );
 }
 function getSearchMaxResultsLimit(providerId) {
   const capabilities = PROVIDERS_BY_ID[providerId].capabilities;
@@ -10456,12 +11500,12 @@ async function executeRawProviderRequest({
     input
   });
 }
-function buildSearchBatchError(outcomes, providerLabel) {
+function buildSearchBatchError(outcomes, providerLabel2) {
   const failed = outcomes.filter((outcome) => outcome.error !== void 0);
   if (failed.length === 1) {
     return new Error(
       formatProviderCapabilityFailure(
-        providerLabel,
+        providerLabel2,
         "search",
         failed[0]?.error ?? ""
       )
@@ -10471,7 +11515,7 @@ function buildSearchBatchError(outcomes, providerLabel) {
     (outcome, index) => `${index + 1}. ${formatQuotedPreview(outcome.query, 40)} \u2014 ${outcome.error}`
   ).join("; ");
   return new Error(
-    `${providerLabel} search failed for ${failed.length} queries: ${summary}`
+    `${providerLabel2} search failed for ${failed.length} queries: ${summary}`
   );
 }
 async function executeSingleSearchQuery({
@@ -10608,12 +11652,12 @@ async function executeAnswerToolInternal({
     })
   };
 }
-function buildAnswerBatchError(outcomes, providerLabel) {
+function buildAnswerBatchError(outcomes, providerLabel2) {
   const failed = outcomes.filter((outcome) => outcome.error !== void 0);
   if (failed.length === 1) {
     return new Error(
       formatProviderCapabilityFailure(
-        providerLabel,
+        providerLabel2,
         "answer",
         failed[0]?.error ?? ""
       )
@@ -10623,7 +11667,7 @@ function buildAnswerBatchError(outcomes, providerLabel) {
     (outcome, index) => `${index + 1}. ${formatQuotedPreview(outcome.query, 40)} \u2014 ${outcome.error}`
   ).join("; ");
   return new Error(
-    `${providerLabel} answer failed for ${failed.length} questions: ${summary}`
+    `${providerLabel2} answer failed for ${failed.length} questions: ${summary}`
   );
 }
 function formatAnswerResponses(outcomes) {
@@ -10839,7 +11883,7 @@ async function executeProviderToolInternal({
     })
   };
 }
-async function dispatchWebResearch({
+async function dispatchWebResearch2({
   pi,
   activeWebResearchRequests,
   updateWebResearchWidget,
@@ -10868,188 +11912,59 @@ async function dispatchWebResearchInternal({
   input,
   executionOverride
 }) {
-  await cleanupContentStore();
-  const provider = resolveProviderForTool(
+  return dispatchWebResearch({
+    activeWebResearchRequests,
     config,
-    ctx.cwd,
-    "research",
-    explicitProvider
-  );
-  const request = createWebResearchRequest(ctx.cwd, provider.id, input);
-  const providerConfig = getEffectiveProviderConfig(config, provider.id);
-  activeWebResearchRequests.set(request.id, request);
-  updateWebResearchWidget(ctx);
-  trackPendingResearchTask(
-    runDispatchedWebResearch({
-      pi,
-      activeWebResearchRequests,
-      updateWebResearchWidget,
-      request,
-      config,
+    explicitProvider,
+    ctx: { cwd: ctx.cwd },
+    options: providerOptions,
+    input,
+    executionOverride,
+    executeResearch: async ({
+      config: config2,
       provider,
       providerConfig,
-      ctx,
-      options: providerOptions,
-      executionOverride
-    })
-  );
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Started web research via ${provider.label}.`
-      }
-    ],
-    details: request,
-    display: buildProviderToolDisplay2({
-      capability: "research",
-      providerId: provider.id,
-      details: { tool: "web_research", provider: provider.id },
-      text: "started"
-    })
-  };
-}
-async function runDispatchedWebResearch({
-  pi,
-  activeWebResearchRequests,
-  updateWebResearchWidget,
-  request,
-  config,
-  provider,
-  providerConfig,
-  ctx,
-  options,
-  executionOverride
-}) {
-  let result;
-  let reportText = "";
-  try {
-    const response = await executeProviderOperation({
+      ctx: ctx2,
+      signal,
+      options,
+      input: input2,
+      onProgress,
+      executionOverride: executionOverride2
+    }) => executeProviderOperation({
       capability: "research",
-      config,
+      config: config2,
       provider,
       providerConfig,
-      ctx,
-      signal: void 0,
+      ctx: ctx2,
+      signal,
       options,
-      input: request.input,
-      onProgress: (message) => {
-        request.progress = summarizeWebResearchProgress(
-          message,
-          provider.label
-        );
-        updateWebResearchWidget();
-      },
-      executionOverride
-    });
-    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    result = {
-      ...request,
-      status: "completed",
-      completedAt,
-      elapsedMs: Math.max(
-        0,
-        Date.parse(completedAt) - Date.parse(request.startedAt)
-      ),
-      itemCount: response.itemCount
-    };
-    reportText = response.text;
-  } catch (error) {
-    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    result = {
-      ...request,
-      status: "failed",
-      completedAt,
-      elapsedMs: Math.max(
-        0,
-        Date.parse(completedAt) - Date.parse(request.startedAt)
-      ),
-      error: formatErrorMessage(error)
-    };
-  }
-  try {
-    await writeWebResearchArtifact(result, reportText);
-    pi.sendMessage({
-      customType: WEB_RESEARCH_RESULT_MESSAGE_TYPE,
-      content: formatWebResearchResultMessage(result, reportText),
-      display: true,
-      details: result
-    });
-  } finally {
-    activeWebResearchRequests.delete(request.id);
-    updateWebResearchWidget();
-  }
-}
-function createWebResearchRequest(cwd, provider, input) {
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    tool: "web_research",
-    id: randomUUID(),
-    provider,
-    input,
-    outputPath: buildWebResearchArtifactPath(cwd, input, startedAt),
-    startedAt
-  };
-}
-function buildWebResearchArtifactPath(cwd, input, startedAt) {
-  const timestamp = startedAt.replaceAll(":", "-").replace(".", "-");
-  const slug = slugifyWebResearchInput(input);
-  return join2(cwd, RESEARCH_ARTIFACTS_DIR, `${timestamp}-${slug}.md`);
-}
-function slugifyWebResearchInput(input) {
-  const slug = input.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "");
-  return slug.length > 0 ? slug : "research";
+      input: input2,
+      onProgress,
+      executionOverride: executionOverride2
+    }),
+    deliverResult: (message) => pi.sendMessage(message),
+    onJobsChanged: () => updateWebResearchWidget(ctx),
+    resultMessageType: WEB_RESEARCH_RESULT_MESSAGE_TYPE
+  });
 }
 function buildWebResearchWidgetLines(requests, theme, now = Date.now()) {
-  const lines = [theme.fg("accent", "Research jobs:")];
-  for (const request of requests.slice().sort((left, right) => left.startedAt.localeCompare(right.startedAt)).slice(0, 3)) {
-    const providerLabel = PROVIDERS_BY_ID[request.provider]?.label ?? request.provider;
-    const elapsed = formatCompactElapsed(now - Date.parse(request.startedAt));
-    const icon = getWebResearchWidgetIcon(request, now);
-    lines.push(
-      `${icon}${providerLabel} ${theme.fg("muted", `(${elapsed}): `)}${truncateInline(cleanSingleLine(request.input), 70)}`
-    );
-  }
-  if (requests.length > 3) {
-    lines.push(theme.fg("muted", `+${requests.length - 3} more`));
-  }
-  return lines;
-}
-function getWebResearchWidgetIcon(request, _now) {
-  if (request.progress === "poll retrying after transient errors") {
-    return "\u27F3 ";
-  }
-  if (request.progress === "queued") {
-    return "\u25CC ";
-  }
-  if (request.progress === "starting") {
-    return "\u25D4 ";
-  }
-  if (request.progress?.startsWith("started:")) {
-    return "\u25D1 ";
-  }
-  return "\u25CF ";
-}
-function summarizeWebResearchProgress(message, providerLabel) {
-  const startingMessage = `Starting research via ${providerLabel}`;
-  if (message === startingMessage) {
-    return "starting";
-  }
-  const startedPrefix = `${providerLabel} research started: `;
-  if (message.startsWith(startedPrefix)) {
-    return `started: ${message.slice(startedPrefix.length)}`;
-  }
-  const statusPrefix = `Research via ${providerLabel}: `;
-  if (message.startsWith(statusPrefix)) {
-    return message.slice(statusPrefix.length).replace(/\s+\([^)]* elapsed\)$/u, "").trim();
-  }
-  const retryPrefix = `${providerLabel} research poll is still retrying after transient errors`;
-  if (message.startsWith(retryPrefix)) {
-    return "poll retrying after transient errors";
+  const sorted = requests.slice().sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+  const jobs = sorted.slice(0, 3).map((request) => {
+    const providerLabel2 = PROVIDERS_BY_ID[request.provider]?.label ?? request.provider;
+    const elapsed = formatCompactElapsed2(now - Date.parse(request.startedAt));
+    const icon = getWebResearchProgressIcon(request);
+    const status = request.progress === "cancelling" ? " cancelling" : "";
+    return `${icon} ${providerLabel2} ${elapsed}${status}`;
+  });
+  if (sorted.length > 3) {
+    jobs.push(`+${sorted.length - 3} more`);
   }
-  return message.trim();
+  const count = sorted.length === 1 ? "1 research" : `${sorted.length} researches`;
+  return [
+    `${theme.fg("accent", `${count} running`)}${theme.fg("muted", ` \xB7 ${jobs.join(" \xB7 ")} \xB7 /web-research`)}`
+  ];
 }
-function formatCompactElapsed(ms) {
+function formatCompactElapsed2(ms) {
   const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
   const minutes = Math.floor(totalSeconds / 60);
   const seconds = totalSeconds % 60;
@@ -11058,68 +11973,6 @@ function formatCompactElapsed(ms) {
   }
   return `${totalSeconds}s`;
 }
-function formatWebResearchResultMessage(result, reportText) {
-  const text = reportText.trim();
-  if (text.length > 0) {
-    return `${text}
-`;
-  }
-  if (result.error) {
-    return `${result.error}
-`;
-  }
-  return "";
-}
-async function writeWebResearchArtifact(result, reportText) {
-  await mkdir2(dirname2(result.outputPath), { recursive: true });
-  await writeFile2(
-    result.outputPath,
-    formatWebResearchArtifact(result, reportText),
-    "utf-8"
-  );
-}
-function formatWebResearchArtifact(result, reportText) {
-  const providerLabel = PROVIDERS_BY_ID[result.provider]?.label ?? result.provider;
-  const lines = [
-    "# Web research report",
-    "",
-    "## Query",
-    result.input,
-    "",
-    "## Provider",
-    providerLabel,
-    "",
-    "## Status",
-    result.status,
-    "",
-    "## Started",
-    result.startedAt,
-    "",
-    "## Completed",
-    result.completedAt,
-    "",
-    "## Elapsed",
-    formatElapsed(result.elapsedMs)
-  ];
-  if (typeof result.itemCount === "number") {
-    lines.push("", "## Items", String(result.itemCount));
-  }
-  if (result.error) {
-    lines.push("", "## Error", result.error);
-  }
-  if (reportText) {
-    lines.push("", "## Report", reportText);
-  }
-  return `${lines.join("\n")}
-`;
-}
-function trackPendingResearchTask(task) {
-  const tracked = task.catch(() => {
-  }).finally(() => {
-    pendingResearchTasks.delete(tracked);
-  });
-  pendingResearchTasks.add(tracked);
-}
 async function executeBatchedContentsTool({
   config,
   provider,
@@ -11281,10 +12134,10 @@ function createToolProgressReporter(capability, providerId, progress) {
       if (Date.now() - lastUpdateAt < RESEARCH_HEARTBEAT_MS) {
         return;
       }
-      const providerLabel = PROVIDERS_BY_ID[providerId]?.label ?? providerId;
+      const providerLabel2 = PROVIDERS_BY_ID[providerId]?.label ?? providerId;
       const elapsed = formatElapsed(Date.now() - startedAt);
       emit(
-        `Researching via ${providerLabel} (${elapsed} elapsed)`,
+        `Researching via ${providerLabel2} (${elapsed} elapsed)`,
         buildProgressDisplay2(providerId, `Researching ${elapsed}`)
       );
       lastUpdateAt = Date.now();
@@ -11307,38 +12160,38 @@ function renderListCallHeader(toolName, items, theme, suffix, options = {}) {
     invalidate() {
     },
     render(width) {
-      const normalizedItems = items.map((item) => cleanSingleLine(item)).filter((item) => item.length > 0);
+      const normalizedItems = items.map((item) => cleanSingleLine2(item)).filter((item) => item.length > 0);
       const toolTitle = theme.fg("toolTitle", theme.bold(toolName));
       const mutedSuffix = suffix ? theme.fg("muted", suffix) : "";
       if (!options.forceMultiline && normalizedItems.length === 1) {
         const singleItem = options.quoteSingleItem ? formatQuotedPreview(normalizedItems[0], 80) : truncateInline(normalizedItems[0], 120);
         const inline = `${toolTitle} ${theme.fg("accent", singleItem)}${mutedSuffix}`;
-        const line = truncateToWidth(inline.trimEnd(), width);
-        return [line + " ".repeat(Math.max(0, width - visibleWidth(line)))];
+        const line = truncateToWidth2(inline.trimEnd(), width);
+        return [line + " ".repeat(Math.max(0, width - visibleWidth2(line)))];
       }
       let header = toolTitle;
       if (mutedSuffix) {
         header += mutedSuffix;
       }
       const lines = [];
-      const headerLine = truncateToWidth(header.trimEnd(), width);
+      const headerLine = truncateToWidth2(header.trimEnd(), width);
       lines.push(
-        headerLine + " ".repeat(Math.max(0, width - visibleWidth(headerLine)))
+        headerLine + " ".repeat(Math.max(0, width - visibleWidth2(headerLine)))
       );
       for (const item of normalizedItems) {
         const itemLines = options.forceMultiline ? wrapTextWithAnsi(
           theme.fg("accent", item),
           Math.max(1, width - 2)
         ).map((line) => `  ${line}`) : [
-          truncateToWidth(
+          truncateToWidth2(
             `  ${theme.fg("accent", truncateInline(item, 120))}`,
             width
           )
         ];
         for (const itemLine of itemLines) {
-          const line = truncateToWidth(itemLine, width);
+          const line = truncateToWidth2(itemLine, width);
           lines.push(
-            line + " ".repeat(Math.max(0, width - visibleWidth(line)))
+            line + " ".repeat(Math.max(0, width - visibleWidth2(line)))
           );
         }
       }
@@ -11433,7 +12286,8 @@ function renderWebResearchResultMessage(message, { expanded }, theme, symbols =
   const text = typeof message.content === "string" ? message.content : extractTextContent(message.content);
   const details = isWebResearchResult(message.details) ? message.details : void 0;
   const isSuccess = details?.status === "completed";
-  const accent = isSuccess ? "success" : "error";
+  const isCancelled = details?.status === "cancelled";
+  const accent = isSuccess ? "success" : isCancelled ? "warning" : "error";
   const box = new Box(1, 1, (value) => theme.bg("customMessageBg", value));
   if (!expanded) {
     const summary = details ? buildWebResearchResultSummaryLine(details, theme, symbols) : theme.fg(accent, "Web research update");
@@ -11443,10 +12297,42 @@ function renderWebResearchResultMessage(message, { expanded }, theme, symbols =
     return box;
   }
   box.addChild(
-    details ? renderMarkdownBlock(renderWebResearchResultMarkdown(details)) : isSuccess ? renderMarkdownBlock(text ?? "") : renderBlockText(text ?? "", theme, "error")
+    details ? renderMarkdownBlock(renderWebResearchResultMarkdown(details)) : isSuccess ? renderMarkdownBlock(text ?? "") : renderBlockText(
+      text ?? "",
+      theme,
+      isCancelled ? "toolOutput" : "error"
+    )
   );
   return box;
 }
+function formatWebResearchReportMessage(title, body, item) {
+  const provenance = `Saved web research report "${title}" (provider: ${item.provider || "unknown"}, status: ${item.status}, artifact: \`${item.outputPath}\`):`;
+  return `${provenance}
+
+${body}
+`;
+}
+function renderWebResearchReportMessage(message, { expanded }, theme) {
+  const text = typeof message.content === "string" ? message.content : extractTextContent(message.content);
+  const details = isWebResearchReportDetails(message.details) ? message.details : void 0;
+  const box = new Box(1, 1, (value) => theme.bg("customMessageBg", value));
+  if (!expanded) {
+    const title = details?.title ?? "saved report";
+    box.addChild(
+      new Text(
+        `${theme.fg("success", `Injected research report: ${title}`)}${theme.fg("muted", ` (${getExpandHint()})`)}`,
+        0,
+        0
+      )
+    );
+    return box;
+  }
+  box.addChild(renderMarkdownBlock(text ?? ""));
+  return box;
+}
+function isWebResearchReportDetails(details) {
+  return typeof details === "object" && details !== null && "title" in details && "outputPath" in details && !("tool" in details);
+}
 function renderWebResearchRequestMarkdown(request) {
   return [
     "### Web research",
@@ -11472,7 +12358,7 @@ function renderWebResearchResultMarkdown(result) {
   ].join("\n");
 }
 function buildWebResearchResultSummaryLine(result, theme, symbols) {
-  const providerLabel = PROVIDERS_BY_ID[result.provider]?.label ?? result.provider;
+  const providerLabel2 = PROVIDERS_BY_ID[result.provider]?.label ?? result.provider;
   if (result.status === "completed") {
     return renderSuccessSummary(
       `${formatSummaryElapsed(result.elapsedMs)} \xB7 ${basename(result.outputPath)}`,
@@ -11480,8 +12366,8 @@ function buildWebResearchResultSummaryLine(result, theme, symbols) {
       symbols
     );
   }
-  const statusText = result.status === "cancelled" ? `${providerLabel} research canceled after ${formatSummaryElapsed(result.elapsedMs)}` : `${providerLabel} research failed after ${formatSummaryElapsed(result.elapsedMs)}`;
-  const errorSuffix = result.error ? `: ${normalizeProviderFailureDetail(providerLabel, result.error)}` : "";
+  const statusText = result.status === "cancelled" ? `${providerLabel2} research canceled after ${formatSummaryElapsed(result.elapsedMs)}` : `${providerLabel2} research failed after ${formatSummaryElapsed(result.elapsedMs)}`;
+  const errorSuffix = result.error ? `: ${normalizeProviderFailureDetail(providerLabel2, result.error)}` : "";
   return renderFailureSummary(`${statusText}${errorSuffix}`, theme, symbols);
 }
 function isWebResearchRequest(details) {
@@ -11580,7 +12466,7 @@ function renderEntryList(width, theme, entries, selection) {
     const paddedLabel = entry.label.padEnd(labelWidth, " ");
     const label = selected ? theme.fg("accent", paddedLabel) : paddedLabel;
     const value = selected ? theme.fg("accent", entry.currentValue) : theme.fg("muted", entry.currentValue);
-    return truncateToWidth(`${prefix}${label}  ${value}`, width);
+    return truncateToWidth2(`${prefix}${label}  ${value}`, width);
   });
 }
 function renderSelectedEntryDescription(width, theme, entry) {
@@ -11588,7 +12474,7 @@ function renderSelectedEntryDescription(width, theme, entry) {
     return [];
   }
   return wrapTextWithAnsi(entry.description, Math.max(10, width - 2)).map(
-    (line) => truncateToWidth(theme.fg("dim", line), width)
+    (line) => truncateToWidth2(theme.fg("dim", line), width)
   );
 }
 function formatProviderCapabilityChecks(providerId, theme) {
@@ -11769,7 +12655,7 @@ var WebProvidersSettingsView = class {
     }
     lines.push("");
     lines.push(
-      truncateToWidth(
+      truncateToWidth2(
         this.theme.fg(
           "dim",
           "\u2191\u2193 move \xB7 Tab/Shift+Tab switch section \xB7 Enter edit/open \xB7 Esc close"
@@ -11788,7 +12674,7 @@ var WebProvidersSettingsView = class {
       this.tui.requestRender();
       return;
     }
-    const kb = getKeybindings();
+    const kb = getKeybindings2();
     const entries = this.getActiveSectionEntries();
     if (kb.matches(data, "tui.select.up")) {
       if (entries.length > 0) {
@@ -11798,9 +12684,9 @@ var WebProvidersSettingsView = class {
       if (entries.length > 0) {
         this.moveSelection(1);
       }
-    } else if (matchesKey(data, Key.tab)) {
+    } else if (matchesKey2(data, Key2.tab)) {
       this.moveSection(1);
-    } else if (matchesKey(data, Key.shift("tab"))) {
+    } else if (matchesKey2(data, Key2.shift("tab"))) {
       this.moveSection(-1);
     } else if (kb.matches(data, "tui.select.confirm") || data === " ") {
       void this.activateCurrentEntry();
@@ -11933,14 +12819,14 @@ var WebProvidersSettingsView = class {
       Math.max(20, Math.floor(width * 0.45))
     );
     const lines = [
-      truncateToWidth(
+      truncateToWidth2(
         this.activeSection === section ? this.theme.fg("accent", this.theme.bold(title)) : this.theme.bold(title),
         width
       )
     ];
     if (section === "provider") {
       lines.push(
-        truncateToWidth(
+        truncateToWidth2(
           this.theme.fg(
             "dim",
             `  ${"Provider".padEnd(labelWidth, " ")}  S C A R  Status`
@@ -11955,15 +12841,15 @@ var WebProvidersSettingsView = class {
       const paddedLabel = entry.label.padEnd(labelWidth, " ");
       const label = selected ? this.theme.fg("accent", paddedLabel) : paddedLabel;
       if (entry.currentValue.trim().length === 0) {
-        lines.push(truncateToWidth(`${prefix}${label}`, width));
+        lines.push(truncateToWidth2(`${prefix}${label}`, width));
         continue;
       }
       const value = entry.preserveValueStyle ? entry.currentValue : selected ? this.theme.fg("accent", entry.currentValue) : this.theme.fg("muted", entry.currentValue);
-      lines.push(truncateToWidth(`${prefix}${label}  ${value}`, width));
+      lines.push(truncateToWidth2(`${prefix}${label}  ${value}`, width));
     }
     if (section === "provider") {
       lines.push(
-        truncateToWidth(
+        truncateToWidth2(
           this.theme.fg("dim", "  S=Search  C=Contents  A=Answer  R=Research"),
           width
         )
@@ -12098,7 +12984,7 @@ var ToolSettingsSubmenu = class {
     }
     const entries = this.getEntries();
     const lines = [
-      truncateToWidth(
+      truncateToWidth2(
         this.theme.fg("accent", TOOL_INFO[this.toolId].label),
         width
       ),
@@ -12114,7 +13000,7 @@ var ToolSettingsSubmenu = class {
     }
     lines.push("");
     lines.push(
-      truncateToWidth(
+      truncateToWidth2(
         this.theme.fg("dim", "\u2191\u2193 move \xB7 Enter edit/toggle \xB7 Esc back"),
         width
       )
@@ -12130,7 +13016,7 @@ var ToolSettingsSubmenu = class {
       this.tui.requestRender();
       return;
     }
-    const kb = getKeybindings();
+    const kb = getKeybindings2();
     const entries = this.getEntries();
     if (kb.matches(data, "tui.select.up")) {
       if (this.selection > 0) {
@@ -12333,7 +13219,7 @@ var ProviderSettingsSubmenu = class {
     const providerConfig = this.getProviderConfig();
     const entries = this.getEntries();
     const lines = [
-      truncateToWidth(this.theme.fg("accent", provider.label), width),
+      truncateToWidth2(this.theme.fg("accent", provider.label), width),
       "",
       ...renderEntryList(width, this.theme, entries, this.selection)
     ];
@@ -12350,10 +13236,10 @@ var ProviderSettingsSubmenu = class {
     );
     lines.push("");
     lines.push(
-      truncateToWidth(this.theme.fg("dim", `Status: ${status}`), width)
+      truncateToWidth2(this.theme.fg("dim", `Status: ${status}`), width)
     );
     lines.push(
-      truncateToWidth(
+      truncateToWidth2(
         this.theme.fg("dim", "\u2191\u2193 move \xB7 Enter edit/toggle \xB7 Esc back"),
         width
       )
@@ -12369,7 +13255,7 @@ var ProviderSettingsSubmenu = class {
       this.tui.requestRender();
       return;
     }
-    const kb = getKeybindings();
+    const kb = getKeybindings2();
     const entries = this.getEntries();
     if (kb.matches(data, "tui.select.up")) {
       if (this.selection > 0) {
@@ -12504,12 +13390,12 @@ var TextValueSubmenu = class {
   editor;
   render(width) {
     return [
-      truncateToWidth(this.theme.fg("accent", this.title), width),
+      truncateToWidth2(this.theme.fg("accent", this.title), width),
       "",
       ...this.editor.render(width),
       "",
-      truncateToWidth(this.theme.fg("dim", this.help), width),
-      truncateToWidth(
+      truncateToWidth2(this.theme.fg("dim", this.help), width),
+      truncateToWidth2(
         this.theme.fg(
           "dim",
           "Enter to save \xB7 Shift+Enter for newline \xB7 Esc to cancel"
@@ -12522,7 +13408,7 @@ var TextValueSubmenu = class {
     this.editor.invalidate();
   }
   handleInput(data) {
-    if (matchesKey(data, Key.escape)) {
+    if (matchesKey2(data, Key2.escape)) {
       this.done(void 0);
       return;
     }
@@ -12646,7 +13532,7 @@ function getSearchQueriesForDisplay(queries) {
 function getAnswerQueriesForDisplay(queries) {
   return getSearchQueriesForDisplay(queries);
 }
-function createBatchCompletionReporter(verb, providerId, providerLabel, total, report) {
+function createBatchCompletionReporter(verb, providerId, providerLabel2, total, report) {
   if (!report) {
     return {
       start: () => {
@@ -12660,7 +13546,7 @@ function createBatchCompletionReporter(verb, providerId, providerLabel, total, r
   let completedCount = 0;
   let failedCount = 0;
   const emit = () => {
-    let message = `${verb} via ${providerLabel}: ${completedCount}/${total} completed`;
+    let message = `${verb} via ${providerLabel2}: ${completedCount}/${total} completed`;
     if (failedCount > 0) {
       message += `, ${failedCount} failed`;
     }
@@ -12712,8 +13598,8 @@ function renderMarkdownBlock(text) {
   if (!text) {
     return new Text("", 0, 0);
   }
-  return new Markdown(`
-${text}`, 0, 0, getMarkdownTheme());
+  return new Markdown2(`
+${text}`, 0, 0, getMarkdownTheme2());
 }
 function renderBlockText(text, theme, color) {
   if (!text) {
@@ -12747,12 +13633,12 @@ function prefixWithSymbol(text, symbol) {
 }
 function renderToolProgress(display, fallbackText, theme) {
   const progress = display?.progress;
-  const providerLabel = display?.provider?.label;
-  if (!progress || !providerLabel) {
+  const providerLabel2 = display?.provider?.label;
+  if (!progress || !providerLabel2) {
     return renderSimpleText(fallbackText ?? "Working\u2026", theme, "warning");
   }
   return new Text(
-    `${theme.fg("warning", progress.action)} ${theme.fg("muted", `via ${providerLabel}`)}`,
+    `${theme.fg("warning", progress.action)} ${theme.fg("muted", `via ${providerLabel2}`)}`,
     0,
     0
   );
@@ -12804,15 +13690,15 @@ function buildFailureSummary({
   fallback
 }) {
   const detail = stripTrailingSentencePunctuation(getFirstLine2(text) ?? "");
-  const providerLabel = details?.provider !== void 0 ? PROVIDERS_BY_ID[details.provider]?.label ?? details.provider : void 0;
-  if (!providerLabel) {
+  const providerLabel2 = details?.provider !== void 0 ? PROVIDERS_BY_ID[details.provider]?.label ?? details.provider : void 0;
+  if (!providerLabel2) {
     return detail || fallback;
   }
-  return formatProviderCapabilityFailure(providerLabel, capability, detail);
+  return formatProviderCapabilityFailure(providerLabel2, capability, detail);
 }
-function formatProviderCapabilityFailure(providerLabel, capability, detail) {
+function formatProviderCapabilityFailure(providerLabel2, capability, detail) {
   const action = getFailureAction(capability);
-  const base2 = `${providerLabel} ${action} failed`;
+  const base2 = `${providerLabel2} ${action} failed`;
   if (!detail || detail === base2) {
     return base2;
   }
@@ -12820,14 +13706,14 @@ function formatProviderCapabilityFailure(providerLabel, capability, detail) {
     return detail;
   }
   const normalizedDetail = normalizeProviderFailureDetail(
-    providerLabel,
+    providerLabel2,
     detail
   );
   return `${base2}: ${normalizedDetail}`;
 }
-function normalizeProviderFailureDetail(providerLabel, detail) {
+function normalizeProviderFailureDetail(providerLabel2, detail) {
   const normalized = stripTrailingSentencePunctuation(detail);
-  const providerPrefix = `${providerLabel}:`;
+  const providerPrefix = `${providerLabel2}:`;
   return normalized.toLowerCase().startsWith(providerPrefix.toLowerCase()) ? normalized.slice(providerPrefix.length).trim() : normalized;
 }
 function getFailureAction(capability) {
@@ -12876,7 +13762,7 @@ function getFirstLine2(text) {
 }
 function getExpandHint() {
   try {
-    const keys = getKeybindings().getKeys("app.tools.expand");
+    const keys = getKeybindings2().getKeys("app.tools.expand");
     if (keys.length > 0) {
       return `${keys.join("/")} to expand`;
     }
@@ -12884,11 +13770,11 @@ function getExpandHint() {
   }
   return "ctrl+o to expand";
 }
-function cleanSingleLine(text) {
+function cleanSingleLine2(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 function formatQuotedPreview(text, maxLength = 80) {
-  return `"${truncateInline(cleanSingleLine(text), maxLength)}"`;
+  return `"${truncateInline(cleanSingleLine2(text), maxLength)}"`;
 }
 function formatSearchResponses(outcomes, prefetch) {
   const body = outcomes.map(
@@ -12914,10 +13800,10 @@ function formatSearchOutcomeSection(outcome, index, total) {
 ${body}`;
 }
 function formatSearchHeading(query2) {
-  return `"${escapeMarkdownText(cleanSingleLine(query2))}"`;
+  return `"${escapeMarkdownText(cleanSingleLine2(query2))}"`;
 }
 function formatAnswerHeading(query2) {
-  return `"${escapeMarkdownText(cleanSingleLine(query2))}"`;
+  return `"${escapeMarkdownText(cleanSingleLine2(query2))}"`;
 }
 function collectSearchResultUrls(outcomes) {
   return outcomes.flatMap(
@@ -12933,7 +13819,7 @@ function formatSearchResponseMarkdown(response) {
       `${index + 1}. ${formatMarkdownLink(result.title, result.url)}`
     ];
     if (result.snippet) {
-      lines.push(`   ${escapeMarkdownText(cleanSingleLine(result.snippet))}`);
+      lines.push(`   ${escapeMarkdownText(cleanSingleLine2(result.snippet))}`);
     }
     return lines.join("\n");
   }).join("\n\n");
@@ -12942,7 +13828,7 @@ function formatMarkdownLink(label, url2) {
   return `[${escapeMarkdownLinkLabel(label)}](<${url2}>)`;
 }
 function escapeMarkdownLinkLabel(text) {
-  return cleanSingleLine(text).replaceAll("\\", "\\\\").replaceAll("]", "\\]");
+  return cleanSingleLine2(text).replaceAll("\\", "\\\\").replaceAll("]", "\\]");
 }
 function escapeMarkdownText(text) {
   return text.replaceAll("\\", "\\\\").replaceAll("*", "\\*").replaceAll("_", "\\_").replaceAll("`", "\\`").replaceAll("#", "\\#").replaceAll("[", "\\[").replaceAll("]", "\\]");
@@ -12963,10 +13849,10 @@ async function truncateAndSaveWithMetadata(text, prefix) {
       truncated: false
     };
   }
-  const dir = join2(tmpdir(), `pi-web-providers-${prefix}-${Date.now()}`);
-  await mkdir2(dir, { recursive: true });
-  const fullPath = join2(dir, "output.txt");
-  await writeFile2(fullPath, text, "utf-8");
+  const dir = join3(tmpdir(), `pi-web-providers-${prefix}-${Date.now()}`);
+  await mkdir3(dir, { recursive: true });
+  const fullPath = join3(dir, "output.txt");
+  await writeFile3(fullPath, text, "utf-8");
   return {
     text: truncation.content + `
 
@@ -13073,6 +13959,12 @@ var __test__ = {
   }),
   extractTextContent,
   formatWebResearchResultMessage,
+  getActiveWebResearchRequests,
+  getWebResearchTaskSnapshots,
+  cancelWebResearchTask,
+  loadWebResearchHistory,
+  loadWebResearchPreview,
+  loadWebResearchReport,
   getAvailableManagedToolNames,
   getReadyCompatibleProvidersForTool,
   getEnabledCompatibleProvidersForTool: getReadyCompatibleProvidersForTool,
@@ -13090,9 +13982,10 @@ var __test__ = {
   renderProviderToolResult,
   renderWebResearchDispatchResult,
   renderWebResearchResultMessage,
-  waitForPendingResearchTasks: async () => {
-    await Promise.all([...pendingResearchTasks]);
-  },
+  renderWebResearchReportMessage,
+  formatWebResearchReportMessage,
+  buildWebResearchWidgetLines,
+  waitForPendingResearchTasks,
   formatSearchResponses,
   formatAnswerResponses
 };