@multiclawcli/dashboard 0.11.0 → 0.13.0

package/dist/tui.js

@@ -10,6 +10,7 @@ import {
   describeResumePlan,
   isAbortError,
   Orchestrator,
+  resolvePermissionMode,
   validateRuntimeQuestionContent
 } from "@multiclawcli/core";
 import { Box as Box6, Text as Text6, useApp, useInput, useWindowSize } from "ink";
@@ -57,154 +58,95 @@ function appendLines(target, lines) {
 
 // src/tui/commands.ts
 var COMMANDS = [
-  { name: "agents", description: "List the configured team", availability: "always" },
+  { name: "new", description: "Start an empty session", availability: "idle" },
+  { name: "sessions", description: "Switch or delete saved sessions", availability: "idle" },
   {
     name: "focus",
-    args: "<id>",
-    description: "Focus an agent by id",
+    args: "[id]",
+    description: "Choose the focused agent",
     availability: "always",
     completes: "agent"
   },
-  { name: "clear", description: "Clear the focused agent's log", availability: "always" },
   {
-    name: "history",
-    description: "Browse finished turns, or continue one",
+    name: "mode",
+    args: "[auto | ask | deny]",
+    description: "Choose the permission mode",
     availability: "always"
   },
+  { name: "verbose", description: "Toggle tool detail in the stream", availability: "always" },
   {
-    name: "sessions",
-    description: "Switch between, or delete, saved sessions",
-    availability: "always"
-  },
-  {
-    name: "verbose",
-    description: "Toggle tool detail in the stream",
+    name: "search",
+    args: "[text]",
+    description: "Search the focused stream",
     availability: "always"
   },
+  { name: "latest", description: "Jump to latest output", availability: "always" },
   {
     name: "retry",
     args: "[id]",
-    description: "Re-run a failed agent (or all of them)",
+    description: "Choose failed agents to retry",
     availability: "idle"
   },
   {
     name: "replay",
     args: "[turn]",
-    description: "Run an earlier turn again",
+    description: "Choose a turn to run again",
     availability: "idle"
   },
   {
-    name: "fork",
+    name: "edit",
     args: "[turn]",
-    description: "Edit an earlier turn's requirement",
+    description: "Edit a previous 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",
+    description: "Export a turn as Markdown",
     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: "new",
-    args: "<requirement>",
-    description: "Start a new session with fresh agent sessions",
-    availability: "idle"
-  },
   {
     name: "steer",
-    args: "<text>",
-    description: "Send a message into the agents running right now",
+    args: "[text]",
+    description: "Send a message to running agents",
     availability: "running"
   },
-  {
-    name: "answer",
-    args: "<text>",
-    description: "Answer the leader's pending question",
-    availability: "idle"
-  },
-  {
-    name: "pause",
-    description: "Pause queued turns, not the active agent",
-    availability: "always"
-  },
+  { name: "pause", description: "Pause queued turns", availability: "always" },
   {
     name: "continue",
-    description: "Resume queued turns or pass a checkpoint",
+    description: "Resume the queue or continue a checkpoint",
     availability: "always"
-  },
-  {
-    name: "modify",
-    args: "<instruction>",
-    description: "Provide feedback at a checkpoint and continue",
-    availability: "running"
-  },
-  {
-    name: "respond",
-    args: "<question id> <JSON object>",
-    description: "Answer a question in one line of JSON",
-    availability: "always"
-  },
-  {
-    name: "skip",
-    args: "<question id>",
-    description: "Decline a structured tool question",
-    availability: "always"
-  },
-  {
-    name: "dismiss",
-    args: "<question id>",
-    description: "Cancel a structured tool question",
-    availability: "always"
-  },
-  {
-    name: "approve",
-    args: "[id] <number>",
-    description: "Approve the request on screen, or a named one",
-    availability: "always"
-  },
-  {
-    name: "deny",
-    args: "[id]",
-    description: "Deny the request on screen, or a named one",
-    availability: "always"
-  },
-  { name: "help", description: "Show the key map", availability: "always" },
-  { name: "quit", description: "Exit the console", availability: "always" }
+  }
 ];
-function availableCommands(running) {
+function relevant(name, context) {
+  if (!context) return true;
+  if (context.checkpoint) return name === "continue";
+  if (["replay", "edit", "export"].includes(name)) return context.history;
+  if (name === "retry") return context.retry;
+  if (name === "pause") return context.queue > 0 && !context.paused;
+  if (name === "continue") return context.queue > 0 && context.paused && !context.awaitingAnswer;
+  return true;
+}
+function availableCommands(running, context) {
   const phase = running ? "running" : "idle";
-  return COMMANDS.filter((c) => c.availability === "always" || c.availability === phase);
+  return COMMANDS.filter(
+    (c) => (c.availability === "always" || c.availability === phase) && relevant(c.name, context)
+  );
 }
-function canRun(name, running) {
+function canRun(name, running, context) {
   const command = COMMANDS.find((c) => c.name === name);
   if (!command) return true;
-  return availableCommands(running).includes(command);
+  return availableCommands(running, context).includes(command);
 }
-function unavailableReason(name, running) {
+function unavailableReason(name, running, context) {
   const command = COMMANDS.find((c) => c.name === name);
-  if (!command || availableCommands(running).includes(command)) return void 0;
+  if (!command || availableCommands(running, context).includes(command)) return void 0;
+  if (!relevant(name, context)) return `/${name} has nothing to act on right now`;
   return running ? `/${name} waits for the current turn to finish` : `/${name} only applies while a turn is running`;
 }
-function matchCommands(query, running) {
+function matchCommands(query, running, context) {
   const q = query.trim().toLowerCase();
-  const pool = availableCommands(running);
+  const pool = availableCommands(running, context);
   if (!q) return pool;
   const byName = [];
   const byDescription = [];
@@ -464,16 +406,24 @@ function computeLayout(input) {
   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 promptRows = Math.max(1, input.promptRows ?? 1);
   const railRows = showRail ? Math.min(MAX_RAIL_ROWS, Math.max(1, measureRailRows(input.railCells, columns))) : 0;
+  const fixedRows = 4 + MIN_BODY_ROWS + promptRows + (input.notice ? 1 : 0) + (railRows > 0 ? railRows + 1 : 0);
+  const queueRows = Math.min(
+    Math.max(0, input.queueRows ?? 0),
+    MAX_QUEUE_ROWS,
+    Math.max(0, rows - fixedRows - (input.menuRows > 0 ? 1 : 0))
+  );
+  const menuRows = Math.min(
+    Math.max(0, input.menuRows),
+    MAX_MENU_ROWS,
+    Math.max(1, rows - fixedRows - queueRows)
+  );
   const chrome = 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 + promptRows + 1;
+  (input.notice ? 1 : 0) + queueRows + menuRows + promptRows + 1;
   const barRoom = Math.max(0, rows - chrome - MIN_BODY_ROWS - 1);
   const interactionRows2 = barRoom < MIN_INTERACTION_ROWS ? 0 : Math.min(Math.max(0, input.interactionRows ?? 0), MAX_INTERACTION_ROWS, barRoom);
   const reserved = chrome + (interactionRows2 > 0 ? interactionRows2 + 1 : 0);
@@ -803,14 +753,14 @@ function reduceEvent(state, event) {
     case "stage:complete": {
       const stage = state.stages.find((stage2) => stage2.stageIndex === event.payload.stageIndex);
       if (!stage || stage.outcome !== void 0) return state;
-      const outcome2 = stageStatus(stage, state.agents);
+      const outcome = stageStatus(stage, state.agents);
       const memberStatuses = Object.fromEntries(
         stage.agents.map((agent) => [agent.id, state.agents[agent.id]?.status ?? "pending"])
       );
       return {
         ...state,
         stages: state.stages.map(
-          (entry) => entry === stage ? { ...entry, outcome: outcome2, memberStatuses } : entry
+          (entry) => entry === stage ? { ...entry, outcome, memberStatuses } : entry
         )
       };
     }
@@ -882,8 +832,9 @@ function reduceEvent(state, event) {
       if (event.type === "agent:failed") {
         if (next.logs.length === 0 && result.output)
           next.logs = appendLog([], result.output, "text");
-        if (result.error && !next.logs.some((s) => s.text.includes(stripAnsi(result.error)))) {
-          next.logs = appendLog(next.logs, result.error, "system");
+        const error = result.error;
+        if (error && !next.logs.some((s) => s.text.includes(stripAnsi(error)))) {
+          next.logs = appendLog(next.logs, error, "system");
         }
       }
       return { ...state, agents: { ...state.agents, [result.agentId]: next } };
@@ -925,14 +876,120 @@ function reduceEvent(state, event) {
       return state;
   }
 }
+var wrappedCache = /* @__PURE__ */ new WeakMap();
+var MAX_CACHED_WIDTHS = 3;
 function wrapLog(logs, width) {
   if (logs.length === 0) return [];
+  let byWidth = wrappedCache.get(logs);
+  if (byWidth === void 0) {
+    byWidth = /* @__PURE__ */ new Map();
+    wrappedCache.set(logs, byWidth);
+  }
+  const cached = byWidth.get(width);
+  if (cached !== void 0) return cached;
   const rendered = renderSegments(logs, width);
-  return rendered.trimEnd().split("\n").flatMap((line) => wrapLine(line, width));
+  const rows = rendered.trimEnd().split("\n").flatMap((line) => wrapLine(line, width));
+  if (byWidth.size >= MAX_CACHED_WIDTHS) byWidth.clear();
+  byWidth.set(width, rows);
+  return rows;
+}
+function totalRows(parts) {
+  let total = 0;
+  for (const part of parts) total += part.length;
+  return total;
+}
+function windowParts(parts, viewport, scroll) {
+  const height = Math.max(1, viewport);
+  const total = totalRows(parts);
+  const maxScroll = Math.max(0, total - height);
+  const scrolledBack = Math.min(Math.max(0, scroll), maxScroll);
+  const end = total - scrolledBack;
+  const start = Math.max(0, end - height);
+  const rows = [];
+  let offset = 0;
+  for (const part of parts) {
+    const partEnd = offset + part.length;
+    if (partEnd <= start) {
+      offset = partEnd;
+      continue;
+    }
+    if (offset >= end) break;
+    const from = Math.max(0, start - offset);
+    const to = Math.min(part.length, end - offset);
+    for (let i = from; i < to; i++) rows.push(part[i]);
+    offset = partEnd;
+  }
+  return { rows, scrolledBack, following: scrolledBack === 0 };
 }
-function focusedRowCount(turn, width) {
-  const agent = turn.focusId ? turn.agents[turn.focusId] : void 0;
-  return agent?.logs ? wrapLog(agent.logs, width).length : 0;
+function clipToColumns(text, max) {
+  if (max <= 0) return "";
+  if (displayWidth(text) <= max) return text;
+  let head = "";
+  let used = 0;
+  for (const char of text) {
+    const width = displayWidth(char);
+    if (used + width > max - 1) break;
+    head += char;
+    used += width;
+  }
+  return `${head}\u2026`;
+}
+function turnDivider(turn, width) {
+  const MAX_REQ = 45;
+  const raw = turn.requirement?.replace(/\s+/g, " ").trim();
+  const req = raw ? clipToColumns(raw, MAX_REQ) : void 0;
+  const label = req ? ` turn ${turn.turn} \xB7 ${req} ` : ` turn ${turn.turn} `;
+  const fill = Math.max(1, Math.floor((width - displayWidth(label)) / 2));
+  const rule = `${"\u2500".repeat(fill)}${label}${"\u2500".repeat(fill)}`;
+  return `\x1B[2m${clipToColumns(rule, width)}\x1B[0m`;
+}
+function pushRows(target, rows) {
+  for (const row of rows) target.push(row);
+}
+var historyCache = /* @__PURE__ */ new WeakMap();
+function historyRows(history, agentId, width) {
+  if (history.length === 0) return [];
+  let byAgent = historyCache.get(history);
+  if (byAgent === void 0) {
+    byAgent = /* @__PURE__ */ new Map();
+    historyCache.set(history, byAgent);
+  }
+  let byWidth = byAgent.get(agentId);
+  if (byWidth === void 0) {
+    byWidth = /* @__PURE__ */ new Map();
+    byAgent.set(agentId, byWidth);
+  }
+  const cached = byWidth.get(width);
+  if (cached !== void 0) return cached;
+  const rows = [];
+  for (const turn of history) {
+    rows.push(turnDivider(turn, width));
+    const agent = turn.agents[agentId];
+    if (agent && agent.logs.length > 0) pushRows(rows, wrapLog(agent.logs, width));
+  }
+  if (byWidth.size >= MAX_CACHED_WIDTHS) byWidth.clear();
+  byWidth.set(width, rows);
+  return rows;
+}
+function liveRows(state, agentId, width) {
+  const agent = state.agents[agentId];
+  if (!agent || agent.logs.length === 0) return [];
+  const rows = wrapLog(agent.logs, width);
+  if (state.history.length === 0) return rows;
+  const out = [turnDivider(state, width)];
+  pushRows(out, rows);
+  return out;
+}
+function timelineParts(state, agentId, width) {
+  const history = historyRows(state.history, agentId, width);
+  const live = liveRows(state, agentId, width);
+  if (live.length === 0) return history.length === 0 ? [] : [history];
+  return history.length === 0 ? [live] : [history, live];
+}
+function streamMatches(state, query, width) {
+  if (!state.focusId || !query.trim()) return [];
+  const needle = query.toLowerCase();
+  return timelineParts(state, state.focusId, width).flat().flatMap((row, index) => row.toLowerCase().includes(needle) ? [index] : []);
 }
 function snapshot(state) {
   return {
@@ -959,14 +1016,6 @@ function snapshot(state) {
     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)] : []];
 }
@@ -1040,68 +1089,55 @@ function tuiReducer(state, action) {
         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.
+        // response to the new request.
         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 "focus:cycle": {
+      const ids = Object.keys(state.agents);
+      if (ids.length === 0) return state;
+      const current = state.focusId ? ids.indexOf(state.focusId) : -1;
+      const nextIndex = (current + action.delta + ids.length) % ids.length;
+      if (nextIndex === current) return state;
+      return { ...state, focusId: ids[nextIndex], autoFollow: false, scroll: 0 };
+    }
+    case "focus:set": {
+      if (!state.agents[action.agentId]) return state;
+      if (state.focusId === action.agentId && !state.autoFollow && state.scroll === 0) return state;
+      return { ...state, focusId: action.agentId, autoFollow: false, scroll: 0 };
+    }
+    case "stream:scroll": {
+      const focusId = state.focusId;
+      if (!focusId) return state;
+      const rows = totalRows(timelineParts(state, focusId, action.width));
+      const maxScroll = Math.max(0, rows - Math.max(1, action.viewport));
+      const next = Math.min(Math.max(0, state.scroll + action.delta), maxScroll);
+      return next === state.scroll ? state : { ...state, scroll: next };
+    }
+    case "stream:search": {
+      const focusId = state.focusId;
+      if (!focusId || action.query === "") return state;
+      const parts = timelineParts(state, focusId, action.width);
+      const matches = streamMatches(state, action.query, action.width);
+      const index = matches[action.match ?? matches.length - 1];
+      if (index === void 0) return state;
+      const total = totalRows(parts);
+      const height = Math.max(1, action.viewport);
+      const maxScroll = Math.max(0, total - height);
+      const scroll = Math.min(Math.max(0, total - 1 - index), maxScroll);
+      return scroll === state.scroll && !state.autoFollow ? state : { ...state, 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 };
-      });
+      return state.scroll === 0 && state.autoFollow ? state : { ...state, scroll: 0, autoFollow: true };
+    case "stream:clear": {
+      const id = state.focusId;
+      const agent = id ? state.agents[id] : void 0;
+      if (!id || !agent) return state;
+      return { ...state, agents: { ...state.agents, [id]: { ...agent, logs: [] } }, scroll: 0 };
+    }
     case "stream:note": {
       const agent = state.agents[action.agentId];
       if (!agent) return state;
@@ -1113,12 +1149,6 @@ function tuiReducer(state, action) {
         }
       };
     }
-    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 };
     case "session:reset":
@@ -1153,7 +1183,6 @@ function seededState(state, agents, leaderIds, history) {
     autoFollow: true,
     scroll: 0,
     history,
-    view: void 0,
     verbose: state.verbose
   };
 }
@@ -1189,18 +1218,8 @@ function turnElapsed(turn, now) {
   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
-  };
+function visibleTimeline(state, agentId, viewport, width, scroll) {
+  return windowParts(timelineParts(state, agentId, width), viewport, scroll);
 }
 
 // src/tui/interaction.ts
@@ -1457,7 +1476,7 @@ function formComplete(fields, state) {
 }
 var MAX_FORM_FIELDS = 6;
 function questionBarRows(fields) {
-  return 2 + Math.min(fields.length, MAX_FORM_FIELDS) + 1 + 1;
+  return 2 + Math.min(fields.length, MAX_FORM_FIELDS) + 1 + 2;
 }
 function interactionRows(interactions, width) {
   const front = interactions[0];
@@ -1485,11 +1504,11 @@ var HELP_GROUPS = [
   {
     title: "panes",
     rows: [
-      ["tab  \u21E7tab", "Next / previous agent"],
+      ["tab", "Next agent"],
+      ["\u21E7tab", "Toggle permission mode"],
       ["\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"]
+      ["ctrl+l", "Clear the current turn's output"]
     ]
   },
   {
@@ -1503,10 +1522,10 @@ var HELP_GROUPS = [
   }
 ];
 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));
+var ITEM_ROWS = 3;
+var OVERLAY_CHROME_ROWS = 4;
+function overlayCapacity(maxRows) {
+  return Math.max(1, Math.floor((maxRows - OVERLAY_CHROME_ROWS) / ITEM_ROWS));
 }
 function listWindowStart(selected, total, capacity) {
   const maxStart = Math.max(0, total - capacity);
@@ -1532,81 +1551,6 @@ function HelpOverlay({ width, maxRows }) {
     /* @__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.interrupted || turn.phase !== "complete") {
-    return { text: "interrupted", color: COLOR.warn };
-  }
-  if (turn.acceptance) {
-    switch (turn.acceptance.status) {
-      case "approved":
-        return { text: `${STATUS.success.glyph} approved`, color: COLOR.ok };
-      case "changes_required":
-        return { text: `${GLYPH.warn} changes required`, color: COLOR.warn };
-      case "failed":
-        return { text: `${STATUS.failed.glyph} acceptance failed`, color: COLOR.error };
-      case "cancelled":
-        return { text: `${STATUS.cancelled.glyph} acceptance cancelled`, color: COLOR.warn };
-    }
-  }
-  if (turn.cancelled) return { text: `${STATUS.cancelled.glyph} cancelled`, 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 c continue \xB7 esc close${range}` }) })
-  ] });
-}
 function SessionsOverlay({
   sessions,
   selected,
@@ -1615,7 +1559,7 @@ function SessionsOverlay({
   maxRows,
   now
 }) {
-  const capacity = historyCapacity(maxRows);
+  const capacity = overlayCapacity(maxRows);
   const start = listWindowStart(selected, sessions.length, capacity);
   const visible = sessions.slice(start, start + capacity);
   const range = sessions.length > capacity ? ` \xB7 showing ${start + 1}\u2013${start + visible.length} of ${sessions.length}` : "";
@@ -1663,18 +1607,22 @@ function PermissionBar({
   others,
   cursor,
   released,
-  width
+  width,
+  maxRows = Number.POSITIVE_INFINITY
 }) {
   const choices = permissionChoices(request);
-  const impact = describeImpact(request, Math.max(8, width - 6));
-  const also = waitingLine(others);
+  const capacity = Math.max(1, Math.min(choices.length, maxRows - 3));
+  const start = listWindowStart(cursor ?? 0, choices.length, capacity);
+  const extra = Math.max(0, maxRows - 3 - capacity);
+  const impact = describeImpact(request, Math.max(8, width - 6)).slice(0, extra);
+  const also = extra > impact.length ? waitingLine(others) : void 0;
   const tool = clean(request.toolName ?? request.kind ?? "tool");
   return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", flexShrink: 0, paddingLeft: 2, width, children: [
     /* @__PURE__ */ jsx3(Text3, { bold: true, color: COLOR.warn, wrap: "truncate-end", children: `permission \xB7 ${clean(request.agentId)} \xB7 ${tool}${others.length > 0 ? ` \xB7 ${others.length + 1} waiting` : ""}` }),
     /* @__PURE__ */ jsx3(Text3, { wrap: "truncate-end", children: `  ${truncate(clean(request.title), Math.max(8, width - 4))}` }),
     impact.map((line) => /* @__PURE__ */ jsx3(Text3, { dimColor: true, wrap: "truncate-end", children: `  ${line}` }, line)),
-    choices.map((choice, index) => {
-      const active = index === cursor;
+    choices.slice(start, start + capacity).map((choice, index) => {
+      const active = start + index === cursor;
       return /* @__PURE__ */ jsx3(
         Text3,
         {
@@ -1687,7 +1635,7 @@ function PermissionBar({
       );
     }),
     also === void 0 ? null : /* @__PURE__ */ jsx3(Text3, { dimColor: true, wrap: "truncate-end", children: `  ${also}` }),
-    /* @__PURE__ */ jsx3(Text3, { dimColor: true, wrap: "truncate-end", children: released ? "  typing \xB7 /approve 1 or /deny still reach it" : "  \u2191\u2193 or 1-9 choose \xB7 enter confirm \xB7 esc to type instead" })
+    maxRows < 4 ? null : /* @__PURE__ */ jsx3(Text3, { dimColor: true, wrap: "truncate-end", children: released ? "  typing \xB7 esc to return to permission options" : "  \u2191\u2193 or 1-9 choose \xB7 enter confirm \xB7 esc to type instead" })
   ] });
 }
 function QuestionForm({
@@ -1696,18 +1644,26 @@ function QuestionForm({
   fields,
   form,
   draft,
-  width
+  width,
+  maxRows = Number.POSITIVE_INFINITY
 }) {
   const focused = fields[form.field];
   const titleWidth = Math.min(
     24,
     Math.max(4, ...fields.map((field) => field.title.length + (field.required ? 2 : 0)))
   );
-  const capacity = Math.min(fields.length, MAX_FORM_FIELDS);
-  const start = listWindowStart(form.field, fields.length, Math.max(1, capacity));
+  const actions = ["Submit answers", "Skip question", "Cancel request"];
+  const actionIndex = form.field - fields.length;
+  const compact = maxRows < 7;
+  const capacity = compact ? focused ? 1 : 0 : Math.min(fields.length, MAX_FORM_FIELDS, maxRows - 5);
+  const start = listWindowStart(
+    Math.min(form.field, fields.length - 1),
+    fields.length,
+    Math.max(1, capacity)
+  );
   const visible = fields.slice(start, start + capacity);
-  const range = fields.length > capacity ? ` \xB7 ${start + 1}\u2013${start + visible.length}/${fields.length}` : "";
-  const detail = focused === void 0 ? [] : detailLines(focused, width);
+  const range = fields.length > capacity && focused ? ` \xB7 field ${form.field + 1}/${fields.length}` : "";
+  const detail = focused && (!compact || maxRows >= 5) ? detailLines(focused, width).slice(0, 1) : [];
   return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", flexShrink: 0, paddingLeft: 2, width, children: [
     /* @__PURE__ */ jsx3(Text3, { bold: true, color: COLOR.warn, wrap: "truncate-end", children: `question \xB7 ${clean(request.agentId)}${others.length > 0 ? ` \xB7 ${others.length + 1} waiting` : ""}` }),
     /* @__PURE__ */ jsx3(Text3, { wrap: "truncate-end", children: clean(request.message) }),
@@ -1728,7 +1684,8 @@ function QuestionForm({
       );
     }),
     detail.map((line) => /* @__PURE__ */ jsx3(Text3, { dimColor: true, wrap: "truncate-end", children: `  ${line}` }, line)),
-    /* @__PURE__ */ jsx3(Text3, { dimColor: true, wrap: "truncate-end", children: `  tab next \xB7 \u2191\u2193 pick \xB7 space toggle \xB7 enter next${range} \xB7 esc clear` })
+    compact && focused ? null : /* @__PURE__ */ jsx3(Text3, { color: actionIndex >= 0 ? COLOR.accent : void 0, wrap: "truncate-end", children: compact || width < 72 ? actionIndex >= 0 ? `\u203A ${actions[actionIndex]}` : "tab to submit / skip / cancel" : actions.map((label, index) => (actionIndex === index ? "\u203A " : "  ") + label).join(" \xB7 ") }),
+    maxRows < 4 ? null : /* @__PURE__ */ jsx3(Text3, { dimColor: true, wrap: "truncate-end", children: `  tab next \xB7 \u2191\u2193 pick \xB7 space toggle \xB7 enter next${range} \xB7 esc clear` })
   ] });
 }
 function fieldValue(field, form, draft, focused) {
@@ -1846,17 +1803,19 @@ function Divider() {
   );
 }
 function StreamPanel({
-  turn,
+  state,
   height,
   width,
   now,
   spinner
 }) {
-  const agent = turn.focusId ? turn.agents[turn.focusId] : void 0;
+  const agent = state.focusId ? state.agents[state.focusId] : void 0;
   const viewport = Math.max(1, height - 1);
-  const window = visibleLog(turn, viewport, width);
+  const window = visibleTimeline(state, state.focusId ?? "", viewport, width, state.scroll);
   const style = agent ? STATUS[agent.status] : void 0;
   const elapsed = agent ? agentElapsed(agent, now) : void 0;
+  const focusId = state.focusId;
+  const turnCount = focusId ? recordedTurns(state).filter((turn) => (turn.agents[focusId]?.logs.length ?? 0) > 0).length : 0;
   return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", flexGrow: 1, height, paddingLeft: 1, children: [
     /* @__PURE__ */ jsxs4(Box4, { justifyContent: "space-between", children: [
       /* @__PURE__ */ jsx4(Box4, { flexShrink: 1, children: /* @__PURE__ */ jsxs4(Text4, { wrap: "truncate-end", children: [
@@ -1883,6 +1842,11 @@ function StreamPanel({
         agent?.costUsd !== void 0 ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
           " \xB7 ",
           formatCost(agent.costUsd)
+        ] }) : null,
+        turnCount > 1 ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          " \xB7 ",
+          turnCount,
+          " turns"
         ] }) : null
       ] }) }),
       /* @__PURE__ */ jsxs4(Box4, { flexShrink: 0, children: [
@@ -1893,13 +1857,14 @@ function StreamPanel({
         /* @__PURE__ */ jsx4(Text4, { color: window.following ? COLOR.accent : COLOR.warn, children: window.following ? GLYPH.live : `${GLYPH.paused} ${window.scrolledBack}\u2191` })
       ] })
     ] }),
-    window.rows.length === 0 ? /* @__PURE__ */ jsx4(Text4, { 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.
+    window.rows.length === 0 ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: state.phase === "running" ? "waiting for output\u2026" : "no output yet" }) : (
+      // The tail, already wrapped to `width` by `visibleTimeline` — the pane
+      // draws rows, and one log line is several of them. `visibleTimeline`
+      // 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
@@ -2419,6 +2384,16 @@ var SESSION_SAVE_INTERVAL_MS = 2e3;
 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 retryCandidates(state) {
+  const turn = recordedTurns(state).slice(-1)[0];
+  if (!turn?.requirement) return [];
+  if (turn.acceptance && turn.acceptance.status !== "approved") {
+    return [
+      ...new Set(turn.stages.flatMap((stage) => stage.agents.map((agent) => agent.id)))
+    ].filter((id) => id !== turn.acceptance?.reviewer);
+  }
+  return Object.values(turn.agents).filter((agent) => agent.status === "failed").map((agent) => agent.id);
+}
 function pickRecordedTurn(state, raw, whenEmpty) {
   const turns = recordedTurns(state);
   if (turns.length === 0) return { error: whenEmpty };
@@ -2483,10 +2458,10 @@ function StatusLine({
   }
   if (state.phase === "complete") {
     const time = state.totalDuration === void 0 ? "" : ` ${formatDuration(state.totalDuration)}`;
-    const outcome2 = state.acceptance ? `${state.success ? STATUS.success.glyph : STATUS.failed.glyph} ${state.acceptance.status === "approved" ? "delivery approved" : state.acceptance.status === "changes_required" ? "changes required" : "acceptance failed"}${time}` : state.success ? `${STATUS.success.glyph} done${time}` : `${STATUS.failed.glyph} finished with failures${time}`;
+    const outcome = state.acceptance ? `${state.success ? STATUS.success.glyph : STATUS.failed.glyph} ${state.acceptance.status === "approved" ? "delivery approved" : state.acceptance.status === "changes_required" ? "changes required" : "acceptance failed"}${time}` : 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__ */ jsxs6(Text6, { color: state.success ? COLOR.ok : COLOR.error, wrap: "truncate-end", children: [
-      outcome2,
+      outcome,
       cost,
       state.warning ? ` \xB7 ${GLYPH.warn} ${state.warning}` : ""
     ] });
@@ -2550,12 +2525,19 @@ function App({
   queueRef.current = queue;
   const [cancelled, setCancelled] = useState(false);
   const [error, setError] = useState();
+  const [permissionMode, setPermissionMode] = useState(
+    // Same precedence the runner uses, so the header can never announce a mode
+    // the agents are not actually running under. `ask` when nobody configured
+    // one, because a human is sitting here to answer.
+    resolvePermissionMode(config) ?? "ask"
+  );
   const [notice, setNotice] = useState(
     launchNoticeRef.current ?? restored.notice
   );
   const [helpOpen, setHelpOpen] = useState(false);
-  const [historyOpen, setHistoryOpen] = useState(false);
-  const [historyCursor, setHistoryCursor] = useState(0);
+  const [picker, setPicker] = useState(null);
+  const [operationInput, setOperationInput] = useState(null);
+  const [searchResult, setSearchResult] = useState(null);
   const [sessionsOpen, setSessionsOpen] = useState(false);
   const [sessionCursor, setSessionCursor] = useState(0);
   const [sessionList, setSessionList] = useState([]);
@@ -2567,6 +2549,12 @@ function App({
   const sessionsRef = useRef(null);
   if (!sessionsRef.current) sessionsRef.current = providedSessions ?? new AgentSessionManager();
   const continuationRef = useRef(null);
+  useEffect(() => {
+    if (initialSession?.kind !== "resume" || !("id" in initialSession)) return;
+    const history = restoredRef.current?.history ?? [];
+    const resumable = [...history].reverse().find((turn) => Object.keys(turnSessions(turn)).length > 0);
+    continuationRef.current = resumable ? { turn: resumable.turn, sessions: turnSessions(resumable) } : null;
+  }, [initialSession]);
   const activeTurnRef = useRef(null);
   const reporterErrorRef = useRef(null);
   const closingRef = useRef(false);
@@ -2637,16 +2625,21 @@ function App({
   const handleCheckpoint = useCallback((info, signal) => {
     if (closingRef.current || signal.aborted) return Promise.resolve({ action: "cancel" });
     return new Promise((resolve2) => {
-      checkpointResolveRef.current = resolve2;
+      const settle = (response) => {
+        signal.removeEventListener("abort", onAbort);
+        if (checkpointResolveRef.current === settle) {
+          checkpointResolveRef.current = null;
+          checkpointLabelRef.current = "";
+        }
+        resolve2(response);
+      };
+      checkpointResolveRef.current = settle;
       checkpointLabelRef.current = info.label;
       const names = info.completedAgents.map((a) => a.name).join(", ");
       setNotice(
-        `checkpoint: ${info.label} \u2014 ${names} done \xB7 /continue /modify <instruction> /cancel`
+        `checkpoint: ${info.label} \u2014 ${names} done \xB7 /continue \xB7 type feedback \xB7 ctrl+c cancel`
       );
-      const onAbort = () => {
-        checkpointResolveRef.current = null;
-        resolve2({ action: "cancel" });
-      };
+      const onAbort = () => settle({ action: "cancel" });
       signal.addEventListener("abort", onAbort, { once: true });
     });
   }, []);
@@ -2763,6 +2756,13 @@ function App({
       setError(void 0);
       setCancelled(false);
       setNotice(void 0);
+      if (opts?.newSession && !requirement) {
+        busyRef.current = false;
+        setRunning(false);
+        setSearchResult(null);
+        setNotice("new session \u2014 type a requirement to begin");
+        return;
+      }
       const earlierTurns = opts?.newSession ? [] : conversationTurns(stateRef.current);
       dispatch({
         type: "turn:start",
@@ -2780,7 +2780,16 @@ function App({
         // so the leader is handed the turns behind this one as well.
         history: earlierTurns,
         logDir,
-        permissions: !config.permissions || config.permissions.mode === "ask" ? { mode: "ask", onRequest: requestPermission } : config.permissions,
+        permissions: permissionMode === "ask" ? { mode: "ask", onRequest: requestPermission } : { mode: permissionMode },
+        // The console's mode is a live decision, so it outranks any per-agent
+        // `permissions` written in the file: otherwise shift+tab would relabel
+        // the header while an agent that declares its own mode kept the old
+        // behaviour. Per-agent modes stay a headless-run concern.
+        agents: config.agents.map((agent) => ({
+          ...agent,
+          permissions: { mode: permissionMode }
+        })),
+        ...config.leader ? { leader: { ...config.leader, permissions: { mode: permissionMode } } } : {},
         questions: config.questions?.onRequest ? config.questions : { onRequest: requestQuestion },
         onCheckpoint: config.onCheckpoint ?? handleCheckpoint,
         // A retry names the agents to redo; a continued conversation carries only
@@ -2845,7 +2854,8 @@ function App({
       requestPermission,
       requestQuestion,
       handleCheckpoint,
-      clearInteractions
+      clearInteractions,
+      permissionMode
     ]
   );
   useEffect(() => {
@@ -2865,6 +2875,7 @@ function App({
         return;
       }
       if (closingRef.current) return;
+      setSearchResult(null);
       const restored2 = restoreConsole(config.workDir, id);
       sessionIdRef.current = id;
       persistedTurnRef.current = restored2.persistedTurn;
@@ -2955,30 +2966,32 @@ function App({
     })();
     return shutdownRef.current;
   }, [config.workDir, exit, cleanup]);
-  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) => ({
+  const commandContext = {
+    history: recordedTurns(state).length > 0,
+    retry: retryCandidates(state).length > 0,
+    queue: queue.length,
+    paused: queuePaused,
+    awaitingAnswer,
+    checkpoint: checkpointResolveRef.current !== null
+  };
+  const query = interactions[0]?.kind === "question" ? void 0 : menuQuery(line.text);
+  const matches = query === void 0 ? [] : matchCommands(query, running, commandContext);
+  const arg = interactions[0]?.kind === "question" ? void 0 : argQuery(line.text);
+  const argRows = arg ? completeAgents(arg.partial, Object.keys(state.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
+    description: state.agents[id]?.description ?? state.agents[id]?.name ?? id
   })) : [];
-  const allRows = arg ? argRows : paletteRows(matches);
+  const allRows = picker ? picker.rows : 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 && !sessionsOpen && query !== void 0 && matches.length > 0;
-  const argOpen = !helpOpen && !historyOpen && !sessionsOpen && arg !== void 0 && argRows.length > 0;
-  const paletteOpen = menuOpen || argOpen;
+  const selected = paletteTotal === 0 ? 0 : Math.min(picker?.cursor ?? menuIndex, paletteTotal - 1);
+  const menuOpen = !picker && !operationInput && !helpOpen && !sessionsOpen && query !== void 0 && matches.length > 0;
+  const argOpen = !picker && !operationInput && !helpOpen && !sessionsOpen && arg !== void 0 && argRows.length > 0;
+  const paletteOpen = picker !== null || menuOpen || argOpen;
   const front = interactions[0];
   const menu = front?.kind === "permission" && permissionMenu.id === front.shortId ? permissionMenu : { id: front?.shortId ?? "", cursor: 0, released: false };
   const frontQuestion = front?.kind === "question" ? front : void 0;
@@ -2998,15 +3011,14 @@ function App({
     columns,
     rows,
     turn: state.turn,
-    overlay: helpOpen || historyOpen || sessionsOpen,
+    overlay: helpOpen || sessionsOpen,
     menuRows: paletteOpen ? paletteTotal : 0,
     queueRows: queue.length,
     interactionRows: interactionRows(interactions, Math.max(MIN_COLUMNS, columns)),
     promptRows,
     notice: notice !== void 0 || queuePaused && queue.length > 0,
-    viewing: state.view !== void 0,
-    hasRail: shown.leaderIds.length > 0 || shown.stages.length > 0,
-    railCells: railCellWidths(shown)
+    hasRail: state.leaderIds.length > 0 || state.stages.length > 0,
+    railCells: railCellWidths(state)
   });
   const steerRunningAgents = useCallback(async (text) => {
     const manager = sessionsRef.current;
@@ -3031,11 +3043,11 @@ function App({
     setNotice(describeSteering(reports));
   }, []);
   const runCommand = useCallback(
-    (name, args, rawText) => {
+    (name, args) => {
       setLine(EMPTY_LINE);
-      if (checkpointResolveRef.current && name !== "continue" && name !== "modify" && name !== "cancel") {
+      if (checkpointResolveRef.current && name !== "continue") {
         setNotice(
-          `checkpoint: ${checkpointLabelRef.current} \xB7 /continue /modify <instruction> /cancel`
+          `checkpoint: ${checkpointLabelRef.current} \xB7 /continue \xB7 type feedback \xB7 ctrl+c cancel`
         );
         return;
       }
@@ -3043,111 +3055,86 @@ function App({
         setNotice(unavailableReason(name, running));
         return;
       }
-      const shown2 = state.view ?? state;
       if (closingRef.current) return;
-      switch (name) {
-        case "respond":
-        case "skip":
-        case "dismiss": {
-          const [id, ...jsonParts] = args;
-          if (!id || (name === "respond" ? jsonParts.length === 0 : args.length !== 1)) {
-            setNotice(
-              name === "respond" ? "usage: /respond <question id> <JSON object>" : `usage: /${name} <question id>`
-            );
-            return;
-          }
-          const matches2 = interactionsRef.current.filter(
-            (entry2) => entry2.request.requestId === id || entry2.shortId === id
+      const choose = (rows2) => {
+        setPicker({ command: name, rows: rows2, cursor: 0 });
+        setNotice(`choose ${name} \xB7 enter confirm \xB7 esc cancel`);
+      };
+      if (args.length === 0) {
+        if (name === "mode") {
+          choose(
+            ["ask", "auto", "deny"].map((mode) => ({
+              key: mode,
+              label: mode,
+              description: mode === "ask" ? "Ask before tools run" : mode === "auto" ? "Allow tools automatically" : "Refuse tool requests"
+            }))
           );
-          const entry = matches2.length === 1 ? matches2[0] : void 0;
-          if (entry?.kind !== "question") {
-            setNotice(`unknown or stale question request: ${id}`);
-            return;
-          }
-          if (name !== "respond") {
-            entry.settle({ action: name === "skip" ? "decline" : "cancel" });
-            setNotice(`${name === "skip" ? "skipped" : "dismissed"} ${entry.shortId}`);
-            return;
-          }
-          let content;
-          try {
-            const rawJson = /^\/respond\s+\S+\s+([\s\S]+)$/.exec(rawText ?? "")?.[1] ?? "";
-            content = JSON.parse(rawJson);
-          } catch {
-            setNotice("response must be a valid JSON object");
+          return;
+        }
+        if (name === "focus") {
+          choose(
+            Object.values(state.agents).map((agent) => ({
+              key: agent.id,
+              label: agent.name,
+              description: agent.description ?? agent.id
+            }))
+          );
+          return;
+        }
+        if (name === "retry") {
+          const ids = retryCandidates(state);
+          if (ids.length === 0) {
+            setNotice("nothing failed");
             return;
           }
-          if (!validateRuntimeQuestionContent(entry.request.requestedSchema, content)) {
-            setNotice(
-              "response does not match the question schema; check required fields and choices"
-            );
+          choose([
+            { key: "all", label: "All failed / repair agents", description: ids.join(", ") },
+            ...ids.map((id) => ({
+              key: id,
+              label: state.agents[id]?.name ?? id,
+              description: state.agents[id]?.error ?? "Retry this agent"
+            }))
+          ]);
+          return;
+        }
+        if (["replay", "edit", "export"].includes(name)) {
+          const turns = recordedTurns(state).slice().reverse();
+          if (turns.length === 0) {
+            setNotice(`nothing to ${name} yet`);
             return;
           }
-          entry.settle({
-            action: "accept",
-            content
-          });
-          setNotice(`responded to ${entry.shortId}`);
+          choose(
+            turns.map((turn) => ({
+              key: String(turn.turn),
+              label: `Turn ${turn.turn}`,
+              description: turn.requirement?.replace(/\s+/g, " ") ?? "(no requirement)"
+            }))
+          );
+          return;
+        }
+        if (name === "search" || name === "steer") {
+          setOperationInput(name);
+          setNotice(
+            name === "search" ? "search the focused stream \xB7 enter find \xB7 esc cancel" : "message running agents \xB7 enter send \xB7 esc cancel"
+          );
           return;
         }
-        case "approve":
-        case "deny": {
-          const onScreen = interactionsRef.current[0];
-          const byId = (id) => {
-            const found = interactionsRef.current.filter(
-              (item) => item.request.requestId === id || item.shortId === id
-            );
-            if (found.length !== 1) setNotice(`unknown or stale permission request: ${id}`);
-            return found.length === 1 ? found[0] : void 0;
-          };
-          let entry;
-          let number;
-          if (name === "approve" && args.length === 1 && /^\d+$/.test(args[0])) {
-            number = args[0];
-            entry = onScreen;
-          } else if (name === "approve" && args.length === 2) {
-            number = args[1];
-            entry = byId(args[0]);
-          } else if (name === "deny" && args.length === 0) {
-            entry = onScreen;
-          } else if (name === "deny" && args.length === 1) {
-            entry = byId(args[0]);
+      }
+      switch (name) {
+        case "mode": {
+          const m = args[0];
+          if (m === "auto" || m === "ask" || m === "deny") {
+            setPermissionMode(m);
+            setNotice(`permission mode: ${m}`);
           } else {
-            setNotice(
-              name === "approve" ? "usage: /approve [id] <option number>" : "usage: /deny [id]"
-            );
-            return;
-          }
-          if (entry === void 0) {
-            if (args.length === 0 || /^\d+$/.test(args[0] ?? "")) {
-              setNotice("no permission request on screen");
-            }
-            return;
-          }
-          if (entry.kind !== "permission") {
-            setNotice("the request on screen is a question, not a permission");
-            return;
+            setNotice("usage: /mode auto | ask | deny");
           }
-          if (name === "deny") {
-            entry.settle();
-            setNotice(`denied ${entry.shortId}`);
-            return;
-          }
-          const option = /^\d+$/.test(number ?? "") ? entry.request.options[Number(number) - 1] : void 0;
-          if (!option) {
-            setNotice(
-              `invalid option for ${entry.shortId}; choose 1\u2013${entry.request.options.length}`
-            );
-            return;
-          }
-          entry.settle(option.optionId);
-          setNotice(`selected ${clean(option.name)} for ${entry.shortId}`);
           return;
         }
         case "new": {
           const text = args.join(" ");
-          if (!text) {
-            setNotice("usage: /new <requirement> \u2014 starts a new session with fresh agent sessions");
+          if (text) {
+            setNotice("/new opens an empty session \u2014 enter the requirement afterwards");
             return;
           }
           setQueue([]);
@@ -3156,15 +3143,6 @@ function App({
           void startTurn(text, { newSession: true });
           return;
         }
-        case "answer": {
-          const text = args.join(" ");
-          if (!awaitingAnswerRef.current || !text) {
-            setNotice("usage: /answer <text> \u2014 only when the leader is waiting for an answer");
-            return;
-          }
-          void startTurn(text);
-          return;
-        }
         case "steer": {
           const text = args.join(" ");
           if (!text) {
@@ -3175,6 +3153,10 @@ function App({
           return;
         }
         case "pause":
+          if (queueRef.current.length === 0) {
+            setNotice("no queued turns to pause");
+            return;
+          }
           queuePausedRef.current = true;
           setQueuePaused(true);
           setNotice("queue paused \u2014 the active turn continues");
@@ -3192,65 +3174,31 @@ function App({
             setNotice("answer the leader first; queued input is not an answer");
             return;
           }
+          if (queueRef.current.length === 0) {
+            setNotice("no queued turns to resume");
+            return;
+          }
           queuePausedRef.current = false;
           setQueuePaused(false);
           setNotice("queue resumed");
           return;
         }
-        case "modify": {
-          const instruction = args.join(" ");
-          if (!instruction) {
-            setNotice("usage: /modify <instruction> \u2014 only at a checkpoint");
-            return;
-          }
-          if (!checkpointResolveRef.current) {
-            setNotice("no checkpoint is waiting");
-            return;
-          }
-          const resolve2 = checkpointResolveRef.current;
-          checkpointResolveRef.current = null;
-          checkpointLabelRef.current = "";
-          resolve2({ action: "modify", instruction });
-          setNotice("modifying and continuing\u2026");
-          return;
-        }
-        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));
+          const resolved = resolveAgentId(input, Object.keys(state.agents));
           if ("error" in resolved) {
             setNotice(resolved.error);
             return;
           }
+          setSearchResult(null);
           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 "sessions": {
           const list = listSessions(config.workDir);
           setSessionList(list);
@@ -3265,38 +3213,44 @@ function App({
           setNotice(state.verbose ? "verbose off" : "verbose on \u2014 showing tool detail");
           return;
         case "retry": {
-          if (state.phase !== "complete" || !state.requirement) {
+          const turn = recordedTurns(state).slice(-1)[0];
+          if (!turn?.requirement) {
             setNotice("nothing to retry yet");
             return;
           }
+          if (args[0] === "all") args = [];
           let ids;
-          if (state.acceptance && state.acceptance.status !== "approved" && (!args[0] || args[0] === state.acceptance.reviewer)) {
+          if (turn.acceptance && turn.acceptance.status !== "approved" && (!args[0] || args[0] === turn.acceptance.reviewer)) {
             ids = [
-              ...new Set(state.stages.flatMap((stage) => stage.agents.map((agent) => agent.id)))
-            ].filter((id) => id !== state.acceptance?.reviewer);
+              ...new Set(turn.stages.flatMap((stage) => stage.agents.map((agent) => agent.id)))
+            ].filter((id) => id !== turn.acceptance?.reviewer);
           } else if (args[0]) {
-            const resolved = resolveAgentId(args[0], Object.keys(state.agents));
+            const resolved = resolveAgentId(args[0], Object.keys(turn.agents));
             if ("error" in resolved) {
               setNotice(resolved.error);
               return;
             }
+            if (!retryCandidates(state).includes(resolved.id)) {
+              setNotice(`agent has not failed or does not need repair: ${resolved.id}`);
+              return;
+            }
             ids = [resolved.id];
           } else {
-            ids = Object.values(state.agents).filter((agent) => agent.status === "failed").map((agent) => agent.id);
+            ids = Object.values(turn.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])
+            ids.filter((id) => turn.agents[id]?.sessionId).map((id) => [id, turn.agents[id].sessionId])
           );
-          if (ids.some((id) => state.leaderIds.includes(id))) {
-            void startTurn(state.requirement);
+          if (ids.some((id) => turn.leaderIds.includes(id))) {
+            void startTurn(turn.requirement);
             setNotice("retrying leader routing");
             return;
           }
-          void startTurn(state.effectiveRequirement ?? state.requirement, {
+          void startTurn(turn.effectiveRequirement ?? turn.requirement, {
             resume: {
               agents: ids,
               ...Object.keys(sessions).length > 0 ? { sessions } : {}
@@ -3321,8 +3275,8 @@ function App({
           setNotice(`replaying turn ${target.record.turn}`);
           return;
         }
-        case "fork": {
-          const target = pickTurn(state, args[0], "nothing to fork yet");
+        case "edit": {
+          const target = pickTurn(state, args[0], "nothing to edit yet");
           if ("error" in target) {
             setNotice(target.error);
             return;
@@ -3347,74 +3301,66 @@ function App({
             setNotice("usage: /search <text>");
             return;
           }
+          const matches2 = streamMatches(state, text, layout.streamWidth);
+          if (matches2.length === 0) {
+            setSearchResult(null);
+            setNotice(`no matches for ${text}`);
+            return;
+          }
+          const index = matches2.length - 1;
+          setSearchResult({ query: text, index });
           dispatch({
             type: "stream:search",
             query: text,
+            match: index,
             viewport: layout.logViewport,
             width: layout.streamWidth
           });
-          setNotice(`searched for ${text}`);
+          setNotice(
+            "searched for " + text + " \xB7 match " + (index + 1) + "/" + matches2.length + " \xB7 ctrl+n next \xB7 ctrl+p previous"
+          );
           return;
         }
         case "latest":
+          setSearchResult(null);
           dispatch({ type: "stream:latest" });
           setNotice("showing latest output");
           return;
-        case "cancel": {
-          if (checkpointResolveRef.current) {
-            const resolve2 = checkpointResolveRef.current;
-            checkpointResolveRef.current = null;
-            checkpointLabelRef.current = "";
-            resolve2({ action: "cancel" });
-            setNotice("checkpoint cancelled");
-            return;
-          }
-          if (!abortRef.current) {
-            setNotice("nothing to cancel");
-            return;
-          }
-          const dropped = queue.length;
-          abortRef.current.abort();
-          clearInteractions();
-          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":
-          void shutdown();
-          return;
         default:
           setNotice(`unknown command: /${name}`);
       }
     },
-    [
-      config,
-      shutdown,
-      clearInteractions,
-      layout.logViewport,
-      layout.streamWidth,
-      queue.length,
-      running,
-      state,
-      startTurn,
-      steerRunningAgents
-    ]
+    [config, layout.logViewport, layout.streamWidth, running, state, startTurn, steerRunningAgents]
   );
   const submit = useCallback(() => {
     const text = line.text.trim();
     if (!text || closingRef.current) return;
+    if (operationInput) {
+      const operation = operationInput;
+      setOperationInput(null);
+      if (operation === "steer" && !running) {
+        setLine(EMPTY_LINE);
+        setQueue((current) => [...current, text]);
+        queuePausedRef.current = true;
+        setQueuePaused(true);
+        setNotice("turn finished \u2014 message queued; /continue runs it");
+        return;
+      }
+      runCommand(operation, [text]);
+      return;
+    }
     const command = parseCommand(text);
     if (command) {
-      runCommand(command.name, command.args, text);
+      runCommand(command.name, command.args);
       return;
     }
     if (checkpointResolveRef.current) {
-      runCommand("modify", [text], text);
+      const resolve2 = checkpointResolveRef.current;
+      checkpointResolveRef.current = null;
+      checkpointLabelRef.current = "";
+      setLine(EMPTY_LINE);
+      resolve2({ action: "modify", instruction: text });
+      setNotice("modifying and continuing\u2026");
       return;
     }
     setLine(EMPTY_LINE);
@@ -3424,7 +3370,7 @@ function App({
       return;
     }
     void startTurn(text);
-  }, [line.text, runCommand, running, startTurn]);
+  }, [line.text, operationInput, runCommand, running, startTurn]);
   const insert = useCallback((chunk) => {
     setLine((l) => ({
       text: l.text.slice(0, l.cursor) + chunk + l.text.slice(l.cursor),
@@ -3454,10 +3400,13 @@ function App({
   const spinner = SPINNER[tick % SPINNER.length];
   const handleKey = (char, key) => {
     if (key.ctrl && char === "c") {
-      if (helpOpen) {
+      if (picker || operationInput) {
+        setNotice(void 0);
+        setPicker(null);
+        setOperationInput(null);
+        setLine(EMPTY_LINE);
+      } else if (helpOpen) {
         setHelpOpen(false);
-      } else if (historyOpen) {
-        setHistoryOpen(false);
       } else if (sessionsOpen) {
         setSessionsOpen(false);
       } else if (abortRef.current) {
@@ -3477,43 +3426,6 @@ function App({
       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;
-      }
-      if (char === "c") {
-        const target = historyTurns[historyIndex];
-        const sessions = turnSessions(target);
-        const count = Object.keys(sessions).length;
-        if (count === 0) {
-          setNotice(`turn ${target.turn} has no agent sessions to continue`);
-          return;
-        }
-        continuationRef.current = { turn: target.turn, sessions };
-        dispatch({ type: "view:open", turn: target.turn });
-        setHistoryOpen(false);
-        setNotice(
-          `continuing turn ${target.turn} \u2014 ${count} ${count === 1 ? "session" : "sessions"} \xB7 type your next instruction`
-        );
-        return;
-      }
-      return;
-    }
     if (sessionsOpen) {
       if (key.escape) {
         setSessionsOpen(false);
@@ -3558,13 +3470,61 @@ function App({
       }
       return;
     }
+    if (picker) {
+      if (key.escape) {
+        setPicker(null);
+        setLine(EMPTY_LINE);
+        setNotice(void 0);
+        return;
+      }
+      if (key.upArrow || key.downArrow || key.tab) {
+        const delta = key.upArrow || key.tab && key.shift ? -1 : 1;
+        setPicker({
+          ...picker,
+          cursor: (picker.cursor + delta + picker.rows.length) % picker.rows.length
+        });
+        return;
+      }
+      if (key.return) {
+        const row = picker.rows[picker.cursor];
+        setPicker(null);
+        if (row) runCommand(picker.command, [row.key]);
+        return;
+      }
+      if (!(key.ctrl && char === "d")) return;
+    }
+    if (operationInput && key.escape) {
+      setOperationInput(null);
+      setLine(EMPTY_LINE);
+      setNotice(void 0);
+      return;
+    }
+    if (searchResult && key.ctrl && (char === "n" || char === "p")) {
+      const matches2 = streamMatches(state, searchResult.query, layout.streamWidth);
+      if (matches2.length === 0) {
+        setSearchResult(null);
+        setNotice(`no matches for ${searchResult.query}`);
+        return;
+      }
+      const index = (searchResult.index + (char === "n" ? 1 : -1) + matches2.length) % matches2.length;
+      setSearchResult({ ...searchResult, index });
+      dispatch({
+        type: "stream:search",
+        query: searchResult.query,
+        match: index,
+        viewport: layout.logViewport,
+        width: layout.streamWidth
+      });
+      setNotice(`match ${index + 1}/${matches2.length} \xB7 ctrl+n next \xB7 ctrl+p previous`);
+      return;
+    }
     if (key.ctrl && char === "d") {
       if (!line.text) void shutdown();
       return;
     }
     if (key.ctrl && char === "l") {
       dispatch({ type: "stream:clear" });
-      setNotice(shown.focusId ? `cleared ${shown.focusId}` : "nothing focused");
+      setNotice(state.focusId ? `cleared ${state.focusId}` : "nothing focused");
       return;
     }
     if (key.ctrl && char === "a") {
@@ -3575,9 +3535,16 @@ function App({
       setLine((l) => ({ ...l, cursor: l.text.length }));
       return;
     }
-    const formFront = front?.kind === "question" && !isCommandLine(line.text) ? front : void 0;
+    const formFront = front?.kind === "question" && !operationInput ? front : void 0;
     if (key.tab && formFront === void 0 && !paletteOpen) {
-      dispatch({ type: "focus:cycle", delta: key.shift ? -1 : 1 });
+      if (key.shift) {
+        const next = permissionMode === "auto" ? "ask" : "auto";
+        setPermissionMode(next);
+        setNotice(`permission mode: ${next}`);
+        return;
+      }
+      setSearchResult(null);
+      dispatch({ type: "focus:cycle", delta: 1 });
       return;
     }
     if (paletteOpen) {
@@ -3609,7 +3576,7 @@ function App({
         return;
       }
     }
-    if (front?.kind === "permission" && line.text === "" && !menu.released) {
+    if (!operationInput && front?.kind === "permission" && line.text === "" && !menu.released) {
       const total = permissionChoices(front.request).length;
       if (key.upArrow || key.downArrow) {
         setPermissionMenu({
@@ -3645,8 +3612,12 @@ function App({
         if (draft !== void 0) setLine({ text: draft, cursor: draft.length });
       };
       const moveFocus = (index, state2 = committed) => {
-        const next = focusField(questionFields, state2, index);
-        save(next.state, next.draft);
+        const target = (index + total + 3) % (total + 3);
+        if (target >= total) save({ ...state2, field: target }, "");
+        else {
+          const next = focusField(questionFields, state2, target);
+          save(next.state, next.draft);
+        }
       };
       const submit2 = (state2) => {
         if (!formComplete(questionFields, state2)) {
@@ -3668,15 +3639,29 @@ function App({
         setNotice(`answered ${front2.shortId}`);
       };
       const advance = (state2) => {
-        if (form.field >= total - 1) submit2(state2);
-        else moveFocus(form.field + 1, state2);
+        moveFocus(form.field + 1, state2);
       };
       if (field === void 0) {
-        if (key.return) submit2(committed);
+        const action = Math.max(0, form.field - total);
+        if (key.tab || key.leftArrow || key.rightArrow || key.upArrow || key.downArrow) {
+          const delta = key.leftArrow || key.upArrow || key.tab && key.shift ? -1 : 1;
+          moveFocus(form.field + delta);
+          return;
+        }
+        if (key.return) {
+          if (action === 0) submit2(committed);
+          else {
+            front2.settle({ action: action === 1 ? "decline" : "cancel" });
+            setFormEntry({ id: "", state: initialForm() });
+            setLine(EMPTY_LINE);
+            setNotice(action === 1 ? "question skipped" : "question cancelled");
+          }
+        }
         return;
       }
       if (key.tab) {
-        moveFocus(key.shift ? form.field - 1 : form.field + 1);
+        const next = field.kind === "choice" ? commitField(questionFields, committed) : committed;
+        moveFocus(key.shift ? form.field - 1 : form.field + 1, next);
         return;
       }
       if (field.choices.length > 0 && (key.upArrow || key.downArrow)) {
@@ -3780,12 +3765,8 @@ function App({
         setError(void 0);
         return;
       }
-      if (state.view) {
-        dispatch({ type: "view:close" });
-        return;
-      }
       if (front !== void 0) {
-        setPermissionMenu({ id: front.shortId, cursor: void 0, released: true });
+        setPermissionMenu({ id: front.shortId, cursor: 0, released: !menu.released });
       }
       setLine(EMPTY_LINE);
       setNotice(void 0);
@@ -3804,17 +3785,42 @@ function App({
   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" : sessionsOpen ? "\u2191\u2193 select \xB7 enter open \xB7 d delete \xB7 esc close" : argOpen ? `\u2191\u2193 select \xB7 tab complete \xB7 enter ${arg?.command.name} \xB7 esc close` : menuOpen ? "\u2191\u2193 select \xB7 tab complete \xB7 enter run \xB7 esc close" : running ? checkpointResolveRef.current ? `/continue \xB7 /modify <instruction> \xB7 /cancel` : interactions.length > 0 ? layout.interactionRows === 0 ? (
-    // Too short to dock the bar, so the commands are the only way in.
-    "decide with /approve 1 \xB7 /deny \xB7 /respond"
-  ) : interactions[0].kind === "question" ? "tab field \xB7 \u2191\u2193 pick \xB7 enter next \xB7 /dismiss" : menu.released ? "/approve 1 and /deny still reach it" : "\u2191\u2193 or 1-9 choose \xB7 enter confirm \xB7 esc to type" : "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";
-  const placeholder = frontQuestion !== void 0 ? formField === void 0 ? "enter to answer" : editingField !== void 0 ? `${editingField.title}${editingField.required ? " *" : ""} \u2014 enter for the next field` : `${formField.title} \u2014 \u2191\u2193 to pick \xB7 enter for the next field` : front?.kind === "permission" && !menu.released ? "choose above \xB7 esc to type here instead" : checkpointResolveRef.current ? `checkpoint: ${checkpointLabelRef.current} \u2014 type feedback or /continue` : running ? RUNNING_PLACEHOLDER : awaitingAnswer ? "answer the leader\u2026 \xB7 /task starts a new task" : INPUT_PLACEHOLDER;
+  const keys = picker ? "\u2191\u2193 select \xB7 enter confirm \xB7 esc cancel" : operationInput ? "enter submit \xB7 esc cancel" : helpOpen ? "esc close" : sessionsOpen ? "\u2191\u2193 select \xB7 enter open \xB7 d delete \xB7 esc close" : argOpen ? `\u2191\u2193 select \xB7 tab complete \xB7 enter ${arg?.command.name} \xB7 esc close` : menuOpen ? "\u2191\u2193 select \xB7 tab complete \xB7 enter run \xB7 esc close" : running ? checkpointResolveRef.current ? `/continue \xB7 type feedback \xB7 ctrl+c cancel` : interactions.length > 0 ? layout.interactionRows === 0 ? (
+    // On short terminals the decision is shown in the body.
+    "\u2191\u2193 choose \xB7 enter confirm \xB7 esc type \xB7 ctrl+c cancel"
+  ) : interactions[0].kind === "question" ? "tab field / actions \xB7 \u2191\u2193 pick \xB7 enter confirm" : menu.released ? "esc return to permission options" : "\u2191\u2193 or 1-9 choose \xB7 enter confirm \xB7 esc to type" : "enter queues \xB7 ctrl+c cancel" : state.reply ? "enter sends \xB7 / commands \xB7 ? help" : "tab switch \xB7 shift+tab mode \xB7 / commands \xB7 ? help";
+  const placeholder = picker ? "choose an option above\u2026" : operationInput ? operationInput === "search" ? "search text\u2026" : "message for running agents\u2026" : frontQuestion !== void 0 ? formField === void 0 ? "enter to answer" : editingField !== void 0 ? `${editingField.title}${editingField.required ? " *" : ""} \u2014 enter for the next field` : `${formField.title} \u2014 \u2191\u2193 to pick \xB7 enter for the next field` : front?.kind === "permission" && !menu.released ? "choose above \xB7 esc to type here instead" : checkpointResolveRef.current ? `checkpoint: ${checkpointLabelRef.current} \u2014 type feedback or /continue` : running ? RUNNING_PLACEHOLDER : awaitingAnswer ? "answer the leader\u2026 \xB7 /new starts a new session" : INPUT_PLACEHOLDER;
+  const renderInteraction = (maxRows) => {
+    if (!front) return null;
+    return front.kind === "permission" ? /* @__PURE__ */ jsx6(
+      PermissionBar,
+      {
+        request: front.request,
+        others: interactions.slice(1).flatMap((entry) => entry.kind === "permission" ? [entry.request] : []),
+        cursor: menu.cursor,
+        released: menu.released,
+        width: layout.columns,
+        maxRows
+      }
+    ) : /* @__PURE__ */ jsx6(
+      QuestionForm,
+      {
+        request: front.request,
+        others: interactions.slice(1).flatMap((entry) => entry.kind === "question" ? [entry.request] : []),
+        fields: questionFields,
+        form,
+        draft: line.text,
+        width: layout.columns,
+        maxRows
+      }
+    );
+  };
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height: layout.rows, children: [
     /* @__PURE__ */ jsx6(
       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"}`
+        right: `turn ${state.turn} \xB7 ${running ? formatDuration(turnElapsed(state, now) ?? 0) : state.phase === "complete" ? "complete" : "ready"} \xB7 ${permissionMode}`
       }
     ),
     /* @__PURE__ */ jsx6(Rule, { width: layout.columns }),
@@ -3823,9 +3829,9 @@ function App({
       // 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__ */ jsx6(Box6, { marginTop: 1, height: layout.railRows, overflow: "hidden", flexShrink: 0, children: /* @__PURE__ */ jsx6(PipelineRail, { turn: shown, spinner }) })
+      /* @__PURE__ */ jsx6(Box6, { marginTop: 1, height: layout.railRows, overflow: "hidden", flexShrink: 0, children: /* @__PURE__ */ jsx6(PipelineRail, { turn: state, spinner }) })
     ) : null,
-    shown.reason ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, wrap: "truncate-end", children: `  reason: ${shown.reason}` }) : null,
+    state.reason ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, wrap: "truncate-end", children: `  reason: ${state.reason}` }) : null,
     /* @__PURE__ */ jsx6(
       Box6,
       {
@@ -3834,15 +3840,7 @@ function App({
         flexShrink: 0,
         flexDirection: "column",
         overflow: "hidden",
-        children: helpOpen ? /* @__PURE__ */ jsx6(HelpOverlay, { width: layout.columns, maxRows: layout.bodyHeight }) : historyOpen ? /* @__PURE__ */ jsx6(
-          HistoryOverlay,
-          {
-            turns: historyTurns,
-            selected: historyIndex,
-            width: layout.columns,
-            maxRows: layout.bodyHeight
-          }
-        ) : sessionsOpen ? /* @__PURE__ */ jsx6(
+        children: helpOpen ? /* @__PURE__ */ jsx6(HelpOverlay, { width: layout.columns, maxRows: layout.bodyHeight }) : sessionsOpen ? /* @__PURE__ */ jsx6(
           SessionsOverlay,
           {
             sessions: sessionList,
@@ -3852,20 +3850,20 @@ function App({
             maxRows: layout.bodyHeight,
             now
           }
-        ) : layout.welcome ? /* @__PURE__ */ jsx6(WelcomePanel, { turn: state, width: layout.columns }) : error ? (
+        ) : front && layout.interactionRows === 0 && !paletteOpen ? renderInteraction(layout.bodyHeight) : layout.welcome ? /* @__PURE__ */ jsx6(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__ */ jsx6(ErrorPanel, { message: error, width: layout.columns })
-        ) : shown.reply ? /* @__PURE__ */ jsx6(ReplyPanel, { reply: shown.reply, width: layout.columns }) : /* @__PURE__ */ jsxs6(Box6, { height: layout.bodyHeight, flexShrink: 0, flexDirection: "row", children: [
+        ) : state.reply ? /* @__PURE__ */ jsx6(ReplyPanel, { reply: state.reply, width: layout.columns }) : /* @__PURE__ */ jsxs6(Box6, { height: layout.bodyHeight, flexShrink: 0, flexDirection: "row", children: [
           layout.showTeam ? /* @__PURE__ */ jsxs6(Fragment3, { children: [
-            /* @__PURE__ */ jsx6(TeamPanel, { turn: shown, width: layout.teamWidth, now, spinner }),
+            /* @__PURE__ */ jsx6(TeamPanel, { turn: state, width: layout.teamWidth, now, spinner }),
             /* @__PURE__ */ jsx6(Divider, {})
           ] }) : null,
           /* @__PURE__ */ jsx6(
             StreamPanel,
             {
-              turn: shown,
+              state,
               height: layout.bodyHeight,
               width: layout.streamWidth,
               now,
@@ -3875,7 +3873,6 @@ function App({
         ] })
       }
     ),
-    state.view ? /* @__PURE__ */ jsx6(Text6, { color: COLOR.warn, wrap: "truncate-end", children: `  viewing turn ${shown.turn} \xB7 ${shown.requirement ?? "(no requirement)"} \xB7 esc to return` }) : null,
     notice || queuePaused && queue.length > 0 ? /* @__PURE__ */ jsxs6(Text6, { dimColor: true, wrap: "truncate-end", children: [
       "  ",
       notice ?? (awaitingAnswer ? "queue paused \u2014 answer the leader first" : "queue paused \u2014 /continue resumes it")
@@ -3890,26 +3887,7 @@ function App({
           overflow: "hidden",
           flexShrink: 0,
           flexDirection: "column",
-          children: front.kind === "permission" ? /* @__PURE__ */ jsx6(
-            PermissionBar,
-            {
-              request: front.request,
-              others: interactions.slice(1).flatMap((entry) => entry.kind === "permission" ? [entry.request] : []),
-              cursor: menu.cursor,
-              released: menu.released,
-              width: layout.columns
-            }
-          ) : /* @__PURE__ */ jsx6(
-            QuestionForm,
-            {
-              request: front.request,
-              others: interactions.slice(1).flatMap((entry) => entry.kind === "question" ? [entry.request] : []),
-              fields: questionFields,
-              form,
-              draft: line.text,
-              width: layout.columns
-            }
-          )
+          children: renderInteraction(layout.interactionRows)
         }
       )
     ] }),
@@ -4009,8 +3987,9 @@ export {
   seedAgents,
   stageStatus,
   startTui,
+  streamMatches,
   stripAnsi,
   tuiReducer,
   turnElapsed,
-  visibleLog
+  visibleTimeline
 };