@parallel-cli/parallel 0.3.3

package/dist/index.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { render } from 'ink';
+import { App } from './ui/App.js';
+import { Controller } from './controller.js';
+import { loadConfig, setConfigHome } from './config.js';
+import { setLang } from './i18n.js';
+const argv = process.argv.slice(2);
+function takeFlagValue(flag) {
+    const i = argv.indexOf(flag);
+    if (i === -1)
+        return undefined;
+    const value = argv[i + 1];
+    argv.splice(i, value && !value.startsWith('-') ? 2 : 1);
+    return value && !value.startsWith('-') ? value : undefined;
+}
+const firstRun = argv.includes('--first-run');
+if (firstRun)
+    argv.splice(argv.indexOf('--first-run'), 1);
+const headless = argv.includes('--headless');
+if (headless)
+    argv.splice(argv.indexOf('--headless'), 1);
+const jsonOut = argv.includes('--json');
+if (jsonOut)
+    argv.splice(argv.indexOf('--json'), 1);
+const configHome = takeFlagValue('--config-home');
+if (argv.includes('--help') || argv.includes('-h')) {
+    console.log(`⚡ Parallel — real-time parallel coding agents.
+
+Usage:
+  parallel [folder]      Start the TUI (wizard only if first setup is incomplete)
+  prl [folder]           Short alias
+  parallel attach <agent> [--root <dir>]
+                          Open a DEDICATED terminal view on one agent of a
+                          running session (native scrollback + live steering)
+  parallel --first-run   Test the first-run wizard with a temporary config home
+  parallel --config-home <dir> [folder]
+                          Use <dir>/config.json instead of ~/.parallel/config.json
+  parallel --headless "task1" ["task2"…] [--json]
+                          No TUI: one agent per task in the current folder,
+                          auto-approved commands, summary (or JSON) on stdout — for CI
+
+Environment variables:
+  PARALLEL_API_KEY / DEEPSEEK_API_KEY   API key
+  PARALLEL_MODEL                        Default model (e.g. deepseek-chat)
+  PARALLEL_BASE_URL                     OpenAI-compatible endpoint
+
+Inside the TUI:
+  <task> + Enter         Launch agent N+1 — even while the others are working
+  @a1 <message>          Real-time instruction to an agent (@all for everyone)
+  /help                  All commands
+`);
+    process.exit(0);
+}
+if (firstRun) {
+    setConfigHome(fs.mkdtempSync(path.join(os.tmpdir(), 'parallel-first-run-')));
+}
+else if (configHome) {
+    setConfigHome(configHome);
+}
+// ---------- attach mode: dedicated terminal for ONE agent of a running session ----------
+if (argv[0] === 'attach') {
+    const root = path.resolve(takeFlagValue('--root') ?? process.cwd());
+    const agentRef = argv[1];
+    if (!agentRef) {
+        console.error('Usage: parallel attach <agent> [--root <dir>]');
+        process.exit(1);
+    }
+    if (!process.stdout.isTTY) {
+        console.error('Parallel requires an interactive terminal (TTY).');
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (config.language)
+        setLang(config.language);
+    const { socketPath } = await import('./server.js');
+    const sock = socketPath(root);
+    if (!fs.existsSync(sock)) {
+        console.error(`No running Parallel session found in ${root} (missing ${sock}).`);
+        console.error('Start `parallel` in that folder first, then re-run attach.');
+        process.exit(1);
+    }
+    const { AttachApp } = await import('./ui/AttachApp.js');
+    // NO alternate screen here: <Static> writes into the native scrollback,
+    // so the user can scroll this agent's history like any terminal output.
+    const attachApp = render(_jsx(AttachApp, { agentRef: agentRef, sock: sock }), { exitOnCtrlC: true });
+    await attachApp.waitUntilExit();
+    process.exit(0);
+}
+// ---------- headless mode (CI / scripts): no TUI, one agent per task ----------
+if (headless) {
+    const tasks = argv.filter((a) => !a.startsWith('-'));
+    if (tasks.length === 0) {
+        console.error('Usage: parallel --headless "task1" ["task2"…] [--json]');
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (config.language)
+        setLang(config.language);
+    const ctl = new Controller(config, process.cwd());
+    // No human in the loop: commands are auto-approved (like /approvals auto).
+    ctl.setSessionApprovalMode('auto');
+    const provider = ctl.sessionProvider();
+    if (!provider || !provider.apiKey) {
+        console.error('Headless mode needs a configured provider + API key. Run `parallel` interactively once, or set PARALLEL_API_KEY.');
+        process.exit(1);
+    }
+    // Agent questions cannot be asked: auto-answer with the recommended option.
+    ctl.on('update', () => {
+        for (const q of [...ctl.questions])
+            ctl.answerQuestion(q.id, q.options[q.recommended] ?? '', true);
+    });
+    for (const task of tasks) {
+        if (!ctl.spawnAgent(task)) {
+            console.error(`Failed to spawn an agent for: ${task}`);
+            process.exit(1);
+        }
+    }
+    const TERMINAL = ['done', 'error', 'stopped'];
+    let printed = 0;
+    await new Promise((resolve) => {
+        const iv = setInterval(() => {
+            if (!jsonOut) {
+                // Stream the live log to stdout (text mode only).
+                const logs = ctl.board.logs;
+                for (; printed < logs.length; printed++) {
+                    const l = logs[printed];
+                    const who = l.agentId ? (ctl.board.agents.get(l.agentId)?.name ?? l.agentId) : 'system';
+                    console.log(`[${who}] ${l.text}`);
+                }
+            }
+            const all = [...ctl.board.agents.values()];
+            if (all.length > 0 && all.every((a) => TERMINAL.includes(a.state))) {
+                clearInterval(iv);
+                resolve();
+            }
+        }, 400);
+    });
+    ctl.saveSession();
+    const agents = [...ctl.board.agents.values()].map((a) => ({
+        name: a.name,
+        alias: a.alias,
+        task: a.task,
+        state: a.state,
+        steps: a.steps,
+        tokensIn: a.tokensIn,
+        tokensOut: a.tokensOut,
+        cost: a.cost,
+        result: a.lastResult ?? null,
+    }));
+    const changedFiles = [...new Set(ctl.board.changes.map((c) => c.path))];
+    if (jsonOut) {
+        console.log(JSON.stringify({ agents, changedFiles }, null, 2));
+    }
+    else {
+        console.log('\n— Summary —');
+        for (const a of agents) {
+            console.log(`${a.state === 'done' ? '✅' : '❌'} ${a.name} [${a.state}] ${a.result ?? ''}`);
+        }
+        if (changedFiles.length > 0)
+            console.log(`Files changed: ${changedFiles.join(', ')}`);
+    }
+    process.exit(agents.every((a) => a.state === 'done') ? 0 : 1);
+}
+if (!process.stdout.isTTY) {
+    console.error('Parallel requires an interactive terminal (TTY).');
+    process.exit(1);
+}
+const config = loadConfig();
+if (config.language)
+    setLang(config.language);
+const initialFolder = argv.find((a) => !a.startsWith('-'));
+const useAltScreen = process.stdout.isTTY && process.env.PARALLEL_NO_ALT_SCREEN !== '1';
+const restoreTerminal = () => {
+    if (!useAltScreen)
+        return;
+    process.stdout.write('\x1b[?25h\x1b[?1049l');
+};
+if (useAltScreen) {
+    process.stdout.write('\x1b[?1049h\x1b[2J\x1b[3J\x1b[H');
+    process.once('exit', restoreTerminal);
+    process.once('SIGINT', () => {
+        restoreTerminal();
+        process.exit(130);
+    });
+    process.once('SIGTERM', () => {
+        restoreTerminal();
+        process.exit(143);
+    });
+}
+const app = render(_jsx(App, { config: config, initialFolder: initialFolder }), { exitOnCtrlC: true });
+await app.waitUntilExit();
+restoreTerminal();

package/dist/llm/client.js

@@ -0,0 +1,46 @@
+import OpenAI from 'openai';
+export class LLMClient {
+    client;
+    model;
+    constructor(apiKey, baseUrl, model) {
+        this.client = new OpenAI({ apiKey, baseURL: baseUrl });
+        this.model = model;
+    }
+    /**
+     * One chat completion round, with optional function-calling tools.
+     * Retries on transient errors (429/5xx) with exponential backoff.
+     */
+    async chat(messages, tools, signal) {
+        let lastErr;
+        for (let attempt = 0; attempt < 4; attempt++) {
+            try {
+                const res = await this.client.chat.completions.create({
+                    model: this.model,
+                    messages,
+                    tools: tools && tools.length > 0 ? tools : undefined,
+                    temperature: 0.2,
+                    max_tokens: 4096,
+                }, { signal });
+                const choice = res.choices[0];
+                if (!choice?.message)
+                    throw new Error('Empty response from model');
+                return {
+                    message: choice.message,
+                    tokensIn: res.usage?.prompt_tokens ?? 0,
+                    tokensOut: res.usage?.completion_tokens ?? 0,
+                };
+            }
+            catch (err) {
+                lastErr = err;
+                if (signal?.aborted)
+                    throw err;
+                const status = err?.status ?? err?.response?.status;
+                const retriable = status === 429 || (typeof status === 'number' && status >= 500) || err?.code === 'ECONNRESET';
+                if (!retriable || attempt === 3)
+                    throw err;
+                await new Promise((r) => setTimeout(r, 1500 * Math.pow(2, attempt)));
+            }
+        }
+        throw lastErr;
+    }
+}

package/dist/pricing.js

@@ -0,0 +1,76 @@
+/**
+ * Built-in pricing table (USD per 1M tokens) for well-known models — same
+ * approach as Roo Code: known models are priced out of the box, and the user
+ * can override or add prices per model in /settings (stored on the provider).
+ * Prices drift over time; overrides always win.
+ */
+const BUILTIN = {
+    // DeepSeek
+    'deepseek-v4-flash': { input: 0.27, output: 1.1 },
+    'deepseek-v4-pro': { input: 0.55, output: 2.19 },
+    'deepseek-chat': { input: 0.27, output: 1.1 },
+    'deepseek-reasoner': { input: 0.55, output: 2.19 },
+    // OpenAI
+    'gpt-4o': { input: 2.5, output: 10 },
+    'gpt-4o-mini': { input: 0.15, output: 0.6 },
+    'gpt-4.1': { input: 2, output: 8 },
+    'gpt-4.1-mini': { input: 0.4, output: 1.6 },
+    'gpt-4.1-nano': { input: 0.1, output: 0.4 },
+    'o3-mini': { input: 1.1, output: 4.4 },
+    'o4-mini': { input: 1.1, output: 4.4 },
+    // Anthropic
+    'claude-opus-4': { input: 15, output: 75 },
+    'claude-sonnet-4': { input: 3, output: 15 },
+    'claude-haiku-4': { input: 1, output: 5 },
+    'claude-3-5-haiku': { input: 0.8, output: 4 },
+    // Mistral
+    'mistral-large': { input: 2, output: 6 },
+    'codestral': { input: 0.3, output: 0.9 },
+    'devstral': { input: 0.1, output: 0.3 },
+    // Alibaba
+    'qwen2.5-coder': { input: 0.09, output: 0.09 },
+    'qwen-max': { input: 1.6, output: 6.4 },
+    // Local endpoints are free
+    'ollama': { input: 0, output: 0 },
+};
+/**
+ * Resolve the price of a model: provider override first, then built-in table
+ * (exact match, then prefix/substring for versioned names like
+ * "claude-sonnet-4-20250514" or "openai/gpt-4o-mini"). null = unknown.
+ */
+export function priceFor(provider, model) {
+    const override = provider?.prices?.[model];
+    if (override)
+        return override;
+    const m = model.toLowerCase();
+    // strip an optional "vendor/" prefix (OpenRouter-style ids)
+    const bare = m.includes('/') ? m.slice(m.lastIndexOf('/') + 1) : m;
+    if (BUILTIN[bare])
+        return BUILTIN[bare];
+    // longest prefix wins so "deepseek-chat" beats nothing else
+    let best = null;
+    for (const key of Object.keys(BUILTIN)) {
+        if ((bare.startsWith(key) || bare.includes(key)) && (!best || key.length > best.length))
+            best = key;
+    }
+    if (best)
+        return BUILTIN[best];
+    // local endpoints (ollama, llama.cpp, vLLM on localhost) → free
+    if (provider && /localhost|127\.0\.0\.1|0\.0\.0\.0/.test(provider.baseUrl))
+        return { input: 0, output: 0 };
+    return null;
+}
+/** Cost in USD of a token delta at a given price. */
+export function costOf(price, tokensIn, tokensOut) {
+    return (tokensIn * price.input + tokensOut * price.output) / 1_000_000;
+}
+/** "$0.0042", "$0.13", "$2.41" — compact, always meaningful. */
+export function fmtCost(usd) {
+    if (usd === 0)
+        return '$0.00';
+    if (usd < 0.01)
+        return `$${usd.toFixed(4)}`;
+    if (usd < 1)
+        return `$${usd.toFixed(3)}`;
+    return `$${usd.toFixed(2)}`;
+}

package/dist/server.js

@@ -0,0 +1,149 @@
+import net from 'node:net';
+import fs from 'node:fs';
+import path from 'node:path';
+export function socketPath(projectRoot) {
+    return path.join(projectRoot, '.parallel', 'session.sock');
+}
+/** Start the session server. Returns a stop function (closes socket + clients). */
+export function startSessionServer(ctl) {
+    const sock = socketPath(ctl.projectRoot);
+    try {
+        fs.mkdirSync(path.dirname(sock), { recursive: true });
+        // A previous run may have crashed without cleaning up: remove the stale socket.
+        if (fs.existsSync(sock))
+            fs.unlinkSync(sock);
+    }
+    catch {
+        return null;
+    }
+    const clients = new Set();
+    const infoFor = (ref) => ctl.board.getAgentByName(ref);
+    const send = (socket, msg) => {
+        try {
+            socket.write(JSON.stringify(msg) + '\n');
+        }
+        catch {
+            /* client gone — cleaned up on 'close' */
+        }
+    };
+    const pushTo = (c) => {
+        const info = infoFor(c.agent);
+        if (!info) {
+            send(c.socket, { type: 'state', info: null, others: [], logs: [] });
+            return;
+        }
+        const fresh = [];
+        for (const l of ctl.board.logs) {
+            if ((l.seq ?? 0) > c.lastSeq && (l.agentId === info.id || l.agentId === ''))
+                fresh.push(l);
+        }
+        if (fresh.length > 0)
+            c.lastSeq = fresh[fresh.length - 1].seq ?? c.lastSeq;
+        // Shared awareness, made VISIBLE: every attached terminal also sees what
+        // the other agents are doing right now (same data the agents receive).
+        const others = [...ctl.board.agents.values()]
+            .filter((a) => a.id !== info.id)
+            .map((a) => ({ name: a.name, alias: a.alias, state: a.state, task: a.task, currentAction: a.currentAction }));
+        // Pending interaction for THIS agent (if any): the attached terminal can
+        // answer it directly — no need to switch back to the hub.
+        const appr = ctl.approvals.find((a) => a.agentId === info.id);
+        const q = ctl.questions.find((x) => x.agentId === info.id);
+        const approval = appr ? { id: appr.id, agentName: appr.agentName, command: appr.command } : undefined;
+        const question = q
+            ? { id: q.id, agentName: q.agentName, question: q.question, options: q.options, recommended: q.recommended }
+            : undefined;
+        send(c.socket, { type: 'state', info, others, logs: fresh, approval, question });
+    };
+    // Throttled broadcast: at most one push per ~120ms, on blackboard updates.
+    let pending = false;
+    const onUpdate = () => {
+        if (pending || clients.size === 0)
+            return;
+        pending = true;
+        setTimeout(() => {
+            pending = false;
+            for (const c of clients)
+                pushTo(c);
+        }, 120).unref?.();
+    };
+    ctl.on('update', onUpdate);
+    const server = net.createServer((socket) => {
+        const client = { socket, agent: '', lastSeq: 0 };
+        let buffer = '';
+        socket.setEncoding('utf8');
+        socket.on('data', (chunk) => {
+            buffer += chunk;
+            let nl;
+            while ((nl = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, nl).trim();
+                buffer = buffer.slice(nl + 1);
+                if (!line)
+                    continue;
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (msg.type === 'hello' && typeof msg.agent === 'string') {
+                    client.agent = msg.agent;
+                    clients.add(client);
+                    pushTo(client); // immediate first snapshot (full backlog: lastSeq = 0)
+                }
+                else if (msg.type === 'input' && typeof msg.text === 'string' && client.agent) {
+                    const text = msg.text.trim();
+                    if (!text)
+                        continue;
+                    if (!ctl.sendToAgent(client.agent, text)) {
+                        send(socket, { type: 'state', info: infoFor(client.agent) ?? null, others: [], logs: [] });
+                    }
+                }
+                else if (msg.type === 'approve' && typeof msg.id === 'number') {
+                    // First answer wins (hub or any attached terminal) — the controller
+                    // ignores answers for ids that are no longer pending.
+                    ctl.answerApproval(msg.id, !!msg.approved, !!msg.always);
+                }
+                else if (msg.type === 'answer' && typeof msg.id === 'number' && typeof msg.text === 'string') {
+                    ctl.answerQuestion(msg.id, msg.text);
+                }
+                else if (msg.type === 'spawn' && typeof msg.text === 'string') {
+                    // Agent N+1 can be launched from ANY terminal of the session —
+                    // its own dedicated terminal then opens automatically.
+                    const task = msg.text.trim();
+                    if (task)
+                        ctl.spawnAgent(task);
+                }
+            }
+        });
+        const drop = () => {
+            clients.delete(client);
+        };
+        socket.on('close', drop);
+        socket.on('error', drop);
+    });
+    try {
+        server.listen(sock);
+    }
+    catch {
+        return null;
+    }
+    server.on('error', () => {
+        /* keep the TUI alive even if the server dies */
+    });
+    return () => {
+        ctl.off('update', onUpdate);
+        for (const c of clients) {
+            send(c.socket, { type: 'bye' });
+            c.socket.destroy();
+        }
+        clients.clear();
+        server.close();
+        try {
+            fs.unlinkSync(sock);
+        }
+        catch {
+            /* already gone */
+        }
+    };
+}

package/dist/skills.js

@@ -0,0 +1,132 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+function parseFrontMatter(raw) {
+    const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!m)
+        return { fields: {}, body: raw.trim() };
+    const fields = {};
+    for (const line of m[1].split(/\r?\n/)) {
+        const kv = line.match(/^([A-Za-z][\w-]*)\s*:\s*(.*)$/);
+        if (kv)
+            fields[kv[1].toLowerCase()] = kv[2].trim();
+    }
+    return { fields, body: m[2].trim() };
+}
+function globalDir(kind) {
+    return path.join(os.homedir(), '.parallel', kind);
+}
+function projectDir(projectRoot, kind) {
+    return path.join(projectRoot, '.parallel', kind);
+}
+function readMarkdownFiles(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const e of entries) {
+        if (!e.endsWith('.md'))
+            continue;
+        const file = path.join(dir, e);
+        try {
+            out.push({ file, raw: fs.readFileSync(file, 'utf8') });
+        }
+        catch {
+            /* unreadable file — skip */
+        }
+    }
+    return out;
+}
+/** Load skills: global first, then project (project overrides same-name global). */
+export function loadSkills(projectRoot) {
+    const byName = new Map();
+    for (const scope of ['global', 'project']) {
+        const dir = scope === 'global' ? globalDir('skills') : projectDir(projectRoot, 'skills');
+        for (const { file, raw } of readMarkdownFiles(dir)) {
+            const { fields, body } = parseFrontMatter(raw);
+            const name = (fields.name || path.basename(file, '.md')).toLowerCase();
+            if (!body)
+                continue;
+            byName.set(name, {
+                name,
+                description: fields.description || '',
+                body,
+                scope,
+                file,
+            });
+        }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Load specialists: same layering as skills; body is the role definition. */
+export function loadSpecialists(projectRoot) {
+    const byName = new Map();
+    for (const scope of ['global', 'project']) {
+        const dir = scope === 'global' ? globalDir('specialists') : projectDir(projectRoot, 'specialists');
+        for (const { file, raw } of readMarkdownFiles(dir)) {
+            const { fields, body } = parseFrontMatter(raw);
+            const name = (fields.name || path.basename(file, '.md')).toLowerCase();
+            if (!body)
+                continue;
+            byName.set(name, {
+                name,
+                description: fields.description || '',
+                model: fields.model || undefined,
+                role: body,
+                scope,
+                file,
+            });
+        }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function slug(name) {
+    return name.toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'unnamed';
+}
+/** Create a skill template file; returns its path. Throws if it already exists. */
+export function createSkillTemplate(name, description, scope, projectRoot) {
+    const dir = scope === 'global' ? globalDir('skills') : projectDir(projectRoot, 'skills');
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `${slug(name)}.md`);
+    if (fs.existsSync(file))
+        throw new Error(`already exists: ${file}`);
+    const content = `---
+name: ${slug(name)}
+description: ${description || 'What this skill is for (used to decide relevance)'}
+---
+
+Write here the instructions, conventions or checklists the agent must follow
+when this skill is loaded. Plain markdown.
+`;
+    fs.writeFileSync(file, content, 'utf8');
+    return file;
+}
+/** Create a specialist template file; returns its path. Throws if it already exists. */
+export function createSpecialistTemplate(name, description, scope, projectRoot, model) {
+    const dir = scope === 'global' ? globalDir('specialists') : projectDir(projectRoot, 'specialists');
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `${slug(name)}.md`);
+    if (fs.existsSync(file))
+        throw new Error(`already exists: ${file}`);
+    const content = `---
+name: ${slug(name)}
+description: ${description || 'What this specialist is good at'}
+${model ? `model: ${model}\n` : ''}---
+
+You are a ${name} specialist. Describe here the role, focus areas, constraints
+and working style of this specialist. This text is appended to the agent's
+system prompt.
+`;
+    fs.writeFileSync(file, content, 'utf8');
+    return file;
+}
+/** Compact catalog of skills for the agent system prompt (name — description). */
+export function skillsCatalog(skills) {
+    if (skills.length === 0)
+        return '';
+    return skills.map((s) => `- ${s.name}${s.description ? ` — ${s.description}` : ''}`).join('\n');
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/AgentPanel.js

@@ -0,0 +1,25 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Spinner } from './Spinner.js';
+import { fmtCost } from '../pricing.js';
+import { STATE_LABEL, stateLabel, elapsed, truncate } from './theme.js';
+import { Md } from './Md.js';
+import { t } from '../i18n.js';
+export const KIND_COLOR = {
+    tool: 'cyanBright',
+    llm: 'gray',
+    error: 'red',
+    note: 'magentaBright',
+    system: 'yellow',
+    info: 'white',
+};
+/** Thinking/commentary lines (kind 'llm') are dimmed + italic, à la Codex/Claude Code. */
+export const KIND_DIM = { llm: true };
+export function AgentPanel({ agent, logs, width, expanded = false, }) {
+    const st = STATE_LABEL[agent.state];
+    const busy = agent.state === 'thinking' || agent.state === 'working' || agent.state === 'listening';
+    return (_jsx(Box, { width: width, paddingX: 0, children: _jsxs(Box, { borderStyle: agent.state === 'listening' ? 'double' : 'round', borderColor: agent.state === 'error' ? 'red' : agent.state === 'listening' ? 'cyanBright' : agent.color, flexDirection: "column", paddingX: 1, flexGrow: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { children: [_jsxs(Text, { color: agent.color, bold: true, children: ["\u25C6 ", agent.name, agent.alias && agent.alias !== agent.name ? _jsxs(Text, { color: "gray", children: [" @", agent.alias] }) : null, ' '] }), _jsxs(Text, { backgroundColor: st.color, color: "black", bold: true, children: [' ', st.icon, " ", stateLabel(agent.state), ' '] }), busy && (_jsxs(Text, { children: [' ', _jsx(Spinner, { color: agent.color })] }))] }), _jsxs(Text, { color: "gray", wrap: "truncate-end", children: [agent.specialist ? `🎓${agent.specialist} · ` : '', truncate(agent.model, 18), " \u00B7 ", elapsed(agent.startedAt), " \u00B7 ", agent.steps, " st \u00B7", ' ', Math.round((agent.tokensIn + agent.tokensOut) / 1000), "k \u00B7", ' ', agent.ctxPct !== undefined ? (_jsxs(Text, { color: agent.ctxPct >= 90 ? 'redBright' : agent.ctxPct >= 70 ? 'yellowBright' : 'gray', children: ["\u25D4", agent.ctxPct, "% \u00B7", ' '] })) : null, _jsx(Text, { color: "greenBright", children: agent.cost === null ? '$—' : fmtCost(agent.cost) })] })] }), _jsxs(Text, { color: "gray", wrap: expanded ? 'wrap' : 'truncate-end', children: ["\u25E6 ", expanded ? agent.task : truncate(agent.task, 120)] }), agent.claims && agent.claims.length > 0 ? (_jsxs(Text, { color: "yellowBright", wrap: "truncate-end", children: ["\uD83D\uDEA9 ", agent.claims.join(' ')] })) : null, agent.currentAction ? (_jsxs(Text, { color: agent.color, wrap: "truncate-end", children: ["\u25B8 ", truncate(agent.currentAction, 120)] })) : null, agent.lastResult ? (_jsxs(Box, { borderStyle: "single", borderColor: "gray", flexDirection: "column", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "greenBright", bold: true, children: t('agent.summary') }), expanded || agent.state === 'done' ? (
+                        // A finished agent's summary is the deliverable: show it ENTIRELY,
+                        // wrapped and lightly formatted — never truncated.
+                        _jsx(Md, { text: agent.lastResult })) : (_jsx(Text, { color: "white", wrap: "truncate-end", children: truncate(agent.lastResult, 260) }))] })) : null, _jsx(Box, { flexDirection: "column", marginTop: 0, children: logs.map((l, i) => (_jsx(Text, { color: KIND_COLOR[l.kind] ?? 'white', italic: KIND_DIM[l.kind] ?? false, wrap: "truncate-end", children: truncate(l.text, expanded ? 220 : 140) }, i))) })] }) }));
+}