multiarena 0.1.0 → 0.1.1

package/dist/config/loader.js

@@ -48,8 +48,8 @@ export function validateConfig(config) {
 }
 export function loadConfig() {
     const candidates = [
-        path.join(process.cwd(), ".arenarc"),
-        path.join(os.homedir(), ".arenarc"),
+        path.join(process.cwd(), ".multiarenarc"),
+        path.join(os.homedir(), ".multiarenarc"),
     ];
     let resolved = {};
     for (const p of candidates) {

package/dist/config/types.d.ts

@@ -1,5 +1,5 @@
 export interface ModelConfig {
-    provider: "anthropic" | "openai" | "google" | "ollama";
+    provider: "anthropic" | "openai" | "google" | "ollama" | "deepseek" | "minimax";
     model: string;
     api_key?: string;
     endpoint?: string;

package/dist/core/session.d.ts

@@ -28,6 +28,7 @@ export declare class Session {
     addAssistantMessage(modelName: string, content: string): void;
     /** Append tool result to a model's history */
     addToolResult(modelName: string, toolCallId: string, result: string): void;
+    setTarget(target: TargetMode): void;
     /** Cycle Tab through targets: broadcast → model1 → model2 → ... → broadcast */
     cycleTarget(): TargetMode;
     jumpToModel(modelName: string): void;
@@ -38,3 +39,4 @@ export declare class Session {
     toJSON(): SessionSnapshot;
     private findModel;
 }
+export declare function contextLimitForModel(provider: string, explicit?: number): number;

package/dist/core/session.js

@@ -23,7 +23,7 @@ export class Session {
                     buffer: "",
                     isStreaming: false,
                     usage: { input: 0, output: 0 },
-                    contextLimit: contextLimitForModel(mc?.model ?? "", mc?.context_limit),
+                    contextLimit: contextLimitForModel(mc?.provider ?? "", mc?.context_limit),
                 };
             });
             this.state = {
@@ -71,6 +71,9 @@ export class Session {
             m.messages.push({ role: "tool", content: result, tool_call_id: toolCallId });
         }
     }
+    setTarget(target) {
+        this.state.targetMode = target;
+    }
     /** Cycle Tab through targets: broadcast → model1 → model2 → ... → broadcast */
     cycleTarget() {
         const current = this.state.targetMode;
@@ -138,18 +141,17 @@ export class Session {
         return this.state.models.find((m) => m.name === name);
     }
 }
-function contextLimitForModel(model, explicit) {
+export function contextLimitForModel(provider, explicit) {
     if (explicit && explicit > 0)
         return explicit;
-    if (model.includes("claude"))
-        return 200000;
-    if (model.includes("gpt-4"))
-        return 128000;
-    if (model.includes("gpt-3.5"))
-        return 16384;
-    if (model.includes("gemini"))
-        return 1048576;
-    if (model.includes("deepseek"))
-        return 128000;
-    return 128000;
+    // Sensible defaults per provider. Users can override with context_limit in config.
+    switch (provider) {
+        case "anthropic": return 200000;
+        case "openai": return 128000;
+        case "google": return 1048576;
+        case "deepseek": return 1048576;
+        case "minimax": return 1048576;
+        case "ollama": return 128000;
+        default: return 128000;
+    }
 }

package/dist/core/turn.d.ts

@@ -29,3 +29,5 @@ export interface TurnResult {
  * have been pushed into ctx.messages — the caller only needs to persist.
  */
 export declare function runTurn(ctx: TurnContext): AsyncGenerator<StreamEvent>;
+/** Turn a tool name + args into a human-readable action label. */
+export declare function friendlyToolLabel(name: string, args: Record<string, unknown>): string;

package/dist/core/turn.js

@@ -65,15 +65,19 @@ export async function* runTurn(ctx) {
             });
             // Execute tools and feed results back
             for (const tc of pendingToolCalls) {
-                const toolLabel = `\n[Tool: ${tc.name}]\n`;
-                allText.push(toolLabel);
-                yield { type: "text", content: toolLabel };
+                if (!tc.name || tc.name.trim() === "") {
+                    const errMsg = "Tool call with empty name — skipped";
+                    ctx.messages.push({ role: "tool", content: errMsg, tool_call_id: tc.id });
+                    allText.push(errMsg + "\n");
+                    yield { type: "text", content: errMsg + "\n" };
+                    continue;
+                }
                 let args;
                 try {
-                    args = JSON.parse(tc.arguments);
+                    args = JSON.parse(tc.arguments || "{}");
                 }
                 catch {
-                    const errMsg = `Failed to parse tool arguments: ${tc.arguments}`;
+                    const errMsg = `Failed to parse tool arguments: ${tc.arguments || "(empty)"}`;
                     ctx.messages.push({ role: "tool", content: errMsg, tool_call_id: tc.id });
                     allText.push(errMsg + "\n");
                     yield { type: "text", content: errMsg + "\n" };
@@ -87,6 +91,10 @@ export async function* runTurn(ctx) {
                     yield { type: "text", content: errMsg + "\n" };
                     continue;
                 }
+                // Friendly label — shows what the model is doing in plain language
+                const label = friendlyToolLabel(tc.name, args);
+                allText.push(label);
+                yield { type: "text", content: label };
                 let result;
                 try {
                     result = await ctx.registry.execute(tc.name, args, ctx.worktreePath);
@@ -110,3 +118,22 @@ export async function* runTurn(ctx) {
         provider?.abort();
     }
 }
+/** Turn a tool name + args into a human-readable action label. */
+export function friendlyToolLabel(name, args) {
+    switch (name) {
+        case "bash":
+            return `\n$ ${args.command ?? "(no command)"}\n`;
+        case "read_file":
+            return `\nReading ${args.file_path ?? "(?)"}\n`;
+        case "write_file":
+            return `\nWriting ${args.file_path ?? "(?)"}\n`;
+        case "edit_file":
+            return `\nEditing ${args.file_path ?? "(?)"}\n`;
+        case "glob":
+            return `\nFinding ${args.pattern ?? "(?)"}\n`;
+        case "grep":
+            return `\nSearching "${args.pattern ?? "(?)"}"\n`;
+        default:
+            return `\nRunning ${name}...\n`;
+    }
+}

package/dist/index.js

@@ -17,10 +17,10 @@ const PKG_VERSION = (() => {
         return "0.1.0";
     }
 })();
-const HELP = `Arena — Multi-Model AI Coding Assistant
+const HELP = `multiarena — Multi-Model AI Coding Assistant
 
 Usage:
-  arena [options]
+  multiarena [options]
 
 Options:
   --new              Start a new session (default)
@@ -56,7 +56,7 @@ if (showHelp) {
     process.exit(0);
 }
 if (showVersion) {
-    console.log(`arena v${PKG_VERSION}`);
+    console.log(`multiarena v${PKG_VERSION}`);
     process.exit(0);
 }
 if (listOnly) {

package/dist/isolation/worktree.d.ts

@@ -2,7 +2,7 @@ export declare class WorktreeManager {
     private git;
     private worktrees;
     constructor(repoPath: string);
-    /** Clean up orphaned arena branches and worktree directories from prior crashes. */
+    /** Clean up orphaned multiarena branches and worktree directories from prior crashes. */
     sweepOrphans(): Promise<number>;
     setup(taskId: string, modelNames: string[]): Promise<Map<string, string>>;
     getWorktreePath(modelName: string): string | undefined;

package/dist/isolation/worktree.js

@@ -8,7 +8,7 @@ export class WorktreeManager {
     constructor(repoPath) {
         this.git = simpleGit(repoPath);
     }
-    /** Clean up orphaned arena branches and worktree directories from prior crashes. */
+    /** Clean up orphaned multiarena branches and worktree directories from prior crashes. */
     async sweepOrphans() {
         let cleaned = 0;
         // Parse registered worktrees from `git worktree list --porcelain`
@@ -23,7 +23,7 @@ export class WorktreeManager {
                     registeredPaths.add(currentPath);
                 }
                 else if (line.startsWith("branch ") && currentPath) {
-                    // branch line looks like "branch refs/heads/arena/..."
+                    // branch line looks like "branch refs/heads/multiarena/..."
                     const ref = line.slice("branch ".length);
                     const branchName = ref.replace("refs/heads/", "");
                     registeredBranches.add(branchName);
@@ -33,10 +33,10 @@ export class WorktreeManager {
         catch {
             return cleaned;
         }
-        // Remove orphaned arena branches (branch exists but no worktree)
+        // Remove orphaned multiarena branches (branch exists but no worktree)
         const branches = await this.git.branchLocal();
         for (const branch of branches.all) {
-            if (!branch.startsWith("arena/"))
+            if (!branch.startsWith("multiarena/"))
                 continue;
             if (!registeredBranches.has(branch)) {
                 await this.git.deleteLocalBranch(branch, true).catch(() => { });
@@ -44,7 +44,7 @@ export class WorktreeManager {
             }
         }
         // Remove orphaned worktree directories (dir exists but not registered)
-        const arenaDir = path.join(os.tmpdir(), "arena-worktrees");
+        const arenaDir = path.join(os.tmpdir(), "multiarena-worktrees");
         if (fs.existsSync(arenaDir)) {
             let entries = [];
             try {
@@ -67,10 +67,10 @@ export class WorktreeManager {
         return cleaned;
     }
     async setup(taskId, modelNames) {
-        const baseName = `arena/${taskId}`;
+        const baseName = `multiarena/${taskId}`;
         for (const name of modelNames) {
             const branchName = `${baseName}-${name}`;
-            const worktreePath = path.join(os.tmpdir(), "arena-worktrees", `${taskId}-${name}`);
+            const worktreePath = path.join(os.tmpdir(), "multiarena-worktrees", `${taskId}-${name}`);
             // Ensure the parent directory exists; git worktree add creates the leaf directory
             fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
             // Remove leftover directory from a previous run that wasn't cleaned up
@@ -109,7 +109,7 @@ export class WorktreeManager {
                 fs.rmSync(wtPath, { recursive: true, force: true });
             }
             await this.git
-                .deleteLocalBranch(`arena/${taskId}-${modelName}`, true)
+                .deleteLocalBranch(`multiarena/${taskId}-${modelName}`, true)
                 .catch(() => { });
             this.worktrees.delete(modelName);
         }

package/dist/persistence/session.js

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-const SESSIONS_DIR = path.join(os.homedir(), ".arena", "sessions");
+const SESSIONS_DIR = path.join(os.homedir(), ".multiarena", "sessions");
 export function saveSession(session) {
     fs.mkdirSync(SESSIONS_DIR, { recursive: true });
     const filePath = path.join(SESSIONS_DIR, `${session.id}.json`);

package/dist/provider/adapters/openai.js

@@ -20,11 +20,12 @@ export class OpenAIProvider {
                 stream: true,
                 stream_options: { include_usage: true },
             }, { signal: abortController.signal });
-            // Track pending tool calls across stream chunks
             const pendingToolCalls = new Map();
             let doneYielded = false;
+            // Stateful think-tag filter for reasoning models (e.g. MiniMax, DeepSeek-R1)
+            let inThink = false;
+            let thinkBuf = "";
             for await (const chunk of stream) {
-                // Token usage chunk (when stream_options.include_usage is true)
                 if (chunk.usage) {
                     inputTokens = chunk.usage.prompt_tokens;
                     outputTokens = chunk.usage.completion_tokens;
@@ -34,7 +35,6 @@ export class OpenAIProvider {
                 if (!choice)
                     continue;
                 const delta = choice.delta;
-                // Accumulate tool call deltas
                 if (delta.tool_calls) {
                     for (const tc of delta.tool_calls) {
                         const idx = tc.index;
@@ -52,11 +52,47 @@ export class OpenAIProvider {
                         pendingToolCalls.set(idx, existing);
                     }
                 }
-                // Text delta
+                // Text delta with think-tag filtering (for reasoning models)
                 if (delta.content) {
-                    yield { type: "text", content: delta.content };
+                    let text = delta.content;
+                    if (inThink) {
+                        thinkBuf += text;
+                        const endIdx = thinkBuf.indexOf("</think>");
+                        if (endIdx !== -1) {
+                            inThink = false;
+                            text = thinkBuf.slice(endIdx + "</think>".length);
+                            thinkBuf = "";
+                            if (!text)
+                                continue;
+                        }
+                        else {
+                            continue;
+                        }
+                    }
+                    // Check for <think> opening tag
+                    const startIdx = text.indexOf("<think>");
+                    if (startIdx !== -1) {
+                        const before = text.slice(0, startIdx);
+                        const rest = text.slice(startIdx + "<think>".length);
+                        const endIdx = rest.indexOf("</think>");
+                        if (endIdx !== -1) {
+                            // Complete think block in this chunk
+                            const after = rest.slice(endIdx + "</think>".length);
+                            text = before + after;
+                            if (!text)
+                                continue;
+                        }
+                        else {
+                            // Think block spans chunks
+                            if (before)
+                                yield { type: "text", content: before };
+                            inThink = true;
+                            thinkBuf = rest;
+                            continue;
+                        }
+                    }
+                    yield { type: "text", content: text };
                 }
-                // On finish_reason === "tool_calls", emit all pending tool_calls
                 if (choice.finish_reason === "tool_calls") {
                     for (const [, tc] of pendingToolCalls) {
                         yield {
@@ -73,8 +109,18 @@ export class OpenAIProvider {
                     };
                     doneYielded = true;
                 }
-                // handle stop
                 if (choice.finish_reason === "stop") {
+                    // Flush any remaining think buffer
+                    if (inThink && thinkBuf) {
+                        const endIdx = thinkBuf.indexOf("</think>");
+                        if (endIdx !== -1) {
+                            const after = thinkBuf.slice(endIdx + "</think>".length);
+                            if (after)
+                                yield { type: "text", content: after };
+                        }
+                        inThink = false;
+                        thinkBuf = "";
+                    }
                     yield {
                         type: "done",
                         usage: { input: inputTokens, output: outputTokens },
@@ -82,7 +128,6 @@ export class OpenAIProvider {
                     doneYielded = true;
                 }
             }
-            // Ensure done is always yielded (e.g. when stream ends on usage chunk)
             if (!doneYielded) {
                 yield {
                     type: "done",

package/dist/provider/provider.js

@@ -15,6 +15,10 @@ export function createProvider(config) {
             const baseURL = config.endpoint?.replace(/\/v1\/?$/, "") ?? "http://localhost:11434";
             return new OllamaProvider(baseURL);
         }
+        case "deepseek":
+            return new OpenAIProvider(key, config.endpoint ?? "https://api.deepseek.com/v1");
+        case "minimax":
+            return new OpenAIProvider(key, config.endpoint ?? "https://api.minimax.chat/v1");
         default:
             throw new Error(`Unknown provider: ${config.provider}`);
     }

package/dist/tools/builtin/bash.js

@@ -13,6 +13,9 @@ export const bashTool = {
     },
     async execute(args, worktreePath) {
         const command = args.command;
+        if (!command || command.trim() === "") {
+            return "Error: no command provided";
+        }
         const dangerous = ["rm -rf /", "sudo ", "mkfs.", "dd if=", "> /dev/sda"];
         for (const d of dangerous) {
             if (command.includes(d))
@@ -24,11 +27,13 @@ export const bashTool = {
                 encoding: "utf-8",
                 timeout: 30000,
                 maxBuffer: 1024 * 1024,
+                shell: "bash",
             });
             return output || "(no output)";
         }
         catch (err) {
-            return `Command failed (exit ${err.status}): ${err.stderr ?? err.message}`;
+            const detail = (err.stderr || err.message || "unknown error").trim();
+            return `Command failed (exit ${err.status ?? "?"}): ${detail}\n[cmd] ${command}`;
         }
     },
 };

package/dist/ui/app.js

@@ -1,16 +1,17 @@
 import React, { useState, useCallback, useEffect, useRef } from "react";
 import { Box, Text, useInput, useApp } from "ink";
-import { StatusBar } from "./components/StatusBar.js";
 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.";
+function makeSystemPrompt(modelName, provider) {
+    return `You are a helpful AI coding assistant. You are the "${modelName}" model (provider: ${provider}). Be concise.`;
+}
 // App-level (module-scoped) tool registry and permission manager.
 // Created once and shared across all submissions.
 const toolRegistry = createDefaultRegistry();
@@ -34,7 +35,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,6 +51,7 @@ export const App = ({ sessionId: initialSessionId }) => {
     const [scrollOffsets, setScrollOffsets] = useState({});
     const [modelStates, setModelStates] = useState(() => session.models);
     const [comparisonModel, setComparisonModel] = useState(null);
+    const comparisonFromBroadcastRef = useRef(false);
     const activeScrollModel = session.targetMode.type === "directed" ? session.targetMode.modelName : null;
     const adjustScroll = useCallback((delta) => {
         const modelName = activeScrollModel;
@@ -132,13 +134,19 @@ export const App = ({ sessionId: initialSessionId }) => {
         if (key.tab) {
             session.cycleTarget();
             setComparisonModel(null);
+            comparisonFromBroadcastRef.current = false;
             setModelStates([...session.models]);
             return;
         }
-        // Escape dismisses comparison mode
+        // Escape dismisses comparison mode (restore broadcast if entered from there)
         if (key.escape) {
             if (comparisonModel) {
+                if (comparisonFromBroadcastRef.current) {
+                    session.setTarget({ type: "broadcast" });
+                    comparisonFromBroadcastRef.current = false;
+                }
                 setComparisonModel(null);
+                setModelStates([...session.models]);
                 shortcutHandledRef.current = true;
                 return;
             }
@@ -186,14 +194,28 @@ export const App = ({ sessionId: initialSessionId }) => {
         // '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);
             }
             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) {
+                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) {
@@ -201,6 +223,7 @@ export const App = ({ sessionId: initialSessionId }) => {
                     }
                 }
             }
+            setModelStates([...session.models]);
             shortcutHandledRef.current = true;
             return;
         }
@@ -210,6 +233,7 @@ export const App = ({ sessionId: initialSessionId }) => {
                 session.toggleMute(session.targetMode.modelName);
                 setModelStates([...session.models]);
                 setComparisonModel(null);
+                comparisonFromBroadcastRef.current = false;
             }
             shortcutHandledRef.current = true;
             return;
@@ -272,7 +296,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,
@@ -300,10 +324,6 @@ export const App = ({ sessionId: initialSessionId }) => {
         saveCurrentSession();
     }, [session, config, sessionId, saveCurrentSession]);
     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 +336,37 @@ 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(OutputArea, { models: modelStates, targetMode: session.targetMode, scrollOffsets: scrollOffsets, comparisonModel: comparisonModel, terminalWidth: terminalWidth }),
         React.createElement(Text, null, "─".repeat(terminalWidth)),
-        React.createElement(InputBar, { prefix: targetPrefix, value: input, onChange: handleInputChange, onSubmit: handleSubmit })));
+        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 "./StatusBar.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/InputBar.d.ts

@@ -1,5 +1,8 @@
 import React from "react";
+import type { ModelState } from "../../core/types.js";
 interface Props {
+    models: ModelState[];
+    activeModelName: string | null;
     prefix: string;
     value: string;
     onChange: (value: string) => void;

package/dist/ui/components/InputBar.js

@@ -1,11 +1,21 @@
 import React from "react";
 import { Box, Text } from "ink";
 import TextInput from "ink-text-input";
-export const InputBar = ({ prefix, value, onChange, onSubmit }) => (React.createElement(Box, { height: 1, flexDirection: "row" },
-    React.createElement(Box, { marginRight: 1 },
-        React.createElement(Text, { color: "green" },
-            "[",
-            prefix,
-            "]")),
-    React.createElement(Text, null, "> "),
-    React.createElement(TextInput, { value: value, onChange: onChange, onSubmit: onSubmit })));
+export const InputBar = ({ models, activeModelName, prefix, value, onChange, onSubmit, }) => (React.createElement(Box, { flexDirection: "column" },
+    React.createElement(Box, { height: 1, flexDirection: "row" },
+        models.map((m) => {
+            const isTargeted = activeModelName === null || activeModelName === m.name;
+            return (React.createElement(Box, { key: m.name, marginRight: 1 },
+                React.createElement(Text, { color: isTargeted && !m.muted ? "green" : "gray", bold: isTargeted }, m.name),
+                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(Box, { height: 1, flexDirection: "row" },
+        React.createElement(Box, { marginRight: 1 },
+            React.createElement(Text, { color: "green" },
+                "[",
+                prefix,
+                "]")),
+        React.createElement(Text, null, "> "),
+        React.createElement(TextInput, { value: value, onChange: onChange, onSubmit: onSubmit }))));

package/dist/ui/components/ModelDetail.js

@@ -1,13 +1,25 @@
 import React from "react";
 import { Box, Text } from "ink";
+import { formatTokens } from "./StatusBar.js";
 export const ModelDetail = ({ model, scrollOffset }) => {
-    const allLines = model.buffer.split("\n");
+    const allLines = model.buffer ? model.buffer.split("\n") : [];
     const visibleLines = allLines.slice(scrollOffset);
-    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
-        visibleLines.length === 0 && !model.isStreaming && (React.createElement(Text, { dimColor: true }, "No output yet")),
+    const totalTokens = model.usage.input + model.usage.output;
+    const isEmpty = allLines.length === 0 || (allLines.length === 1 && allLines[0].trim() === "");
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1, borderStyle: "single", borderColor: "gray" },
+        React.createElement(Text, { bold: true }, model.name),
+        isEmpty && !model.isStreaming && (React.createElement(Text, { dimColor: true }, "No output")),
         visibleLines.map((line, i) => {
             const isError = /^\[?(?:Error|error)[:\]]/.test(line);
             return (React.createElement(Text, { key: scrollOffset + i, color: isError ? "red" : undefined }, line || " "));
         }),
-        model.isStreaming && React.createElement(Text, { color: "gray" }, "\u258B")));
+        model.isStreaming && React.createElement(Text, { color: "gray" }, "\u258B"),
+        React.createElement(Text, { dimColor: true },
+            formatTokens(totalTokens),
+            "/",
+            formatTokens(model.contextLimit),
+            " \u00B7 ",
+            isEmpty ? 0 : allLines.length,
+            " lines \u00B7 ",
+            model.isStreaming ? "streaming..." : "done")));
 };

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

@@ -10,6 +10,7 @@ interface Props {
     };
     scrollOffsets: Record<string, number>;
     comparisonModel?: string | null;
+    terminalWidth: number;
 }
 export declare const OutputArea: React.FC<Props>;
 export {};

package/dist/ui/components/OutputArea.js

@@ -2,9 +2,9 @@ import React from "react";
 import { Box, Text } from "ink";
 import { BroadcastSummary } from "./BroadcastSummary.js";
 import { ModelDetail } from "./ModelDetail.js";
-export const OutputArea = ({ models, targetMode, scrollOffsets, comparisonModel, }) => {
+export const OutputArea = ({ models, targetMode, scrollOffsets, comparisonModel, terminalWidth, }) => {
     if (targetMode.type === "broadcast") {
-        return React.createElement(BroadcastSummary, { models: models });
+        return React.createElement(BroadcastSummary, { models: models, terminalWidth: terminalWidth });
     }
     const activeModel = models.find((m) => m.name === targetMode.modelName);
     if (!activeModel) {
@@ -19,10 +19,8 @@ export const OutputArea = ({ models, targetMode, scrollOffsets, comparisonModel,
         }
         return (React.createElement(Box, { flexDirection: "row", flexGrow: 1 },
             React.createElement(Box, { flexDirection: "column", flexGrow: 1, marginRight: 1 },
-                React.createElement(Text, { bold: true }, activeModel.name),
                 React.createElement(ModelDetail, { model: activeModel, scrollOffset: scrollOffsets[activeModel.name] ?? 0 })),
             React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
-                React.createElement(Text, { bold: true }, compModel.name),
                 React.createElement(ModelDetail, { model: compModel, scrollOffset: scrollOffsets[compModel.name] ?? 0 }))));
     }
     return React.createElement(ModelDetail, { model: activeModel, scrollOffset: scrollOffsets[activeModel.name] ?? 0 });

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

@@ -5,5 +5,6 @@ interface Props {
     activeModelName: string | null;
     contextUsages: Record<string, number>;
 }
+export declare function formatTokens(n: number): string;
 export declare const StatusBar: React.FC<Props>;
 export {};

package/dist/ui/components/StatusBar.js

@@ -5,7 +5,7 @@ function renderBar(ratio) {
     const filled = Math.round(ratio * blocks);
     return "█".repeat(filled) + "░".repeat(blocks - filled);
 }
-function formatTokens(n) {
+export function formatTokens(n) {
     if (n >= 1_000_000)
         return `${(n / 1_000_000).toFixed(1)}M`;
     if (n >= 1_000)
@@ -21,12 +21,11 @@ function barColor(ratio) {
 }
 export const StatusBar = ({ models, activeModelName, contextUsages }) => (React.createElement(Box, { flexDirection: "column" },
     React.createElement(Box, { height: 1, flexDirection: "row" }, models.map((m) => {
-        const isActive = activeModelName === m.name;
-        const hasNew = m.buffer.length > 0 && !isActive;
-        const color = isActive ? "green" : "white";
+        const isTargeted = activeModelName === null || activeModelName === m.name;
+        const color = isTargeted ? "green" : "white";
         return (React.createElement(Box, { key: m.name, marginRight: 1 },
-            React.createElement(Text, { color: color, bold: isActive }, m.name),
-            hasNew && React.createElement(Text, { color: "yellow" }, " \u25CF"),
+            React.createElement(Text, { color: color, bold: isTargeted }, m.name),
+            isTargeted && !m.muted && React.createElement(Text, { color: "yellow" }, " \u25CF"),
             m.muted && React.createElement(Text, { color: "gray" }, " [muted]")));
     })),
     React.createElement(Box, { height: 1, flexDirection: "row" }, models.map((m) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiarena",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Terminal-native multi-model AI coding assistant — chat with multiple LLMs side by side",
   "type": "module",
   "license": "MIT",