multiarena 0.1.1 → 0.1.4

package/dist/ui/app.js

@@ -1,5 +1,6 @@
 import React, { useState, useCallback, useEffect, useRef } from "react";
 import { Box, Text, useInput, useApp } from "ink";
+import { readFile } from "node:fs/promises";
 import { OutputArea } from "./components/OutputArea.js";
 import { InputBar } from "./components/InputBar.js";
 import { Session, contextLimitForModel } from "../core/session.js";
@@ -9,8 +10,10 @@ import { PermissionManager } from "../tools/permission.js";
 import { runTurn } from "../core/turn.js";
 import { WorktreeManager } from "../isolation/worktree.js";
 import { saveSession, loadSession } from "../persistence/session.js";
+import { runDeliberation, runMerge, autoAssignRounds, } from "../core/deliberation.js";
+import { reduceTab, reduceShiftTab, reduceEscape, reduceKeyD, reduceSubmitInTeam, buildModeState, } from "./modeTransitions.js";
 function makeSystemPrompt(modelName, provider) {
-    return `You are a helpful AI coding assistant. You are the "${modelName}" model (provider: ${provider}). Be concise.`;
+    return `You are a helpful AI assistant. You can help with coding, writing, analysis, and creative tasks. You are the "${modelName}" model (provider: ${provider}). Respond directly to the user's request — if asked to write content, just write it; only use tools when the task genuinely requires file or command operations.`;
 }
 // App-level (module-scoped) tool registry and permission manager.
 // Created once and shared across all submissions.
@@ -52,8 +55,29 @@ export const App = ({ sessionId: initialSessionId }) => {
     const [modelStates, setModelStates] = useState(() => session.models);
     const [comparisonModel, setComparisonModel] = useState(null);
     const comparisonFromBroadcastRef = useRef(false);
+    // Lightweight trigger for re-renders when only session.targetMode changes (not model data)
+    const [targetVersion, setTargetVersion] = useState(0);
+    // ── Team / Broadcast mode ──────────────────────────────────────
+    const [teamMode, setTeamMode] = useState(false);
+    // ── Deliberation state ─────────────────────────────────────────
+    const [deliberationProgress, setDeliberationProgress] = useState(null);
+    const [deliberationDocument, setDeliberationDocument] = useState("");
+    const [deliberationThinkText, setDeliberationThinkText] = useState("");
+    const [deliberationRounds, setDeliberationRounds] = useState([]);
+    const [deliberationScrollOffset, setDeliberationScrollOffset] = useState(0);
+    const deliberatingRef = useRef(false);
+    const deliberationAbortRef = useRef(null);
+    // Ref mirroring currentModeState() so the raw stdin Esc listener
+    // always reads fresh mode state without re-subscribing on every render.
+    const modeStateRef = useRef(currentModeState());
+    modeStateRef.current = currentModeState();
     const activeScrollModel = session.targetMode.type === "directed" ? session.targetMode.modelName : null;
     const adjustScroll = useCallback((delta) => {
+        // Team overview with deliberation content → scroll the deliberation view
+        if (teamMode && isOverview() && deliberationProgress) {
+            setDeliberationScrollOffset((prev) => Math.max(0, prev + delta));
+            return;
+        }
         const modelName = activeScrollModel;
         if (!modelName)
             return;
@@ -61,7 +85,7 @@ export const App = ({ sessionId: initialSessionId }) => {
             ...prev,
             [modelName]: Math.max(0, (prev[modelName] ?? 0) + delta),
         }));
-    }, [activeScrollModel]);
+    }, [activeScrollModel, teamMode, deliberationProgress]);
     // Input history
     const inputHistoryRef = useRef([]);
     const historyIdxRef = useRef(-1);
@@ -95,9 +119,13 @@ export const App = ({ sessionId: initialSessionId }) => {
             lastTarget,
         });
     }, [session, sessionId]);
-    const targetPrefix = session.targetMode.type === "broadcast"
-        ? "all"
-        : session.targetMode.modelName;
+    const targetPrefix = teamMode
+        ? session.targetMode.type === "broadcast"
+            ? "team"
+            : `team:${session.targetMode.modelName}`
+        : session.targetMode.type === "broadcast"
+            ? "all"
+            : session.targetMode.modelName;
     const activeModelName = session.targetMode.type === "broadcast" ? null : session.targetMode.modelName;
     // Save session on process exit (Ctrl+C, kill, etc.)
     useEffect(() => {
@@ -119,6 +147,63 @@ export const App = ({ sessionId: initialSessionId }) => {
         const wm = new WorktreeManager(process.cwd());
         wm.sweepOrphans().catch(() => { });
     }, []);
+    // Raw stdin listener for Escape key.
+    // Ink's useInput key.escape is unreliable on some terminal setups
+    // (Windows Terminal + bash in particular). We listen for the raw
+    // \x1b byte directly and use a brief timeout to distinguish
+    // standalone Esc from escape sequences (arrow keys, etc.).
+    useEffect(() => {
+        let escTimer = null;
+        const handleEsc = () => {
+            const state = modeStateRef.current;
+            const r = reduceEscape(state, deliberatingRef.current);
+            if (r.teamMode !== state.teamMode)
+                setTeamMode(r.teamMode);
+            if (r.abortDeliberation) {
+                deliberationAbortRef.current?.abort();
+                deliberatingRef.current = false;
+            }
+            if (r.resetDeliberation) {
+                setDeliberationProgress(null);
+                setDeliberationDocument("");
+                setDeliberationRounds([]);
+            }
+            setComparisonModel(r.comparisonModel);
+            comparisonFromBroadcastRef.current = r.comparisonFromBroadcast;
+            if (r.goToOverview) {
+                session.setTarget({ type: "broadcast" });
+                setTargetVersion((v) => v + 1);
+            }
+            if (r.restoreBroadcast) {
+                session.setTarget({ type: "broadcast" });
+                comparisonFromBroadcastRef.current = false;
+                setModelStates([...session.models]);
+            }
+            shortcutHandledRef.current = true;
+        };
+        const onData = (data) => {
+            // A single 0x1b byte might be standalone Esc or the start of
+            // an escape sequence (\x1b[A for Up, etc.). Wait briefly to
+            // see if more bytes follow.
+            if (data.length === 1 && data[0] === 0x1b) {
+                if (escTimer)
+                    clearTimeout(escTimer);
+                escTimer = setTimeout(() => { handleEsc(); escTimer = null; }, 35);
+                return;
+            }
+            // Any other input — cancel pending Esc (it was part of a sequence)
+            if (escTimer) {
+                clearTimeout(escTimer);
+                escTimer = null;
+            }
+        };
+        process.stdin.on("data", onData);
+        return () => {
+            process.stdin.removeListener("data", onData);
+            if (escTimer)
+                clearTimeout(escTimer);
+        };
+    }, []);
     // Clear the input bar whenever a shortcut was handled (runs after the render
     // batch so it overrides any concurrent setInput from ink-text-input).
     useEffect(() => {
@@ -127,29 +212,83 @@ export const App = ({ sessionId: initialSessionId }) => {
             setInput("");
         }
     });
+    // Build a ModeState snapshot from current React state so the pure
+    // decision functions in modeTransitions.ts can drive the keyboard handler.
+    function currentModeState() {
+        return buildModeState({
+            teamMode,
+            deliberationProgress,
+            comparisonModel,
+            comparisonFromBroadcast: comparisonFromBroadcastRef.current,
+        });
+    }
+    /** True when the current target is the mode overview (broadcast target). */
+    function isOverview() {
+        return session.targetMode.type === "broadcast";
+    }
     // Keyboard input: Tab cycling, scrolling, and single-key shortcuts.
-    // Single-key shortcuts (d/m/r) only fire when the input bar is empty so they
-    // don't interfere with message typing.
     useInput((inputValue, key) => {
-        if (key.tab) {
-            session.cycleTarget();
+        // ── Tab (no shift): cycle target within current mode ──────────
+        // Tab never changes teamMode. It cycles: overview → model1 → … → overview.
+        if (key.tab && !key.shift) {
+            const r = reduceTab(currentModeState());
+            if (r.clearComparison) {
+                setComparisonModel(null);
+                comparisonFromBroadcastRef.current = false;
+            }
+            if (r.cycleTarget) {
+                session.cycleTarget();
+                setTargetVersion((v) => v + 1);
+            }
+            return;
+        }
+        // ── Shift+Tab: toggle between broadcast ↔ team ──────────────
+        if (key.tab && key.shift) {
+            const r = reduceShiftTab(currentModeState(), isOverview());
+            if (!r)
+                return;
+            setTeamMode(r.teamMode);
             setComparisonModel(null);
-            comparisonFromBroadcastRef.current = false;
-            setModelStates([...session.models]);
+            if (r.goToOverview) {
+                session.setTarget({ type: "broadcast" });
+                setTargetVersion((v) => v + 1);
+            }
+            if (r.resetDeliberation) {
+                setDeliberationProgress(null);
+                setDeliberationDocument("");
+                setDeliberationRounds([]);
+            }
             return;
         }
-        // Escape dismisses comparison mode (restore broadcast if entered from there)
+        // ── Escape: return to current mode's overview ────────────────
         if (key.escape) {
-            if (comparisonModel) {
-                if (comparisonFromBroadcastRef.current) {
-                    session.setTarget({ type: "broadcast" });
-                    comparisonFromBroadcastRef.current = false;
-                }
-                setComparisonModel(null);
+            const r = reduceEscape(currentModeState(), deliberatingRef.current);
+            // teamMode is preserved — Esc never toggles it
+            if (r.teamMode !== teamMode)
+                setTeamMode(r.teamMode);
+            if (r.abortDeliberation) {
+                deliberationAbortRef.current?.abort();
+                deliberatingRef.current = false;
+            }
+            if (r.resetDeliberation) {
+                setDeliberationProgress(null);
+                setDeliberationDocument("");
+                setDeliberationRounds([]);
+            }
+            setComparisonModel(r.comparisonModel);
+            comparisonFromBroadcastRef.current = r.comparisonFromBroadcast;
+            if (r.goToOverview) {
+                session.setTarget({ type: "broadcast" });
+                setTargetVersion((v) => v + 1);
+            }
+            if (r.restoreBroadcast) {
+                // Exiting comparison that entered from broadcast — restore broadcast
+                session.setTarget({ type: "broadcast" });
+                comparisonFromBroadcastRef.current = false;
                 setModelStates([...session.models]);
-                shortcutHandledRef.current = true;
-                return;
             }
+            shortcutHandledRef.current = true;
+            return;
         }
         if (key.upArrow) {
             if (input.length === 0) {
@@ -193,37 +332,21 @@ export const App = ({ sessionId: initialSessionId }) => {
             return;
         // 'd' — toggle comparison mode (current model vs next unmuted model)
         if (inputValue === "d") {
-            if (comparisonModel) {
-                // Exiting comparison: restore broadcast if we entered from there
-                if (comparisonFromBroadcastRef.current) {
-                    session.setTarget({ type: "broadcast" });
-                    comparisonFromBroadcastRef.current = false;
-                }
-                setComparisonModel(null);
+            const unmutedNames = session.models.filter((m) => !m.muted).map((m) => m.name);
+            const currentTarget = session.targetMode.type === "directed" ? session.targetMode.modelName : null;
+            const r = reduceKeyD(currentModeState(), unmutedNames, currentTarget);
+            // Exiting comparison — restore broadcast if we entered from there
+            if (comparisonModel && !r.comparisonModel && comparisonFromBroadcastRef.current) {
+                session.setTarget({ type: "broadcast" });
+                comparisonFromBroadcastRef.current = false;
+                setTargetVersion((v) => v + 1);
             }
-            else {
-                const unmuted = session.models.filter((m) => !m.muted);
-                if (unmuted.length < 2) {
-                    shortcutHandledRef.current = true;
-                    return;
-                }
-                if (session.targetMode.type === "broadcast") {
-                    // From broadcast: switch to directed for the first model, compare with second
-                    session.setTarget({ type: "directed", modelName: unmuted[0].name });
-                    setComparisonModel(unmuted[1].name);
-                    comparisonFromBroadcastRef.current = true;
-                }
-                else {
-                    // From directed: toggle comparison on/off for the current model
-                    const baseName = session.targetMode.modelName;
-                    const idx = unmuted.findIndex((m) => m.name === baseName);
-                    const next = unmuted[(idx + 1) % unmuted.length];
-                    if (next && next.name !== baseName) {
-                        setComparisonModel(next.name);
-                    }
-                }
+            setComparisonModel(r.comparisonModel);
+            comparisonFromBroadcastRef.current = r.comparisonFromBroadcast;
+            if (r.setDirectedTarget) {
+                session.setTarget({ type: "directed", modelName: r.setDirectedTarget });
+                setTargetVersion((v) => v + 1);
             }
-            setModelStates([...session.models]);
             shortcutHandledRef.current = true;
             return;
         }
@@ -254,10 +377,294 @@ export const App = ({ sessionId: initialSessionId }) => {
             return;
         }
     });
+    // ── Deliberation runner ───────────────────────────────────────
+    const runDeliberationPipeline = useCallback(async () => {
+        if (deliberatingRef.current)
+            return;
+        deliberatingRef.current = true;
+        const activeModels = session.models
+            .filter((m) => !m.muted)
+            .map((m) => m.name);
+        if (activeModels.length < 2) {
+            // Need at least 2 models for deliberation
+            setDeliberationProgress({
+                type: "error",
+                round: 0,
+                totalRounds: 0,
+                error: "Deliberation requires at least 2 active (non-muted) models.",
+            });
+            deliberatingRef.current = false;
+            return;
+        }
+        // Use config deliberation settings or auto-assign
+        const delibConfig = config.deliberation;
+        let roundConfigs;
+        if (delibConfig?.rounds && delibConfig.rounds.length > 0) {
+            roundConfigs = delibConfig.rounds
+                .filter((r) => activeModels.includes(r.model) && config.models[r.model])
+                .map((r) => ({
+                modelName: r.model,
+                role: r.role,
+                config: config.models[r.model],
+            }));
+        }
+        else {
+            roundConfigs = autoAssignRounds(activeModels, config.models);
+        }
+        if (roundConfigs.length < 2) {
+            setDeliberationProgress({
+                type: "error",
+                round: 0,
+                totalRounds: 0,
+                error: "Not enough configured models for deliberation (need ≥2).",
+            });
+            deliberatingRef.current = false;
+            return;
+        }
+        // Load constraint document if configured
+        let constraint;
+        if (delibConfig?.constraint_file) {
+            try {
+                constraint = await readFile(delibConfig.constraint_file, "utf-8");
+            }
+            catch {
+                // Constraint file not found — proceed without it
+            }
+        }
+        setDeliberationDocument("");
+        setDeliberationRounds([]);
+        setDeliberationScrollOffset(0);
+        let doc = "";
+        const stream = runDeliberation(session.teamMessages, roundConfigs, constraint);
+        for await (const event of stream) {
+            setDeliberationProgress(event);
+            if (event.type === "think_start") {
+                setDeliberationThinkText("");
+                setDeliberationDocument("");
+            }
+            else if (event.type === "think_text" && event.content) {
+                setDeliberationThinkText((prev) => prev + event.content);
+            }
+            else if (event.type === "think_end") {
+                // Think done — keep think text in state for UI reference,
+                // main round will populate deliberationDocument next.
+            }
+            else if (event.type === "round_start") {
+                doc = "";
+                setDeliberationDocument("");
+                setDeliberationThinkText("");
+                setDeliberationRounds((prev) => [
+                    ...prev,
+                    { round: event.round, modelName: event.modelName, role: event.role },
+                ]);
+            }
+            else if (event.type === "text" && event.content) {
+                doc += event.content;
+                setDeliberationDocument(doc);
+            }
+            else if (event.type === "round_end") {
+                // Update the round entry with change metadata
+                setDeliberationRounds((prev) => prev.map((r) => r.round === event.round
+                    ? {
+                        ...r,
+                        changeCount: event.changeCount,
+                        changeSamples: event.changeSamples,
+                    }
+                    : r));
+            }
+            else if (event.type === "done") {
+                setDeliberationDocument(event.document ?? doc);
+            }
+            else if (event.type === "error") {
+                deliberatingRef.current = false;
+                return;
+            }
+        }
+        deliberatingRef.current = false;
+    }, [session.models, config]);
+    // ── Merge runner ──────────────────────────────────────────────
+    const runMergePipeline = useCallback(async () => {
+        if (deliberatingRef.current)
+            return;
+        deliberatingRef.current = true;
+        // Collect the last assistant response from each non-muted model
+        const outputs = [];
+        for (const m of session.models) {
+            if (m.muted)
+                continue;
+            // Find the last assistant message
+            const lastAssistant = [...m.messages].reverse().find((msg) => msg.role === "assistant");
+            if (lastAssistant?.content) {
+                outputs.push({ modelName: m.name, content: lastAssistant.content });
+            }
+        }
+        if (outputs.length < 2) {
+            setDeliberationProgress({
+                type: "error",
+                round: 0,
+                totalRounds: 0,
+                error: "需要至少 2 个模型有回复才能合并。",
+            });
+            deliberatingRef.current = false;
+            return;
+        }
+        // Find the last user message as the task
+        const firstModel = session.models.find((m) => !m.muted);
+        const lastUserMsg = firstModel?.messages
+            ? [...firstModel.messages].reverse().find((m) => m.role === "user")
+            : null;
+        const task = lastUserMsg?.content ?? "合并以下模型输出";
+        // Use the first non-muted model as the merger
+        const mergerName = session.models.find((m) => !m.muted).name;
+        const mergerConfig = config.models[mergerName];
+        if (!mergerConfig) {
+            setDeliberationProgress({
+                type: "error",
+                round: 0,
+                totalRounds: 0,
+                error: `未找到模型 "${mergerName}" 的配置。`,
+            });
+            deliberatingRef.current = false;
+            return;
+        }
+        setDeliberationDocument("");
+        setDeliberationRounds([]);
+        setDeliberationScrollOffset(0);
+        let doc = "";
+        const stream = runMerge(task, outputs, mergerConfig, mergerName);
+        for await (const event of stream) {
+            setDeliberationProgress(event);
+            if (event.type === "round_start") {
+                doc = "";
+                setDeliberationDocument("");
+                setDeliberationRounds([
+                    { round: 1, modelName: mergerName, role: "draft" },
+                ]);
+            }
+            else if (event.type === "text" && event.content) {
+                doc += event.content;
+                setDeliberationDocument(doc);
+            }
+            else if (event.type === "done") {
+                setDeliberationDocument(event.document ?? doc);
+            }
+            else if (event.type === "error") {
+                deliberatingRef.current = false;
+                return;
+            }
+        }
+        // Inject the merged document into each model's history so they
+        // can discuss it when the user switches to chat mode.
+        if (doc) {
+            const contextMsg = `[合并结果]\n\n以下是将各模型输出合并后的最终文档。用户可以就此文档与你讨论。\n\n---\n${doc}\n---`;
+            for (const m of session.models) {
+                if (!m.muted) {
+                    m.messages.push({ role: "user", content: contextMsg });
+                }
+            }
+        }
+        deliberatingRef.current = false;
+    }, [session.models, config]);
     const handleSubmit = useCallback(async (value) => {
         const trimmed = value.trim();
         if (!trimmed)
             return;
+        // ── Team mode: submit runs deliberation or routes to model ──
+        if (teamMode) {
+            const r = reduceSubmitInTeam(currentModeState(), isOverview());
+            if (r.action === "block")
+                return;
+            inputHistoryRef.current.push(trimmed);
+            historyIdxRef.current = -1;
+            setInput("");
+            // All team interactions share session.teamMessages as context.
+            session.teamMessages.push({ role: "user", content: trimmed });
+            if (r.action === "deliberate") {
+                setDeliberationDocument("");
+                // Reset target to overview so OutputArea shows deliberation progress
+                session.setTarget({ type: "broadcast" });
+                setTargetVersion((v) => v + 1);
+                runDeliberationPipeline();
+                return;
+            }
+            // r.action === "route_normally" — team directed chat.
+            // The user is drilling into a specific model. Use shared team context.
+            const targetModel = session.targetMode.type === "directed"
+                ? session.targetMode.modelName
+                : null;
+            if (!targetModel)
+                return;
+            const tm = session.models.find((m) => m.name === targetModel && !m.muted);
+            if (!tm)
+                return;
+            const tmc = config.models[targetModel];
+            if (!tmc) {
+                tm.buffer = `[Error: No config for model "${targetModel}"]`;
+                setModelStates([...session.models]);
+                return;
+            }
+            // Worktree setup
+            const taskId = Date.now().toString(36);
+            const wtManager = new WorktreeManager(process.cwd());
+            await wtManager.setup(taskId, [targetModel]);
+            const wtPath = wtManager.getWorktreePath(targetModel) ?? process.cwd();
+            tm.isStreaming = true;
+            tm.buffer = "";
+            setModelStates([...session.models]);
+            const stream = runTurn({
+                modelName: targetModel,
+                config: tmc,
+                messages: session.teamMessages,
+                systemPrompt: makeSystemPrompt(targetModel, tmc.provider),
+                tools: toolRegistry.getDefinitions(),
+                registry: toolRegistry,
+                permission: permissionManager,
+                worktreePath: wtPath,
+            });
+            for await (const event of stream) {
+                if (event.type === "text") {
+                    tm.buffer += event.content;
+                }
+                else if (event.type === "done") {
+                    tm.usage.input += event.usage.input;
+                    tm.usage.output += event.usage.output;
+                    tm.isStreaming = false;
+                }
+                else if (event.type === "error") {
+                    tm.buffer += `\n[Error: ${event.message}]`;
+                    tm.isStreaming = false;
+                }
+                setModelStates([...session.models]);
+            }
+            await wtManager.cleanup(taskId);
+            saveCurrentSession();
+            return;
+        }
+        // ── Team mode toggle ────────────────────────────────────
+        if (trimmed === "/team" || trimmed === "/t") {
+            inputHistoryRef.current.push(trimmed);
+            historyIdxRef.current = -1;
+            setInput("");
+            setTeamMode((prev) => !prev);
+            // Entering a mode always lands on its overview
+            session.setTarget({ type: "broadcast" });
+            setTargetVersion((v) => v + 1);
+            setDeliberationProgress(null);
+            setDeliberationDocument("");
+            setDeliberationRounds([]);
+            setComparisonModel(null);
+            shortcutHandledRef.current = true;
+            return;
+        }
+        // ── Merge command: synthesize last outputs ───────────────
+        if (trimmed === "/merge" || trimmed === "/m") {
+            inputHistoryRef.current.push(trimmed);
+            historyIdxRef.current = -1;
+            setInput("");
+            setDeliberationDocument("");
+            runMergePipeline();
+            return;
+        }
         // Add to input history
         inputHistoryRef.current.push(trimmed);
         historyIdxRef.current = -1;
@@ -322,7 +729,7 @@ export const App = ({ sessionId: initialSessionId }) => {
         await worktreeManager.cleanup(taskId);
         // ── Auto-save session ─────────────────────────────────────
         saveCurrentSession();
-    }, [session, config, sessionId, saveCurrentSession]);
+    }, [session, config, sessionId, saveCurrentSession, teamMode, deliberationProgress, runDeliberationPipeline, setTargetVersion]);
     const terminalWidth = process.stdout.columns ?? 80;
     // ── No models configured: show startup guide ──────────────────
     if (modelStates.length === 0) {
@@ -365,8 +772,7 @@ broadcast = true`;
         configWarnings.length > 0 && (React.createElement(Box, { flexDirection: "column" }, configWarnings.map((w, i) => (React.createElement(Text, { key: i, color: "yellow" },
             "\u26A0 ",
             w.message))))),
-        React.createElement(Text, null, "─".repeat(terminalWidth)),
-        React.createElement(OutputArea, { models: modelStates, targetMode: session.targetMode, scrollOffsets: scrollOffsets, comparisonModel: comparisonModel, terminalWidth: terminalWidth }),
-        React.createElement(Text, null, "─".repeat(terminalWidth)),
+        React.createElement(Box, { flexGrow: 1 },
+            React.createElement(OutputArea, { models: modelStates, targetMode: session.targetMode, scrollOffsets: scrollOffsets, comparisonModel: comparisonModel, terminalWidth: terminalWidth, deliberationProgress: deliberationProgress, deliberationDocument: deliberationDocument, deliberationThinkText: deliberationThinkText, deliberationRounds: deliberationRounds, teamMode: teamMode, deliberationScrollOffset: deliberationScrollOffset })),
         React.createElement(InputBar, { models: modelStates, activeModelName: activeModelName, prefix: targetPrefix, value: input, onChange: handleInputChange, onSubmit: handleSubmit })));
 };

package/dist/ui/components/BroadcastSummary.js

@@ -1,6 +1,6 @@
 import React from "react";
 import { Box, Text } from "ink";
-import { formatTokens } from "./StatusBar.js";
+import { formatTokens } from "./formatTokens.js";
 const PANEL_LINES = 4;
 export const BroadcastSummary = ({ models, terminalWidth }) => {
     const activeModels = models.filter((m) => !m.muted);

package/dist/ui/components/DeliberationView.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import type { DeliberationProgress, RoundRole } from "../../core/deliberation.js";
+export interface RoundSummary {
+    round: number;
+    modelName: string;
+    role: RoundRole;
+    changeCount?: number;
+    changeSamples?: string[];
+}
+interface Props {
+    progress: DeliberationProgress;
+    document: string;
+    thinkText?: string;
+    rounds: RoundSummary[];
+    scrollOffset?: number;
+}
+export declare const DeliberationView: React.FC<Props>;
+export {};