@lincoln504/pi-research 1.0.6 → 1.0.9

package/dist/cli.mjs

@@ -2295,6 +2295,7 @@ function saveConfig(config, scope = "local", cwd = process.cwd(), changedKeys) {
     PI_RESEARCH_MAX_RESEARCHERS: String(config.MAX_CONCURRENT_RESEARCHERS),
     PI_RESEARCH_MAX_RETRIES: String(config.RESEARCHER_MAX_RETRIES),
     PI_RESEARCH_RETRY_DELAY_MS: String(config.RESEARCHER_MAX_RETRY_DELAY_MS),
+    PI_RESEARCH_MAX_FAILED_RESEARCHERS: String(config.MAX_FAILED_RESEARCHERS ?? DEFAULTS.MAX_FAILED_RESEARCHERS),
     PI_RESEARCH_HEALTH_CHECK_TIMEOUT_MS: String(config.HEALTH_CHECK_TIMEOUT_MS ?? DEFAULTS.HEALTH_CHECK_TIMEOUT_MS),
     PI_RESEARCH_SEARCH_TIMEOUT_MS: String(config.SEARCH_TIMEOUT_MS),
     PI_RESEARCH_TUI_REFRESH_DEBOUNCE_MS: String(config.TUI_REFRESH_DEBOUNCE_MS),
@@ -2457,6 +2458,7 @@ function createConfig(env, processEnv) {
     MAX_CONCURRENT_RESEARCHERS: parseEnvNumber(e, "PI_RESEARCH_MAX_RESEARCHERS", DEFAULTS.MAX_CONCURRENT_RESEARCHERS, 1, 5, true),
     RESEARCHER_MAX_RETRIES: parseEnvNumber(e, "PI_RESEARCH_MAX_RETRIES", DEFAULTS.RESEARCHER_MAX_RETRIES, 0, 5, true),
     RESEARCHER_MAX_RETRY_DELAY_MS: parseEnvNumber(e, "PI_RESEARCH_RETRY_DELAY_MS", DEFAULTS.RESEARCHER_MAX_RETRY_DELAY_MS, 100, 1e4),
+    MAX_FAILED_RESEARCHERS: parseEnvNumber(e, "PI_RESEARCH_MAX_FAILED_RESEARCHERS", DEFAULTS.MAX_FAILED_RESEARCHERS, 1, 10, true),
     DEFAULT_RESEARCH_DEPTH: parseEnvNumber(e, "PI_RESEARCH_DEFAULT_RESEARCH_DEPTH", DEFAULTS.DEFAULT_RESEARCH_DEPTH, 1, 3, true),
     MAX_SCRAPE_BATCHES: parseEnvNumber(e, "PI_RESEARCH_MAX_SCRAPE_BATCHES", DEFAULTS.MAX_SCRAPE_BATCHES, 0, 99, true),
     MAX_GATHERING_CALLS: parseEnvNumber(e, "PI_RESEARCH_MAX_GATHERING_CALLS", DEFAULTS.MAX_GATHERING_CALLS, 1, 100, true),
@@ -2483,7 +2485,7 @@ function createConfig(env, processEnv) {
     SEARCH_TIMEOUT_MS: parseEnvNumber(e, "PI_RESEARCH_SEARCH_TIMEOUT_MS", DEFAULTS.SEARCH_TIMEOUT_MS, 5e3, 12e4),
     TUI_REFRESH_DEBOUNCE_MS: parseEnvNumber(e, "PI_RESEARCH_TUI_REFRESH_DEBOUNCE_MS", DEFAULTS.TUI_REFRESH_DEBOUNCE_MS, 0, 1e3),
     BROWSER_TASK_TIMEOUT_MS: parseEnvNumber(e, "PI_RESEARCH_BROWSER_TASK_TIMEOUT_MS", DEFAULTS.BROWSER_TASK_TIMEOUT_MS, 2e3, 12e4),
-    LLM_TIMEOUT_MS: parseEnvNumber(e, "PI_RESEARCH_LLM_TIMEOUT_MS", DEFAULTS.LLM_TIMEOUT_MS, 6e4, 6e5),
+    LLM_TIMEOUT_MS: parseEnvNumber(e, "PI_RESEARCH_LLM_TIMEOUT_MS", DEFAULTS.LLM_TIMEOUT_MS, 6e4, 18e5),
     LLM_THINKING_LEVEL: parseEnvEnum(e, "PI_RESEARCH_LLM_THINKING_LEVEL", ["off", "minimal", "low", "medium", "high"], DEFAULTS.LLM_THINKING_LEVEL),
     PLANNING_MAX_TOKENS: parseEnvNumber(e, "PI_RESEARCH_PLANNING_MAX_TOKENS", DEFAULTS.PLANNING_MAX_TOKENS, 1024, 131072),
     SYNTHESIS_MAX_TOKENS: parseEnvNumber(e, "PI_RESEARCH_SYNTHESIS_MAX_TOKENS", DEFAULTS.SYNTHESIS_MAX_TOKENS, 1024, 131072),
@@ -2580,6 +2582,8 @@ var init_config = __esm({
       RESEARCHER_MAX_RETRIES: Type.Number({ minimum: 0, maximum: 5, default: 2 }),
       /** Base delay between retries in milliseconds (default: 2000, range: 100-10000) */
       RESEARCHER_MAX_RETRY_DELAY_MS: Type.Number({ minimum: 100, maximum: 1e4, default: 2e3 }),
+      /** Unique researcher failures that abort the entire run (default: 2, range: 1-10) */
+      MAX_FAILED_RESEARCHERS: Type.Number({ minimum: 1, maximum: 10, default: 2 }),
       /** Target depth for recursive research (default: 1, range: 1-3) */
       DEFAULT_RESEARCH_DEPTH: Type.Number({ minimum: 1, maximum: 3, default: 1 }),
       /** Number of batches to allow for a single scrape tool call (default: 2, 0=unlimited) */
@@ -2637,9 +2641,13 @@ var init_config = __esm({
        *  never killed before it has used its full nav budget plus time waiting in the queue.
        *  (default: 10000) */
       BROWSER_TASK_TIMEOUT_MS: Type.Number({ minimum: 2e3, maximum: 12e4, default: 1e4 }),
-      /** Timeout for coordinator/evaluator/repair/knowledge LLM calls in ms (default: 300000 = 5 min, range: 60s-600s).
-       *  Not exposed in TUI — controlled via PI_RESEARCH_LLM_TIMEOUT_MS env var. */
-      LLM_TIMEOUT_MS: Type.Number({ minimum: 6e4, maximum: 6e5, default: 3e5 }),
+      /** Timeout for coordinator/evaluator/repair/knowledge LLM calls in ms (default: 300000 = 5 min, range: 60s-30min).
+       *  Not exposed in TUI — controlled via PI_RESEARCH_LLM_TIMEOUT_MS env var.
+       *  Ceiling raised to 30min (matching RESEARCHER_TIMEOUT_MS): a slow model on a
+       *  large-context synthesis/plan call can legitimately run >10min, and the old
+       *  600000 ceiling silently clamped an explicit PI_RESEARCH_LLM_TIMEOUT_MS
+       *  (e.g. 900000), causing those calls to time out mid-generation. */
+      LLM_TIMEOUT_MS: Type.Number({ minimum: 6e4, maximum: 18e5, default: 3e5 }),
       /** Chain-of-thought "thinking" level for the engine's own LLM calls (coordinator,
        *  evaluator, synthesis, JSON-repair, knowledge extraction) AND the researcher
        *  sub-agents. Default 'off': these calls emit structured JSON / cited reports, not
@@ -3197,7 +3205,8 @@ var init_agentic_repair = __esm({
 });
 
 // src/core/llm/model-registry-factory.ts
-import { AuthStorage, ModelRegistry, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { ModelRegistry, ModelRuntime, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { InMemoryCredentialStore } from "@earendil-works/pi-ai";
 import * as path6 from "node:path";
 import * as fs5 from "node:fs";
 function safeGetAll(registry) {
@@ -3239,27 +3248,27 @@ function buildHeaders(provider) {
   if (provider === "openrouter") return { "HTTP-Referer": "https://pi.ai", "X-Title": "pi-research" };
   return {};
 }
-function buildModelRegistry(apiKey, provider) {
+async function buildModelRegistry(apiKey, provider) {
   const agentDir = getAgentDir();
   const modelsJsonPath = path6.join(agentDir, "models.json");
   const authPath = path6.join(agentDir, "auth.json");
+  const hasModels = fs5.existsSync(modelsJsonPath);
+  const hasAuth = fs5.existsSync(authPath);
+  const runtime = await ModelRuntime.create({
+    authPath: hasAuth ? authPath : void 0,
+    credentials: hasAuth ? void 0 : new InMemoryCredentialStore(),
+    modelsPath: hasModels ? modelsJsonPath : null,
+    allowModelNetwork: false
+  });
   if (apiKey && provider) {
-    const authStorage = AuthStorage.inMemory({
-      [provider]: { type: "api_key", key: apiKey }
-    });
-    return ModelRegistry.create(
-      authStorage,
-      fs5.existsSync(modelsJsonPath) ? modelsJsonPath : void 0
-    );
-  }
-  if (fs5.existsSync(authPath) || fs5.existsSync(modelsJsonPath)) {
-    const authStorage = AuthStorage.create(authPath);
-    return ModelRegistry.create(
-      authStorage,
-      fs5.existsSync(modelsJsonPath) ? modelsJsonPath : void 0
-    );
+    await runtime.setRuntimeApiKey(provider, apiKey, { allowNetwork: false });
   }
-  return ModelRegistry.inMemory(AuthStorage.inMemory());
+  const registry = new ModelRegistry(runtime);
+  registryRuntimes.set(registry, runtime);
+  return registry;
+}
+function getRuntimeForRegistry(registry) {
+  return registry instanceof Object ? registryRuntimes.get(registry) : void 0;
 }
 function constructMinimalModel(provider, modelId, _apiKey) {
   return {
@@ -3351,10 +3360,12 @@ function pickPreferredAvailable(available, providerOrder) {
   }
   return available[0];
 }
+var registryRuntimes;
 var init_model_registry_factory = __esm({
   "src/core/llm/model-registry-factory.ts"() {
     "use strict";
     init_logger();
+    registryRuntimes = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -14650,7 +14661,7 @@ async function runBrowserTask(taskOrUrl, type = "scrape", config, signal, retrie
         if (now - lastRestartTime > RESTART_COOLDOWN_MS) {
           lastRestartTime = now;
           logger.warn(`[BrowserManager] Forcing scheduler restart and retrying...`);
-          await forceSchedulerRestart2(true, container);
+          await forceSchedulerRestart2(false, container);
           await waitForBrowserPoolIdle(15e3).catch((err) => logger.debug("Wait for browser idle timed out or failed:", err));
         } else {
           logger.warn(`[BrowserManager] Scheduler restart recently triggered, waiting for pool idle...`);
@@ -14685,7 +14696,7 @@ async function runBrowserHealthCheck(config, retries = 1, signal, container = ge
         if (now - lastRestartTime > RESTART_COOLDOWN_MS) {
           lastRestartTime = now;
           logger.warn(`[BrowserManager] Forcing scheduler restart and retrying...`);
-          await forceSchedulerRestart2(true, container);
+          await forceSchedulerRestart2(false, container);
           await waitForBrowserPoolIdle(15e3).catch((err) => logger.debug("Wait for browser idle timed out or failed:", err));
         } else {
           await waitForBrowserPoolIdle(15e3).catch((err) => logger.debug("Wait for browser idle timed out or failed:", err));
@@ -14724,7 +14735,7 @@ async function runWorkerSearch(query, config, signal, retries = 1, sessionId, co
         if (now - lastRestartTime > RESTART_COOLDOWN_MS) {
           lastRestartTime = now;
           logger.warn(`[BrowserManager] Forcing scheduler restart and retrying...`);
-          await forceSchedulerRestart2(true, container);
+          await forceSchedulerRestart2(false, container);
           await waitForBrowserPoolIdle(15e3).catch((err) => logger.debug("Wait for browser idle timed out or failed:", err));
         } else {
           await waitForBrowserPoolIdle(15e3).catch((err) => logger.debug("Wait for browser idle timed out or failed:", err));
@@ -14766,7 +14777,7 @@ async function performSearch(queries, config, signal, onProgress, container = ge
   metrics.increment("browser_search_orchestrations_total", 1);
   logger.log(`[Search] Orchestrating ${queries.length} queries across ${maxWorkers} worker processes...`);
   if (onProgress) onProgress(0);
-  const QUERY_TIMEOUT_MS = config?.SEARCH_TIMEOUT_MS ?? 45e3;
+  const QUERY_TIMEOUT_MS = (config?.SEARCH_TIMEOUT_MS ?? 45e3) + (config?.BROWSER_TASK_TIMEOUT_MS ?? 1e4);
   const filteredQueries = queries.filter((q) => q.trim());
   let timeoutCount = 0;
   let errorCount = 0;
@@ -14811,7 +14822,7 @@ async function performSearch(queries, config, signal, onProgress, container = ge
       metrics.observe("browser_search_query_duration_ms", queryDuration, { status });
       metrics.increment("browser_search_queries_total", 1, { status });
       if (isTimeout) {
-        logger.warn(`[Search] Query timed out after ${QUERY_TIMEOUT_MS}ms (likely blocked or slow startup): "${query}"`);
+        logger.warn(`[Search] Query timed out after ${QUERY_TIMEOUT_MS}ms \u2014 likely starved waiting for a free browser worker under concurrent load, or a slow/blocked search provider: "${query}"`);
       } else {
         const msg2 = error instanceof Error ? error.message : String(error);
         if (msg2 !== "Aborted") {
@@ -19445,10 +19456,8 @@ function formatResults(results, rejected) {
     if (typeof r.charCount === "number") meta.push(`${r.charCount.toLocaleString()} chars`);
     if (meta.length) md += `**${meta.join(" \xB7 ")}**
 `;
-    if (r.title) {
-      md += `**Cite as:** ${r.url} \u2014 '${r.title}'${r.author ? ` by ${r.author}` : ""}
+    md += `**Cite as:** ${r.url}${r.title ? ` \u2014 '${r.title}'${r.author ? ` by ${r.author}` : ""}` : ""}
 `;
-    }
     md += `
 ${r.text}
 
@@ -19633,40 +19642,9 @@ function createResearchTools(options) {
 }
 
 // src/utils/make-resource-loader.ts
+import { createExtensionRuntime } from "@earendil-works/pi-coding-agent";
 function makeResourceLoader(systemPromptText) {
-  const mockRuntime = {
-    flagValues: /* @__PURE__ */ new Map(),
-    pendingProviderRegistrations: [],
-    registerProvider: () => {
-    },
-    unregisterProvider: () => {
-    },
-    sendMessage: async () => {
-    },
-    sendUserMessage: async () => {
-    },
-    appendEntry: async () => {
-    },
-    setSessionName: () => void 0,
-    getSessionName: () => void 0,
-    setLabel: async () => {
-    },
-    getActiveTools: () => [],
-    getAllTools: () => [],
-    setActiveTools: () => {
-    },
-    refreshTools: () => {
-    },
-    getCommands: () => [],
-    setModel: async () => true,
-    getThinkingLevel: () => "off",
-    setThinkingLevel: () => {
-    },
-    assertActive: () => {
-    },
-    invalidate: () => {
-    }
-  };
+  const mockRuntime = createExtensionRuntime();
   return {
     getExtensions: () => ({ extensions: [], errors: [], runtime: mockRuntime }),
     getSkills: () => ({ skills: [], diagnostics: [] }),
@@ -19820,6 +19798,7 @@ function createDefaultToolLimits(config) {
 // src/orchestration/researcher.ts
 init_logger();
 init_research_model_resolver();
+init_model_registry_factory();
 async function createResearcherSession(options) {
   const {
     cwd,
@@ -19887,7 +19866,17 @@ async function createResearcherSession(options) {
       // Each researcher gets its own isolated session
       settingsManager: researcherSettings,
       model: modelToUse,
-      modelRegistry,
+      // pi 0.80.8 replaced the SDK's `modelRegistry`/`authStorage` session options
+      // with the async `modelRuntime`. Pass the runtime backing OUR registry when
+      // this run built one (standalone CLI/SDK): it carries any explicit API key
+      // seeded via setRuntimeApiKey, which the session's own default runtime
+      // (auto-built from ~/.pi/agent/{auth,models}.json) would never see — without
+      // this, standalone PI_RESEARCH_API_KEY users fail auth on every researcher
+      // LLM call despite passing pre-flight. For registries we did NOT build
+      // (the pi host's ExtensionContext.modelRegistry), this resolves to
+      // undefined and the host auto-builds from its own agent dir — correct
+      // in-host, where auth lives in the host's config.
+      modelRuntime: getRuntimeForRegistry(modelRegistry),
       resourceLoader: makeResourceLoader(systemPrompt),
       // Thinking/reasoning is disabled for researcher agents: they do retrieval and
       // synthesis from scraped pages, not open-ended reasoning. Keeping it off reduces
@@ -20108,10 +20097,10 @@ function getFailedResearchers(piSessionId, researchId) {
   const failures = state.failures.get(researchId) || [];
   return [...new Set(failures)];
 }
-var MAX_FAILED_RESEARCHERS = 2;
-function shouldStopResearch(piSessionId, researchId) {
+var DEFAULT_MAX_FAILED_RESEARCHERS = 2;
+function shouldStopResearch(piSessionId, researchId, maxFailedResearchers = DEFAULT_MAX_FAILED_RESEARCHERS) {
   const sid = normalizeSessionId(piSessionId);
-  return getFailedResearchers(sid, researchId).length >= MAX_FAILED_RESEARCHERS;
+  return getFailedResearchers(sid, researchId).length >= maxFailedResearchers;
 }
 function getResearchStopMessage(piSessionId, researchId) {
   const sid = normalizeSessionId(piSessionId);
@@ -20137,6 +20126,12 @@ function getResearchStopMessage(piSessionId, researchId) {
     "Partial results may be available below."
   ].join("\n");
 }
+var RESEARCH_STOPPED_ERROR_CODE = "RESEARCH_STOPPED";
+function createResearchStopError(piSessionId, researchId) {
+  const err = new Error(getResearchStopMessage(piSessionId, researchId));
+  err.code = RESEARCH_STOPPED_ERROR_CODE;
+  return err;
+}
 
 // src/orchestration/researcher-executor.ts
 async function runResearcher(options) {
@@ -20171,18 +20166,42 @@ ${currentPlan.allQueries.map((q) => `- ${q}`).join("\n")}
   Previous summary: ${e.description}`).join("\n");
   }
   const researcherPromptTemplate = loadPrompt("researcher");
-  if (initialLinks.length === 0 && historicalUrls.length === 0) {
-    logger.warn(`[ResearcherExecutor] Researcher ${id} has no initial search results or historical links; skipping.`);
-    recordResearcherFailure(sessionId, researchId, id, "no initial search results or historical links (search produced nothing usable)");
-    metrics.increment("researcher_skipped_total", 1, { mode: "deep", complexity: String(complexity), reason: "no_initial_links" });
-    observer?.onResearcherFailure?.(id, "No initial search results or historical links available");
-    return;
+  let effectiveInitialLinks = initialLinks;
+  if (effectiveInitialLinks.length === 0 && historicalUrls.length === 0) {
+    const retryQueries = researcherConfig.queries?.length ? researcherConfig.queries : [researcherConfig.goal];
+    const maxLinkAttempts = config.RESEARCHER_MAX_RETRIES + 1;
+    for (let linkAttempt = 1; linkAttempt <= maxLinkAttempts && effectiveInitialLinks.length === 0; linkAttempt++) {
+      if (linkAttempt > 1) {
+        if (signal?.aborted || container?.isDisposing) break;
+        const delay2 = Math.min(1e3 * Math.pow(2, linkAttempt - 2), config.RESEARCHER_MAX_RETRY_DELAY_MS);
+        logger.warn(`[ResearcherExecutor] Researcher ${id} has no initial search results; retry ${linkAttempt - 1}/${config.RESEARCHER_MAX_RETRIES} after ${delay2}ms`);
+        await new Promise((r) => setTimeout(r, delay2));
+      }
+      if (signal?.aborted || container?.isDisposing) break;
+      try {
+        const queryResults = await search(retryQueries, config, signal, void 0, container);
+        const urls = /* @__PURE__ */ new Set();
+        for (const qr of queryResults) {
+          for (const r of qr.results || []) urls.add(r.url);
+        }
+        effectiveInitialLinks = [...urls];
+      } catch (err) {
+        logger.debug(`[ResearcherExecutor] Researcher ${id} link-retry search burst failed:`, err);
+      }
+    }
+    if (effectiveInitialLinks.length === 0) {
+      logger.warn(`[ResearcherExecutor] Researcher ${id} has no initial search results or historical links after ${maxLinkAttempts} attempt(s); skipping.`);
+      recordResearcherFailure(sessionId, researchId, id, "no initial search results or historical links (search produced nothing usable)");
+      metrics.increment("researcher_skipped_total", 1, { mode: "deep", complexity: String(complexity), reason: "no_initial_links" });
+      observer?.onResearcherFailure?.(id, "No initial search results or historical links available");
+      return;
+    }
   }
   let evidenceSection = "";
-  if (initialLinks.length > 0) {
+  if (effectiveInitialLinks.length > 0) {
     evidenceSection = `## Evidence Provided
 Initial search results provided the following URLs to investigate:
-${initialLinks.map((l) => `- ${l}`).join("\n")}`;
+${effectiveInitialLinks.map((l) => `- ${l}`).join("\n")}`;
   }
   const maxAttempts = config.RESEARCHER_MAX_RETRIES + 1;
   let lastError;
@@ -21414,12 +21433,13 @@ var ResearchOrchestrationService = class {
     const researchers = plan.researchers || [];
     const active = /* @__PURE__ */ new Set();
     const maxConcurrent = orchestratorOptions.config?.MAX_CONCURRENT_RESEARCHERS ?? DEFAULTS.MAX_CONCURRENT_RESEARCHERS;
+    const maxFailedResearchers = orchestratorOptions.config?.MAX_FAILED_RESEARCHERS ?? DEFAULTS.MAX_FAILED_RESEARCHERS;
     for (const configItem of researchers) {
       if (signal?.aborted) break;
-      if (shouldStopResearch(sessionId, researchId)) {
+      if (shouldStopResearch(sessionId, researchId, maxFailedResearchers)) {
         const sessionService = await getService(ServiceNames.RESEARCH_SESSION_SERVICE, ctx, container);
         await sessionService.abortAllSessions(researchId);
-        throw new Error(getResearchStopMessage(sessionId, researchId));
+        throw createResearchStopError(sessionId, researchId);
       }
       if (active.size >= maxConcurrent) {
         if (signal?.aborted) break;
@@ -21488,11 +21508,10 @@ var ResearchOrchestrationService = class {
         });
         if (signal?.aborted) break;
       }
-      if (shouldStopResearch(sessionId, researchId)) {
+      if (shouldStopResearch(sessionId, researchId, maxFailedResearchers)) {
         const sessionService = await getService(ServiceNames.RESEARCH_SESSION_SERVICE, ctx, container);
         await sessionService.abortAllSessions(researchId);
-        const stopMessage = getResearchStopMessage(sessionId, researchId);
-        throw new Error(stopMessage);
+        throw createResearchStopError(sessionId, researchId);
       }
     }
     await Promise.all(active);
@@ -21889,18 +21908,26 @@ Research performed using ${modelId}`;
   ensureCitedLinks(sessionId, synthesis) {
     const reports = this.getSessionReports(sessionId);
     let globalCitations = reports.size > 0 ? normalizeCitations(reports).globalCitations : [];
-    if (globalCitations.length === 0) {
+    if (reports.size > 0) {
       const scraped = getScrapedLinks(sessionId);
       if (scraped.length > 0) {
-        globalCitations = scraped.map((url, i) => ({
-          id: i + 1,
-          url,
-          description: "",
-          source: isTranscribedLink(sessionId, url) ? "YouTube Transcript" : "Scrape"
-        }));
-        logger.warn(
-          `[ResearchSynthesisService] No citations parsed from reports; rebuilt ${scraped.length} source(s) from scrape/transcript provenance.`
-        );
+        const known = new Set(globalCitations.map((c) => normalizeUrl(c.url)));
+        const missing = scraped.filter((url) => !known.has(normalizeUrl(url)));
+        if (missing.length > 0) {
+          const startId = globalCitations.reduce((max, c) => Math.max(max, c.id), 0) + 1;
+          globalCitations = [
+            ...globalCitations,
+            ...missing.map((url, i) => ({
+              id: startId + i,
+              url,
+              description: "",
+              source: isTranscribedLink(sessionId, url) ? "YouTube Transcript" : "Scrape"
+            }))
+          ];
+          logger.warn(
+            `[ResearchSynthesisService] Folded in ${missing.length} source(s) from scrape/transcript provenance not covered by parsed citations.`
+          );
+        }
       }
     }
     if (globalCitations.length > 0) {
@@ -22114,6 +22141,79 @@ init_metrics();
 
 // src/utils/metrics-summary.ts
 init_text_utils();
+function sumCounter(counters, baseName) {
+  let total = 0;
+  for (const [key, value] of Object.entries(counters)) {
+    if (key === baseName || key.startsWith(baseName + "{")) {
+      total += value;
+    }
+  }
+  return total;
+}
+function getLabeledCounter(counters, baseName, labels) {
+  const labelParts = Object.entries(labels).map(([k, v]) => `${k}="${v}"`);
+  const suffix = `{${labelParts.join(",")}}`;
+  for (const [key, value] of Object.entries(counters)) {
+    if (key === `${baseName}${suffix}`) {
+      return value;
+    }
+  }
+  return 0;
+}
+function extractRunStats(snapshot) {
+  const counters = snapshot.counters || {};
+  const histograms = snapshot.histograms || {};
+  const researchersLaunched = sumCounter(counters, "researchers_launched_total");
+  const browserSearchQueries = sumCounter(counters, "browser_search_queries_total");
+  const searchQueries = sumCounter(counters, "search_queries_total") + browserSearchQueries;
+  const urlsDiscovered = sumCounter(counters, "browser_search_results_total") + sumCounter(counters, "browser_search_unique_urls_total");
+  const fetchSuccess = getLabeledCounter(counters, "scrape_results_total", { outcome: "fetch_success" });
+  const browserSuccess = getLabeledCounter(counters, "scrape_results_total", { outcome: "browser_success" });
+  const totalFailure = getLabeledCounter(counters, "scrape_results_total", { outcome: "total_failure" });
+  const browserFallbacks = sumCounter(counters, "scrape_layer_fallbacks_total");
+  const urlsAnalyzed = fetchSuccess + browserSuccess;
+  const urlsFailed = totalFailure;
+  const toolUsage = {
+    searches: sumCounter(counters, "tool_search_calls_total"),
+    scrapes: sumCounter(counters, "tool_scrape_calls_total"),
+    securitySearches: sumCounter(counters, "tool_security_search_calls_total"),
+    stackexchangeQueries: sumCounter(counters, "stackexchange_requests_total"),
+    knowledgeLookups: sumCounter(counters, "research_knowledge_search_total")
+  };
+  const errors = sumCounter(counters, "researcher_errors_total") + sumCounter(counters, "llm_api_errors_total");
+  const tokens = sumCounter(counters, "llm_tokens_total");
+  const cost = sumCounter(counters, "llm_cost_total");
+  const durationMs = histograms['research_session_duration_ms{mode="deep",complexity="1",status="success"}']?.max || histograms['research_session_duration_ms{mode="deep",complexity="2",status="success"}']?.max || histograms['research_session_duration_ms{mode="deep",complexity="3",status="success"}']?.max || histograms['research_session_duration_ms{mode="quick",complexity="0",status="success"}']?.max || 0;
+  const roundsCompleted = sumCounter(counters, "evaluator_runs_total");
+  let complexity = 1;
+  for (const key of Object.keys(counters)) {
+    if (key.startsWith("research_sessions_total{")) {
+      const match = key.match(/complexity="(\d+)"/);
+      if (match?.[1]) complexity = parseInt(match[1], 10);
+      break;
+    }
+  }
+  if (researchersLaunched === 0 && searchQueries === 0 && urlsAnalyzed === 0 && tokens === 0) {
+    return null;
+  }
+  return {
+    durationMs,
+    complexity,
+    researchersLaunched,
+    roundsCompleted,
+    searchQueries,
+    urlsDiscovered,
+    fetchSuccess,
+    browserSuccess,
+    browserFallbacks,
+    urlsAnalyzed,
+    urlsFailed,
+    errors,
+    tokens,
+    cost,
+    toolUsage
+  };
+}
 
 // src/sdk.ts
 init_error_tracker();
@@ -22135,6 +22235,7 @@ var _isRunning = false;
 var _lastResearchId = null;
 var _lastRunSummary = null;
 var _lastErrorReport = null;
+var _lastResearcherOutcome = null;
 var _onSignal = null;
 var _sigintHandler = null;
 var _sigtermHandler = null;
@@ -22218,7 +22319,7 @@ async function _doInit(options = {}) {
   if (globalApiKey && !parsedProvider) {
     throw new Error("Provider must be specified when using an explicit API key (set provider option or PI_RESEARCH_PROVIDER).");
   }
-  globalRegistry = buildModelRegistry(globalApiKey, parsedProvider);
+  globalRegistry = await buildModelRegistry(globalApiKey, parsedProvider);
   try {
     if (effectiveModel && typeof effectiveModel === "object" && effectiveModel.id) {
       globalModel = effectiveModel;
@@ -22321,6 +22422,7 @@ async function runDeepResearch(query, options = {}, signal) {
     metrics.recordRunSummary(_lastRunSummary);
     _lastErrorReport = runTracker.getReport();
     logRunErrorSummary(_lastErrorReport, depthLabel, "success");
+    _lastResearcherOutcome = await captureResearcherOutcome(sessionId, researchId, _lastRunSummary.snapshot);
     return result;
   } catch (err) {
     const completedAt = Date.now();
@@ -22336,6 +22438,7 @@ async function runDeepResearch(query, options = {}, signal) {
     metrics.recordRunSummary(_lastRunSummary);
     _lastErrorReport = runTracker.getReport();
     logRunErrorSummary(_lastErrorReport, depthLabel, "error");
+    _lastResearcherOutcome = await captureResearcherOutcome(sessionId, researchId, _lastRunSummary.snapshot);
     throw err;
   } finally {
     try {
@@ -22345,11 +22448,35 @@ async function runDeepResearch(query, options = {}, signal) {
     _isRunning = false;
   }
 }
+function getLastErrorReport() {
+  return _lastErrorReport;
+}
+function getLastResearcherOutcome() {
+  return _lastResearcherOutcome;
+}
 function logRunErrorSummary(report, depthLabel, status) {
   if (!report || report.totalErrors === 0) return;
   const top = report.patterns.slice(0, 3).map((p) => `"${String(p.message ?? p.signature ?? "error").slice(0, 48)}" \xD7${p.count}`).join(", ");
   logger.warn(`[SDK] run ${status} with ${report.totalErrors} tracked error(s) across ${report.uniquePatterns} pattern(s) [${depthLabel}]${top ? ` \u2014 top: ${top}` : ""}`);
 }
+async function captureResearcherOutcome(sessionId, researchId, snapshot) {
+  try {
+    const planningService = await getService(ServiceNames.PLANNING, void 0, globalContainer);
+    const planned = planningService.getTotalResearchersPlanned(researchId);
+    const launched = extractRunStats(snapshot)?.researchersLaunched ?? 0;
+    const failed = getFailedResearchers(sessionId, researchId);
+    return {
+      planned,
+      launched,
+      succeeded: Math.max(0, launched - failed.length),
+      failed: failed.length,
+      failureReasons: getResearcherFailureReasons(sessionId, researchId)
+    };
+  } catch (err) {
+    logger.debug("[SDK] Failed to capture researcher outcome (non-fatal):", err);
+    return null;
+  }
+}
 async function searchKnowledge(queries, signal) {
   if (!isInitialized || !globalContainer) {
     throw new Error("SDK not initialized. Call initResearchSDK() first.");
@@ -22433,6 +22560,7 @@ async function _doShutdown() {
   _lastResearchId = null;
   _lastRunSummary = null;
   _lastErrorReport = null;
+  _lastResearcherOutcome = null;
   resetConfig();
   _removeSignalHandlers();
   if (errors.length > 0) {
@@ -22799,16 +22927,16 @@ function fileExists(p) {
     return false;
   }
 }
-function piKeysAvailable(piAuthPresent, provider) {
+async function piKeysAvailable(piAuthPresent, provider) {
   try {
-    const available = safeGetAvailable(buildModelRegistry(void 0, void 0));
+    const available = safeGetAvailable(await buildModelRegistry(void 0, void 0));
     if (!provider) return available.length > 0;
     return available.some((m) => m.provider === provider);
   } catch {
     return piAuthPresent;
   }
 }
-function detectCredentials(explicitModel) {
+async function detectCredentials(explicitModel) {
   const paths = resolvedConfigPaths();
   const piAuthPresent = fileExists(paths.piAuth);
   const piModelsPresent = fileExists(paths.piModels);
@@ -22819,7 +22947,7 @@ function detectCredentials(explicitModel) {
   const model = explicitModel ?? modelEnv ?? modelConfig;
   const modelFrom = explicitModel ? "--model" : modelEnv ? "PI_RESEARCH_MODEL" : modelConfig ? "config.env" : "unset";
   const provider = providerEnv ?? (model && model.includes("/") ? model.slice(0, model.indexOf("/")) : void 0);
-  const piKeysUsable = piKeysAvailable(piAuthPresent, provider);
+  const piKeysUsable = await piKeysAvailable(piAuthPresent, provider);
   if (apiKey) {
     if (!provider) {
       return {
@@ -22911,7 +23039,7 @@ function configBlock(det, extraNote) {
   return lines.join("\n");
 }
 async function cmdResearch(args) {
-  const det = detectCredentials(args.model);
+  const det = await detectCredentials(args.model);
   if (det.problem) {
     if (args.json) toStdout(pretty({ ok: false, error: det.problem, exitCode: EXIT.CONFIG }));
     else toStderr(`
@@ -22938,6 +23066,8 @@ Error: ${vmsg}
 `);
   const observer = makeProgressObserver();
   let exit = EXIT.OK;
+  const abortController = new AbortController();
+  activeResearchAbortController = abortController;
   try {
     await initResearchSDK({
       model: runModel,
@@ -22954,7 +23084,7 @@ Error: ${vmsg}
       observer,
       ...args.excludeTools ? { excludeTools: args.excludeTools } : {},
       ...args.initialLinks ? { initialLinks: args.initialLinks } : {}
-    });
+    }, abortController.signal);
     let reportPath = null;
     const exportCfg = getConfig(process.cwd(), "cli");
     if (exportCfg.RESEARCH_REPORT_EXPORT_ENABLED) {
@@ -22966,19 +23096,31 @@ Error: ${vmsg}
       }
     }
     if (args.json) {
-      toStdout(pretty({ ok: true, depth, report, ...reportPath ? { reportPath } : {} }));
+      const outcome = getLastResearcherOutcome();
+      const errorReport = getLastErrorReport();
+      toStdout(pretty({
+        ok: true,
+        depth,
+        report,
+        ...reportPath ? { reportPath } : {},
+        ...outcome ? { researchers: { planned: outcome.planned, launched: outcome.launched, succeeded: outcome.succeeded, failed: outcome.failed } } : {},
+        ...errorReport && errorReport.totalErrors > 0 ? {
+          trackedErrors: { total: errorReport.totalErrors, uniquePatterns: errorReport.uniquePatterns }
+        } : {}
+      }));
     } else {
       toStdout(report.endsWith("\n") ? report : report + "\n");
     }
   } catch (err) {
-    exit = reportError(err, "research", args.json);
+    exit = await reportError(err, "research", args.json);
   } finally {
+    if (activeResearchAbortController === abortController) activeResearchAbortController = null;
     await safeShutdown();
   }
   return exit;
 }
 async function cmdKnowledge(queries, json) {
-  const det = detectCredentials();
+  const det = await detectCredentials();
   if (det.problem) {
     if (json) {
       toStdout(pretty({ ok: false, error: det.problem, exitCode: EXIT.CONFIG }));
@@ -23032,7 +23174,7 @@ Configure in:
   return exit;
 }
 async function cmdStatus(json) {
-  const det = detectCredentials();
+  const det = await detectCredentials();
   const paths = resolvedConfigPaths();
   const cfg = getConfig(process.cwd(), "cli");
   const summary = {
@@ -23246,10 +23388,11 @@ function describeUninstall(r) {
       return r.status;
   }
 }
-function reportError(err, what, json) {
+async function reportError(err, what, json) {
   const msg2 = err instanceof Error ? err.message : String(err);
   const lower = msg2.toLowerCase();
-  const isConfigError = lower.includes("no llm model available") || lower.includes("not found in pi") || lower.includes("no api key") || lower.includes("provider must be specified") || lower.includes("invalid model string") || lower.includes("authentication") || lower.includes("unauthorized") || lower.includes("api key");
+  const isTaggedResearchStop = err?.code === RESEARCH_STOPPED_ERROR_CODE;
+  const isConfigError = !isTaggedResearchStop && (lower.includes("no llm model available") || lower.includes("not found in pi") || lower.includes("no api key") || lower.includes("provider must be specified") || lower.includes("invalid model string") || lower.includes("authentication") || lower.includes("unauthorized") || lower.includes("api key"));
   const isRateLimit = lower.includes("429") || lower.includes("rate limit") || lower.includes("too many requests");
   const exitCode = isConfigError && !isRateLimit ? EXIT.CONFIG : EXIT.SOFTWARE;
   if (json) {
@@ -23271,7 +23414,7 @@ Error: pi-research ${what} halted: provider rate limit reached. Wait a moment an
     toStderr(`
 Error: pi-research ${what} failed: ${msg2}
 
-${configBlock(detectCredentials())}
+${configBlock(await detectCredentials())}
 `);
     return exitCode;
   }
@@ -23557,6 +23700,7 @@ var flushAndExit = (code) => {
     });
   });
 };
+var activeResearchAbortController = null;
 async function main(argv) {
   let _signalCleanupDone = false;
   const onSignal = (sig) => {
@@ -23565,6 +23709,7 @@ async function main(argv) {
     toStderr(`
 [pi-research] ${sig} \u2014 cleaning up\u2026
 `);
+    activeResearchAbortController?.abort();
     void safeShutdown().finally(() => flushAndExit(EXIT.SOFTWARE));
   };
   process.once("SIGINT", () => onSignal("SIGINT"));
@@ -23634,5 +23779,6 @@ export {
   EXIT,
   UsageError,
   bridgeConfigEnv,
-  parseArgs
+  parseArgs,
+  reportError
 };