@cjhyy/code-shell-arena 0.8.0

package/dist/providers/index.js

@@ -0,0 +1,132 @@
+/**
+ * Provider registry — evidence collectors for Arena.
+ */
+import { gitProvider } from "./git.js";
+import { repoProvider } from "./repo.js";
+import { docsProvider } from "./docs.js";
+import { noneProvider } from "./none.js";
+import { logger } from "@cjhyy/code-shell-core/extension";
+export { gitProvider } from "./git.js";
+export { repoProvider } from "./repo.js";
+export { docsProvider } from "./docs.js";
+export { noneProvider } from "./none.js";
+const PROVIDER_MAP = {
+    git: gitProvider,
+    repo: repoProvider,
+    docs: docsProvider,
+    web: noneProvider, // web deferred to Phase 4 — falls back to none for now
+    none: noneProvider,
+};
+// Hard ceiling for any single provider. The repo provider can fan
+// out 5+ recursive greps; without this, one slow grep on a large
+// tree would freeze the entire arena startup. Tuned to be generous
+// for normal cases but tight enough that the user doesn't sit
+// staring at "Arena {}" for a minute.
+const PROVIDER_TIMEOUT_MS = 8_000;
+/**
+ * Collect all evidence according to the plan's sources.
+ * Returns unified ArenaArtifact[] and quickFacts.
+ *
+ * Providers run in parallel (independent of one another) with a
+ * per-provider timeout, so a single slow source can't stall the
+ * whole arena. Heartbeats are emitted around each provider so the
+ * UI can show "collecting from repo..." instead of a blank pause.
+ */
+export async function collectEvidence(plan, topic, options = {}) {
+    const artifacts = [];
+    const quickFacts = [];
+    const seenSources = 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;
+        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: r.kind,
+            count: r.artifacts.length,
+            durationMs: r.durationMs,
+            timedOut: r.timedOut || undefined,
+        });
+        onProgress?.({
+            type: "evidence_collected",
+            source: r.kind,
+            count: r.artifacts.length,
+            durationMs: r.durationMs,
+            timedOut: r.timedOut,
+        });
+    }
+    // Build quick facts from artifacts
+    const branchArtifact = artifacts.find((a) => a.id === "git-branch");
+    if (branchArtifact)
+        quickFacts.push({ label: "Branch", value: branchArtifact.preview });
+    const changedFilesArtifact = artifacts.find((a) => a.id === "git-changed-files");
+    if (changedFilesArtifact?.metadata?.totalCount) {
+        quickFacts.push({ label: "Changed Files", value: String(changedFilesArtifact.metadata.totalCount) });
+    }
+    const docCount = artifacts.filter((a) => a.source === "docs").length;
+    if (docCount > 0)
+        quickFacts.push({ label: "Documents", value: String(docCount) });
+    quickFacts.push({ label: "Sources", value: [...seenSources].join(", ") });
+    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;
+    // Hold the timer outside the timeout Promise so the work-winner
+    // branch can clear it. Previously the timer kept ticking after
+    // work resolved and fired a spurious "timeout" warn 8s later.
+    let timer;
+    let abortHandler;
+    const cleanup = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        if (abortHandler) {
+            signal?.removeEventListener("abort", abortHandler);
+            abortHandler = undefined;
+        }
+    };
+    const work = Promise.resolve().then(() => provider.collect(plan, topic));
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            timedOut = true;
+            logger.warn("arena.provider.timeout", { source: provider.kind, ms: PROVIDER_TIMEOUT_MS });
+            resolve([]);
+        }, PROVIDER_TIMEOUT_MS);
+        if (typeof timer.unref === "function")
+            timer.unref();
+        if (signal) {
+            abortHandler = () => resolve([]);
+            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,
+    };
+}

package/dist/providers/none.d.ts

@@ -0,0 +1,7 @@
+/**
+ * NoneProvider — returns no external evidence.
+ * Used for pure topic discussions, brainstorming, or debates
+ * where no external context is needed.
+ */
+import type { ArenaContextProvider } from "../types.js";
+export declare const noneProvider: ArenaContextProvider;

package/dist/providers/none.js

@@ -0,0 +1,11 @@
+/**
+ * NoneProvider — returns no external evidence.
+ * Used for pure topic discussions, brainstorming, or debates
+ * where no external context is needed.
+ */
+export const noneProvider = {
+    kind: "none",
+    collect(_plan, _topic) {
+        return [];
+    },
+};

package/dist/providers/repo.d.ts

@@ -0,0 +1,7 @@
+/**
+ * RepoProvider — collects evidence from the code repository:
+ * directory trees, key files, grep results.
+ */
+import type { ArenaContextProvider } from "../types.js";
+export declare const repoProvider: ArenaContextProvider;
+export declare function truncate(content: string): string;

package/dist/providers/repo.js

@@ -0,0 +1,258 @@
+/**
+ * RepoProvider — collects evidence from the code repository:
+ * directory trees, key files, grep results.
+ */
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { logger } from "@cjhyy/code-shell-core/extension";
+const MAX_FILE_CHARS = 8_000;
+// Per-grep ceiling. We run up to 5 hints in parallel, so the worst-case
+// wall time is ~3s rather than the previous 5×10s = 50s in series.
+const GREP_TIMEOUT_MS = 3_000;
+// Hard cap on tree-walk work — large monorepos (or recursive symlinks)
+// could otherwise blow up readdirSync/statSync time.
+const MAX_TREE_NODES = 400;
+const execFileAsync = promisify(execFile);
+export const repoProvider = {
+    kind: "repo",
+    async collect(plan, topic) {
+        const artifacts = [];
+        const targets = plan.sources.find((s) => s.kind === "repo")?.targets ?? [];
+        // Project tree overview
+        const tree = await buildTree(".", 2);
+        if (tree) {
+            artifacts.push({
+                id: "repo-tree",
+                kind: "tree",
+                source: "repo",
+                title: "Project Structure",
+                preview: tree,
+            });
+        }
+        // If specific targets provided, read them
+        for (const target of targets) {
+            if (!existsSync(target))
+                continue;
+            const st = statSync(target);
+            if (st.isDirectory()) {
+                const dirTree = await buildTree(target, 3);
+                if (dirTree) {
+                    artifacts.push({
+                        id: `repo-tree-${target}`,
+                        kind: "tree",
+                        source: "repo",
+                        title: `Directory: ${target}`,
+                        preview: dirTree,
+                    });
+                }
+                // Read entry files
+                for (const file of (await collectEntryFiles(target)).slice(0, 3)) {
+                    const content = safeReadFile(file);
+                    if (content) {
+                        artifacts.push({
+                            id: `repo-file-${file}`,
+                            kind: "file",
+                            source: "repo",
+                            title: file,
+                            ref: file,
+                            preview: truncate(content),
+                        });
+                    }
+                }
+            }
+            else {
+                const content = safeReadFile(target);
+                if (content) {
+                    artifacts.push({
+                        id: `repo-file-${target}`,
+                        kind: "file",
+                        source: "repo",
+                        title: target,
+                        ref: target,
+                        preview: truncate(content),
+                    });
+                }
+            }
+        }
+        // Search for topic-related files if no specific targets.
+        // Fan out hints in parallel — the previous serial loop was the
+        // single biggest contributor to Arena's startup latency.
+        if (targets.length === 0) {
+            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} → ${file}`,
+                            ref: file,
+                            preview: file,
+                        });
+                    }
+                }
+            }
+        }
+        // Recent git activity — only if git source is not already active (avoids duplicate)
+        const hasGitSource = plan.sources.some((s) => s.kind === "git");
+        if (!hasGitSource) {
+            const recentLog = await gitLog();
+            if (recentLog) {
+                artifacts.push({
+                    id: "repo-recent-activity",
+                    kind: "doc",
+                    source: "repo",
+                    title: "Recent Git Activity",
+                    preview: recentLog,
+                });
+            }
+        }
+        logger.info("arena.provider.repo", { artifactCount: artifacts.length });
+        return artifacts;
+    },
+};
+async function buildTree(dir, maxDepth) {
+    // Async + node-capped walk. The previous *Sync variant blocked the
+    // event loop while the new collectEvidence runs providers in
+    // parallel, partially defeating the parallelism win.
+    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 {
+        entries = (await readdir(dir)).filter((e) => !e.startsWith(".") && e !== "node_modules" && e !== "dist" && e !== "__pycache__");
+    }
+    catch {
+        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);
+        }
+    }
+}
+async function collectEntryFiles(dir) {
+    const files = [];
+    try {
+        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));
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            if (/\.(ts|js|tsx|jsx|py)$/.test(entry) && !files.includes(full)) {
+                files.push(full);
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return files;
+}
+function safeReadFile(filePath) {
+    try {
+        if (!existsSync(filePath))
+            return null;
+        const st = statSync(filePath);
+        if (st.size > 500_000)
+            return null;
+        return readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+export function truncate(content) {
+    if (content.length <= MAX_FILE_CHARS)
+        return content;
+    const t = content.slice(0, MAX_FILE_CHARS);
+    const lastNl = t.lastIndexOf("\n");
+    // No newline in the window (e.g. a minified file) → lastNl is -1 and
+    // slice(0,-1) would drop just the last char; cut at MAX_FILE_CHARS instead.
+    const body = lastNl > 0 ? t.slice(0, lastNl) : t;
+    return body + `\n... (truncated, ${content.length} chars total)`;
+}
+async function safeGrep(pattern) {
+    try {
+        const { stdout } = await execFileAsync("grep", [
+            "-rl",
+            "--include=*.ts", "--include=*.js", "--include=*.py", "--include=*.md",
+            "-i", pattern, ".",
+        ], { encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: GREP_TIMEOUT_MS });
+        return stdout.trim();
+    }
+    catch (err) {
+        // grep exits 1 when there are no matches — that's the expected
+        // "no hits" path. Anything else (signal kill on timeout, ENOENT
+        // because grep isn't installed, permission denied, etc.) is a
+        // real failure that the caller should know about, otherwise
+        // Arena silently degrades with zero artifacts.
+        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 "";
+    }
+}
+async function gitLog() {
+    try {
+        const { stdout } = await execFileAsync("git", ["log", "--oneline", "-10"], {
+            encoding: "utf-8",
+            maxBuffer: 1024 * 1024,
+            timeout: 10_000,
+        });
+        return stdout.trim();
+    }
+    catch {
+        return "";
+    }
+}
+function extractSearchHints(topic) {
+    const stopWords = new Set([
+        "the", "a", "an", "is", "are", "was", "were", "be", "been", "have", "has",
+        "do", "does", "did", "will", "would", "could", "should", "may", "might",
+        "to", "of", "in", "for", "on", "with", "at", "by", "from", "about",
+        "and", "but", "or", "not", "this", "that", "my", "your", "what", "how",
+        "review", "discuss", "plan", "help", "please", "look", "check",
+        "一下", "看看", "帮", "我", "的", "是否", "怎么", "如何", "讨论", "规划", "审查",
+    ]);
+    return topic
+        .split(/[\s,;:]+/)
+        .map((w) => w.toLowerCase().replace(/[^a-z0-9_\-/]/g, ""))
+        .filter((w) => w.length > 2 && !stopWords.has(w));
+}

package/dist/render/session.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Session renderer — formats ArenaResultV2 into markdown suitable for
+ * displaying as assistant_text and as context for follow-up LLM turns.
+ *
+ * Scene-aware output order:
+ *   1. Subject Summary — factual framing / what changed / current scope
+ *   2. Overall assessment
+ *   3. Roadmap (planning-first when present)
+ *   4. Consensus sections ordered by output emphasis
+ *   5. Next Actions
+ *   6. Per-participant findings (collapsed)
+ */
+import type { ArenaResultV2 } from "../types.js";
+/**
+ * Format an ArenaResultV2 into markdown text.
+ */
+export declare function formatArenaResultForSession(result: ArenaResultV2): string;

package/dist/render/session.js

@@ -0,0 +1,190 @@
+/**
+ * Session renderer — formats ArenaResultV2 into markdown suitable for
+ * displaying as assistant_text and as context for follow-up LLM turns.
+ *
+ * Scene-aware output order:
+ *   1. Subject Summary — factual framing / what changed / current scope
+ *   2. Overall assessment
+ *   3. Roadmap (planning-first when present)
+ *   4. Consensus sections ordered by output emphasis
+ *   5. Next Actions
+ *   6. Per-participant findings (collapsed)
+ */
+/**
+ * Format an ArenaResultV2 into markdown text.
+ */
+export function formatArenaResultForSession(result) {
+    const lines = [];
+    const modeLabel = result.mode.charAt(0).toUpperCase() + result.mode.slice(1);
+    lines.push(`## Arena ${modeLabel} Result`);
+    lines.push(`**Topic:** ${result.topic}`);
+    lines.push(`**Models:** ${result.participants.join(" vs ")}`);
+    lines.push("");
+    const c = result.consensus;
+    // 1. Subject Summary — factual overview (adapts label per mode)
+    if (c.subjectSummary) {
+        const overviewLabel = result.plan.outputShape.overviewLabel
+            ?? (result.mode === "review" ? "What Changed"
+                : result.mode === "planning" ? "Current Scope"
+                    : "Problem Framing");
+        lines.push(`### ${overviewLabel}`);
+        lines.push(c.subjectSummary);
+        lines.push("");
+    }
+    // 2. Overall assessment
+    if (c.summary) {
+        lines.push("### Overall Assessment");
+        lines.push(c.summary);
+        lines.push("");
+    }
+    // 3. Roadmap — surfaced early for planning scenes
+    if (result.mode === "planning" && c.roadmap.length > 0) {
+        lines.push("### Roadmap");
+        for (const [index, phase] of c.roadmap.entries()) {
+            lines.push(...formatRoadmapPhase(index, phase));
+        }
+        lines.push("");
+        // 3b. Implementation Details — expanded phase details
+        if (c.roadmapDetails && c.roadmapDetails.length > 0) {
+            lines.push("### Implementation Details");
+            for (const detail of c.roadmapDetails) {
+                lines.push(...formatPhaseDetail(detail));
+            }
+            lines.push("");
+        }
+    }
+    // 4. Consensus sections ordered by output emphasis
+    for (const section of getOrderedConsensusSections(result)) {
+        lines.push(`### ${section.title}`);
+        for (const item of section.items) {
+            lines.push(`- **${item.title}**: ${item.summary}`);
+        }
+        lines.push("");
+    }
+    // 5. Roadmap for non-planning scenes
+    if (result.mode !== "planning" && c.roadmap.length > 0) {
+        lines.push("### Roadmap");
+        for (const [index, phase] of c.roadmap.entries()) {
+            lines.push(...formatRoadmapPhase(index, phase));
+        }
+        lines.push("");
+    }
+    // 6. Next Actions
+    if (c.nextActions.length > 0) {
+        lines.push("### Next Actions");
+        for (const action of c.nextActions) {
+            const pri = action.priority === "high" ? "🔴" : action.priority === "medium" ? "🟡" : "⚪";
+            lines.push(`- ${pri} **${action.title}**: ${action.rationale}`);
+        }
+        lines.push("");
+    }
+    // 7. Per-participant findings (detail section)
+    if (result.reports.some((r) => r.findings.length > 0)) {
+        lines.push("---");
+        lines.push("### Participant Findings");
+        for (const report of result.reports) {
+            if (report.findings.length === 0) {
+                lines.push(`\n**${report.participant}**: ${report.contextSummary || "(no findings)"}`);
+                continue;
+            }
+            lines.push(`\n**${report.participant}** (${report.findings.length} findings)`);
+            if (report.contextSummary) {
+                lines.push(`> ${report.contextSummary}`);
+            }
+            for (const f of report.findings) {
+                const severity = f.severity ? `/${f.severity}` : "";
+                lines.push(`- [${f.kind}${severity}] **${f.title}**: ${f.summary}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function formatRoadmapPhase(index, phase) {
+    const pri = phase.priority === "high" ? "High" : phase.priority === "medium" ? "Medium" : "Low";
+    const lines = [`#### Phase ${index + 1}: ${phase.title} (${pri} priority)`];
+    if (phase.goal) {
+        lines.push(`Goal: ${phase.goal}`);
+    }
+    if (phase.scope.length > 0) {
+        lines.push(`Scope: ${phase.scope.join("; ")}`);
+    }
+    if (phase.deliverables.length > 0) {
+        lines.push(`Deliverables: ${phase.deliverables.join("; ")}`);
+    }
+    if (phase.dependencies.length > 0) {
+        lines.push(`Dependencies: ${phase.dependencies.join("; ")}`);
+    }
+    if (phase.risks.length > 0) {
+        lines.push(`Risks: ${phase.risks.join("; ")}`);
+    }
+    if (phase.successCriteria.length > 0) {
+        lines.push(`Success Criteria: ${phase.successCriteria.join("; ")}`);
+    }
+    lines.push("");
+    return lines;
+}
+function formatPhaseDetail(detail) {
+    const effort = detail.effort === "large" ? "Large" : detail.effort === "small" ? "Small" : "Medium";
+    const lines = [`#### ${detail.phaseTitle} (${effort} effort)`];
+    if (detail.objective) {
+        lines.push(detail.objective);
+    }
+    if (detail.targetFiles.length > 0) {
+        lines.push(`**Target files:** ${detail.targetFiles.map((f) => "`" + f + "`").join(", ")}`);
+    }
+    if (detail.codeChanges.length > 0) {
+        lines.push("**Code changes:**");
+        for (const change of detail.codeChanges) {
+            lines.push(`- ${change}`);
+        }
+    }
+    if (detail.interfaces.length > 0) {
+        lines.push(`**Interfaces:** ${detail.interfaces.join("; ")}`);
+    }
+    if (detail.migrationSteps.length > 0) {
+        lines.push("**Migration steps:**");
+        for (const [i, step] of detail.migrationSteps.entries()) {
+            lines.push(`${i + 1}. ${step}`);
+        }
+    }
+    if (detail.validation.length > 0) {
+        lines.push(`**Validation:** ${detail.validation.join("; ")}`);
+    }
+    if (detail.blockers.length > 0) {
+        lines.push(`**Blockers:** ${detail.blockers.join("; ")}`);
+    }
+    lines.push("");
+    return lines;
+}
+function getOrderedConsensusSections(result) {
+    const VALID_KINDS = new Set(["strength", "improvement", "risk", "question"]);
+    const defaultOrder = ["risk", "improvement", "strength", "question"];
+    const emphasize = (result.plan?.outputShape?.emphasize ?? []).filter((k) => VALID_KINDS.has(k));
+    const orderedKinds = dedupeFindingKinds([...emphasize, ...defaultOrder]);
+    const sections = orderedKinds.map((kind) => {
+        switch (kind) {
+            case "strength":
+                return { kind, title: "✓ Strengths", items: result.consensus.strengths };
+            case "improvement":
+                return { kind, title: "→ Improvements", items: result.consensus.improvements };
+            case "risk":
+                return { kind, title: "⚠ Risks", items: result.consensus.risks };
+            case "question":
+                return { kind, title: "? Open Questions", items: result.consensus.openQuestions };
+        }
+    });
+    return sections
+        .filter((section) => section != null)
+        .filter((section) => section.items.length > 0);
+}
+function dedupeFindingKinds(kinds) {
+    const seen = new Set();
+    const result = [];
+    for (const kind of kinds) {
+        if (!seen.has(kind)) {
+            seen.add(kind);
+            result.push(kind);
+        }
+    }
+    return result;
+}

package/dist/render/terminal.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Terminal renderer — renders ArenaConsensus and ArenaResultV2.
+ *
+ * All render functions return strings instead of printing directly,
+ * so callers can decide where to display (ctx.addStatus vs console.log).
+ *
+ * Output sections:
+ * 1. Summary
+ * 2. Roadmap (surfaced early for planning scenes)
+ * 3. Consensus sections ordered by output emphasis
+ * 4. Next Actions
+ */
+import { type Colorizer } from "@cjhyy/code-shell-core/extension";
+import type { ArenaResultV2, ArenaProgressEvent } from "../types.js";
+/** Output sink — callers provide this to control where text goes. */
+export type OutputSink = (text: string) => void;
+/**
+ * Format the full arena result as a styled string.
+ */
+export declare function formatArenaResult(result: ArenaResultV2, c?: Colorizer): string;
+/**
+ * Print the full arena result directly to stdout.
+ * Used by the CLI `code-shell arena` command (non-REPL).
+ */
+export declare function printArenaResult(result: ArenaResultV2, c?: Colorizer): void;
+/**
+ * Create a progress renderer that sends output to a sink.
+ * For REPL: pass ctx.addStatus. For CLI: pass console.log.
+ */
+export declare function createProgressRenderer(sink: OutputSink, c?: Colorizer): (event: ArenaProgressEvent) => void;
+/**
+ * Legacy: direct console.log progress renderer for CLI mode.
+ */
+export declare function renderProgress(event: ArenaProgressEvent, c?: Colorizer): void;