@wrongstack/tui 0.1.10 → 0.2.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { render, useApp, Box, useStdout, Static, Text, useInput } from 'ink';
+import { render, useApp, Box, useStdout, Static, Text, useInput, useStdin } from 'ink';
 import React, { useState, useReducer, useRef, useEffect, useMemo } from 'react';
 import * as fs from 'fs/promises';
 import * as path3 from 'path';
@@ -217,6 +217,159 @@ function FilePicker({ query, matches, selected }) {
 function highlight(path4, query) {
   return path4;
 }
+var STATUS_ICON = {
+  idle: { icon: "\u25CB", color: "gray" },
+  running: { icon: "\u25CF", color: "green" },
+  success: { icon: "\u2713", color: "green" },
+  failed: { icon: "\u2717", color: "red" },
+  timeout: { icon: "\u23F1", color: "yellow" },
+  stopped: { icon: "\u2298", color: "yellow" }
+};
+function fmtCost(n) {
+  if (n === 0) return "\u2014";
+  return `$${n.toFixed(3)}`;
+}
+function fmtCount(n) {
+  if (n === 0) return "\u2014";
+  return String(n);
+}
+function fmtModel(provider, model) {
+  if (!provider && !model) return "";
+  const p = provider ?? "";
+  const m = model ?? "";
+  return p && m ? `${p}/${m}` : p || m;
+}
+function resolveName(entry, roster) {
+  const rosterEntry = roster?.[entry.id];
+  if (rosterEntry) return rosterEntry.name;
+  return entry.name;
+}
+function FleetPanel({ entries, totalCost, roster }) {
+  const list = Object.values(entries);
+  if (list.length === 0) return null;
+  const sorted = [...list].sort((a, b) => {
+    const order = { running: 0, success: 1, failed: 2, timeout: 3, stopped: 4, idle: 5 };
+    const ao = order[a.status] ?? 9;
+    const bo = order[b.status] ?? 9;
+    if (ao !== bo) return ao - bo;
+    return b.lastEventAt - a.lastEventAt;
+  });
+  const runningCount = list.filter((e) => e.status === "running").length;
+  const totalLabel = totalCost > 0 ? `$${totalCost.toFixed(3)} \xB7 ${runningCount} active` : `${runningCount} active`;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      paddingX: 1,
+      borderStyle: "single",
+      borderTop: false,
+      borderBottom: false,
+      borderLeft: false,
+      borderRight: false,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 2, children: [
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Fleet" }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            list.length,
+            " agent",
+            list.length === 1 ? "" : "s"
+          ] }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: totalLabel })
+        ] }),
+        sorted.map((entry) => {
+          const si = STATUS_ICON[entry.status];
+          const modelTag = fmtModel(entry.provider, entry.model);
+          const name = resolveName(entry, roster);
+          return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
+              /* @__PURE__ */ jsx(Text, { color: si.color, children: si.icon }),
+              /* @__PURE__ */ jsx(Text, { children: name.slice(0, 16).padEnd(16) }),
+              modelTag ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7" }),
+                /* @__PURE__ */ jsx(Text, { dimColor: true, children: modelTag })
+              ] }) : null,
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7" }),
+              /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                fmtCount(entry.iterations).padStart(3),
+                "it"
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                fmtCount(entry.toolCalls).padStart(3),
+                "tc"
+              ] }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7" }),
+              /* @__PURE__ */ jsx(Text, { color: "yellow", children: fmtCost(entry.cost) })
+            ] }),
+            entry.status === "running" && entry.currentTool ? /* @__PURE__ */ jsxs(Box, { paddingLeft: 2, children: [
+              /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+                "\u2192 ",
+                entry.currentTool.name
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                " (",
+                Math.max(0, Date.now() - entry.currentTool.startedAt),
+                "ms)"
+              ] })
+            ] }) : null,
+            entry.status === "running" && entry.streamingText ? /* @__PURE__ */ jsx(Box, { paddingLeft: 2, children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+              ">",
+              " ",
+              entry.streamingText.slice(-80)
+            ] }) }) : null,
+            entry.transcriptPath ? /* @__PURE__ */ jsx(Box, { paddingLeft: 2, children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+              "log: ",
+              entry.transcriptPath
+            ] }) }) : null
+          ] }, entry.id);
+        })
+      ]
+    }
+  );
+}
+function fmtElapsed(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const m = Math.floor(ms / 6e4);
+  const s = Math.floor(ms % 6e4 / 1e3);
+  return `${m}m${s.toString().padStart(2, "0")}s`;
+}
+function LiveActivityStrip({
+  entries,
+  nowTick,
+  maxRows = 4
+}) {
+  const running = Object.values(entries).filter((e) => e.status === "running").sort((a, b) => a.startedAt - b.startedAt).slice(0, maxRows);
+  if (running.length === 0) return null;
+  const now = Date.now();
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    running.map((e) => {
+      const toolElapsed = e.currentTool ? now - e.currentTool.startedAt : 0;
+      const taskElapsed = now - e.startedAt;
+      const toolSeg = e.currentTool ? `\u2192 ${e.currentTool.name} (${fmtElapsed(toolElapsed)})` : "idle between tools";
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u25CF" }),
+        /* @__PURE__ */ jsx(Text, { children: e.name.slice(0, 14).padEnd(14) }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7" }),
+        /* @__PURE__ */ jsx(Text, { color: e.currentTool ? "green" : "yellow", children: toolSeg }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7" }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          e.iterations,
+          "it ",
+          e.toolCalls,
+          "tc \xB7 ",
+          fmtElapsed(taskElapsed)
+        ] })
+      ] }, e.id);
+    }),
+    Object.values(entries).filter((e) => e.status === "running").length > maxRows ? /* @__PURE__ */ jsx(Box, { paddingLeft: 2, children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "\u2026+",
+      Object.values(entries).filter((e) => e.status === "running").length - maxRows,
+      " more"
+    ] }) }) : null
+  ] });
+}
 
 // src/markdown-table.ts
 function renderMarkdownTables(text, maxWidth) {
@@ -596,6 +749,29 @@ function Entry({
       );
     case "banner":
       return /* @__PURE__ */ jsx(Banner, { entry });
+    case "subagent": {
+      const lines = entry.text.split("\n");
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: entry.agentColor, bold: true, children: `[${entry.agentLabel}]` }),
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          /* @__PURE__ */ jsx(Text, { color: entry.agentColor, children: entry.icon }),
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          /* @__PURE__ */ jsx(Text, { children: lines[0] ?? "" }),
+          entry.detail ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  \xB7  " }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: entry.detail })
+          ] }) : null
+        ] }),
+        lines.slice(1).map((line, i) => (
+          // biome-ignore lint/suspicious/noArrayIndexKey: stable line index
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  " }),
+            /* @__PURE__ */ jsx(Text, { children: line })
+          ] }, i)
+        ))
+      ] });
+    }
   }
 }
 function Banner({
@@ -1120,8 +1296,51 @@ function formatToolOutput(toolName, output, ok, _outputBytes, outputLines) {
     const lastLine = lines[lines.length - 1];
     return lastLine ? [head, `"${truncMid(lastLine.trim(), 70)}"`] : [head];
   }
-  const firstLine = text.split("\n").find((l) => l.trim()) ?? text;
-  return [truncMid(firstLine.replace(/\s+/g, " "), OUT_BUDGET)];
+  if (json && typeof json === "object" && !Array.isArray(json)) {
+    const summary = summarizeJsonObject(json);
+    if (summary) return [summary];
+  }
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  return [truncMid(collapsed, GENERIC_BUDGET)];
+}
+var GENERIC_BUDGET = 240;
+function summarizeJsonObject(obj) {
+  const keys = Object.keys(obj);
+  if (keys.length === 0) return null;
+  const priority = [
+    "ok",
+    "status",
+    "timedOut",
+    "stopReason",
+    "reason",
+    "error",
+    "message",
+    "result",
+    "summary",
+    "iterations",
+    "toolCalls",
+    "durationMs",
+    "subagentId",
+    "taskId"
+  ];
+  const ordered = [
+    ...priority.filter((k) => keys.includes(k)),
+    ...keys.filter((k) => !priority.includes(k))
+  ];
+  const parts = [];
+  let used = 0;
+  for (const key of ordered) {
+    const v = obj[key];
+    if (v === void 0 || v === null) continue;
+    const rendered = typeof v === "string" ? `${key}="${truncMid(v.replace(/\s+/g, " "), 80)}"` : typeof v === "number" || typeof v === "boolean" ? `${key}=${v}` : Array.isArray(v) ? `${key}=[${v.length}]` : `${key}={\u2026}`;
+    if (used + rendered.length > GENERIC_BUDGET) {
+      parts.push("\u2026");
+      break;
+    }
+    parts.push(rendered);
+    used += rendered.length + 3;
+  }
+  return parts.length > 0 ? parts.join(" \xB7 ") : null;
 }
 function firstNonEmpty(text) {
   if (!text) return void 0;
@@ -1239,6 +1458,31 @@ function truncMid(s, max) {
   if (s.length <= max) return s;
   return `${s.slice(0, max - 1)}\u2026`;
 }
+function isHomeEnd(data) {
+  if (data === "\x1B[H" || data === "\x1B[1~" || data === "\x1BOH" || data === "\x1B[7~")
+    return "home";
+  if (data === "\x1B[F" || data === "\x1B[4~" || data === "\x1BOF" || data === "\x1B[8~")
+    return "end";
+  return null;
+}
+var EMPTY_KEY = {
+  upArrow: false,
+  downArrow: false,
+  leftArrow: false,
+  rightArrow: false,
+  return: false,
+  escape: false,
+  ctrl: false,
+  meta: false,
+  shift: false,
+  tab: false,
+  backspace: false,
+  delete: false,
+  pageUp: false,
+  pageDown: false,
+  home: false,
+  end: false
+};
 function Input({
   prompt = "\u203A ",
   value,
@@ -1252,6 +1496,19 @@ function Input({
     if (disabled) return;
     onKey(input, key);
   });
+  const { stdin } = useStdin();
+  useEffect(() => {
+    if (!stdin || disabled) return;
+    const handleData = (data) => {
+      const kind = isHomeEnd(data.toString());
+      if (kind === "home") onKey("", { ...EMPTY_KEY, home: true });
+      else if (kind === "end") onKey("", { ...EMPTY_KEY, end: true });
+    };
+    stdin.on("data", handleData);
+    return () => {
+      stdin.off("data", handleData);
+    };
+  }, [stdin, disabled, onKey]);
   const before = value.slice(0, cursor);
   const at = value.slice(cursor, cursor + 1) || " ";
   const after = value.slice(cursor + 1);
@@ -1348,6 +1605,9 @@ function StatusBar({
   yolo = false,
   elapsedMs,
   todos,
+  plan,
+  fleet,
+  fleetAgents,
   git,
   subagentCount = 0,
   context,
@@ -1358,7 +1618,9 @@ function StatusBar({
   const cache2 = tokenCounter?.cacheStats();
   const stateColor = state === "idle" ? "cyan" : state === "aborting" ? "yellow" : "green";
   const stateLabel = state === "idle" ? "idle" : state === "aborting" ? "aborting\u2026" : "thinking\u2026";
-  const hasSecondLine = yolo || elapsedMs !== void 0 || todos && (todos.pending > 0 || todos.inProgress > 0 || todos.completed > 0) || git !== null && git !== void 0 || subagentCount > 0 || projectName !== void 0 && projectName.length > 0;
+  const hasSecondLine = yolo || elapsedMs !== void 0 || git !== null && git !== void 0 || projectName !== void 0 && projectName.length > 0;
+  const fleetHasActivity = fleet && (fleet.running > 0 || fleet.idle > 0 || fleet.pending > 0 || fleet.completed > 0) || subagentCount > 0;
+  const hasThirdLine = todos && (todos.pending > 0 || todos.inProgress > 0 || todos.completed > 0) || plan && (plan.open > 0 || plan.inProgress > 0 || plan.done > 0) || fleetHasActivity;
   return /* @__PURE__ */ jsxs(
     Box,
     {
@@ -1425,7 +1687,7 @@ function StatusBar({
             yolo ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }) : null,
             /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
               "\u23F1 ",
-              fmtElapsed(elapsedMs)
+              fmtElapsed2(elapsedMs)
             ] })
           ] }) : null,
           projectName ? /* @__PURE__ */ jsxs(Fragment, { children: [
@@ -1455,36 +1717,93 @@ function StatusBar({
                 git.untracked
               ] }) : null
             ] })
+          ] }) : null
+        ] }) : null,
+        hasThirdLine ? /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 2, children: [
+          todos && (todos.pending > 0 || todos.inProgress > 0 || todos.completed > 0) ? /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "todos " }),
+            todos.inProgress > 0 ? /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+              "\u231B",
+              todos.inProgress
+            ] }) : null,
+            todos.inProgress > 0 && (todos.pending > 0 || todos.completed > 0) ? " " : "",
+            todos.pending > 0 ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+              "\u2610",
+              todos.pending
+            ] }) : null,
+            todos.pending > 0 && todos.completed > 0 ? " " : "",
+            todos.completed > 0 ? /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+              "\u2713",
+              todos.completed
+            ] }) : null
           ] }) : null,
-          todos && (todos.pending > 0 || todos.inProgress > 0 || todos.completed > 0) ? /* @__PURE__ */ jsxs(Fragment, { children: [
-            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+          plan && (plan.open > 0 || plan.inProgress > 0 || plan.done > 0) ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            todos && (todos.pending > 0 || todos.inProgress > 0 || todos.completed > 0) ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }) : null,
             /* @__PURE__ */ jsxs(Text, { children: [
-              todos.inProgress > 0 ? /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
-                "\u231B ",
-                todos.inProgress
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u{1F4CB} " }),
+              plan.inProgress > 0 ? /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+                "\u231B",
+                plan.inProgress
               ] }) : null,
-              todos.inProgress > 0 && (todos.pending > 0 || todos.completed > 0) ? " " : "",
-              todos.pending > 0 ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-                "\u2610 ",
-                todos.pending
+              plan.inProgress > 0 && (plan.open > 0 || plan.done > 0) ? " " : "",
+              plan.open > 0 ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                "\u2610",
+                plan.open
               ] }) : null,
-              todos.pending > 0 && todos.completed > 0 ? " " : "",
-              todos.completed > 0 ? /* @__PURE__ */ jsxs(Text, { color: "green", children: [
-                "\u2713 ",
-                todos.completed
+              plan.open > 0 && plan.done > 0 ? " " : "",
+              plan.done > 0 ? /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+                "\u2713",
+                plan.done
               ] }) : null
             ] })
           ] }) : null,
-          subagentCount > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
-            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
-            /* @__PURE__ */ jsxs(Text, { color: "blue", children: [
+          fleetHasActivity ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            todos && (todos.pending > 0 || todos.inProgress > 0 || todos.completed > 0) || plan && (plan.open > 0 || plan.inProgress > 0 || plan.done > 0) ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }) : null,
+            fleet ? /* @__PURE__ */ jsxs(Text, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "blue", children: "\u{1F310} " }),
+              fleet.running > 0 ? /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+                "\u25B6",
+                fleet.running
+              ] }) : null,
+              fleet.running > 0 && (fleet.pending > 0 || fleet.idle > 0 || fleet.completed > 0) ? " " : "",
+              fleet.pending > 0 ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                "\u2610",
+                fleet.pending
+              ] }) : null,
+              fleet.pending > 0 && (fleet.idle > 0 || fleet.completed > 0) ? " " : "",
+              fleet.idle > 0 ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                "\xB7",
+                fleet.idle,
+                "idle"
+              ] }) : null,
+              fleet.idle > 0 && fleet.completed > 0 ? " " : "",
+              fleet.completed > 0 ? /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+                "\u2713",
+                fleet.completed
+              ] }) : null
+            ] }) : /* @__PURE__ */ jsxs(Text, { color: "blue", children: [
               "\u{1F310} ",
               subagentCount,
               " agent",
               subagentCount === 1 ? "" : "s"
             ] })
           ] }) : null
-        ] }) : null
+        ] }) : null,
+        fleetAgents && fleetAgents.length > 0 ? /* @__PURE__ */ jsx(Box, { flexDirection: "row", gap: 2, children: fleetAgents.map((a, i) => (
+          // biome-ignore lint/suspicious/noArrayIndexKey: agent list is stable per render
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { color: a.color, bold: true, children: a.label }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: " " }),
+            /* @__PURE__ */ jsx(Text, { color: a.running ? "yellow" : void 0, dimColor: !a.running, children: a.running ? "\u25B6" : "\xB7" }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: " " }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: fmtElapsed2(a.elapsedMs) }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 " }),
+            /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+              a.toolCalls,
+              "t"
+            ] })
+          ] }, i)
+        )) }) : null
       ]
     }
   );
@@ -1524,7 +1843,7 @@ function fmtTok2(n) {
   if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
   return `${(n / 1e6).toFixed(1)}M`;
 }
-function fmtElapsed(ms) {
+function fmtElapsed2(ms) {
   const totalSec = Math.floor(ms / 1e3);
   const h = Math.floor(totalSec / 3600);
   const m = Math.floor(totalSec % 3600 / 60);
@@ -1782,6 +2101,10 @@ function reducer(state, action) {
       return { ...state, status: action.status };
     case "interrupt":
       return { ...state, interrupts: state.interrupts + 1 };
+    case "steerStart":
+      return { ...state, steeringPending: true, steerSnapshot: action.snapshot };
+    case "steerConsume":
+      return { ...state, steeringPending: false, steerSnapshot: null };
     case "resetInterrupts":
       return { ...state, interrupts: 0 };
     case "hint":
@@ -1982,9 +2305,234 @@ function reducer(state, action) {
       return { ...state, confirm: null };
     case "resetContextChip":
       return { ...state, contextChipVersion: state.contextChipVersion + 1 };
+    // --- Fleet ---
+    case "fleetSeed": {
+      const seeded = {};
+      for (const e of action.entries) seeded[e.id] = e;
+      return { ...state, fleet: seeded, fleetCost: action.cost };
+    }
+    case "fleetSpawn": {
+      if (state.fleet[action.id]) return state;
+      const entry = {
+        id: action.id,
+        name: action.name ?? action.id.slice(0, 8),
+        provider: action.provider,
+        model: action.model,
+        status: "idle",
+        streamingText: "",
+        iterations: 0,
+        toolCalls: 0,
+        cost: 0,
+        startedAt: Date.now(),
+        lastEventAt: Date.now(),
+        transcriptPath: action.transcriptPath
+      };
+      return { ...state, fleet: { ...state.fleet, [action.id]: entry } };
+    }
+    case "fleetToolStart": {
+      const cur = state.fleet[action.id];
+      if (!cur) return state;
+      return {
+        ...state,
+        fleet: {
+          ...state.fleet,
+          [action.id]: {
+            ...cur,
+            currentTool: { name: action.name, startedAt: Date.now() },
+            lastEventAt: Date.now()
+          }
+        }
+      };
+    }
+    case "fleetToolEnd": {
+      const cur = state.fleet[action.id];
+      if (!cur) return state;
+      return {
+        ...state,
+        fleet: {
+          ...state.fleet,
+          [action.id]: { ...cur, currentTool: void 0, lastEventAt: Date.now() }
+        }
+      };
+    }
+    case "fleetStart": {
+      const cur = state.fleet[action.id];
+      if (!cur) return state;
+      return {
+        ...state,
+        fleet: {
+          ...state.fleet,
+          [action.id]: {
+            ...cur,
+            status: "running",
+            streamingText: "",
+            startedAt: Date.now()
+          }
+        }
+      };
+    }
+    case "fleetDelta": {
+      const cur = state.fleet[action.id];
+      if (!cur) return state;
+      const appended = (cur.streamingText + action.text).slice(-200);
+      return {
+        ...state,
+        fleet: {
+          ...state.fleet,
+          [action.id]: { ...cur, streamingText: appended, lastEventAt: Date.now() }
+        }
+      };
+    }
+    case "fleetTool": {
+      const cur = state.fleet[action.id];
+      if (!cur) return state;
+      return {
+        ...state,
+        fleet: {
+          ...state.fleet,
+          [action.id]: { ...cur, toolCalls: cur.toolCalls + 1, lastEventAt: Date.now() }
+        }
+      };
+    }
+    case "fleetUsage": {
+      const cur = state.fleet[action.id];
+      if (!cur) return state;
+      const cost = cur.cost;
+      return {
+        ...state,
+        fleet: { ...state.fleet, [action.id]: { ...cur, cost, lastEventAt: Date.now() } }
+      };
+    }
+    case "fleetDone": {
+      const cur = state.fleet[action.id];
+      if (!cur) return state;
+      return {
+        ...state,
+        fleet: {
+          ...state.fleet,
+          [action.id]: {
+            ...cur,
+            status: action.status,
+            iterations: action.iterations,
+            toolCalls: action.toolCalls,
+            streamingText: "",
+            lastEventAt: Date.now()
+          }
+        }
+      };
+    }
+    case "fleetCost": {
+      return { ...state, fleetCost: action.cost };
+    }
+    case "setStreamFleet": {
+      return { ...state, streamFleet: action.enabled };
+    }
   }
 }
 var PASTE_THRESHOLD_CHARS = 200;
+function buildSteeringPreamble(snapshot, newDirection) {
+  const lines = ["[STEERING \u2014 I pressed Esc to interrupt you mid-task on purpose.", ""];
+  const ctx = [];
+  if (snapshot?.runningTools && snapshot.runningTools.length > 0) {
+    ctx.push(`- in-flight tools (now cancelled): ${snapshot.runningTools.join(", ")}`);
+  }
+  if (snapshot?.subagentsTerminated && snapshot.subagentsTerminated > 0) {
+    const subDetails = snapshot.subagents.map((s) => `${s.label}${s.tool ? ` (was running: ${s.tool})` : ""}`).join(", ");
+    ctx.push(
+      `- subagents (${snapshot.subagentsTerminated} terminated by me, do NOT await them): ${subDetails}`
+    );
+  }
+  if (snapshot?.partialAssistantText && snapshot.partialAssistantText.trim().length > 0) {
+    const tail = snapshot.partialAssistantText.trim().slice(-300);
+    ctx.push(`- your last partial output (truncated, for context only): "${tail}"`);
+  }
+  if (ctx.length > 0) {
+    lines.push("What was happening when I cut you off:");
+    lines.push(...ctx);
+    lines.push("");
+  }
+  lines.push("You have authority to:");
+  lines.push("- Abandon the prior plan entirely if the new direction makes it stale.");
+  lines.push("- Re-spawn fresh subagents (with different roles or tasks) if needed.");
+  lines.push('- Skip a polite "should I continue?" \u2014 just pivot.');
+  lines.push("- Ask me to clarify if the new direction is genuinely ambiguous.");
+  lines.push("");
+  lines.push("New direction:");
+  lines.push("---");
+  lines.push(newDirection);
+  lines.push("---");
+  lines.push("]");
+  return lines.join("\n");
+}
+function buildGoalPreamble(goal) {
+  return [
+    "[GOAL \u2014 LOCKED IN. You will work on this until it is verifiably done.",
+    "The user granted you full autonomy. Read these constraints once, then act.",
+    "",
+    "YOUR GOAL:",
+    "---",
+    goal,
+    "---",
+    "",
+    "AUTHORITY YOU HAVE:",
+    "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
+    "  Parallel + recursive fan-out are both fine. There is no spawn budget.",
+    "- Use any provider/model per subagent \u2014 pick the right tool for each",
+    "  piece of work. Heavy reasoning model for planning, fast model for",
+    "  batch work, specialist model for domain code.",
+    "- Run unlimited tool calls and iterations. There is NO hidden budget.",
+    "  The Agent loop auto-extends every 100 iterations forever.",
+    "- Retry failed tools with different inputs, alternative paths, fresh",
+    "  subagents. Switch providers mid-run if one is rate-limited.",
+    "- Re-plan freely when an approach hits a dead end. You are not obliged",
+    "  to stick with the first plan you proposed.",
+    "",
+    'WHAT "DONE" MEANS \u2014 non-negotiable:',
+    "- You can name a concrete artifact (a passing test, a written file at",
+    "  a specific path, a fixed bug verified by re-running the failing case,",
+    "  a clean grep that previously had matches).",
+    "- You can tell the user HOW to verify it themselves in 10 seconds.",
+    '- You have NOT hedged. None of: "looks like it should work", "I',
+    '  believe this fixes it", "the changes appear correct".',
+    "",
+    "WHAT IS NOT DONE \u2014 never report any of these as completion:",
+    "- An error message you didn't recover from.",
+    '- An empty result, a 0-line file, a "no matches found" you accepted',
+    "  without questioning the search.",
+    '- "Should I continue?" / "Want me to also...?" / "Let me know if you',
+    '  want X." Those are hedges. The user already told you to finish the',
+    "  goal \u2014 just do it.",
+    "- Partial progress dressed up as success. Fixed 3 of 5 bugs = 60%",
+    "  done, not done.",
+    "- A subagent's failed/timeout/stopped TaskResult that you didn't",
+    "  respond to with a fresh attempt (different role, different model,",
+    "  tighter prompt).",
+    "",
+    "PERSISTENCE PROTOCOL:",
+    "- If blocked, try at least 3 different angles before reporting the",
+    "  problem to the user. Different tool inputs, different subagent",
+    "  roles, different providers, different decomposition of the task.",
+    "- If a tool fails, read its error, alter the input, try again. Do",
+    "  not just report the failure back.",
+    "- If a subagent returns useless output, respawn with a tighter prompt",
+    '  or a different role. Do not accept "I could not determine\u2026" as the',
+    "  final answer.",
+    "- Use `ask_subagent` for one-shot questions when you don't need a",
+    "  full delegated task.",
+    "",
+    "REPORTING:",
+    "- Stream short progress notes between major actions so the user can",
+    "  monitor. Do not go silent for 50 tool calls then dump a wall of",
+    "  text \u2014 but also do not narrate every tool call.",
+    "- Use the shared scratchpad (if available) to leave breadcrumbs",
+    "  subagents can read.",
+    "- Final response must include: (a) what was accomplished, (b) how",
+    "  to verify, (c) any caveats (residual TODOs, things the user",
+    "  should know about).",
+    "",
+    "BEGIN.]"
+  ].join("\n");
+}
 function App({
   agent,
   slashRegistry,
@@ -2003,7 +2551,12 @@ function App({
   switchProviderAndModel,
   effectiveMaxContext,
   onExit,
-  onClearHistory
+  director,
+  fleetRoster,
+  onClearHistory,
+  fleetStreamController,
+  initialGoal,
+  initialAsk
 }) {
   const { exit } = useApp();
   const [liveModel, setLiveModel] = useState(model);
@@ -2028,6 +2581,8 @@ function App({
     toolStream: null,
     status: "idle",
     interrupts: 0,
+    steeringPending: false,
+    steerSnapshot: null,
     hint: "",
     nextId: 1,
     picker: { open: false, query: "", matches: [], selected: 0 },
@@ -2045,13 +2600,18 @@ function App({
       selected: 0
     },
     confirm: null,
-    contextChipVersion: 0
+    contextChipVersion: 0,
+    fleet: {},
+    fleetCost: 0,
+    streamFleet: true
   });
   const builderRef = useRef(null);
   if (builderRef.current === null) {
     builderRef.current = new InputBuilder({ store: attachments });
   }
   const activeCtrlRef = useRef(null);
+  const inputGateRef = useRef(false);
+  const lastEnterAtRef = useRef(0);
   const projectRoot = agent.ctx.projectRoot;
   const projectName = React.useMemo(() => {
     const base = path3.basename(projectRoot);
@@ -2108,6 +2668,111 @@ function App({
     }
     return counts;
   }, [nowTick, agent.ctx.todos]);
+  const fleetCounts = useMemo(() => {
+    const entries = Object.values(state.fleet);
+    if (entries.length === 0) return void 0;
+    let running = 0;
+    let idle = 0;
+    let completed = 0;
+    for (const e of entries) {
+      if (e.status === "running") running += 1;
+      else if (e.status === "idle") idle += 1;
+      else completed += 1;
+    }
+    return { running, idle, pending: 0, completed };
+  }, [state.fleet]);
+  const STREAM_COLORS = ["cyan", "magenta", "yellow", "green", "blue"];
+  const labelsRef = useRef(/* @__PURE__ */ new Map());
+  const labelFor = (id, name) => {
+    const m = labelsRef.current;
+    const existing = m.get(id);
+    if (existing) return existing;
+    const n = m.size + 1;
+    const suffix = name && name !== id ? ` ${name}` : "";
+    const v = {
+      label: `AGENT#${n}${suffix}`,
+      color: STREAM_COLORS[(n - 1) % STREAM_COLORS.length]
+    };
+    m.set(id, v);
+    return v;
+  };
+  const fleetAgents = useMemo(() => {
+    const entries = Object.entries(state.fleet);
+    if (entries.length === 0) return void 0;
+    const active = entries.filter(([_id, e]) => e.status === "running" || e.status === "idle");
+    if (active.length === 0) return void 0;
+    active.sort((a, b) => {
+      const sa = a[1].status === "running" ? 0 : 1;
+      const sb = b[1].status === "running" ? 0 : 1;
+      if (sa !== sb) return sa - sb;
+      return a[1].startedAt - b[1].startedAt;
+    });
+    return active.slice(0, 4).map(([id, e]) => {
+      const lbl = labelFor(id, e.name);
+      return {
+        label: lbl.label,
+        color: lbl.color,
+        elapsedMs: Math.max(0, nowTick - e.startedAt),
+        toolCalls: e.toolCalls,
+        running: e.status === "running"
+      };
+    });
+  }, [state.fleet, nowTick]);
+  const [planCounts, setPlanCounts] = useState(null);
+  useEffect(() => {
+    const planPath = agent.ctx.meta["plan.path"];
+    if (typeof planPath !== "string" || !planPath) return;
+    let cancelled = false;
+    const poll = async () => {
+      try {
+        const data = await fs.readFile(planPath, "utf8");
+        const parsed = JSON.parse(data);
+        if (cancelled) return;
+        if (!Array.isArray(parsed.items)) {
+          setPlanCounts(null);
+          return;
+        }
+        let open = 0;
+        let inProgress = 0;
+        let done = 0;
+        for (const it of parsed.items) {
+          if (it?.status === "done") done++;
+          else if (it?.status === "in_progress") inProgress++;
+          else open++;
+        }
+        setPlanCounts(open + inProgress + done > 0 ? { open, inProgress, done } : null);
+      } catch {
+        if (!cancelled) setPlanCounts(null);
+      }
+    };
+    void poll();
+    const id = setInterval(poll, 3e3);
+    return () => {
+      cancelled = true;
+      clearInterval(id);
+    };
+  }, [agent.ctx.meta]);
+  const prevAnyOverlayOpen = useRef(false);
+  const prevEntriesCount = useRef(0);
+  useEffect(() => {
+    const anyOpenNow = state.picker.open || state.slashPicker.open || state.modelPicker.open || !!state.confirm;
+    const overlayClosed = prevAnyOverlayOpen.current && !anyOpenNow;
+    const newEntryCommitted = state.entries.length > prevEntriesCount.current;
+    prevAnyOverlayOpen.current = anyOpenNow;
+    prevEntriesCount.current = state.entries.length;
+    if (overlayClosed || newEntryCommitted) {
+      try {
+        process.stdout.write("\x1B[J");
+      } catch {
+      }
+    }
+  }, [
+    state.picker.open,
+    state.slashPicker.open,
+    state.modelPicker.open,
+    state.confirm,
+    state.entries.length
+  ]);
   useEffect(() => {
     const detected = detectAtToken(state.buffer, state.cursor);
     if (!detected) {
@@ -2267,6 +2932,128 @@ function App({
       slashRegistry.unregister("queue");
     };
   }, [slashRegistry]);
+  useEffect(() => {
+    const ALT_OFF = "\x1B[?1049l";
+    const ALT_ON = "\x1B[?1049h";
+    const cmd = {
+      name: "altscreen",
+      description: "Toggle the alt-screen buffer. Default is OFF (native scroll); /altscreen on for full-screen mode.",
+      async run(args) {
+        const arg = args.trim().toLowerCase();
+        if (arg === "off") {
+          try {
+            process.stdout.write(ALT_OFF);
+          } catch {
+            return { message: "Failed to exit alt-screen." };
+          }
+          return {
+            message: "Alt-screen disabled. New entries will land in normal scrollback (mouse wheel / Shift+PgUp work). On-screen history rendered before this command is no longer reachable via terminal scroll. Resize may now leak the live region \u2014 `/altscreen on` to re-enable."
+          };
+        }
+        if (arg === "on") {
+          try {
+            process.stdout.write(ALT_ON);
+          } catch {
+            return { message: "Failed to re-enter alt-screen." };
+          }
+          return { message: "Alt-screen re-enabled. Native scroll is now disabled." };
+        }
+        return { message: "Usage: /altscreen on|off" };
+      }
+    };
+    slashRegistry.register(cmd);
+    return () => {
+      slashRegistry.unregister("altscreen");
+    };
+  }, [slashRegistry]);
+  useEffect(() => {
+    const cmd = {
+      name: "steer",
+      description: "Interrupt the running agent (incl. fleet) and redirect: /steer <new direction>",
+      help: [
+        "Usage: /steer <new direction>",
+        "",
+        "Aborts the active iteration, terminates any running subagents,",
+        "drops queued messages, and sends your text to the model with a",
+        "STEERING preamble explaining what was in flight and what the",
+        "model is authorised to do (pivot hard, respawn subagents, ask",
+        "for clarification). Equivalent to pressing Esc then typing."
+      ].join("\n"),
+      async run(args) {
+        const text = args.trim();
+        if (!text) {
+          return { message: "Usage: /steer <new direction>" };
+        }
+        const s = stateRef.current;
+        const runningTools = Array.from(s.runningTools.values()).map((t) => t.name);
+        const subagents = Object.values(s.fleet).filter((e) => e.status === "running").map((e) => ({ label: e.name, status: e.status, tool: e.currentTool?.name }));
+        const subagentsTerminated = subagents.length;
+        const partialAssistantText = streamingTextRef.current.slice(-1500);
+        activeCtrlRef.current?.abort();
+        dispatch({
+          type: "steerStart",
+          snapshot: { runningTools, subagents, subagentsTerminated, partialAssistantText }
+        });
+        const droppedCount = s.queue.length;
+        if (droppedCount > 0) dispatch({ type: "queueClear" });
+        if (director && subagentsTerminated > 0) {
+          const cap = new Promise((resolve) => {
+            const t = setTimeout(resolve, 1500);
+            t.unref?.();
+          });
+          void Promise.race([director.terminateAll().catch(() => void 0), cap]);
+        }
+        const preamble = buildSteeringPreamble(
+          { runningTools, subagents, subagentsTerminated, partialAssistantText },
+          text
+        );
+        dispatch({ type: "steerConsume" });
+        const droppedTag = droppedCount > 0 ? ` \xB7 dropped ${droppedCount} queued` : "";
+        const fleetTag = subagentsTerminated > 0 ? ` \xB7 stopped ${subagentsTerminated} subagent${subagentsTerminated === 1 ? "" : "s"}` : "";
+        return {
+          message: `\u21AF Steering${droppedTag}${fleetTag}.`,
+          runText: preamble
+        };
+      }
+    };
+    slashRegistry.register(cmd);
+    return () => {
+      slashRegistry.unregister("steer");
+    };
+  }, [slashRegistry, director]);
+  useEffect(() => {
+    const cmd = {
+      name: "goal",
+      description: "Lock in a goal \u2014 no budgets, no hedging, no premature done. /goal <description>",
+      help: [
+        "Usage: /goal <description>",
+        "",
+        "Hands the agent a task it must drive to a verifiable finish.",
+        "Adds a preamble to the next turn that grants full autonomy",
+        "(unlimited subagents, any provider/model, retry-until-it-works),",
+        'spells out what "done" actually means, and forbids hedge-style',
+        'completions ("I believe this works", "should I continue?").',
+        "",
+        "Combine with /steer to redirect mid-goal, or Ctrl+C / /fleet kill",
+        "to bail out \u2014 only the user can stop a /goal."
+      ].join("\n"),
+      async run(args) {
+        const goal = args.trim();
+        if (!goal) return { message: "Usage: /goal <description>" };
+        const preamble = buildGoalPreamble(goal);
+        const shortGoal = goal.length > 80 ? `${goal.slice(0, 80)}\u2026` : goal;
+        return {
+          message: `\u{1F3AF} Goal locked: ${shortGoal}
+   Agent will work until verifiably complete. Esc / /steer to redirect, Ctrl+C to stop.`,
+          runText: preamble
+        };
+      }
+    };
+    slashRegistry.register(cmd);
+    return () => {
+      slashRegistry.unregister("goal");
+    };
+  }, [slashRegistry]);
   useEffect(() => {
     if (!getPickableProviders || !switchProviderAndModel) return;
     const cmd = {
@@ -2397,18 +3184,298 @@ function App({
       offConfirmNeeded();
       if (flushTimerRef.current) clearTimeout(flushTimerRef.current);
     };
+  }, [events, agent.ctx.todos]);
+  const streamFleetRef = useRef(state.streamFleet);
+  useEffect(() => {
+    streamFleetRef.current = state.streamFleet;
+  }, [state.streamFleet]);
+  useEffect(() => {
+    const offSpawned = events.on("subagent.spawned", (e) => {
+      const lbl = labelFor(e.subagentId, e.name);
+      dispatch({
+        type: "fleetSpawn",
+        id: e.subagentId,
+        name: e.name,
+        provider: e.provider,
+        model: e.model,
+        transcriptPath: e.transcriptPath
+      });
+      const where = e.provider && e.model ? `${e.provider}/${e.model}` : "spawned";
+      const desc = e.description ? ` \u2014 ${e.description.slice(0, 80)}` : "";
+      dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "subagent",
+          agentLabel: lbl.label,
+          agentColor: lbl.color,
+          icon: "\u25B6",
+          text: `${where}${desc}`
+        }
+      });
+    });
+    const offStarted = events.on("subagent.task_started", (e) => {
+      const lbl = labelFor(e.subagentId);
+      dispatch({ type: "fleetStart", id: e.subagentId, taskId: e.taskId });
+      const desc = e.description ? ` \u2014 ${e.description.slice(0, 80)}` : "";
+      dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "subagent",
+          agentLabel: lbl.label,
+          agentColor: lbl.color,
+          icon: "\u25CF",
+          text: `task started${desc}`
+        }
+      });
+    });
+    const offCompleted = events.on("subagent.task_completed", (e) => {
+      const lbl = labelFor(e.subagentId);
+      dispatch({
+        type: "fleetDone",
+        id: e.subagentId,
+        status: e.status,
+        iterations: e.iterations,
+        toolCalls: e.toolCalls
+      });
+      const icon = e.status === "success" ? "\u2713" : e.status === "timeout" ? "\u23F1" : e.status === "stopped" ? "\u2298" : "\u2717";
+      const errKind = e.error?.kind;
+      const errMsg = e.error?.message;
+      const errMsgTail = errMsg ? ` \u2014 ${errMsg.replace(/\s+/g, " ").slice(0, 100)}${errMsg.length > 100 ? "\u2026" : ""}` : "";
+      const errChip = errKind ? ` [${errKind}]` : "";
+      const secs = (e.durationMs / 1e3).toFixed(e.durationMs < 1e4 ? 1 : 0);
+      dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "subagent",
+          agentLabel: lbl.label,
+          agentColor: lbl.color,
+          icon,
+          text: `${e.status} (${e.iterations} iter \xB7 ${e.toolCalls} tools \xB7 ${secs}s)${errChip}${errMsgTail}`
+        }
+      });
+    });
+    const offTool = events.on("subagent.tool_executed", (e) => {
+      const lbl = labelFor(e.subagentId);
+      dispatch({ type: "fleetTool", id: e.subagentId });
+      dispatch({ type: "fleetToolEnd", id: e.subagentId });
+      const bytesTag = typeof e.outputBytes === "number" && e.outputBytes > 0 ? ` \xB7 ${e.outputBytes < 1024 ? `${e.outputBytes}B` : `${(e.outputBytes / 1024).toFixed(1)}KB`}` : "";
+      dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "subagent",
+          agentLabel: lbl.label,
+          agentColor: lbl.color,
+          icon: e.ok === false ? "\u2717" : "\u25CF",
+          text: e.name,
+          detail: `${e.durationMs}ms${bytesTag}`
+        }
+      });
+    });
+    return () => {
+      offSpawned();
+      offStarted();
+      offCompleted();
+      offTool();
+    };
   }, [events]);
+  useEffect(() => {
+    if (!fleetStreamController) return;
+    fleetStreamController.enabled = state.streamFleet;
+    fleetStreamController.setEnabled = (enabled) => {
+      dispatch({ type: "setStreamFleet", enabled });
+    };
+    return () => {
+      fleetStreamController.setEnabled = (enabled) => {
+        fleetStreamController.enabled = enabled;
+      };
+    };
+  }, [fleetStreamController, state.streamFleet]);
+  useEffect(() => {
+    if (fleetStreamController) fleetStreamController.enabled = state.streamFleet;
+  }, [state.streamFleet, fleetStreamController]);
+  useEffect(() => {
+    const d = director;
+    if (!d) return;
+    const FLUSH_MS = 150;
+    const streamBuf = /* @__PURE__ */ new Map();
+    let streamFlushTimer = null;
+    const flushStreamBufs = () => {
+      for (const [id, text] of streamBuf) {
+        if (!text.trim()) continue;
+        const lbl = labelFor(id);
+        dispatch({
+          type: "addEntry",
+          entry: {
+            kind: "subagent",
+            agentLabel: lbl.label,
+            agentColor: lbl.color,
+            icon: "\u{1F4AC}",
+            text: text.trim()
+          }
+        });
+      }
+      streamBuf.clear();
+      streamFlushTimer = null;
+    };
+    const status = d.status();
+    for (const s of status.subagents) {
+      const meta = d.getSubagentMeta(s.id);
+      dispatch({
+        type: "fleetSpawn",
+        id: s.id,
+        name: meta?.name ?? s.name,
+        provider: meta?.provider,
+        model: meta?.model
+      });
+      labelFor(s.id, meta?.name ?? s.name);
+    }
+    dispatch({ type: "fleetCost", cost: d.snapshot().total.cost });
+    const seen = new Set(Object.keys(status.subagents));
+    const pending = /* @__PURE__ */ new Map();
+    let flushTimer = null;
+    const doFlush = () => {
+      for (const [id, text] of pending) {
+        if (text) dispatch({ type: "fleetDelta", id, text });
+      }
+      pending.clear();
+      flushTimer = null;
+    };
+    const offFleet = d.fleet.onAny((e) => {
+      const fresh = !seen.has(e.subagentId);
+      if (fresh) {
+        seen.add(e.subagentId);
+        const meta = d.getSubagentMeta(e.subagentId);
+        dispatch({
+          type: "fleetSpawn",
+          id: e.subagentId,
+          name: meta?.name,
+          provider: meta?.provider,
+          model: meta?.model
+        });
+        const lbl = labelFor(e.subagentId, meta?.name);
+        if (streamFleetRef.current) {
+          const where = meta?.provider && meta?.model ? `${meta.provider}/${meta.model}` : "spawned";
+          dispatch({
+            type: "addEntry",
+            entry: {
+              kind: "subagent",
+              agentLabel: lbl.label,
+              agentColor: lbl.color,
+              icon: "\u25B6",
+              text: where
+            }
+          });
+        }
+      }
+      switch (e.type) {
+        case "iteration.started":
+          dispatch({ type: "fleetStart", id: e.subagentId });
+          break;
+        case "provider.text_delta": {
+          const p = e.payload;
+          if (p?.text) {
+            const cur = pending.get(e.subagentId) ?? "";
+            pending.set(e.subagentId, cur + p.text);
+            if (!flushTimer) flushTimer = setTimeout(doFlush, FLUSH_MS);
+            if (streamFleetRef.current) {
+              streamBuf.set(e.subagentId, (streamBuf.get(e.subagentId) ?? "") + p.text);
+              if (!streamFlushTimer) streamFlushTimer = setTimeout(flushStreamBufs, FLUSH_MS * 4);
+            }
+          }
+          break;
+        }
+        case "tool.started": {
+          const p = e.payload;
+          if (p?.name) {
+            dispatch({ type: "fleetToolStart", id: e.subagentId, name: p.name });
+          }
+          break;
+        }
+        case "tool.executed": {
+          dispatch({ type: "fleetTool", id: e.subagentId });
+          dispatch({ type: "fleetToolEnd", id: e.subagentId });
+          if (streamFleetRef.current) {
+            if (streamFlushTimer) {
+              clearTimeout(streamFlushTimer);
+              flushStreamBufs();
+            }
+            const p = e.payload;
+            const args = p?.input ? formatToolArgs(p.name ?? "", p.input) : "";
+            const lbl = labelFor(e.subagentId);
+            dispatch({
+              type: "addEntry",
+              entry: {
+                kind: "subagent",
+                agentLabel: lbl.label,
+                agentColor: lbl.color,
+                icon: p?.ok === false ? "\u2717" : "\u25CF",
+                text: args ? `${p?.name ?? "tool"} ${args}` : p?.name ?? "tool",
+                detail: typeof p?.durationMs === "number" ? `${p.durationMs}ms` : void 0
+              }
+            });
+          }
+          break;
+        }
+        case "provider.response": {
+          dispatch({ type: "fleetCost", cost: d.snapshot().total.cost });
+          break;
+        }
+      }
+    });
+    const offDone = d.on("task.completed", (payload) => {
+      dispatch({
+        type: "fleetDone",
+        id: payload.result.subagentId,
+        status: payload.result.status,
+        iterations: payload.result.iterations,
+        toolCalls: payload.result.toolCalls
+      });
+      dispatch({ type: "fleetCost", cost: d.snapshot().total.cost });
+      if (streamFleetRef.current && streamFlushTimer) {
+        clearTimeout(streamFlushTimer);
+        flushStreamBufs();
+      }
+    });
+    return () => {
+      offFleet();
+      offDone();
+      if (flushTimer) clearTimeout(flushTimer);
+      doFlush();
+      if (streamFlushTimer) clearTimeout(streamFlushTimer);
+      flushStreamBufs();
+    };
+  }, [director]);
   useEffect(() => {
     const onSigint = () => {
-      if (state.interrupts >= 1 && state.status === "idle") {
-        exit();
-        onExit(130);
+      if (state.interrupts >= 1) {
+        if (state.interrupts >= 2) {
+          process.exit(130);
+        }
+        try {
+          exit();
+          onExit(130);
+        } catch {
+        }
+        setTimeout(() => {
+          try {
+            process.exit(130);
+          } catch {
+          }
+        }, 500).unref?.();
+        dispatch({ type: "interrupt" });
         return;
       }
       dispatch({ type: "interrupt" });
       if (activeCtrlRef.current) {
         activeCtrlRef.current.abort();
         dispatch({ type: "status", status: "aborting" });
+        if (director) {
+          const cap = new Promise((resolve) => {
+            const t = setTimeout(resolve, 1500);
+            t.unref?.();
+          });
+          void Promise.race([director.terminateAll().catch(() => void 0), cap]);
+        }
         const droppedCount = stateRef.current.queue.length;
         if (droppedCount > 0) {
           dispatch({ type: "queueClear" });
@@ -2416,13 +3483,16 @@ function App({
             type: "addEntry",
             entry: {
               kind: "warn",
-              text: `Iteration cancelled. Dropped ${droppedCount} queued message${droppedCount === 1 ? "" : "s"}. Press Ctrl+C again to exit.`
+              text: `Iteration cancelled${director ? " + fleet terminated" : ""}. Dropped ${droppedCount} queued message${droppedCount === 1 ? "" : "s"}. Press Ctrl+C again to exit.`
             }
           });
         } else {
           dispatch({
             type: "addEntry",
-            entry: { kind: "warn", text: "Iteration cancelled. Press Ctrl+C again to exit." }
+            entry: {
+              kind: "warn",
+              text: `Iteration cancelled${director ? " + fleet terminated" : ""}. Press Ctrl+C again to exit.`
+            }
           });
         }
       } else {
@@ -2436,9 +3506,11 @@ function App({
     return () => {
       process.off("SIGINT", onSigint);
     };
-  }, [state.interrupts, state.status, exit, onExit]);
+  }, [state.interrupts, exit, onExit, director]);
   const handleKey = async (input, key) => {
     if (state.status === "aborting") return;
+    if (inputGateRef.current) return;
+    const isEnter = key.return || input === "\r" || input === "\n";
     if (state.modelPicker.open) {
       if (key.escape) {
         if (state.modelPicker.step === "model") {
@@ -2456,33 +3528,38 @@ function App({
         dispatch({ type: "modelPickerMove", delta: 1 });
         return;
       }
-      if (key.return) {
-        if (state.modelPicker.step === "provider") {
-          const opt = state.modelPicker.providerOptions[state.modelPicker.selected];
-          if (!opt) return;
+      if (isEnter) {
+        inputGateRef.current = true;
+        try {
+          if (state.modelPicker.step === "provider") {
+            const opt = state.modelPicker.providerOptions[state.modelPicker.selected];
+            if (!opt) return;
+            dispatch({
+              type: "modelPickerPickProvider",
+              providerId: opt.id,
+              models: opt.models
+            });
+            return;
+          }
+          const providerId = state.modelPicker.pickedProviderId;
+          const modelId = state.modelPicker.modelOptions[state.modelPicker.selected];
+          if (!providerId || !modelId) return;
+          const err = switchProviderAndModel?.(providerId, modelId);
+          if (err) {
+            dispatch({ type: "modelPickerHint", text: err });
+            return;
+          }
+          setLiveProvider(providerId);
+          setLiveModel(modelId);
           dispatch({
-            type: "modelPickerPickProvider",
-            providerId: opt.id,
-            models: opt.models
+            type: "addEntry",
+            entry: { kind: "info", text: `Switched to ${providerId} / ${modelId}.` }
           });
+          dispatch({ type: "modelPickerClose" });
           return;
+        } finally {
+          inputGateRef.current = false;
         }
-        const providerId = state.modelPicker.pickedProviderId;
-        const modelId = state.modelPicker.modelOptions[state.modelPicker.selected];
-        if (!providerId || !modelId) return;
-        const err = switchProviderAndModel?.(providerId, modelId);
-        if (err) {
-          dispatch({ type: "modelPickerHint", text: err });
-          return;
-        }
-        setLiveProvider(providerId);
-        setLiveModel(modelId);
-        dispatch({
-          type: "addEntry",
-          entry: { kind: "info", text: `Switched to ${providerId} / ${modelId}.` }
-        });
-        dispatch({ type: "modelPickerClose" });
-        return;
       }
       return;
     }
@@ -2499,8 +3576,10 @@ function App({
         dispatch({ type: "slashPickerMove", delta: 1 });
         return;
       }
-      if (key.return) {
-        await acceptSlashPickerSelection();
+      if (isEnter) {
+        inputGateRef.current = true;
+        acceptSlashPickerSelection();
+        inputGateRef.current = false;
         return;
       }
       if (key.tab && state.slashPicker.matches.length > 0) {
@@ -2525,13 +3604,61 @@ function App({
         dispatch({ type: "pickerMove", delta: 1 });
         return;
       }
-      if (key.return) {
-        await acceptPickerSelection();
+      if (isEnter) {
+        inputGateRef.current = true;
+        try {
+          await acceptPickerSelection();
+        } finally {
+          inputGateRef.current = false;
+        }
         return;
       }
     }
-    if (key.return) {
-      await submit();
+    if (key.escape && state.status !== "idle" && !state.confirm) {
+      const runningTools = Array.from(state.runningTools.values()).map((t) => t.name);
+      const subagents = Object.values(state.fleet).filter((e) => e.status === "running").map((e) => ({
+        label: e.name,
+        status: e.status,
+        tool: e.currentTool?.name
+      }));
+      const subagentsTerminated = subagents.length;
+      const partialAssistantText = streamingTextRef.current.slice(-1500);
+      activeCtrlRef.current?.abort();
+      dispatch({ type: "status", status: "aborting" });
+      dispatch({
+        type: "steerStart",
+        snapshot: {
+          runningTools,
+          subagents,
+          subagentsTerminated,
+          partialAssistantText
+        }
+      });
+      if (director && subagentsTerminated > 0) {
+        const cap = new Promise((resolve) => {
+          const t = setTimeout(resolve, 1500);
+          t.unref?.();
+        });
+        void Promise.race([director.terminateAll().catch(() => void 0), cap]);
+      }
+      const droppedCount = state.queue.length;
+      if (droppedCount > 0) dispatch({ type: "queueClear" });
+      const droppedTag = droppedCount > 0 ? ` \xB7 dropped ${droppedCount} queued` : "";
+      const fleetTag = subagentsTerminated > 0 ? ` \xB7 stopped ${subagentsTerminated} subagent${subagentsTerminated === 1 ? "" : "s"}` : "";
+      dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "warn",
+          text: `\u21AF Interrupted${droppedTag}${fleetTag}. Type your new direction.`
+        }
+      });
+      return;
+    }
+    if (isEnter) {
+      const now = Date.now();
+      if (now - lastEnterAtRef.current < 50) return;
+      lastEnterAtRef.current = now;
+      void submit();
       return;
     }
     if (key.backspace || key.delete) {
@@ -2586,6 +3713,14 @@ function App({
         dispatch({ type: "setBuffer", buffer: state.buffer, cursor: state.cursor + 1 });
       return;
     }
+    if (key.home) {
+      dispatch({ type: "setBuffer", buffer: state.buffer, cursor: 0 });
+      return;
+    }
+    if (key.end) {
+      dispatch({ type: "setBuffer", buffer: state.buffer, cursor: state.buffer.length });
+      return;
+    }
     if (key.upArrow) {
       if (state.inputHistory.length > 0) dispatch({ type: "historyUp" });
       return;
@@ -2725,6 +3860,18 @@ function App({
           exit();
           onExit(0);
         }
+        if (res?.runText) {
+          const b = builderRef.current;
+          if (b) {
+            b.appendText(res.runText);
+            const blocks2 = await b.submit();
+            const start = Date.now();
+            while (stateRef.current.status !== "idle" && Date.now() - start < 1500) {
+              await new Promise((r) => setTimeout(r, 25));
+            }
+            await runBlocks(blocks2);
+          }
+        }
         const cmd = trimmed.slice(1).split(/\s+/, 1)[0];
         if (cmd === "clear") {
           onClearHistory?.(dispatch);
@@ -2739,9 +3886,14 @@ function App({
     }
     const builder = builderRef.current;
     if (!builder) return;
-    if (trimmed) builder.appendText(trimmed);
+    const steering = state.steeringPending;
+    if (trimmed) {
+      const toAppend = steering ? buildSteeringPreamble(state.steerSnapshot, trimmed) : trimmed;
+      builder.appendText(toAppend);
+    }
+    if (steering) dispatch({ type: "steerConsume" });
     const blocks = await builder.submit();
-    const displayText = trimmed || "(attachments only)";
+    const displayText = trimmed ? steering ? `\u21AF ${trimmed}` : trimmed : "(attachments only)";
     dispatch({ type: "clearInput" });
     if (state.status !== "idle") {
       dispatch({
@@ -2756,6 +3908,36 @@ function App({
     if (state.historyIndex > 0) dispatch({ type: "historyPush", text: trimmed });
     await runBlocks(blocks);
   };
+  const bootInjectedRef = useRef(false);
+  useEffect(() => {
+    if (bootInjectedRef.current) return;
+    bootInjectedRef.current = true;
+    const goal = initialGoal?.trim();
+    const ask = initialAsk?.trim();
+    if (!goal && !ask) return;
+    void (async () => {
+      await new Promise((r) => setTimeout(r, 50));
+      const b = builderRef.current;
+      if (!b) return;
+      if (goal) {
+        const shortGoal = goal.length > 80 ? `${goal.slice(0, 80)}\u2026` : goal;
+        dispatch({
+          type: "addEntry",
+          entry: {
+            kind: "info",
+            text: `\u{1F3AF} Goal locked: ${shortGoal}
+   Agent will work until verifiably complete. Esc / /steer to redirect, Ctrl+C to stop.`
+          }
+        });
+        b.appendText(buildGoalPreamble(goal));
+      } else if (ask) {
+        dispatch({ type: "addEntry", entry: { kind: "user", text: ask } });
+        b.appendText(ask);
+      }
+      const blocks = await b.submit();
+      await runBlocks(blocks);
+    })();
+  }, []);
   const inputHint = useMemo(() => {
     if (state.status !== "idle") return "";
     if (state.buffer.startsWith("/")) return "slash command \u2014 Enter to dispatch";
@@ -2771,6 +3953,7 @@ function App({
         toolStream: state.toolStream
       }
     ),
+    /* @__PURE__ */ jsx(LiveActivityStrip, { entries: state.fleet, nowTick }),
     /* @__PURE__ */ jsx(
       Input,
       {
@@ -2829,11 +4012,16 @@ function App({
         yolo,
         elapsedMs,
         todos,
+        plan: planCounts ?? void 0,
+        fleet: fleetCounts,
+        fleetAgents,
         git: gitInfo,
         context: contextWindow,
-        projectName
+        projectName,
+        subagentCount: Object.keys(state.fleet).length
       }
-    )
+    ),
+    director ? /* @__PURE__ */ jsx(FleetPanel, { entries: state.fleet, totalCost: state.fleetCost, roster: fleetRoster }) : null
   ] });
 }
 function renderRunningTools(running) {
@@ -2889,6 +4077,15 @@ async function runTui(opts) {
     stdout.write(CURSOR_HOME);
   }
   stdout.write(BRACKETED_PASTE_ON);
+  const swallowSignals = ["SIGTSTP", "SIGQUIT", "SIGTTIN", "SIGTTOU"];
+  const swallow = () => {
+  };
+  for (const s of swallowSignals) {
+    try {
+      process.on(s, swallow);
+    } catch {
+    }
+  }
   let cleaned = false;
   const cleanup = () => {
     if (cleaned) return;
@@ -2908,6 +4105,12 @@ async function runTui(opts) {
   process.on("exit", exitHandler);
   const detachListeners = () => {
     for (const s of signals) process.off(s, signalHandler);
+    for (const s of swallowSignals) {
+      try {
+        process.off(s, swallow);
+      } catch {
+      }
+    }
     process.off("exit", exitHandler);
   };
   return new Promise((resolve) => {
@@ -2947,7 +4150,12 @@ async function runTui(opts) {
           switchProviderAndModel: opts.switchProviderAndModel,
           effectiveMaxContext: opts.effectiveMaxContext,
           onExit,
-          onClearHistory: opts.onClearHistory ? (dispatch) => opts.onClearHistory(dispatch) : void 0
+          director: opts.director ?? null,
+          fleetRoster: opts.fleetRoster,
+          onClearHistory: opts.onClearHistory ? (dispatch) => opts.onClearHistory(dispatch) : void 0,
+          fleetStreamController: opts.fleetStreamController,
+          initialGoal: opts.initialGoal,
+          initialAsk: opts.initialAsk
         }),
         { exitOnCtrlC: false }
       );
@@ -2959,7 +4167,24 @@ async function runTui(opts) {
       settle(1);
       return;
     }
-    instance.waitUntilExit().then(() => settle(exitCode)).catch(() => settle(1));
+    let detachResize = null;
+    if (!useAltScreen) {
+      const onResize = () => {
+        try {
+          stdout.write("\x1B[J");
+        } catch {
+        }
+      };
+      stdout.on("resize", onResize);
+      detachResize = () => stdout.off("resize", onResize);
+    }
+    instance.waitUntilExit().then(() => {
+      detachResize?.();
+      settle(exitCode);
+    }).catch(() => {
+      detachResize?.();
+      settle(1);
+    });
   });
 }