multiarena 0.1.1 → 0.1.3

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,28 @@ 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 [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 +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);
@@ -95,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(() => {
@@ -119,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(() => {
@@ -127,29 +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);
-            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 +331,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 +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;
@@ -322,7 +674,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 +717,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, 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,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 {};

package/dist/ui/components/DeliberationView.js

@@ -0,0 +1,81 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { roundLabel } from "../../core/deliberation.js";
+const ROLE_COLORS = {
+    draft: "cyan",
+    revise: "yellow",
+    polish: "green",
+    review: "magenta",
+};
+function spinner(frame) {
+    const chars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    return chars[frame % chars.length] ?? ".";
+}
+export const DeliberationView = ({ progress, document, rounds, scrollOffset = 0 }) => {
+    const role = progress.role ?? "draft";
+    const roleColor = ROLE_COLORS[role];
+    const isActive = progress.type !== "done" && progress.type !== "error";
+    const isDone = progress.type === "done";
+    const spin = spinner(Date.now() % 10);
+    const allLines = document ? document.split("\n") : [];
+    const lines = allLines.slice(scrollOffset);
+    // Count total changes across all rounds
+    const totalChanges = rounds.reduce((sum, r) => sum + (r.changeCount ?? 0), 0);
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1, padding: 1 },
+        React.createElement(Box, { flexDirection: "row" },
+            React.createElement(Text, { bold: true }, isDone
+                ? `审议完成 · ${rounds.length} 轮 · ${totalChanges} 处修改`
+                : isActive
+                    ? `第 ${progress.round}/${progress.totalRounds} 轮：${progress.modelName ?? "?"} (${roundLabel(role)})`
+                    : "审议出错")),
+        React.createElement(Box, { flexDirection: "row", marginY: 1 }, rounds.map((r, i) => {
+            const isPast = isDone || r.round < progress.round;
+            const isCurrent = !isDone && r.round === progress.round;
+            return (React.createElement(Box, { key: i, marginRight: 2, flexDirection: "column" },
+                React.createElement(Box, { flexDirection: "row" },
+                    React.createElement(Text, { color: isPast ? "green" : isCurrent ? roleColor : "gray" },
+                        isPast ? "✓" : isCurrent ? spin : "○",
+                        " ",
+                        roundLabel(r.role))),
+                React.createElement(Box, { flexDirection: "row" },
+                    React.createElement(Text, { dimColor: true }, r.modelName))));
+        })),
+        isActive && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: roleColor },
+                roundLabel(role),
+                "\u4E2D \u2014 ",
+                progress.modelName,
+                " \u2014 \u6B63\u5728\u751F\u6210\u2026"))),
+        progress.type === "error" && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "red" },
+                "\u9519\u8BEF\uFF1A",
+                progress.error))),
+        isDone && rounds.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { bold: true }, "\u2500\u2500 \u5BA1\u8BAE\u8FC7\u7A0B \u2500\u2500"),
+            rounds.map((r) => {
+                const hasChanges = (r.changeCount ?? 0) > 0;
+                return (React.createElement(Box, { key: r.round, flexDirection: "column", marginTop: 1 },
+                    React.createElement(Text, null,
+                        React.createElement(Text, { color: "cyan" },
+                            r.round,
+                            "."),
+                        " ",
+                        React.createElement(Text, { bold: true }, r.modelName),
+                        React.createElement(Text, { color: "gray" },
+                            "\uFF08",
+                            roundLabel(r.role),
+                            "\uFF09"),
+                        hasChanges && (React.createElement(Text, { color: "yellow" },
+                            " \u2014 ",
+                            r.changeCount,
+                            " \u5904\u4FEE\u6539")),
+                        !hasChanges && r.role !== "draft" && (React.createElement(Text, { color: "gray" }, " \u2014 \u65E0\u4FEE\u6539"))),
+                    r.changeSamples && r.changeSamples.length > 0 && (React.createElement(Box, { flexDirection: "column", marginLeft: 2 }, r.changeSamples.map((s, j) => (React.createElement(Text, { key: j, dimColor: true }, `  ${s}`)))))));
+            }),
+            React.createElement(Text, null, " "))),
+        isDone && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "\u2500\u2500 \u6700\u7EC8\u6587\u6863 \u2500\u2500"))),
+        React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+            lines.length === 0 && isActive && (React.createElement(Text, { dimColor: true }, "\u7B49\u5F85\u8F93\u51FA\u2026")),
+            lines.map((line, i) => (React.createElement(Text, { key: i }, line))))));
+};

package/dist/ui/components/InputBar.js

@@ -10,7 +10,7 @@ export const InputBar = ({ models, activeModelName, prefix, value, onChange, onS
                 isTargeted && !m.muted && React.createElement(Text, { color: "yellow" }, " \u25CF"),
                 m.muted && React.createElement(Text, { color: "gray" }, " [muted]")));
         }),
-        React.createElement(Text, { dimColor: true }, " \u2014 Tab:switch d:compare m:mute r:reset q:quit \u2191\u2193:scroll/history Esc:cancel")),
+        React.createElement(Text, { dimColor: true }, " \u2014 Shift+Tab:/team Tab:model d:compare m:mute r:reset q:quit \u2191\u2193:scroll/history Esc:cancel")),
     React.createElement(Box, { height: 1, flexDirection: "row" },
         React.createElement(Box, { marginRight: 1 },
             React.createElement(Text, { color: "green" },