@multiclawcli/dashboard 0.3.2 → 0.5.0

package/dist/tui.js

@@ -0,0 +1,2076 @@
+// src/tui/index.ts
+import { render } from "ink";
+import { createElement } from "react";
+
+// src/tui/App.tsx
+import * as path2 from "path";
+import { describeResumePlan, isAbortError, Orchestrator } from "@multiclawcli/core";
+import { Box as Box5, Text as Text5, useApp, useInput, useWindowSize } from "ink";
+import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
+
+// src/tui/commands.ts
+var COMMANDS = [
+  { name: "agents", description: "List the configured team", availability: "always" },
+  {
+    name: "focus",
+    args: "<id>",
+    description: "Focus an agent by id",
+    availability: "always",
+    completes: "agent"
+  },
+  { name: "clear", description: "Clear the focused agent's log", availability: "always" },
+  {
+    name: "history",
+    description: "Browse finished turns",
+    availability: "always"
+  },
+  {
+    name: "verbose",
+    description: "Toggle tool detail in the stream",
+    availability: "always"
+  },
+  {
+    name: "retry",
+    args: "[id]",
+    description: "Re-run a failed agent (or all of them)",
+    availability: "idle"
+  },
+  {
+    name: "replay",
+    args: "[turn]",
+    description: "Run an earlier turn again",
+    availability: "idle"
+  },
+  {
+    name: "fork",
+    args: "[turn]",
+    description: "Edit an earlier turn's requirement",
+    availability: "always"
+  },
+  {
+    name: "export",
+    args: "[turn] [path]",
+    description: "Export a finished turn as Markdown",
+    availability: "always"
+  },
+  {
+    name: "search",
+    args: "<text>",
+    description: "Search the focused stream",
+    availability: "always"
+  },
+  {
+    name: "latest",
+    description: "Jump the stream to latest output",
+    availability: "always"
+  },
+  {
+    name: "cancel",
+    description: "Cancel the running turn and its queue",
+    availability: "running"
+  },
+  { name: "help", description: "Show the key map", availability: "always" },
+  { name: "quit", description: "Exit the console", availability: "always" }
+];
+function availableCommands(running) {
+  const phase = running ? "running" : "idle";
+  return COMMANDS.filter((c) => c.availability === "always" || c.availability === phase);
+}
+function canRun(name, running) {
+  const command = COMMANDS.find((c) => c.name === name);
+  if (!command) return true;
+  return availableCommands(running).includes(command);
+}
+function unavailableReason(name, running) {
+  const command = COMMANDS.find((c) => c.name === name);
+  if (!command || availableCommands(running).includes(command)) return void 0;
+  return running ? `/${name} waits for the current turn to finish` : `/${name} only applies while a turn is running`;
+}
+function matchCommands(query, running) {
+  const q = query.trim().toLowerCase();
+  const pool = availableCommands(running);
+  if (!q) return pool;
+  const byName = [];
+  const byDescription = [];
+  for (const command of pool) {
+    if (command.name.startsWith(q)) byName.push(command);
+    else if (command.description.toLowerCase().includes(q)) byDescription.push(command);
+  }
+  return [...byName, ...byDescription];
+}
+function isCommandLine(text) {
+  return text.startsWith("/");
+}
+function menuQuery(text) {
+  if (!isCommandLine(text)) return void 0;
+  const rest = text.slice(1);
+  return /\s/.test(rest) ? void 0 : rest;
+}
+function parseCommand(text) {
+  if (!isCommandLine(text)) return void 0;
+  const [name = "", ...args] = text.slice(1).trim().split(/\s+/);
+  return name ? { name, args } : void 0;
+}
+function paletteRows(commands) {
+  return commands.map((command) => ({
+    key: command.name,
+    label: command.args ? `/${command.name} ${command.args}` : `/${command.name}`,
+    description: command.description
+  }));
+}
+function argQuery(text) {
+  if (!isCommandLine(text)) return void 0;
+  const match = /^(\S+)\s+(\S*)$/.exec(text);
+  if (!match) return void 0;
+  const command = COMMANDS.find((c) => c.name === match[1].slice(1));
+  if (!command?.completes) return void 0;
+  return { command, partial: match[2] };
+}
+function completeAgents(partial, ids, limit = 8) {
+  const query = partial.toLowerCase();
+  const matches = query ? ids.filter((id) => id.toLowerCase().startsWith(query)) : [...ids];
+  return matches.slice(0, limit);
+}
+function resolveAgentId(input, ids) {
+  if (ids.includes(input)) return { id: input };
+  const query = input.toLowerCase();
+  const hits = ids.filter((id) => id.toLowerCase().startsWith(query));
+  if (hits.length === 1) return { id: hits[0] };
+  if (hits.length === 0) return { error: `unknown agent: ${input}` };
+  return { error: `ambiguous: ${hits.join(", ")}` };
+}
+
+// src/tui/components/chrome.tsx
+import { Box, Text } from "ink";
+
+// src/tui/format.ts
+import stringWidth from "string-width";
+function truncate(text, max) {
+  if (max <= 0) return "";
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+function displayWidth(text) {
+  return stringWidth(text);
+}
+function wrapLine(line, width) {
+  const limit = Math.max(1, width);
+  if (line === "") return [""];
+  const rows = [];
+  let row = "";
+  let empty = true;
+  const flush = () => {
+    if (!empty) rows.push(row);
+    row = "";
+    empty = true;
+  };
+  const overflow = (word) => {
+    const chunks = splitByWidth(word, limit);
+    for (const chunk of chunks.slice(0, -1)) rows.push(chunk);
+    row = chunks[chunks.length - 1];
+    empty = row === "";
+  };
+  for (const word of line.split(" ")) {
+    const candidate = empty ? word : `${row} ${word}`;
+    if (displayWidth(candidate) <= limit) {
+      row = candidate;
+      empty = false;
+      continue;
+    }
+    const head = breakableHead(empty ? "" : row, word, limit);
+    if (head === 0) {
+      flush();
+      overflow(word);
+      continue;
+    }
+    rows.push(empty ? word.slice(0, head) : `${row} ${word.slice(0, head)}`);
+    overflow(word.slice(head));
+  }
+  flush();
+  return rows;
+}
+var CLOSERS = "\u3002\uFF0C\u3001\uFF1B\uFF1A\uFF1F\uFF01\uFF09\uFF3D\uFF5D\u300D\u300F\u3011\u300B\u3009\u201D\u2019\u2026\u2014\xB7";
+function breakableHead(row, word, limit) {
+  const chars = [...word];
+  let used = row === "" ? 0 : displayWidth(row) + 1;
+  let head = 0;
+  for (let i = 0; i < chars.length; i++) {
+    const charWidth = displayWidth(chars[i]);
+    if (used + charWidth > limit) break;
+    used += charWidth;
+    const next = chars[i + 1];
+    if (next !== void 0 && CLOSERS.includes(next)) continue;
+    if (charWidth >= 2 || next !== void 0 && displayWidth(next) >= 2) head = i + 1;
+  }
+  return head;
+}
+function splitByWidth(text, width) {
+  const chunks = [];
+  let chunk = "";
+  let used = 0;
+  for (const char of text) {
+    const charWidth = displayWidth(char);
+    if (chunk !== "" && used + charWidth > width) {
+      chunks.push(chunk);
+      chunk = char;
+      used = charWidth;
+    } else {
+      chunk += char;
+      used += charWidth;
+    }
+  }
+  chunks.push(chunk);
+  return chunks;
+}
+function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "\u2014";
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const totalSeconds = Math.round(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  if (minutes < 60) return `${minutes}m ${String(totalSeconds % 60).padStart(2, "0")}s`;
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ${String(minutes % 60).padStart(2, "0")}m`;
+}
+var CIRCLED = "\u2460\u2461\u2462\u2463\u2464\u2465\u2466\u2467\u2468\u2469\u246A\u246B\u246C\u246D\u246E\u246F\u2470\u2471\u2472\u2473";
+function circled(n) {
+  return CIRCLED[n - 1] ?? `(${n})`;
+}
+function padRight(text, width) {
+  return text.length >= width ? text : text + " ".repeat(width - text.length);
+}
+function oneDecimal(value) {
+  const fixed = value.toFixed(1);
+  return fixed.endsWith(".0") ? fixed.slice(0, -2) : fixed;
+}
+function formatTokens(n) {
+  if (!Number.isFinite(n) || n < 0) return "\u2014";
+  if (n < 1e3) return String(Math.round(n));
+  if (n < 1e6) return `${oneDecimal(n / 1e3)}k`;
+  return `${oneDecimal(n / 1e6)}M`;
+}
+function formatCost(usd) {
+  if (!Number.isFinite(usd) || usd < 0) return "\u2014";
+  if (usd === 0) return "$0.00";
+  if (usd < 0.01) return "<$0.01";
+  return `$${usd.toFixed(2)}`;
+}
+
+// src/tui/layout.ts
+var MIN_COLUMNS = 40;
+var MIN_ROWS = 10;
+var COMPACT_COLUMNS = 72;
+var RAIL_MIN_ROWS = 16;
+var MAX_RAIL_ROWS = 2;
+var MAX_MENU_ROWS = 7;
+var MAX_QUEUE_ROWS = 3;
+var MIN_BODY_ROWS = 3;
+function measureRailRows(cells, columns) {
+  if (!cells || cells.length === 0) return 0;
+  if (columns <= 0) return MAX_RAIL_ROWS;
+  let rows = 1;
+  let used = 0;
+  for (const cell of cells) {
+    if (used > 0 && used + cell > columns) {
+      rows += 1;
+      if (rows >= MAX_RAIL_ROWS) return MAX_RAIL_ROWS;
+      used = cell;
+    } else {
+      used += cell;
+    }
+  }
+  return rows;
+}
+function computeLayout(input) {
+  const columns = Math.max(MIN_COLUMNS, input.columns);
+  const rows = Math.max(MIN_ROWS, input.rows);
+  const compact = columns < COMPACT_COLUMNS;
+  const welcome = !input.overlay && input.turn === 0;
+  const showRail = !welcome && !input.overlay && rows >= RAIL_MIN_ROWS && input.hasRail;
+  const menuRows = Math.min(Math.max(0, input.menuRows), MAX_MENU_ROWS);
+  const queueRows = Math.min(Math.max(0, input.queueRows ?? 0), MAX_QUEUE_ROWS);
+  const railRows = showRail ? Math.min(MAX_RAIL_ROWS, Math.max(1, measureRailRows(input.railCells, columns))) : 0;
+  const reserved = 1 + // header
+  1 + // rule under the header
+  (railRows > 0 ? railRows + 1 : 0) + // pipeline rail plus the gap above it
+  1 + // gap before the body
+  (input.notice ? 1 : 0) + (input.viewing ? 1 : 0) + // "viewing turn N" banner
+  queueRows + menuRows + 1 + // prompt
+  1;
+  const bodyHeight = Math.max(MIN_BODY_ROWS, rows - reserved);
+  const showTeam = !compact;
+  const teamWidth = Math.min(30, Math.max(18, Math.floor(columns * 0.24)));
+  const streamChrome = (showTeam ? teamWidth + 1 : 0) + 1;
+  const streamWidth = Math.max(1, columns - streamChrome - 1);
+  return {
+    columns,
+    rows,
+    compact,
+    showTeam,
+    showRail,
+    railRows,
+    welcome,
+    bodyHeight,
+    // The stream spends one of the body's rows on its own header.
+    logViewport: Math.max(1, bodyHeight - 1),
+    teamWidth,
+    streamWidth,
+    menuRows,
+    queueRows
+  };
+}
+
+// src/tui/theme.ts
+var COLOR = {
+  accent: "cyan",
+  ok: "green",
+  warn: "yellow",
+  error: "red",
+  muted: "gray"
+};
+var STATUS = {
+  pending: { glyph: "\u25CB", color: COLOR.muted, dim: true, label: "queued" },
+  running: { glyph: "\u25D0", color: COLOR.accent, label: "running" },
+  retrying: { glyph: "\u21BB", color: COLOR.warn, label: "retrying" },
+  success: { glyph: "\u2713", color: COLOR.ok, label: "done" },
+  failed: { glyph: "\u2717", color: COLOR.error, label: "failed" },
+  // Stopped, not broken: a filled square reads as "halted" and shares the muted
+  // treatment of a skip, so a Ctrl-C does not paint the roster red.
+  cancelled: { glyph: "\u25A0", color: COLOR.muted, dim: true, label: "cancelled" },
+  skipped: { glyph: "\u2298", color: COLOR.muted, dim: true, label: "skipped" }
+};
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var GLYPH = {
+  /** Marks the console itself in the header and the welcome screen. */
+  brand: "\u25C6",
+  /** The leader runs before the pipeline exists, so it gets its own mark. */
+  leader: "\u25C6",
+  agent: "\u25C7",
+  /** Points at the focused row in the team list. */
+  caret: "\u203A",
+  /** Pipeline flow between stages. */
+  connector: "\u2500\u2500\u25B8",
+  /** The stream is tailing; new output appears as it arrives. */
+  live: "\u25BC",
+  /** The stream is parked while the user reads back. */
+  paused: "\u23F8",
+  /**
+   * A follow-up waiting for the team to finish.
+   *
+   * Latin-1 on purpose: it renders as exactly one cell in every terminal, which
+   * a pictograph like ⏳ does not.
+   */
+  queued: "\xBB",
+  /** The leader is asking for a decision rather than reporting one. */
+  ask: "?",
+  /** A mid-turn warning that rides alongside the outcome rather than hiding it. */
+  warn: "\u26A0",
+  /**
+   * A pasted line break, drawn in the one-line prompt.
+   *
+   * MUST be exactly one column wide. `Prompt` maps `\n` to this glyph 1:1 — one
+   * character in, one character out — so its caret index stays valid; a glyph
+   * that rendered as two columns would push the caret off by one for every
+   * newline before it. If a terminal disagrees, this single glyph is the fix.
+   */
+  newline: "\u21B5"
+};
+
+// src/tui/components/chrome.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function Header({ name, right }) {
+  return /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", flexShrink: 0, children: [
+    /* @__PURE__ */ jsx(Box, { flexShrink: 1, children: /* @__PURE__ */ jsxs(Text, { wrap: "truncate-end", children: [
+      /* @__PURE__ */ jsxs(Text, { color: COLOR.accent, bold: true, children: [
+        GLYPH.brand,
+        " multiclaw"
+      ] }),
+      name ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " \xB7 ",
+        name
+      ] }) : null
+    ] }) }),
+    /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: right }) })
+  ] });
+}
+function Rule({ width }) {
+  return /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: COLOR.muted, dimColor: true, children: "\u2500".repeat(Math.max(0, width)) }) });
+}
+function Chip({ agent, fallbackName, spinner }) {
+  const status = agent?.status ?? "pending";
+  const style = STATUS[status];
+  const glyph = status === "running" ? spinner : style.glyph;
+  return /* @__PURE__ */ jsx(Box, { marginRight: 1, children: /* @__PURE__ */ jsxs(Text, { color: style.color, dimColor: style.dim, children: [
+    glyph,
+    " ",
+    agent?.icon ? `${agent.icon} ` : "",
+    agent?.name ?? fallbackName
+  ] }) });
+}
+function railCellWidths(turn) {
+  const chip = (name, icon) => `G ${icon ? `${icon} ` : ""}${name}`.length + 1;
+  const cells = [];
+  for (const id of turn.leaderIds) {
+    const agent = turn.agents[id];
+    cells.push(chip(agent?.name ?? id, agent?.icon));
+  }
+  turn.stages.forEach((stage, index) => {
+    cells.push(` ${GLYPH.connector} `.length, `${circled(index + 1)} `.length);
+    for (const agent of stage.agents) {
+      cells.push(chip(agent.name, agent.icon));
+    }
+  });
+  return cells;
+}
+function PipelineRail({ turn, spinner }) {
+  if (turn.leaderIds.length === 0 && turn.stages.length === 0) return null;
+  const items = [];
+  for (const id of turn.leaderIds) {
+    items.push(
+      /* @__PURE__ */ jsx(Chip, { agent: turn.agents[id], fallbackName: id, spinner }, `leader-${id}`)
+    );
+  }
+  turn.stages.forEach((stage, index) => {
+    items.push(
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: ` ${GLYPH.connector} ` }, `flow-${stage.stageIndex}`),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        circled(index + 1),
+        " "
+      ] }, `stage-${stage.stageIndex}`)
+    );
+    for (const agent of stage.agents) {
+      items.push(
+        /* @__PURE__ */ jsx(
+          Chip,
+          {
+            agent: turn.agents[agent.id],
+            fallbackName: agent.name,
+            spinner
+          },
+          agent.id
+        )
+      );
+    }
+  });
+  return /* @__PURE__ */ jsx(Box, { flexWrap: "wrap", children: items });
+}
+function HintBar({ status, keys }) {
+  return /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", flexShrink: 0, children: [
+    /* @__PURE__ */ jsx(Box, { flexShrink: 1, children: status }),
+    /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: keys }) })
+  ] });
+}
+function QueueStrip({ items, max = MAX_QUEUE_ROWS }) {
+  if (items.length === 0 || max <= 0) return null;
+  const shown = items.slice(0, max);
+  const hidden = items.length - shown.length;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexShrink: 0, children: shown.map((text, index) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: a queue may hold the same sentence twice, so position is what tells the rows apart
+    /* @__PURE__ */ jsxs(Text, { wrap: "truncate-end", children: [
+      /* @__PURE__ */ jsx(Text, { color: COLOR.warn, children: index === 0 ? `${GLYPH.queued} ` : "  " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: index > 0, children: text }),
+      hidden > 0 && index === shown.length - 1 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: ` (+${hidden} more)` }) : null
+    ] }, `${index}-${text}`)
+  )) });
+}
+
+// src/tui/components/overlays.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/tui/state.ts
+var MAX_LOG_CHARS = 8e3;
+var ANSI_PATTERN = /\x1b\[[0-9;]*[a-zA-Z]/g;
+var MAX_HISTORY = 20;
+var initialState = {
+  phase: "idle",
+  name: "",
+  turn: 0,
+  stages: [],
+  agents: {},
+  leaderIds: [],
+  autoFollow: true,
+  scroll: 0,
+  history: [],
+  verbose: false
+};
+function stripAnsi(text) {
+  return text.replace(ANSI_PATTERN, "");
+}
+function appendLog(previous, chunk) {
+  const next = previous + stripAnsi(chunk);
+  return next.length > MAX_LOG_CHARS ? next.slice(next.length - MAX_LOG_CHARS) : next;
+}
+function blankAgent(id, name, patch = {}) {
+  return { id, name, status: "pending", logs: "", ...patch };
+}
+function epoch(iso) {
+  const value = Date.parse(iso);
+  return Number.isNaN(value) ? void 0 : value;
+}
+function agentModel(agent) {
+  return agent.model ?? agent.models?.[agent.runtime ?? "acp"];
+}
+function activeLeader(config) {
+  return config.useLeader === false ? void 0 : config.leader;
+}
+function plannedAgents(config) {
+  const leader = activeLeader(config);
+  return leader ? [leader, ...config.agents] : config.agents;
+}
+function leaderAgentIds(config) {
+  const leader = activeLeader(config);
+  return leader ? [leader.id] : [];
+}
+function seedAgents(config) {
+  const agents = {};
+  for (const agent of plannedAgents(config)) {
+    agents[agent.id] = blankAgent(agent.id, agent.name, {
+      icon: agent.icon,
+      model: agentModel(agent),
+      description: agent.description,
+      taskTitle: agent.taskTitle
+    });
+  }
+  return agents;
+}
+function createInitialState(config, history = []) {
+  const agents = seedAgents(config);
+  return {
+    phase: "idle",
+    name: config.name,
+    turn: history[history.length - 1]?.turn ?? 0,
+    stages: [],
+    leaderIds: leaderAgentIds(config),
+    agents,
+    focusId: Object.keys(agents)[0],
+    autoFollow: true,
+    scroll: 0,
+    history,
+    verbose: false
+  };
+}
+function mergeStageAgents(agents, stages) {
+  const next = { ...agents };
+  for (const stage of stages) {
+    for (const a of stage.agents) {
+      const existing = next[a.id];
+      next[a.id] = existing ? {
+        ...existing,
+        name: a.name,
+        icon: a.icon,
+        model: a.model,
+        // The event's `description` is absent for a hand-rolled agent
+        // definition, so fall back rather than blanking a known role.
+        description: a.description ?? existing.description,
+        taskTitle: a.taskTitle
+      } : blankAgent(a.id, a.name, {
+        icon: a.icon,
+        model: a.model,
+        description: a.description,
+        taskTitle: a.taskTitle
+      });
+    }
+  }
+  return next;
+}
+function reduceEvent(state, event) {
+  switch (event.type) {
+    case "orchestration:start": {
+      return {
+        ...state,
+        phase: "running",
+        name: event.payload.name,
+        requirement: event.payload.requirement ?? state.requirement,
+        reason: event.payload.selectionReason,
+        stages: event.payload.stages,
+        agents: mergeStageAgents(state.agents, event.payload.stages)
+      };
+    }
+    // The architect's task plan is applied *after* the first stage, which can
+    // regroup the team. The console drew the pre-plan grouping from
+    // `orchestration:start`; this is how it learns the grouping that ran.
+    case "orchestration:stages": {
+      return {
+        ...state,
+        stages: event.payload.stages,
+        agents: mergeStageAgents(state.agents, event.payload.stages)
+      };
+    }
+    // Stage boundaries carry no state of their own — the per-agent statuses
+    // derived from them already drive the pipeline bar.
+    case "stage:start":
+    case "stage:complete":
+      return state;
+    case "agent:start": {
+      const { agentId, agentName, icon, model, taskTitle } = event.payload;
+      const existing = state.agents[agentId];
+      const startedAt = epoch(event.timestamp);
+      const next = existing ? {
+        ...existing,
+        name: agentName,
+        icon: icon ?? existing.icon,
+        model: model ?? existing.model,
+        taskTitle: taskTitle ?? existing.taskTitle,
+        status: "running",
+        startedAt: startedAt ?? existing.startedAt
+      } : blankAgent(agentId, agentName, {
+        icon,
+        model,
+        taskTitle,
+        status: "running",
+        startedAt
+      });
+      const takesFocus = state.autoFollow;
+      return {
+        ...state,
+        agents: { ...state.agents, [agentId]: next },
+        focusId: takesFocus ? agentId : state.focusId,
+        // A new agent takes the stream with it, so the window must follow.
+        scroll: takesFocus ? 0 : state.scroll
+      };
+    }
+    case "agent:output": {
+      const { agentId, chunk, kind } = event.payload;
+      if (kind === "tool-detail" && !state.verbose) return state;
+      const existing = state.agents[agentId];
+      if (!existing) return state;
+      return {
+        ...state,
+        agents: {
+          ...state.agents,
+          [agentId]: { ...existing, logs: appendLog(existing.logs, chunk) }
+        }
+      };
+    }
+    case "agent:complete":
+    case "agent:failed": {
+      const result = event.payload;
+      const patch = {
+        status: result.status,
+        duration: result.duration,
+        attempts: result.attempts,
+        error: result.error,
+        usage: result.usage,
+        costUsd: result.costUsd,
+        // Present only on the success path; a failed agent has no session to
+        // continue, so `/retry` re-runs it cold.
+        sessionId: result.sessionId
+      };
+      const existing = state.agents[result.agentId];
+      const next = existing ? { ...existing, ...patch } : blankAgent(result.agentId, result.agentName, patch);
+      return { ...state, agents: { ...state.agents, [result.agentId]: next } };
+    }
+    case "agent:skipped": {
+      const { agentId, agentName, icon } = event.payload;
+      const existing = state.agents[agentId];
+      const next = existing ? { ...existing, status: "skipped" } : blankAgent(agentId, agentName, { icon, status: "skipped" });
+      return { ...state, agents: { ...state.agents, [agentId]: next } };
+    }
+    case "agent:retrying": {
+      const { agentId, agentName, attempt, maxAttempts, error } = event.payload;
+      const note = `
+[retry ${attempt}/${maxAttempts}] ${error}
+`;
+      const existing = state.agents[agentId];
+      const retry = { attempt, max: maxAttempts };
+      const next = existing ? { ...existing, status: "retrying", retry, logs: appendLog(existing.logs, note) } : blankAgent(agentId, agentName, { status: "retrying", retry, logs: note });
+      return { ...state, agents: { ...state.agents, [agentId]: next } };
+    }
+    case "orchestration:warning":
+      return { ...state, warning: event.payload.message };
+    case "orchestration:complete":
+      return {
+        ...state,
+        phase: "complete",
+        success: event.payload.success,
+        totalDuration: event.payload.totalDuration,
+        totalCostUsd: event.payload.totalCostUsd,
+        endedAt: epoch(event.timestamp) ?? Date.now(),
+        reply: event.payload.reply
+      };
+    default:
+      return state;
+  }
+}
+function wrapLog(logs, width) {
+  return logs.split("\n").flatMap((line) => wrapLine(line, width));
+}
+function focusedRowCount(turn, width) {
+  const agent = turn.focusId ? turn.agents[turn.focusId] : void 0;
+  return agent?.logs ? wrapLog(agent.logs, width).length : 0;
+}
+function snapshot(state) {
+  return {
+    turn: state.turn,
+    requirement: state.requirement,
+    phase: state.phase,
+    startedAt: state.startedAt,
+    endedAt: state.endedAt,
+    stages: state.stages,
+    agents: state.agents,
+    leaderIds: state.leaderIds,
+    focusId: state.focusId,
+    autoFollow: state.autoFollow,
+    scroll: state.scroll,
+    success: state.success,
+    totalDuration: state.totalDuration,
+    totalCostUsd: state.totalCostUsd,
+    reason: state.reason,
+    warning: state.warning,
+    reply: state.reply
+  };
+}
+function mapShown(state, fn) {
+  if (state.view) {
+    const next2 = fn(state.view);
+    return next2 === state.view ? state : { ...state, view: next2 };
+  }
+  const next = fn(state);
+  return next === state ? state : { ...state, ...next };
+}
+function recordedTurns(state) {
+  return [...state.history, ...state.phase === "complete" ? [snapshot(state)] : []];
+}
+function conversationTurns(state) {
+  const turns = [];
+  for (const turn of recordedTurns(state)) {
+    if (turn.phase !== "complete" || !turn.requirement) continue;
+    turns.push(
+      turn.reply ? { requirement: turn.requirement, reply: turn.reply } : { requirement: turn.requirement }
+    );
+  }
+  return turns;
+}
+function tuiReducer(state, action) {
+  switch (action.type) {
+    case "event":
+      return reduceEvent(state, action.event);
+    case "turn:start": {
+      const ids = Object.keys(action.agents);
+      const history = state.requirement !== void 0 ? [...state.history, snapshot(state)].slice(-MAX_HISTORY) : state.history;
+      return {
+        phase: "running",
+        name: state.name,
+        turn: state.turn + 1,
+        requirement: action.requirement,
+        startedAt: action.startedAt,
+        stages: [],
+        leaderIds: action.leaderIds,
+        agents: action.agents,
+        focusId: ids[0],
+        autoFollow: true,
+        scroll: 0,
+        history,
+        // A new requirement also replaces the previous leader metadata; leaving
+        // it up would make the old answer or routing reason look like the
+        // response to the new request. Reading a past turn ends for the same
+        // reason — the panes belong to the run.
+        reason: void 0,
+        reply: void 0,
+        view: void 0,
+        // A console setting, carried across turns rather than reset with them.
+        verbose: state.verbose
+      };
+    }
+    case "focus:cycle":
+      return mapShown(state, (turn) => {
+        const ids = Object.keys(turn.agents);
+        if (ids.length === 0) return turn;
+        const current = turn.focusId ? ids.indexOf(turn.focusId) : -1;
+        const nextIndex = (current + action.delta + ids.length) % ids.length;
+        if (nextIndex === current) return turn;
+        return { ...turn, focusId: ids[nextIndex], autoFollow: false, scroll: 0 };
+      });
+    case "focus:set":
+      return mapShown(state, (turn) => {
+        if (!turn.agents[action.agentId]) return turn;
+        if (turn.focusId === action.agentId && !turn.autoFollow && turn.scroll === 0) return turn;
+        return { ...turn, focusId: action.agentId, autoFollow: false, scroll: 0 };
+      });
+    case "stream:scroll":
+      return mapShown(state, (turn) => {
+        const rows = focusedRowCount(turn, action.width);
+        const maxScroll = Math.max(0, rows - Math.max(1, action.viewport));
+        const next = Math.min(Math.max(0, turn.scroll + action.delta), maxScroll);
+        return next === turn.scroll ? turn : { ...turn, scroll: next };
+      });
+    case "stream:search":
+      return mapShown(state, (turn) => {
+        const agent = turn.focusId ? turn.agents[turn.focusId] : void 0;
+        if (!agent?.logs || action.query === "") return turn;
+        const rows = wrapLog(agent.logs, action.width);
+        const needle = action.query.toLowerCase();
+        let index = -1;
+        for (let i = rows.length - 1; i >= 0; i--) {
+          if (rows[i].toLowerCase().includes(needle)) {
+            index = i;
+            break;
+          }
+        }
+        if (index === -1) return turn;
+        const height = Math.max(1, action.viewport);
+        const maxScroll = Math.max(0, rows.length - height);
+        const scroll = Math.min(Math.max(0, rows.length - 1 - index), maxScroll);
+        return scroll === turn.scroll && !turn.autoFollow ? turn : { ...turn, scroll, autoFollow: false };
+      });
+    case "stream:latest":
+      return mapShown(
+        state,
+        (turn) => turn.scroll === 0 && turn.autoFollow ? turn : { ...turn, scroll: 0, autoFollow: true }
+      );
+    case "stream:clear":
+      return mapShown(state, (turn) => {
+        const id = turn.focusId;
+        const agent = id ? turn.agents[id] : void 0;
+        if (!id || !agent) return turn;
+        return { ...turn, agents: { ...turn.agents, [id]: { ...agent, logs: "" } }, scroll: 0 };
+      });
+    case "view:open": {
+      const record = state.history.find((turn) => turn.turn === action.turn);
+      return record ? { ...state, view: record } : state;
+    }
+    case "view:close":
+      return state.view ? { ...state, view: void 0 } : state;
+    case "verbose:toggle":
+      return { ...state, verbose: !state.verbose };
+  }
+}
+function stageStatus(stage, agents) {
+  const statuses = stage.agents.map((a) => agents[a.id]?.status ?? "pending");
+  if (statuses.some((s) => s === "failed")) return "failed";
+  if (statuses.some((s) => s === "running" || s === "retrying")) return "running";
+  if (statuses.length > 0 && statuses.every((s) => s === "success")) return "success";
+  if (statuses.length > 0 && statuses.every((s) => s === "skipped")) return "skipped";
+  if (statuses.length > 0 && statuses.every((s) => s === "cancelled")) return "cancelled";
+  return "pending";
+}
+var SETTLED = /* @__PURE__ */ new Set([
+  "success",
+  "failed",
+  "cancelled",
+  "skipped"
+]);
+function progress(turn) {
+  const agents = Object.values(turn.agents);
+  return { done: agents.filter((a) => SETTLED.has(a.status)).length, total: agents.length };
+}
+function agentElapsed(agent, now) {
+  if (agent.status === "running" || agent.status === "retrying") {
+    return agent.startedAt === void 0 ? void 0 : Math.max(0, now - agent.startedAt);
+  }
+  return agent.duration;
+}
+function turnElapsed(turn, now) {
+  if (turn.totalDuration !== void 0) return turn.totalDuration;
+  if (turn.startedAt === void 0) return void 0;
+  const end = turn.phase === "running" ? now : turn.endedAt ?? now;
+  return Math.max(0, end - turn.startedAt);
+}
+function visibleLog(turn, viewport, width) {
+  const agent = turn.focusId ? turn.agents[turn.focusId] : void 0;
+  const all = agent?.logs ? wrapLog(agent.logs, width) : [];
+  const height = Math.max(1, viewport);
+  const maxScroll = Math.max(0, all.length - height);
+  const scrolledBack = Math.min(Math.max(0, turn.scroll), maxScroll);
+  const end = all.length - scrolledBack;
+  return {
+    rows: all.slice(Math.max(0, end - height), end),
+    scrolledBack,
+    following: scrolledBack === 0
+  };
+}
+
+// src/tui/components/overlays.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var HELP_GROUPS = [
+  {
+    title: "prompt",
+    rows: [
+      ["enter", "Run the requirement"],
+      ["enter (busy)", "Queue it to run next"],
+      ["esc", "Clear the line, close an overlay"],
+      ["\u2190 \u2192 home end", "Move the caret"]
+    ]
+  },
+  {
+    title: "panes",
+    rows: [
+      ["tab  \u21E7tab", "Next / previous agent"],
+      ["\u2191 \u2193", "Scroll the stream one line"],
+      ["pgup pgdn", "Scroll the stream a page"],
+      ["ctrl+l", "Clear the focused log"],
+      ["esc", "Stop reading a past turn"]
+    ]
+  },
+  {
+    title: "commands",
+    rows: [
+      ["/", "Command menu"],
+      ["?", "This help"],
+      ["ctrl+c", "Cancel the turn and its queue \xB7 again to quit"],
+      ["/<command>", `All ${COMMANDS.length} commands \u2014 type / to browse`]
+    ]
+  }
+];
+var KEY_COLUMN = 16;
+var TURN_ROWS = 3;
+var HISTORY_CHROME_ROWS = 4;
+function historyCapacity(maxRows) {
+  return Math.max(1, Math.floor((maxRows - HISTORY_CHROME_ROWS) / TURN_ROWS));
+}
+function listWindowStart(selected, total, capacity) {
+  const maxStart = Math.max(0, total - capacity);
+  return Math.min(Math.max(0, Math.min(selected, selected - capacity + 1)), maxStart);
+}
+function helpRows(compact = false) {
+  const gap = compact ? 0 : 1;
+  const groups = HELP_GROUPS.reduce((total, group) => total + gap + 1 + group.rows.length, 0);
+  return 1 + gap + groups + gap + 1;
+}
+function HelpOverlay({ width, maxRows }) {
+  const compact = helpRows(false) > maxRows;
+  const gap = compact ? 0 : 1;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexShrink: 0, paddingLeft: 2, paddingTop: 1, width, children: [
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "? keys" }),
+    HELP_GROUPS.map((group) => /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: gap, children: [
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: group.title }),
+      group.rows.map(([keys, description]) => /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { color: COLOR.accent, children: padRight(keys, KEY_COLUMN) }),
+        /* @__PURE__ */ jsx2(Text2, { dimColor: true, wrap: "truncate-end", children: description })
+      ] }, keys))
+    ] }, group.title)),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: gap, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "esc or ? to close" }) })
+  ] });
+}
+function outcome(turn) {
+  if (turn.reply) {
+    return turn.reply.mode === "ask" ? { text: `${GLYPH.ask} needs input`, color: COLOR.warn } : { text: `${STATUS.success.glyph} answered`, color: COLOR.ok };
+  }
+  if (turn.phase !== "complete") return { text: "interrupted", color: COLOR.warn };
+  return turn.success ? { text: `${STATUS.success.glyph} done`, color: COLOR.ok } : { text: `${STATUS.failed.glyph} failed`, color: COLOR.error };
+}
+function HistoryOverlay({
+  turns,
+  selected,
+  width,
+  maxRows
+}) {
+  const capacity = historyCapacity(maxRows);
+  const start = listWindowStart(selected, turns.length, capacity);
+  const visible = turns.slice(start, start + capacity);
+  const range = turns.length > capacity ? ` \xB7 showing ${start + 1}\u2013${start + visible.length} of ${turns.length}` : "";
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexShrink: 0, paddingLeft: 2, paddingTop: 1, width, children: [
+    /* @__PURE__ */ jsxs2(Box2, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "HISTORY" }),
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        turns.length,
+        " earlier"
+      ] })
+    ] }),
+    turns.length === 0 ? /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "No earlier turns yet." }) }) : /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: visible.map((turn, offset) => {
+      const index = start + offset;
+      const focused = index === selected;
+      const state = outcome(turn);
+      const { done, total } = progress(turn);
+      const time = turn.totalDuration === void 0 ? "" : ` \xB7 ${formatDuration(turn.totalDuration)}`;
+      return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [
+        /* @__PURE__ */ jsxs2(Box2, { children: [
+          /* @__PURE__ */ jsx2(Text2, { color: focused ? COLOR.accent : void 0, children: focused ? `${GLYPH.caret} ` : "  " }),
+          /* @__PURE__ */ jsxs2(Text2, { bold: focused, color: focused ? COLOR.accent : void 0, children: [
+            "turn ",
+            turn.turn
+          ] }),
+          /* @__PURE__ */ jsxs2(Text2, { color: state.color, children: [
+            " \xB7 ",
+            state.text
+          ] }),
+          /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+            time,
+            " \xB7 ",
+            done,
+            "/",
+            total,
+            " agents"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { dimColor: true, wrap: "truncate-end", children: [
+          "    ",
+          truncate(turn.requirement ?? "(no requirement)", Math.max(8, width - 6))
+        ] })
+      ] }, turn.turn);
+    }) }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: `\u2191\u2193 select \xB7 enter open \xB7 esc close${range}` }) })
+  ] });
+}
+
+// src/tui/components/panels.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function rightColumn(agent, now) {
+  if (agent.status === "retrying" && agent.retry) {
+    return { text: `retry ${agent.retry.attempt}/${agent.retry.max}`, color: COLOR.warn };
+  }
+  const elapsed = agentElapsed(agent, now);
+  if (elapsed !== void 0) return { text: formatDuration(elapsed) };
+  if (agent.status === "skipped") return { text: "skipped" };
+  return { text: "\u2014" };
+}
+function TeamRow({
+  agent,
+  focused,
+  now,
+  spinner
+}) {
+  const style = STATUS[agent.status];
+  const glyph = agent.status === "running" ? spinner : style.glyph;
+  const right = rightColumn(agent, now);
+  return /* @__PURE__ */ jsxs3(Box3, { justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsx3(Box3, { flexShrink: 1, children: /* @__PURE__ */ jsxs3(
+      Text3,
+      {
+        color: focused ? COLOR.accent : style.color,
+        dimColor: !focused && style.dim,
+        bold: focused,
+        wrap: "truncate-end",
+        children: [
+          focused ? `${GLYPH.caret} ` : "  ",
+          glyph,
+          " ",
+          agent.icon ? `${agent.icon} ` : "",
+          agent.name,
+          agent.taskTitle ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+            " ",
+            agent.taskTitle
+          ] }) : null
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx3(Box3, { flexShrink: 0, children: /* @__PURE__ */ jsx3(Text3, { color: right.color, dimColor: right.color === void 0, children: right.text }) })
+  ] });
+}
+function TeamPanel({
+  turn,
+  width,
+  now,
+  spinner
+}) {
+  const ids = Object.keys(turn.agents);
+  const { done, total } = progress(turn);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, flexShrink: 0, paddingRight: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "TEAM" }),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        done,
+        "/",
+        total
+      ] })
+    ] }),
+    ids.length === 0 ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "no agents configured" }) : ids.map((id) => /* @__PURE__ */ jsx3(
+      TeamRow,
+      {
+        agent: turn.agents[id],
+        focused: turn.focusId === id,
+        now,
+        spinner
+      },
+      id
+    ))
+  ] });
+}
+function Divider() {
+  return /* @__PURE__ */ jsx3(
+    Box3,
+    {
+      flexShrink: 0,
+      borderStyle: "single",
+      borderTop: false,
+      borderBottom: false,
+      borderRight: false,
+      borderLeft: true,
+      borderColor: COLOR.muted
+    }
+  );
+}
+function StreamPanel({
+  turn,
+  height,
+  width,
+  now,
+  spinner
+}) {
+  const agent = turn.focusId ? turn.agents[turn.focusId] : void 0;
+  const viewport = Math.max(1, height - 1);
+  const window = visibleLog(turn, viewport, width);
+  const style = agent ? STATUS[agent.status] : void 0;
+  const elapsed = agent ? agentElapsed(agent, now) : void 0;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", flexGrow: 1, height, paddingLeft: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx3(Box3, { flexShrink: 1, children: /* @__PURE__ */ jsxs3(Text3, { wrap: "truncate-end", children: [
+        /* @__PURE__ */ jsx3(Text3, { bold: true, children: agent?.name ?? "\u2014" }),
+        agent?.model ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          " \xB7 ",
+          agent.model
+        ] }) : null,
+        agent && style ? /* @__PURE__ */ jsxs3(Fragment, { children: [
+          /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " \xB7 " }),
+          /* @__PURE__ */ jsx3(Text3, { color: style.color, dimColor: style.dim, children: agent.status === "running" ? `${spinner} ${style.label}` : style.label })
+        ] }) : null,
+        agent?.taskTitle ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          " \xB7 ",
+          agent.taskTitle
+        ] }) : null,
+        agent?.usage?.contextTokens !== void 0 && agent.usage.contextSize !== void 0 ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          " ",
+          "\xB7 ctx ",
+          formatTokens(agent.usage.contextTokens),
+          "/",
+          formatTokens(agent.usage.contextSize)
+        ] }) : null,
+        agent?.costUsd !== void 0 ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          " \xB7 ",
+          formatCost(agent.costUsd)
+        ] }) : null
+      ] }) }),
+      /* @__PURE__ */ jsxs3(Box3, { flexShrink: 0, children: [
+        elapsed === void 0 ? null : /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          formatDuration(elapsed),
+          " "
+        ] }),
+        /* @__PURE__ */ jsx3(Text3, { color: window.following ? COLOR.accent : COLOR.warn, children: window.following ? GLYPH.live : `${GLYPH.paused} ${window.scrolledBack}\u2191` })
+      ] })
+    ] }),
+    window.rows.length === 0 ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: turn.phase === "running" ? "waiting for output\u2026" : "no output yet" }) : (
+      // The tail, already wrapped to `width` by `visibleLog` — the pane draws
+      // rows, and one log line is several of them. `visibleLog` also picks
+      // which rows, so the content here is exactly the pane's height and the
+      // oldest rows are the ones already gone: nothing is left to clip, which
+      // is why this box is not bottom-pinned. Pinning it would only leave a
+      // gap under the header whenever an agent has not said much yet.
+      //
+      // Rows are rendered with `truncate-end` rather than letting Ink wrap
+      // them again: they are supposed to fit, and if `width` was ever
+      // optimistic the failure should be a shaved row, not a re-wrap that
+      // overflows the pane and pushes the newest output out of sight.
+      //
+      // `flexShrink={0}` stops Yoga compressing the rows into each other,
+      // and `overflow="hidden"` is the backstop if any of the above is ever
+      // wrong.
+      /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", flexShrink: 0, height: viewport, overflow: "hidden", children: window.rows.map((row, index) => (
+        // Rows are an append-only tail; position is the identity.
+        // biome-ignore lint/suspicious/noArrayIndexKey: positional log tail
+        /* @__PURE__ */ jsx3(Box3, { flexShrink: 0, children: /* @__PURE__ */ jsx3(Text3, { wrap: "truncate-end", children: row }) }, index)
+      )) })
+    )
+  ] });
+}
+function ReplyPanel({ reply, width }) {
+  const asking = reply.mode === "ask";
+  return (
+    // `flexShrink={0}`: the body must clip this, not compress it. A shrunken
+    // column box folds its own text rows into each other before the body ever
+    // gets a chance to hide the overflow.
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", flexShrink: 0, paddingLeft: 2, paddingTop: 1, width, children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: asking ? COLOR.warn : COLOR.accent, bold: true, children: [
+        asking ? GLYPH.ask : GLYPH.leader,
+        " ",
+        asking ? "the team needs a decision" : "answered"
+      ] }),
+      /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { children: reply.message }) }),
+      /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: asking ? "Answer below and press enter." : "Type a requirement and press enter." }) })
+    ] })
+  );
+}
+function ErrorPanel({ message, width }) {
+  return (
+    // `flexShrink={0}` — see ReplyPanel. A compressed column box folds its own
+    // text rows into each other before the body gets a chance to clip them.
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", flexShrink: 0, paddingLeft: 2, paddingTop: 1, width, children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: COLOR.error, bold: true, children: [
+        GLYPH.warn,
+        " the run stopped"
+      ] }),
+      /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { color: COLOR.error, children: message }) })
+    ] })
+  );
+}
+function WelcomePanel({ turn, width }) {
+  const agents = Object.values(turn.agents);
+  const leaderId = turn.leaderIds[0];
+  const nameWidth = Math.min(24, Math.max(8, ...agents.map((a) => a.name.length)) + 2);
+  return (
+    // `flexShrink={0}` — see ReplyPanel. Compressing the roster folds one agent's
+    // description onto the next row's, which reads as a corrupted screen.
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", flexShrink: 0, paddingLeft: 2, paddingTop: 1, width, children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: COLOR.accent, bold: true, children: [
+        GLYPH.brand,
+        " multiclaw"
+      ] }),
+      /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "A team of agents, one prompt away." }) }),
+      /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", marginTop: 1, children: agents.map((agent) => {
+        const focused = turn.focusId === agent.id;
+        const leader = agent.id === leaderId;
+        return /* @__PURE__ */ jsxs3(Box3, { children: [
+          /* @__PURE__ */ jsxs3(Box3, { flexShrink: 0, children: [
+            /* @__PURE__ */ jsx3(Text3, { color: focused ? COLOR.accent : void 0, children: focused ? `${GLYPH.caret} ` : "  " }),
+            /* @__PURE__ */ jsx3(Text3, { color: leader ? COLOR.accent : COLOR.muted, children: leader ? GLYPH.leader : GLYPH.agent }),
+            /* @__PURE__ */ jsxs3(Text3, { bold: focused, color: focused ? COLOR.accent : void 0, children: [
+              " ",
+              padRight(truncate(agent.name, nameWidth - 2), nameWidth - 1)
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx3(Box3, { flexShrink: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, wrap: "truncate-end", children: agent.taskTitle ?? agent.description ?? "" }) })
+        ] }, agent.id);
+      }) }),
+      /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Type a requirement and press enter." }) })
+    ] })
+  );
+}
+
+// src/tui/components/prompt.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function Prompt({
+  value,
+  cursor,
+  caretVisible,
+  placeholder
+}) {
+  const shown = value.replace(/\r/g, "").replace(/\n/g, GLYPH.newline);
+  const ghost = value === "";
+  const before = shown.slice(0, cursor);
+  const cell = ghost ? placeholder.slice(0, 1) : shown.slice(cursor, cursor + 1);
+  const tail = ghost ? placeholder.slice(1) : shown.slice(cursor + 1);
+  return /* @__PURE__ */ jsxs4(Box4, { flexShrink: 0, children: [
+    /* @__PURE__ */ jsxs4(Text4, { color: COLOR.accent, children: [
+      GLYPH.caret,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: ghost, children: before }),
+    /* @__PURE__ */ jsx4(Text4, { inverse: caretVisible, dimColor: !caretVisible && ghost, children: cell || " " }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: ghost, children: tail })
+  ] });
+}
+function CommandMenu({ rows, selected }) {
+  const labelWidth = Math.max(1, ...rows.map((row) => row.label.length));
+  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", paddingLeft: 2, children: rows.map((row, index) => {
+    const active = index === selected;
+    return /* @__PURE__ */ jsxs4(
+      Text4,
+      {
+        color: active ? COLOR.accent : void 0,
+        dimColor: !active,
+        wrap: "truncate-end",
+        children: [
+          active ? GLYPH.caret : " ",
+          " ",
+          padRight(row.label, labelWidth),
+          " ",
+          row.description
+        ]
+      },
+      row.key
+    );
+  }) });
+}
+
+// src/tui/history.ts
+import * as fs from "fs";
+import * as path from "path";
+var CONSOLE_DIR = "console";
+var HISTORY_FILE = "history.json";
+var EXPORT_DIR = "exports";
+function historyPath(workDir) {
+  return path.join(workDir, ".multiclaw", CONSOLE_DIR, HISTORY_FILE);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isTurnView(value) {
+  if (!isObject(value)) return false;
+  const turn = value;
+  return typeof turn.turn === "number" && typeof turn.phase === "string" && isObject(turn.agents) && Object.values(turn.agents).every(isObject) && Array.isArray(turn.stages) && turn.stages.every(isObject) && Array.isArray(turn.leaderIds);
+}
+function loadHistory(workDir) {
+  try {
+    const raw = fs.readFileSync(historyPath(workDir), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isTurnView).slice(-MAX_HISTORY);
+  } catch {
+    return [];
+  }
+}
+async function saveHistory(workDir, turns) {
+  const target = historyPath(workDir);
+  await fs.promises.mkdir(path.dirname(target), { recursive: true });
+  const tmp = `${target}.tmp`;
+  await fs.promises.writeFile(tmp, JSON.stringify(turns), "utf-8");
+  await fs.promises.rename(tmp, target);
+}
+function exportPath(workDir, turn) {
+  return path.join(workDir, ".multiclaw", CONSOLE_DIR, EXPORT_DIR, `turn-${turn}.md`);
+}
+async function exportTurn(turn, filePath) {
+  await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.promises.writeFile(filePath, formatTurnMarkdown(turn), "utf-8");
+}
+function formatTurnMarkdown(turn) {
+  const lines = [`# Turn ${turn.turn}`, ""];
+  if (turn.requirement) lines.push("## Requirement", "", turn.requirement, "");
+  if (turn.reply) {
+    lines.push("## Reply", "", `_${turn.reply.mode}_`, "", turn.reply.message, "");
+  } else {
+    lines.push("## Result", "", `Status: ${turn.success ? "success" : "failed"}`, "");
+  }
+  const agents = Object.values(turn.agents);
+  if (agents.length > 0) {
+    lines.push("## Agents", "");
+    for (const agent of agents) {
+      lines.push(`- ${agent.id}: ${agent.name} \u2014 ${agent.status}`);
+    }
+    lines.push("");
+    lines.push("## Logs", "");
+    for (const agent of agents) {
+      lines.push(`### ${agent.id}: ${agent.name}`, "", "```", agent.logs ?? "", "```", "");
+    }
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+
+// src/tui/App.tsx
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var FLUSH_INTERVAL_MS = 80;
+var SPINNER_INTERVAL_MS = 110;
+var BLINK_INTERVAL_MS = 530;
+var INPUT_PLACEHOLDER = "describe what the team should do\u2026";
+var RUNNING_PLACEHOLDER = "type to queue a follow-up\u2026";
+var EMPTY_LINE = { text: "", cursor: 0 };
+function pickRecordedTurn(state, raw, whenEmpty) {
+  const turns = recordedTurns(state);
+  if (turns.length === 0) return { error: whenEmpty };
+  const target = raw === void 0 ? turns[turns.length - 1] : turns.find((t) => String(t.turn) === raw);
+  if (!target) return { error: `no turn ${raw}` };
+  return { record: target };
+}
+function pickTurn(state, raw, whenEmpty) {
+  const target = pickRecordedTurn(state, raw, whenEmpty);
+  if ("error" in target) return target;
+  if (!target.record.requirement) return { error: `turn ${target.record.turn} has no requirement` };
+  return { record: target.record, requirement: target.record.requirement };
+}
+function StatusLine({
+  state,
+  running,
+  cancelled,
+  error,
+  now,
+  spinner,
+  queued
+}) {
+  const { done, total } = progress(state);
+  if (error)
+    return /* @__PURE__ */ jsx5(Text5, { color: COLOR.error, wrap: "truncate-end", children: error });
+  if (state.warning && state.phase !== "complete")
+    return /* @__PURE__ */ jsx5(Text5, { color: COLOR.warn, wrap: "truncate-end", children: state.warning });
+  if (cancelled && !running) return /* @__PURE__ */ jsx5(Text5, { color: COLOR.warn, children: "cancelled" });
+  if (state.reply) {
+    const asking = state.reply.mode === "ask";
+    return /* @__PURE__ */ jsx5(Text5, { color: asking ? COLOR.warn : COLOR.ok, wrap: "truncate-end", children: asking ? `${GLYPH.ask} needs your input` : `${STATUS.success.glyph} answered` });
+  }
+  if (running) {
+    const elapsed = turnElapsed(state, now);
+    const time = elapsed === void 0 ? "" : ` ${formatDuration(elapsed)}`;
+    return /* @__PURE__ */ jsxs5(Text5, { color: COLOR.accent, wrap: "truncate-end", children: [
+      spinner,
+      " running",
+      time,
+      " \xB7 ",
+      done,
+      "/",
+      total,
+      " agents",
+      queued > 0 ? ` \xB7 ${queued} queued` : ""
+    ] });
+  }
+  if (state.phase === "complete") {
+    const time = state.totalDuration === void 0 ? "" : ` ${formatDuration(state.totalDuration)}`;
+    const outcome2 = state.success ? `${STATUS.success.glyph} done${time}` : `${STATUS.failed.glyph} finished with failures${time}`;
+    const cost = state.totalCostUsd === void 0 ? "" : ` \xB7 ${formatCost(state.totalCostUsd)}`;
+    return /* @__PURE__ */ jsxs5(Text5, { color: state.success ? COLOR.ok : COLOR.error, wrap: "truncate-end", children: [
+      outcome2,
+      cost,
+      state.warning ? ` \xB7 ${GLYPH.warn} ${state.warning}` : ""
+    ] });
+  }
+  const stages = state.stages.length;
+  return /* @__PURE__ */ jsxs5(Text5, { dimColor: true, wrap: "truncate-end", children: [
+    "ready \xB7 ",
+    total,
+    " agents",
+    stages > 0 ? ` \xB7 ${stages} stages` : ""
+  ] });
+}
+function App({ config, onTurnStart }) {
+  const { exit } = useApp();
+  const { columns, rows } = useWindowSize();
+  const [state, dispatch] = useReducer(
+    tuiReducer,
+    config,
+    (c) => createInitialState(c, loadHistory(c.workDir))
+  );
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const [line, setLine] = useState(EMPTY_LINE);
+  const [caretOn, setCaretOn] = useState(true);
+  const [tick, setTick] = useState(0);
+  const [running, setRunning] = useState(false);
+  const [queue, setQueue] = useState([]);
+  const [cancelled, setCancelled] = useState(false);
+  const [error, setError] = useState();
+  const [notice, setNotice] = useState();
+  const [helpOpen, setHelpOpen] = useState(false);
+  const [historyOpen, setHistoryOpen] = useState(false);
+  const [historyCursor, setHistoryCursor] = useState(0);
+  const [menuCursor, setMenuCursor] = useState({
+    query: void 0,
+    index: 0
+  });
+  const abortRef = useRef(null);
+  const pending = useRef([]);
+  const flush = useCallback(() => {
+    const batch = pending.current;
+    if (batch.length === 0) return;
+    pending.current = [];
+    for (const event of batch) dispatch({ type: "event", event });
+  }, []);
+  useEffect(() => {
+    if (!running) return;
+    const timer = setInterval(() => setTick((value) => value + 1), SPINNER_INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, [running]);
+  useEffect(() => {
+    if (!running && line.text === "") {
+      setCaretOn(true);
+      return;
+    }
+    const timer = setInterval(() => setCaretOn((on) => !on), BLINK_INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, [running, line.text]);
+  const lastSaved = useRef(void 0);
+  useEffect(() => {
+    const turns = recordedTurns(stateRef.current).slice(-MAX_HISTORY);
+    if (turns.length === 0) return;
+    const json = JSON.stringify(turns);
+    if (json === lastSaved.current) return;
+    lastSaved.current = json;
+    void saveHistory(config.workDir, turns).catch(
+      (err) => setNotice(`history not saved: ${err.message}`)
+    );
+  }, [state.history, state.phase]);
+  const startTurn = useCallback(
+    async (requirement, opts) => {
+      setError(void 0);
+      setCancelled(false);
+      setNotice(void 0);
+      const earlierTurns = conversationTurns(stateRef.current);
+      dispatch({
+        type: "turn:start",
+        requirement,
+        agents: seedAgents(config),
+        leaderIds: leaderAgentIds(config),
+        startedAt: Date.now()
+      });
+      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const logDir = path2.join(config.workDir, ".multiclaw", "runs", `run-${stamp}`, "logs");
+      const runConfig = {
+        ...config,
+        context: { ...config.context, requirement },
+        // An answer only reads as a requirement next to the question it answers,
+        // so the leader is handed the turns behind this one as well.
+        history: earlierTurns,
+        logDir,
+        // Only a retry carries this; a normal turn lets the leader route.
+        ...opts?.resume ? { resume: opts.resume } : {}
+      };
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setRunning(true);
+      const orchestrator = new Orchestrator(runConfig);
+      const unsubscribe = orchestrator.eventBus.subscribe((event) => {
+        pending.current.push(event);
+      });
+      onTurnStart?.(orchestrator.eventBus, logDir);
+      const timer = setInterval(flush, FLUSH_INTERVAL_MS);
+      try {
+        await orchestrator.run({ signal: controller.signal });
+      } catch (err) {
+        if (isAbortError(err)) setCancelled(true);
+        else setError(err.message);
+      } finally {
+        clearInterval(timer);
+        flush();
+        unsubscribe();
+        abortRef.current = null;
+        setRunning(false);
+      }
+    },
+    [config, flush, onTurnStart]
+  );
+  useEffect(() => {
+    if (running || queue.length === 0) return;
+    const [next, ...rest] = queue;
+    setQueue(rest);
+    void startTurn(next);
+  }, [running, queue, startTurn]);
+  const query = menuQuery(line.text);
+  const matches = useMemo(
+    () => query === void 0 ? [] : matchCommands(query, running),
+    [query, running]
+  );
+  const historyTurns = useMemo(() => [...state.history].reverse(), [state.history]);
+  const historyIndex = historyTurns.length === 0 ? 0 : Math.min(historyCursor, historyTurns.length - 1);
+  const shown = state.view ?? state;
+  const arg = argQuery(line.text);
+  const argRows = arg ? completeAgents(arg.partial, Object.keys(shown.agents)).map((id) => ({
+    key: id,
+    label: id,
+    // The static role, not the per-turn task title: while completing, the
+    // user is asking "which agent is this", not "what is it doing now".
+    description: shown.agents[id]?.description ?? shown.agents[id]?.name ?? id
+  })) : [];
+  const allRows = arg ? argRows : paletteRows(matches);
+  const paletteKey = arg ? `${arg.command.name} ${arg.partial}` : query;
+  const paletteTotal = allRows.length;
+  const menuIndex = menuCursor.query === paletteKey ? menuCursor.index : 0;
+  const selected = paletteTotal === 0 ? 0 : Math.min(menuIndex, paletteTotal - 1);
+  const menuOpen = !helpOpen && !historyOpen && query !== void 0 && matches.length > 0;
+  const argOpen = !helpOpen && !historyOpen && arg !== void 0 && argRows.length > 0;
+  const paletteOpen = menuOpen || argOpen;
+  const layout = computeLayout({
+    columns,
+    rows,
+    turn: state.turn,
+    overlay: helpOpen || historyOpen,
+    menuRows: paletteOpen ? paletteTotal : 0,
+    queueRows: queue.length,
+    notice: notice !== void 0,
+    viewing: state.view !== void 0,
+    hasRail: shown.leaderIds.length > 0 || shown.stages.length > 0,
+    railCells: railCellWidths(shown)
+  });
+  const runCommand = useCallback(
+    (name, args) => {
+      setLine(EMPTY_LINE);
+      if (!canRun(name, running)) {
+        setNotice(unavailableReason(name, running));
+        return;
+      }
+      const shown2 = state.view ?? state;
+      switch (name) {
+        case "agents":
+          setNotice(
+            `team: ${plannedAgents(config).map((agent) => agent.id).join(", ")}`
+          );
+          return;
+        case "focus": {
+          const input = args[0];
+          if (!input) {
+            setNotice("usage: /focus <agent id>");
+            return;
+          }
+          const resolved = resolveAgentId(input, Object.keys(shown2.agents));
+          if ("error" in resolved) {
+            setNotice(resolved.error);
+            return;
+          }
+          dispatch({ type: "focus:set", agentId: resolved.id });
+          setNotice(`focused ${resolved.id}`);
+          return;
+        }
+        case "clear":
+          if (!shown2.focusId) {
+            setNotice("nothing focused");
+            return;
+          }
+          dispatch({ type: "stream:clear" });
+          setNotice(`cleared ${shown2.focusId}`);
+          return;
+        case "history":
+          if (state.history.length === 0) {
+            setNotice("no earlier turns yet");
+            return;
+          }
+          setNotice(void 0);
+          setHistoryCursor(0);
+          setHistoryOpen(true);
+          return;
+        case "verbose":
+          dispatch({ type: "verbose:toggle" });
+          setNotice(state.verbose ? "verbose off" : "verbose on \u2014 showing tool detail");
+          return;
+        case "retry": {
+          if (state.phase !== "complete" || !state.requirement) {
+            setNotice("nothing to retry yet");
+            return;
+          }
+          let ids;
+          if (args[0]) {
+            const resolved = resolveAgentId(args[0], Object.keys(state.agents));
+            if ("error" in resolved) {
+              setNotice(resolved.error);
+              return;
+            }
+            ids = [resolved.id];
+          } else {
+            ids = Object.values(state.agents).filter((agent) => agent.status === "failed").map((agent) => agent.id);
+          }
+          if (ids.length === 0) {
+            setNotice("nothing failed");
+            return;
+          }
+          const sessions = Object.fromEntries(
+            ids.filter((id) => state.agents[id]?.sessionId).map((id) => [id, state.agents[id].sessionId])
+          );
+          void startTurn(state.requirement, {
+            resume: {
+              agents: ids,
+              ...Object.keys(sessions).length > 0 ? { sessions } : {}
+            }
+          });
+          setNotice(
+            `retrying ${ids.join(", ")} \u2014 ${describeResumePlan({
+              agents: ids,
+              sessions,
+              team: config.agents
+            })}`
+          );
+          return;
+        }
+        case "replay": {
+          const target = pickTurn(state, args[0], "nothing to replay yet");
+          if ("error" in target) {
+            setNotice(target.error);
+            return;
+          }
+          void startTurn(target.requirement);
+          setNotice(`replaying turn ${target.record.turn}`);
+          return;
+        }
+        case "fork": {
+          const target = pickTurn(state, args[0], "nothing to fork yet");
+          if ("error" in target) {
+            setNotice(target.error);
+            return;
+          }
+          setLine({ text: target.requirement, cursor: target.requirement.length });
+          setNotice(`editing turn ${target.record.turn} \u2014 enter to run`);
+          return;
+        }
+        case "export": {
+          const target = pickRecordedTurn(state, args[0], "nothing to export yet");
+          if ("error" in target) {
+            setNotice(target.error);
+            return;
+          }
+          const file = args[1] ? path2.resolve(config.workDir, args[1]) : exportPath(config.workDir, target.record.turn);
+          void exportTurn(target.record, file).then(() => setNotice(`exported turn ${target.record.turn} to ${file}`)).catch((err) => setNotice(`export failed: ${err.message}`));
+          return;
+        }
+        case "search": {
+          const text = args.join(" ");
+          if (!text) {
+            setNotice("usage: /search <text>");
+            return;
+          }
+          dispatch({
+            type: "stream:search",
+            query: text,
+            viewport: layout.logViewport,
+            width: layout.streamWidth
+          });
+          setNotice(`searched for ${text}`);
+          return;
+        }
+        case "latest":
+          dispatch({ type: "stream:latest" });
+          setNotice("showing latest output");
+          return;
+        case "cancel": {
+          if (!abortRef.current) {
+            setNotice("nothing to cancel");
+            return;
+          }
+          const dropped = queue.length;
+          abortRef.current.abort();
+          setQueue([]);
+          setCancelled(true);
+          setNotice(dropped > 0 ? `cancelling\u2026 \xB7 dropped ${dropped} queued` : "cancelling\u2026");
+          return;
+        }
+        case "help":
+          setNotice(void 0);
+          setHelpOpen(true);
+          return;
+        case "quit":
+          exit();
+          return;
+        default:
+          setNotice(`unknown command: /${name}`);
+      }
+    },
+    [config, exit, layout.logViewport, layout.streamWidth, queue.length, running, state, startTurn]
+  );
+  const submit = useCallback(() => {
+    const text = line.text.trim();
+    if (!text) return;
+    const command = parseCommand(text);
+    if (command) {
+      runCommand(command.name, command.args);
+      return;
+    }
+    setLine(EMPTY_LINE);
+    setNotice(void 0);
+    if (running) {
+      setQueue((pending2) => [...pending2, text]);
+      return;
+    }
+    void startTurn(text);
+  }, [line.text, runCommand, running, startTurn]);
+  const insert = useCallback((chunk) => {
+    setLine((l) => ({
+      text: l.text.slice(0, l.cursor) + chunk + l.text.slice(l.cursor),
+      cursor: l.cursor + chunk.length
+    }));
+  }, []);
+  const backspace = useCallback(() => {
+    setLine(
+      (l) => l.cursor === 0 ? l : { text: l.text.slice(0, l.cursor - 1) + l.text.slice(l.cursor), cursor: l.cursor - 1 }
+    );
+  }, []);
+  const deleteForward = useCallback(() => {
+    setLine(
+      (l) => l.cursor >= l.text.length ? l : { text: l.text.slice(0, l.cursor) + l.text.slice(l.cursor + 1), cursor: l.cursor }
+    );
+  }, []);
+  const move = useCallback((delta) => {
+    setLine((l) => ({ ...l, cursor: Math.min(Math.max(0, l.cursor + delta), l.text.length) }));
+  }, []);
+  const moveTo = useCallback((cursor) => {
+    setLine((l) => ({ ...l, cursor }));
+  }, []);
+  const windowStart = listWindowStart(selected, paletteTotal, layout.menuRows);
+  const paletteWindow = allRows.slice(windowStart, windowStart + layout.menuRows);
+  const paletteSelected = selected - windowStart;
+  const now = Date.now();
+  const spinner = SPINNER[tick % SPINNER.length];
+  const handleKey = (char, key) => {
+    if (key.ctrl && char === "c") {
+      if (helpOpen) {
+        setHelpOpen(false);
+      } else if (historyOpen) {
+        setHistoryOpen(false);
+      } else if (abortRef.current) {
+        abortRef.current.abort();
+        setNotice(queue.length > 0 ? `cancelling\u2026 \xB7 dropped ${queue.length} queued` : "cancelling\u2026");
+        setQueue([]);
+        setCancelled(true);
+      } else if (line.text) {
+        setLine(EMPTY_LINE);
+      } else {
+        exit();
+      }
+      return;
+    }
+    if (helpOpen) {
+      if (key.escape || char === "?") setHelpOpen(false);
+      return;
+    }
+    if (historyOpen) {
+      if (key.escape) {
+        setHistoryOpen(false);
+        return;
+      }
+      if (historyTurns.length === 0) return;
+      if (key.upArrow) {
+        setHistoryCursor((historyIndex - 1 + historyTurns.length) % historyTurns.length);
+        return;
+      }
+      if (key.downArrow) {
+        setHistoryCursor((historyIndex + 1) % historyTurns.length);
+        return;
+      }
+      if (key.return) {
+        dispatch({ type: "view:open", turn: historyTurns[historyIndex].turn });
+        setHistoryOpen(false);
+        return;
+      }
+      return;
+    }
+    if (key.ctrl && char === "d") {
+      if (!line.text) exit();
+      return;
+    }
+    if (key.ctrl && char === "l") {
+      dispatch({ type: "stream:clear" });
+      setNotice(shown.focusId ? `cleared ${shown.focusId}` : "nothing focused");
+      return;
+    }
+    if (key.ctrl && char === "a") {
+      moveTo(0);
+      return;
+    }
+    if (key.ctrl && char === "e") {
+      setLine((l) => ({ ...l, cursor: l.text.length }));
+      return;
+    }
+    if (key.tab) {
+      dispatch({ type: "focus:cycle", delta: key.shift ? -1 : 1 });
+      return;
+    }
+    if (paletteOpen) {
+      if (key.upArrow) {
+        setMenuCursor({ query: paletteKey, index: (menuIndex - 1 + paletteTotal) % paletteTotal });
+        return;
+      }
+      if (key.downArrow) {
+        setMenuCursor({ query: paletteKey, index: (menuIndex + 1) % paletteTotal });
+        return;
+      }
+      if (key.escape) {
+        setLine(EMPTY_LINE);
+        return;
+      }
+      if (key.return) {
+        if (arg) runCommand(arg.command.name, [allRows[selected].key]);
+        else runCommand(matches[selected].name, []);
+        return;
+      }
+    }
+    if (key.upArrow) {
+      dispatch({
+        type: "stream:scroll",
+        delta: 1,
+        viewport: layout.logViewport,
+        width: layout.streamWidth
+      });
+      return;
+    }
+    if (key.downArrow) {
+      dispatch({
+        type: "stream:scroll",
+        delta: -1,
+        viewport: layout.logViewport,
+        width: layout.streamWidth
+      });
+      return;
+    }
+    if (key.pageUp) {
+      dispatch({
+        type: "stream:scroll",
+        delta: layout.logViewport,
+        viewport: layout.logViewport,
+        width: layout.streamWidth
+      });
+      return;
+    }
+    if (key.pageDown) {
+      dispatch({
+        type: "stream:scroll",
+        delta: -layout.logViewport,
+        viewport: layout.logViewport,
+        width: layout.streamWidth
+      });
+      return;
+    }
+    if (char === "?" && line.text === "" && !running) {
+      setHelpOpen(true);
+      return;
+    }
+    if (key.return) {
+      submit();
+      return;
+    }
+    if (key.leftArrow) {
+      move(-1);
+      return;
+    }
+    if (key.rightArrow) {
+      move(1);
+      return;
+    }
+    if (key.home) {
+      moveTo(0);
+      return;
+    }
+    if (key.end) {
+      setLine((l) => ({ ...l, cursor: l.text.length }));
+      return;
+    }
+    if (key.escape) {
+      if (error) {
+        setError(void 0);
+        return;
+      }
+      if (state.view) {
+        dispatch({ type: "view:close" });
+        return;
+      }
+      setLine(EMPTY_LINE);
+      setNotice(void 0);
+      return;
+    }
+    if (key.backspace) {
+      backspace();
+      return;
+    }
+    if (key.delete) {
+      deleteForward();
+      return;
+    }
+    if (char && !key.ctrl && !key.meta) insert(char.replace(/\r\n?/g, "\n"));
+  };
+  const handlerRef = useRef(handleKey);
+  handlerRef.current = handleKey;
+  useInput((char, key) => handlerRef.current(char, key));
+  const keys = helpOpen ? "esc close" : historyOpen ? "\u2191\u2193 select \xB7 enter open \xB7 esc close" : argOpen ? `\u2191\u2193 select \xB7 enter ${arg?.command.name} \xB7 esc close` : menuOpen ? "\u2191\u2193 select \xB7 enter run \xB7 esc close" : running ? "enter queues \xB7 ctrl+c cancel" : state.view ? "esc live \xB7 tab agent \xB7 ? help" : state.reply ? "enter sends \xB7 / commands \xB7 ? help" : "tab switch \xB7 / commands \xB7 ? help";
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", height: layout.rows, children: [
+    /* @__PURE__ */ jsx5(
+      Header,
+      {
+        name: state.name || config.name,
+        right: state.view ? `turn ${shown.turn} \xB7 viewing` : `turn ${shown.turn} \xB7 ${running ? formatDuration(turnElapsed(state, now) ?? 0) : state.phase === "complete" ? "complete" : "ready"}`
+      }
+    ),
+    /* @__PURE__ */ jsx5(Rule, { width: layout.columns }),
+    config.useLeader === false ? /* @__PURE__ */ jsx5(Text5, { color: COLOR.warn, dimColor: true, wrap: "truncate-end", children: "  \u26A0 leader off \u2014 every message runs the full team" }) : null,
+    layout.showRail ? (
+      // The rail wraps, so it can be taller than one row. Cap it at the height
+      // the budget reserved and clip, rather than letting the extra rows push
+      // the chrome below it off the screen.
+      /* @__PURE__ */ jsx5(Box5, { marginTop: 1, height: layout.railRows, overflow: "hidden", flexShrink: 0, children: /* @__PURE__ */ jsx5(PipelineRail, { turn: shown, spinner }) })
+    ) : null,
+    shown.reason ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, wrap: "truncate-end", children: `  reason: ${shown.reason}` }) : null,
+    /* @__PURE__ */ jsx5(
+      Box5,
+      {
+        marginTop: 1,
+        height: layout.bodyHeight,
+        flexShrink: 0,
+        flexDirection: "column",
+        overflow: "hidden",
+        children: helpOpen ? /* @__PURE__ */ jsx5(HelpOverlay, { width: layout.columns, maxRows: layout.bodyHeight }) : historyOpen ? /* @__PURE__ */ jsx5(
+          HistoryOverlay,
+          {
+            turns: historyTurns,
+            selected: historyIndex,
+            width: layout.columns,
+            maxRows: layout.bodyHeight
+          }
+        ) : layout.welcome ? /* @__PURE__ */ jsx5(WelcomePanel, { turn: state, width: layout.columns }) : error ? (
+          // The error wins over a reply: a run that stopped with an error is the
+          // most urgent thing on screen, and a stale answer underneath it would
+          // read as the outcome. The status line keeps a one-line version too.
+          /* @__PURE__ */ jsx5(ErrorPanel, { message: error, width: layout.columns })
+        ) : shown.reply ? /* @__PURE__ */ jsx5(ReplyPanel, { reply: shown.reply, width: layout.columns }) : /* @__PURE__ */ jsxs5(Box5, { height: layout.bodyHeight, flexShrink: 0, flexDirection: "row", children: [
+          layout.showTeam ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+            /* @__PURE__ */ jsx5(TeamPanel, { turn: shown, width: layout.teamWidth, now, spinner }),
+            /* @__PURE__ */ jsx5(Divider, {})
+          ] }) : null,
+          /* @__PURE__ */ jsx5(
+            StreamPanel,
+            {
+              turn: shown,
+              height: layout.bodyHeight,
+              width: layout.streamWidth,
+              now,
+              spinner
+            }
+          )
+        ] })
+      }
+    ),
+    state.view ? /* @__PURE__ */ jsx5(Text5, { color: COLOR.warn, wrap: "truncate-end", children: `  viewing turn ${shown.turn} \xB7 ${shown.requirement ?? "(no requirement)"} \xB7 esc to return` }) : null,
+    notice ? /* @__PURE__ */ jsxs5(Text5, { dimColor: true, wrap: "truncate-end", children: [
+      "  ",
+      notice
+    ] }) : null,
+    /* @__PURE__ */ jsx5(QueueStrip, { items: queue, max: layout.queueRows }),
+    paletteOpen ? /* @__PURE__ */ jsx5(CommandMenu, { rows: paletteWindow, selected: paletteSelected }) : null,
+    /* @__PURE__ */ jsx5(
+      Prompt,
+      {
+        value: line.text,
+        cursor: line.cursor,
+        caretVisible: caretOn,
+        placeholder: running ? RUNNING_PLACEHOLDER : INPUT_PLACEHOLDER
+      }
+    ),
+    /* @__PURE__ */ jsx5(
+      HintBar,
+      {
+        status: /* @__PURE__ */ jsx5(
+          StatusLine,
+          {
+            state,
+            running,
+            cancelled,
+            error,
+            now,
+            spinner,
+            queued: queue.length
+          }
+        ),
+        keys
+      }
+    )
+  ] });
+}
+
+// src/tui/index.ts
+async function startTui(options) {
+  if (process.stdout.isTTY !== true) {
+    throw new Error(
+      'The interactive TUI needs a TTY. Use `multiclaw run "<requirement>"` for headless execution.'
+    );
+  }
+  const restore = () => process.stdout.write("\x1B[?25h\x1B[?1049l");
+  process.stdout.write("\x1B[?1049h\x1B[?25l");
+  process.on("exit", restore);
+  try {
+    const app = render(createElement(App, options), { exitOnCtrlC: false });
+    await app.waitUntilExit();
+  } finally {
+    process.off("exit", restore);
+    restore();
+  }
+}
+export {
+  COMPACT_COLUMNS,
+  MAX_HISTORY,
+  MAX_LOG_CHARS,
+  MAX_MENU_ROWS,
+  MAX_QUEUE_ROWS,
+  MAX_RAIL_ROWS,
+  MIN_COLUMNS,
+  MIN_ROWS,
+  RAIL_MIN_ROWS,
+  agentElapsed,
+  appendLog,
+  computeLayout,
+  conversationTurns,
+  createInitialState,
+  initialState,
+  leaderAgentIds,
+  measureRailRows,
+  plannedAgents,
+  progress,
+  recordedTurns,
+  reduceEvent,
+  seedAgents,
+  stageStatus,
+  startTui,
+  stripAnsi,
+  tuiReducer,
+  turnElapsed,
+  visibleLog
+};