multiarena 0.1.0 → 0.1.3

package/dist/ui/app.js

@@ -1,16 +1,20 @@
 import React, { useState, useCallback, useEffect, useRef } from "react";
 import { Box, Text, useInput, useApp } from "ink";
-import { StatusBar } from "./components/StatusBar.js";
+import { readFile } from "node:fs/promises";
 import { OutputArea } from "./components/OutputArea.js";
 import { InputBar } from "./components/InputBar.js";
-import { Session } from "../core/session.js";
+import { Session, contextLimitForModel } from "../core/session.js";
 import { loadConfig, validateConfig } from "../config/loader.js";
 import { createDefaultRegistry } from "../tools/registry.js";
 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";
-const SYSTEM_PROMPT = "You are a helpful AI coding assistant. Be concise.";
+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 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.
 const toolRegistry = createDefaultRegistry();
@@ -34,7 +38,7 @@ export const App = ({ sessionId: initialSessionId }) => {
                         muted: false,
                         buffer: "",
                         usage: { input: 0, output: 0 },
-                        contextLimit: 128000,
+                        contextLimit: contextLimitForModel(config.models[m.name]?.provider ?? "", config.models[m.name]?.context_limit),
                     })),
                     targetMode: saved.lastTarget === "broadcast"
                         ? { type: "broadcast" }
@@ -50,8 +54,29 @@ export const App = ({ sessionId: initialSessionId }) => {
     const [scrollOffsets, setScrollOffsets] = useState({});
     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 [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;
@@ -59,7 +84,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);
@@ -93,9 +118,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(() => {
@@ -117,6 +146,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(() => {
@@ -125,23 +211,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);
-            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
+        // ── Escape: return to current mode's overview ────────────────
         if (key.escape) {
-            if (comparisonModel) {
-                setComparisonModel(null);
-                shortcutHandledRef.current = true;
-                return;
+            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;
         }
         if (key.upArrow) {
             if (input.length === 0) {
@@ -185,21 +331,20 @@ export const App = ({ sessionId: initialSessionId }) => {
             return;
         // 'd' — toggle comparison mode (current model vs next unmuted model)
         if (inputValue === "d") {
-            if (comparisonModel) {
-                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);
-                const baseName = session.targetMode.type === "directed"
-                    ? session.targetMode.modelName
-                    : unmuted[0]?.name;
-                if (baseName && unmuted.length >= 2) {
-                    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);
             }
             shortcutHandledRef.current = true;
             return;
@@ -210,6 +355,7 @@ export const App = ({ sessionId: initialSessionId }) => {
                 session.toggleMute(session.targetMode.modelName);
                 setModelStates([...session.models]);
                 setComparisonModel(null);
+                comparisonFromBroadcastRef.current = false;
             }
             shortcutHandledRef.current = true;
             return;
@@ -230,10 +376,240 @@ export const App = ({ sessionId: initialSessionId }) => {
             return;
         }
     });
+    // ── Deliberation runner ───────────────────────────────────────
+    const runDeliberationPipeline = useCallback(async (task) => {
+        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(task, roundConfigs, constraint);
+        for await (const event of stream) {
+            setDeliberationProgress(event);
+            if (event.type === "round_start") {
+                doc = "";
+                setDeliberationDocument("");
+                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;
+            }
+        }
+        // Keep the final document visible; user presses Esc to dismiss
+        // Inject the final document into each model's message 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]);
+    // ── 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;
+            if (r.action === "deliberate") {
+                inputHistoryRef.current.push(trimmed);
+                historyIdxRef.current = -1;
+                setInput("");
+                setDeliberationDocument("");
+                // Reset target to overview so OutputArea shows deliberation progress
+                session.setTarget({ type: "broadcast" });
+                setTargetVersion((v) => v + 1);
+                runDeliberationPipeline(trimmed);
+                return;
+            }
+            // r.action === "route_normally" — send as directed/broadcast message
+        }
+        // ── 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;
@@ -272,7 +648,7 @@ export const App = ({ sessionId: initialSessionId }) => {
                 modelName: m.name,
                 config: mc,
                 messages: m.messages,
-                systemPrompt: SYSTEM_PROMPT,
+                systemPrompt: makeSystemPrompt(m.name, mc.provider),
                 tools: toolRegistry.getDefinitions(),
                 registry: toolRegistry,
                 permission: permissionManager,
@@ -298,12 +674,8 @@ 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;
-    const contextUsages = {};
-    for (const m of modelStates) {
-        contextUsages[m.name] = session.getContextUsage(m.name);
-    }
     // ── No models configured: show startup guide ──────────────────
     if (modelStates.length === 0) {
         const example = `[models.claude]
@@ -316,28 +688,36 @@ provider = "openai"
 model = "gpt-4o"
 api_key = "\${OPENAI_API_KEY}"
 
+[models.deepseek]
+provider = "deepseek"
+model = "deepseek-chat"
+api_key = "\${DEEPSEEK_API_KEY}"
+
+[models.minimax]
+provider = "minimax"
+model = "MiniMax-M2.1"
+api_key = "\${MINIMAX_API_KEY}"
+
 [defaults]
 active = ["claude", "gpt"]
 broadcast = true`;
         return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Text, { bold: true, color: "cyan" }, "Arena \u2014 Multi-Model AI Coding Assistant"),
+            React.createElement(Text, { bold: true, color: "cyan" }, "multiarena \u2014 Multi-Model AI Coding Assistant"),
             React.createElement(Text, null, " "),
             React.createElement(Text, null,
                 "No models configured. Create a ",
-                React.createElement(Text, { color: "yellow" }, ".arenarc"),
+                React.createElement(Text, { color: "yellow" }, ".multiarenarc"),
                 " file in your project root or home directory:"),
             React.createElement(Text, null, " "),
             React.createElement(Text, { color: "gray" }, example),
             React.createElement(Text, null, " "),
-            React.createElement(Text, { dimColor: true }, "Supported providers: anthropic, openai, google, ollama")));
+            React.createElement(Text, { dimColor: true }, "Supported providers: anthropic, openai, google, ollama, deepseek, minimax")));
     }
     return (React.createElement(Box, { flexDirection: "column", width: "100%" },
-        React.createElement(StatusBar, { models: modelStates, activeModelName: activeModelName, contextUsages: contextUsages }),
         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 }),
-        React.createElement(Text, null, "─".repeat(terminalWidth)),
-        React.createElement(InputBar, { prefix: targetPrefix, value: input, onChange: handleInputChange, onSubmit: handleSubmit })));
+        React.createElement(Box, { flexGrow: 1 },
+            React.createElement(OutputArea, { models: modelStates, targetMode: session.targetMode, scrollOffsets: scrollOffsets, comparisonModel: comparisonModel, terminalWidth: terminalWidth, deliberationProgress: deliberationProgress, deliberationDocument: deliberationDocument, 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.d.ts

@@ -2,6 +2,7 @@ import React from "react";
 import type { ModelState } from "../../core/types.js";
 interface Props {
     models: ModelState[];
+    terminalWidth: number;
 }
 export declare const BroadcastSummary: React.FC<Props>;
 export {};

package/dist/ui/components/BroadcastSummary.js

@@ -1,18 +1,34 @@
 import React from "react";
 import { Box, Text } from "ink";
+import { formatTokens } from "./formatTokens.js";
 const PANEL_LINES = 4;
-export const BroadcastSummary = ({ models }) => {
+export const BroadcastSummary = ({ models, terminalWidth }) => {
     const activeModels = models.filter((m) => !m.muted);
-    return (React.createElement(Box, { flexDirection: "row", flexGrow: 1 }, activeModels.map((m) => {
-        const lines = m.buffer.split("\n").slice(0, PANEL_LINES);
-        const totalLines = m.buffer.split("\n").length;
-        return (React.createElement(Box, { key: m.name, flexDirection: "column", flexGrow: 1, borderStyle: "single", borderColor: "gray", marginRight: 1 },
+    const panelWidth = Math.floor(terminalWidth / activeModels.length);
+    return (React.createElement(Box, { flexDirection: "row", flexGrow: 1 }, activeModels.map((m, idx) => {
+        const rawLines = m.buffer ? m.buffer.split("\n") : [];
+        const totalLines = rawLines.length;
+        const isEmpty = totalLines === 0 || (totalLines === 1 && rawLines[0].trim() === "");
+        const displayLines = rawLines.slice(-PANEL_LINES);
+        while (displayLines.length < PANEL_LINES) {
+            displayLines.unshift("");
+        }
+        const isLast = idx === activeModels.length - 1;
+        return (React.createElement(Box, { key: m.name, flexDirection: "column", width: panelWidth, borderStyle: "single", borderColor: "gray", marginRight: isLast ? 0 : 1 },
             React.createElement(Text, { bold: true }, m.name),
-            lines.map((line, i) => (React.createElement(Text, { key: i, wrap: "truncate" }, line || " "))),
-            totalLines === 0 && (React.createElement(Text, { dimColor: true }, "Waiting...")),
+            displayLines.map((line, i) => {
+                if (isEmpty && i === 0) {
+                    return (React.createElement(Text, { key: i, dimColor: true }, m.isStreaming ? "Waiting..." : "No output"));
+                }
+                return (React.createElement(Text, { key: i, wrap: "truncate" }, line || " "));
+            }),
             React.createElement(Text, { dimColor: true },
-                totalLines,
+                isEmpty ? 0 : totalLines,
                 " lines \u00B7 ",
+                formatTokens(m.usage.input + m.usage.output),
+                "/",
+                formatTokens(m.contextLimit),
+                " \u00B7 ",
                 m.isStreaming ? "streaming..." : "done")));
     })));
 };

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

@@ -0,0 +1,17 @@
+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;
+    rounds: RoundSummary[];
+    scrollOffset?: number;
+}
+export declare const DeliberationView: React.FC<Props>;
+export {};