@cjhyy/code-shell 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/{chunk-SQZHPD3S.js → chunk-Y7TSCDF6.js}

@@ -1,9 +1,9 @@
-import {
-  logger
-} from "./chunk-X4HAERTQ.js";
 import {
   LLMError
 } from "./chunk-FUOKLKR2.js";
+import {
+  logger
+} from "./chunk-ZRVPCXI7.js";
 import {
   init_esm_shims
 } from "./chunk-DI7RDLOS.js";
@@ -18,11 +18,11 @@ async function createLLMClient(config) {
   let Cls = PROVIDER_REGISTRY.get(config.provider);
   if (!Cls) {
     if (config.provider === "anthropic") {
-      const { AnthropicClient } = await import("./anthropic-NENYS535.js");
+      const { AnthropicClient } = await import("./anthropic-W2GU3D76.js");
       registerProvider("anthropic", AnthropicClient);
       Cls = AnthropicClient;
     } else if (config.provider === "openai") {
-      const { OpenAIClient } = await import("./openai-5HQGBL4L.js");
+      const { OpenAIClient } = await import("./openai-RXU5URYI.js");
       registerProvider("openai", OpenAIClient);
       Cls = OpenAIClient;
     }
@@ -158,6 +158,8 @@ function parseReport(participant, text) {
       findings: []
     };
   }
+  const xmlReport = tryParseReportXml(participant, text);
+  if (xmlReport && xmlReport.findings.length > 0) return xmlReport;
   try {
     const json = extractJSON(text);
     const parsed = JSON.parse(json);
@@ -172,22 +174,82 @@ function parseReport(participant, text) {
       contextSummary: parsed.contextSummary ?? parsed.context_summary ?? "",
       findings: Array.isArray(findings) ? findings.map(parseFinding) : []
     };
-    if (report.findings.length === 0) {
-      logger.warn("arena.parse_report_no_findings", {
-        participant,
-        textPreview: text.slice(0, 200)
-      });
-    }
-    return report;
+    if (report.findings.length > 0) return report;
   } catch (err) {
     logger.warn("arena.parse_report_json_fail", {
       participant,
       error: err.message,
       textLength: text.length,
-      text: text.slice(0, 2e3)
+      text: text.slice(0, 500)
     });
-    return extractFindingsFromFreeText(participant, text);
   }
+  if (xmlReport) {
+    logger.warn("arena.parse_report_no_findings", {
+      participant,
+      textPreview: text.slice(0, 200)
+    });
+    return xmlReport;
+  }
+  return extractFindingsFromFreeText(participant, text);
+}
+function tryParseReportXml(participant, text) {
+  const reportMatch = text.match(/<report\b[^>]*>([\s\S]*?)<\/report>/i);
+  if (!reportMatch) return void 0;
+  const body = reportMatch[1];
+  const contextSummary = decodeXmlText(extractTag(body, "contextSummary") ?? "");
+  const findingsBlock = extractTag(body, "findings") ?? "";
+  const findings = [];
+  let i = 0;
+  for (const match of findingsBlock.matchAll(/<finding\b([^>]*)>([\s\S]*?)<\/finding>/gi)) {
+    const attrs = parseAttrs(match[1]);
+    const inner = match[2];
+    const title = decodeXmlText(extractTag(inner, "title") ?? "");
+    const summary = decodeXmlText(extractTag(inner, "summary") ?? "");
+    const evidence = [];
+    for (const ev of inner.matchAll(/<evidence\b([^>]*)>([\s\S]*?)<\/evidence>/gi)) {
+      const evAttrs = parseAttrs(ev[1]);
+      evidence.push({
+        type: evAttrs.type ?? "doc",
+        ref: evAttrs.ref ?? "",
+        note: decodeXmlText(ev[2].trim())
+      });
+    }
+    const affectedFilesBlock = extractTag(inner, "affectedFiles") ?? "";
+    const affectedFiles = [];
+    for (const f of affectedFilesBlock.matchAll(/<file>([\s\S]*?)<\/file>/gi)) {
+      affectedFiles.push(decodeXmlText(f[1].trim()));
+    }
+    const suggestedChange = decodeXmlText(extractTag(inner, "suggestedChange") ?? "").trim();
+    const confidence = Number(attrs.confidence);
+    findings.push({
+      id: attrs.id || `f${i + 1}`,
+      kind: validateFindingKind(attrs.kind),
+      title: title || "Untitled",
+      summary,
+      severity: attrs.severity || void 0,
+      confidence: Number.isFinite(confidence) ? confidence : 0.5,
+      evidence,
+      affectedFiles,
+      suggestedChange: suggestedChange || void 0
+    });
+    i++;
+  }
+  return { participant, contextSummary, findings };
+}
+function extractTag(xml, tag) {
+  const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i");
+  const m = xml.match(re);
+  return m?.[1];
+}
+function parseAttrs(attrString) {
+  const out = {};
+  for (const m of attrString.matchAll(/(\w+)\s*=\s*"([^"]*)"/g)) {
+    out[m[1]] = m[2];
+  }
+  return out;
+}
+function decodeXmlText(s) {
+  return s.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&").trim();
 }
 function parseFinding(raw, index) {
   return {
@@ -564,13 +626,32 @@ var ReviewStrategy = class {
 You may have access to read-only tools to fetch additional context. The base context is intentionally lean \u2014 use tools to inspect details as needed.
 
 IMPORTANT RULES:
-- Limit yourself to 3-5 tool rounds. Do NOT exhaustively read every file.
+- Limit yourself to AT MOST 3 tool rounds. Do NOT exhaustively read every file.
 - Focus on the HIGHEST-IMPACT findings. Quality over quantity.
-- Output as many findings as the topic warrants \u2014 typically 5-15 for a non-trivial subject. Each finding's "summary" should be 80+ words with concrete evidence and rationale, not a one-liner. Rank by confidence.
+- Output as many findings as the topic warrants \u2014 typically 5-15 for a non-trivial subject. Each <summary> should be 80+ words with concrete evidence and rationale, not a one-liner. Rank by confidence.
 - Prioritize: risks > improvements > questions. Strengths are optional.
 
-When ready, respond ONLY with JSON (no markdown fences):
-{"contextSummary": "brief summary of what you investigated", "findings": [{"id": "unique-id", "kind": "risk|improvement|question|strength", "title": "short title", "summary": "detailed explanation", "severity": "high|medium|low", "confidence": 0.0-1.0, "evidence": [{"type": "file|diff|grep|git|doc", "ref": "path", "note": "what it shows"}], "affectedFiles": ["paths"], "suggestedChange": "optional"}]}`;
+When ready, respond ONLY with the following XML structure (no markdown fences, no commentary outside the root element):
+
+<report>
+  <contextSummary>brief summary of what you investigated</contextSummary>
+  <findings>
+    <finding id="unique-id" kind="risk|improvement|question|strength" severity="high|medium|low" confidence="0.0-1.0">
+      <title>short title</title>
+      <summary>detailed explanation, 80+ words, citing specific files/lines</summary>
+      <evidence type="file|diff|grep|git|doc" ref="path">what it shows</evidence>
+      <evidence type="file" ref="another/path">\u2026</evidence>
+      <affectedFiles>
+        <file>src/foo.ts</file>
+        <file>src/bar.ts</file>
+      </affectedFiles>
+      <suggestedChange>optional concrete fix</suggestedChange>
+    </finding>
+    <!-- repeat <finding> blocks as needed -->
+  </findings>
+</report>
+
+XML is preferred over JSON because thinking-mode models produce more reliable output here. Do not wrap the XML in code fences. Do not include text outside <report>\u2026</report>.`;
   }
   researchUserPrompt(topic, baseContext) {
     return `## Review Topic
@@ -578,7 +659,7 @@ ${topic}
 
 ${formatBaseContext(baseContext)}
 
-Use tools to read specific files from the diff. Then output 3-6 highest-confidence findings as JSON.`;
+Use tools to read specific files from the diff. Then output 3-6 highest-confidence findings as a single <report> XML element.`;
   }
   parseResearchResponse(participant, text) {
     return parseReport(participant, text);
@@ -716,7 +797,14 @@ ${debateSummary}
 ## Evidence Digest
 ${formatDigestForPrompt(digest)}
 
-As moderator, adjudicate this claim based on all available evidence.
+As moderator, you MUST issue a verdict \u2014 "unresolved" is reserved ONLY for the rare case where the debate produced genuinely irreconcilable interpretations of the same evidence. Default to deciding.
+
+Decision rule:
+- "accepted": claim is correct as stated AND has direct evidence (file/line refs).
+- "accepted_with_revision": core insight is correct but the challenge surfaced a real refinement (scope/severity/wording). Issue a corrected finalSummary.
+- "rejected": the challenger demonstrated the claim is factually wrong or already addressed in the code under review.
+- "unresolved": ONLY when no amount of further evidence could break the tie \u2014 e.g., taste-level disagreement on design philosophy. Using this on a verifiable code claim is a failure of adjudication.
+
 Respond ONLY with JSON:
 {"outcome": "accepted|accepted_with_revision|rejected|unresolved", "rationale": "...", "finalSummary": "revised claim summary if needed", "supportingEvidenceRefs": ["..."]}`;
   }
@@ -1852,15 +1940,15 @@ var gitProvider = {
       });
     }
     const statArgs = isCompare ? ["diff", "--stat", `${baseRef}...${headRef}`] : ["diff", "--stat", "HEAD"];
-    let stat = git(statArgs);
-    if (!stat && !isCompare) stat = git(["diff", "--stat", "--cached"]);
-    if (stat) {
+    let stat2 = git(statArgs);
+    if (!stat2 && !isCompare) stat2 = git(["diff", "--stat", "--cached"]);
+    if (stat2) {
       artifacts.push({
         id: "git-diffstat",
         kind: "doc",
         source: "git",
         title: "Diff Stat",
-        preview: stat
+        preview: stat2
       });
     }
     const filesArgs = isCompare ? ["diff", "--name-status", `${baseRef}...${headRef}`] : ["diff", "--name-status", "HEAD"];
@@ -1909,7 +1997,7 @@ var gitProvider = {
         metadata: { totalChars: diff.length, truncated }
       });
     }
-    if (!diff && !stat) {
+    if (!diff && !stat2) {
       const status = git(["status", "--short"]);
       if (status) {
         artifacts.push({
@@ -1957,16 +2045,21 @@ function clusterByDirectory(paths) {
 
 // src/arena/providers/repo.ts
 init_esm_shims();
-import { existsSync, readdirSync, statSync, readFileSync } from "fs";
+import { existsSync, readFileSync, statSync } from "fs";
+import { readdir, stat } from "fs/promises";
 import { join } from "path";
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFile } from "child_process";
+import { promisify } from "util";
 var MAX_FILE_CHARS = 8e3;
+var GREP_TIMEOUT_MS = 3e3;
+var MAX_TREE_NODES = 400;
+var execFileAsync = promisify(execFile);
 var repoProvider = {
   kind: "repo",
-  collect(plan, topic) {
+  async collect(plan, topic) {
     const artifacts = [];
     const targets = plan.sources.find((s) => s.kind === "repo")?.targets ?? [];
-    const tree = buildTree(".", 2);
+    const tree = await buildTree(".", 2);
     if (tree) {
       artifacts.push({
         id: "repo-tree",
@@ -1980,7 +2073,7 @@ var repoProvider = {
       if (!existsSync(target)) continue;
       const st = statSync(target);
       if (st.isDirectory()) {
-        const dirTree = buildTree(target, 3);
+        const dirTree = await buildTree(target, 3);
         if (dirTree) {
           artifacts.push({
             id: `repo-tree-${target}`,
@@ -1990,7 +2083,7 @@ var repoProvider = {
             preview: dirTree
           });
         }
-        for (const file of collectEntryFiles(target).slice(0, 3)) {
+        for (const file of (await collectEntryFiles(target)).slice(0, 3)) {
           const content = safeReadFile(file);
           if (content) {
             artifacts.push({
@@ -2018,29 +2111,30 @@ var repoProvider = {
       }
     }
     if (targets.length === 0) {
-      const hints = extractSearchHints(topic);
-      for (const hint of hints.slice(0, 5)) {
-        const grepResult = safeGrep(hint);
-        if (grepResult) {
-          const files = grepResult.split("\n").filter(Boolean).slice(0, 10);
-          for (const file of files) {
-            if (!artifacts.some((a) => a.ref === file)) {
-              artifacts.push({
-                id: `repo-grep-${hint}-${file}`,
-                kind: "grep",
-                source: "repo",
-                title: `Match: ${hint} \u2192 ${file}`,
-                ref: file,
-                preview: file
-              });
-            }
+      const hints = extractSearchHints(topic).slice(0, 5);
+      const grepResults = await Promise.all(hints.map((h) => safeGrep(h)));
+      for (let i = 0; i < hints.length; i++) {
+        const hint = hints[i];
+        const result = grepResults[i] ?? "";
+        if (!result) continue;
+        const files = result.split("\n").filter(Boolean).slice(0, 10);
+        for (const file of files) {
+          if (!artifacts.some((a) => a.ref === file)) {
+            artifacts.push({
+              id: `repo-grep-${hint}-${file}`,
+              kind: "grep",
+              source: "repo",
+              title: `Match: ${hint} \u2192 ${file}`,
+              ref: file,
+              preview: file
+            });
           }
         }
       }
     }
     const hasGitSource = plan.sources.some((s) => s.kind === "git");
     if (!hasGitSource) {
-      const recentLog = gitLog();
+      const recentLog = await gitLog();
       if (recentLog) {
         artifacts.push({
           id: "repo-recent-activity",
@@ -2055,30 +2149,43 @@ var repoProvider = {
     return artifacts;
   }
 };
-function buildTree(dir, maxDepth, depth = 0, prefix = "") {
-  if (depth >= maxDepth) return "";
+async function buildTree(dir, maxDepth) {
+  const lines = [];
+  const counter = { n: 0 };
+  await walkTree(dir, maxDepth, 0, "", lines, counter);
+  return lines.filter(Boolean).join("\n");
+}
+async function walkTree(dir, maxDepth, depth, prefix, out, counter) {
+  if (depth >= maxDepth) return;
+  if (counter.n >= MAX_TREE_NODES) return;
+  let entries;
   try {
-    const entries = readdirSync(dir).filter(
+    entries = (await readdir(dir)).filter(
       (e) => !e.startsWith(".") && e !== "node_modules" && e !== "dist" && e !== "__pycache__"
     );
-    const lines = [];
-    for (const entry of entries.slice(0, 30)) {
-      const fullPath = join(dir, entry);
-      const isDir = statSync(fullPath).isDirectory();
-      lines.push(`${prefix}${isDir ? "/" : ""} ${entry}`);
-      if (isDir && depth < maxDepth - 1) {
-        lines.push(buildTree(fullPath, maxDepth, depth + 1, prefix + "  "));
-      }
-    }
-    return lines.filter(Boolean).join("\n");
   } catch {
-    return "";
+    return;
+  }
+  for (const entry of entries.slice(0, 30)) {
+    if (counter.n >= MAX_TREE_NODES) return;
+    counter.n++;
+    const fullPath = join(dir, entry);
+    let isDir = false;
+    try {
+      isDir = (await stat(fullPath)).isDirectory();
+    } catch {
+      continue;
+    }
+    out.push(`${prefix}${isDir ? "/" : ""} ${entry}`);
+    if (isDir && depth < maxDepth - 1) {
+      await walkTree(fullPath, maxDepth, depth + 1, prefix + "  ", out, counter);
+    }
   }
 }
-function collectEntryFiles(dir) {
+async function collectEntryFiles(dir) {
   const files = [];
   try {
-    const entries = readdirSync(dir);
+    const entries = await readdir(dir);
     const priority = ["index.ts", "index.js", "main.ts", "main.js", "mod.ts", "__init__.py"];
     for (const p of priority) {
       if (entries.includes(p)) files.push(join(dir, p));
@@ -2110,9 +2217,9 @@ function truncate(content) {
   return t.slice(0, lastNl) + `
 ... (truncated, ${content.length} chars total)`;
 }
-function safeGrep(pattern) {
+async function safeGrep(pattern) {
   try {
-    const result = execFileSync2("grep", [
+    const { stdout } = await execFileAsync("grep", [
       "-rl",
       "--include=*.ts",
       "--include=*.js",
@@ -2121,19 +2228,28 @@ function safeGrep(pattern) {
       "-i",
       pattern,
       "."
-    ], { encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: 1e4 });
-    return result.trim();
-  } catch {
+    ], { encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: GREP_TIMEOUT_MS });
+    return stdout.trim();
+  } catch (err) {
+    const e = err;
+    if (e?.code === 1) return "";
+    logger.warn("arena.provider.grep_failed", {
+      pattern,
+      code: e?.code,
+      killed: e?.killed,
+      signal: e?.signal
+    });
     return "";
   }
 }
-function gitLog() {
+async function gitLog() {
   try {
-    return execFileSync2("git", ["log", "--oneline", "-10"], {
+    const { stdout } = await execFileAsync("git", ["log", "--oneline", "-10"], {
       encoding: "utf-8",
       maxBuffer: 1024 * 1024,
       timeout: 1e4
-    }).trim();
+    });
+    return stdout.trim();
   } catch {
     return "";
   }
@@ -2204,7 +2320,7 @@ function extractSearchHints(topic) {
 
 // src/arena/providers/docs.ts
 init_esm_shims();
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "fs";
 import { join as join2, extname } from "path";
 var MAX_DOC_CHARS = 1e4;
 var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".rst", ".adoc", ".org"]);
@@ -2264,7 +2380,7 @@ function findDocFiles(dir, maxDepth, depth = 0) {
   if (depth >= maxDepth) return [];
   const files = [];
   try {
-    const entries = readdirSync2(dir);
+    const entries = readdirSync(dir);
     for (const entry of entries) {
       if (entry.startsWith(".") || entry === "node_modules") continue;
       const full = join2(dir, entry);
@@ -2315,20 +2431,36 @@ var PROVIDER_MAP = {
   // web deferred to Phase 4 — falls back to none for now
   none: noneProvider
 };
-function collectEvidence(plan, topic) {
+var PROVIDER_TIMEOUT_MS = 8e3;
+async function collectEvidence(plan, topic, options = {}) {
   const artifacts = [];
   const quickFacts = [];
   const seenSources = /* @__PURE__ */ new Set();
+  const { onProgress, signal } = options;
+  const tasks = [];
   for (const sourceSpec of plan.sources) {
     if (seenSources.has(sourceSpec.kind)) continue;
     seenSources.add(sourceSpec.kind);
     const provider = PROVIDER_MAP[sourceSpec.kind];
     if (!provider) continue;
-    const collected = provider.collect(plan, topic);
-    artifacts.push(...collected);
+    onProgress?.({ type: "evidence_started", source: sourceSpec.kind });
+    tasks.push(runProviderWithTimeout(provider, plan, topic, signal));
+  }
+  const results = await Promise.all(tasks);
+  for (const r of results) {
+    artifacts.push(...r.artifacts);
     logger.info("arena.evidence_collected", {
-      source: sourceSpec.kind,
-      count: collected.length
+      source: r.kind,
+      count: r.artifacts.length,
+      durationMs: r.durationMs,
+      timedOut: r.timedOut || void 0
+    });
+    onProgress?.({
+      type: "evidence_collected",
+      source: r.kind,
+      count: r.artifacts.length,
+      durationMs: r.durationMs,
+      timedOut: r.timedOut
     });
   }
   const branchArtifact = artifacts.find((a) => a.id === "git-branch");
@@ -2343,17 +2475,61 @@ function collectEvidence(plan, topic) {
   quickFacts.push({ label: "Lenses", value: plan.lenses.map((l) => l.name).join(", ") });
   return { artifacts, quickFacts };
 }
+async function runProviderWithTimeout(provider, plan, topic, signal) {
+  const started = Date.now();
+  let timedOut = false;
+  let timer;
+  let abortHandler;
+  const cleanup = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    if (abortHandler) {
+      signal?.removeEventListener("abort", abortHandler);
+      abortHandler = void 0;
+    }
+  };
+  const work = Promise.resolve().then(() => provider.collect(plan, topic));
+  const timeout = new Promise((resolve2) => {
+    timer = setTimeout(() => {
+      timedOut = true;
+      logger.warn("arena.provider.timeout", { source: provider.kind, ms: PROVIDER_TIMEOUT_MS });
+      resolve2([]);
+    }, PROVIDER_TIMEOUT_MS);
+    if (typeof timer.unref === "function") timer.unref();
+    if (signal) {
+      abortHandler = () => resolve2([]);
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+  });
+  let artifacts;
+  try {
+    artifacts = await Promise.race([work, timeout]);
+  } catch (err) {
+    logger.warn("arena.provider.error", { source: provider.kind, error: err.message });
+    artifacts = [];
+  } finally {
+    cleanup();
+  }
+  return {
+    kind: provider.kind,
+    artifacts,
+    durationMs: Date.now() - started,
+    timedOut
+  };
+}
 
 // src/arena/tools/selector.ts
 init_esm_shims();
 
 // src/arena/context/context-tools.ts
 init_esm_shims();
-import { readFileSync as readFileSync3, existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { execFileSync as execFileSync3 } from "child_process";
+import { readFileSync as readFileSync3, existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { execFileSync as execFileSync2 } from "child_process";
 import { resolve, join as join3 } from "path";
 var MAX_TOOL_RESULT = 15e3;
-var MAX_TOOL_ROUNDS = 5;
+var MAX_TOOL_ROUNDS = 3;
 var REPO_ROOT = resolve(".");
 var CONTEXT_TOOLS = [
   {
@@ -2470,7 +2646,7 @@ function executeListFiles(args) {
   const dir = args.path || ".";
   if (!validatePath(dir)) return `Error: path outside repository: ${dir}`;
   try {
-    const entries = readdirSync3(dir);
+    const entries = readdirSync2(dir);
     const lines = [];
     for (const entry of entries.slice(0, 50)) {
       const fullPath = join3(dir, entry);
@@ -2514,7 +2690,7 @@ function sanitizeGitRef(ref) {
 }
 function execFileSafe(cmd, args, maxLines) {
   try {
-    const raw = execFileSync3(cmd, args, {
+    const raw = execFileSync2(cmd, args, {
       encoding: "utf-8",
       maxBuffer: 512 * 1024,
       timeout: 1e4
@@ -2679,6 +2855,16 @@ async function runParticipantResearchWithDossiers(options) {
           content: result
         });
       }
+      const remaining = MAX_TOOL_ROUNDS - round;
+      const isLastAllowedRound = remaining <= 0;
+      const isPenultimate = remaining === 1;
+      if (isLastAllowedRound || isPenultimate) {
+        const directive = isLastAllowedRound ? "STOP. You have used your tool budget. Your NEXT response MUST be the findings JSON. Do NOT call any more tools \u2014 any further tool_use will be discarded." : "FINAL ROUND. Use the tool results below plus any prior context to output the findings JSON in your NEXT response. Do not call more tools.";
+        resultBlocks.unshift({
+          type: "text",
+          text: `[arena-research:${p.name}] ${directive}`
+        });
+      }
       messages.push({ role: "user", content: resultBlocks });
     }
     if (!finalText) {
@@ -2693,7 +2879,7 @@ async function runParticipantResearchWithDossiers(options) {
           ...messages,
           {
             role: "user",
-            content: "You have gathered enough context. Based on ALL the tool results above, output your findings NOW.\n\nRespond ONLY with JSON \u2014 output your highest-confidence findings (typically 5-15 for a substantive topic; each finding's `summary` should be 80+ words with concrete evidence). Do NOT request any more tools. Just output the JSON."
+            content: "You have gathered enough context. Based on ALL the tool results above, output your findings NOW.\n\nRespond ONLY with the <report> XML element specified in the system prompt \u2014 output your highest-confidence findings (typically 5-15 for a substantive topic; each <summary> should be 80+ words with concrete evidence). Do NOT request any more tools. No prose outside the XML."
           }
         ]
       });
@@ -3857,8 +4043,24 @@ var Arena = class {
       this.config.mode = plan.mode;
     }
     signal?.throwIfAborted();
-    const { artifacts, quickFacts } = collectEvidence(plan, topic);
-    this.config.onProgress?.({ type: "evidence_collected", artifacts });
+    const onProgress = this.config.onProgress;
+    const { artifacts, quickFacts } = await collectEvidence(plan, topic, {
+      signal,
+      onProgress: (e) => {
+        if (e.type === "evidence_started") {
+          onProgress?.({ type: "evidence_started", source: e.source });
+        } else {
+          onProgress?.({
+            type: "evidence_source_done",
+            source: e.source,
+            count: e.count ?? 0,
+            durationMs: e.durationMs ?? 0,
+            timedOut: e.timedOut ?? false
+          });
+        }
+      }
+    });
+    onProgress?.({ type: "evidence_collected", artifacts });
     logger.info("arena.evidence", {
       artifactCount: artifacts.length,
       sources: plan.sources.map((s) => s.kind)
@@ -4299,6 +4501,14 @@ function createProgressRenderer(sink) {
           `Plan: ${event.plan.mode} | lenses: ${event.plan.lenses.map((l) => l.name).join(", ")} | sources: ${event.plan.sources.map((s) => s.kind).join(", ")}` + (event.plan.confidence !== "high" ? ` (${event.plan.confidence} confidence)` : "")
         ));
         break;
+      case "evidence_started":
+        sink(chalk.dim(`  \xB7 collecting from ${event.source}\u2026`));
+        break;
+      case "evidence_source_done": {
+        const tag = event.timedOut ? chalk.yellow(" (timed out)") : "";
+        sink(chalk.dim(`  \xB7 ${event.source}: ${event.count} artifacts in ${event.durationMs}ms${tag}`));
+        break;
+      }
       case "evidence_collected":
         sink(chalk.dim(`Evidence: ${event.artifacts.length} artifacts collected`));
         break;