@multiclawcli/dashboard 0.12.0 → 0.14.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,149 +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: "sessions",
-    description: "Switch between, or delete, saved sessions",
+    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: "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",
-    availability: "always"
-  },
-  {
-    name: "latest",
-    description: "Jump the stream to latest output",
+    description: "Export a turn as Markdown",
     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",
-    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",
+    description: "Resume the queue or continue a checkpoint",
     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 = [];
@@ -459,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.details ? 1 : 0) + (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) + (input.details ? 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);
@@ -508,6 +463,7 @@ var STATUS = {
   pending: { glyph: "\u25CB", color: COLOR.muted, dim: true, label: "queued" },
   running: { glyph: "\u25D0", color: COLOR.accent, label: "running" },
   retrying: { glyph: "\u21BB", color: COLOR.warn, label: "retrying" },
+  handed_back: { glyph: "\u21A9", color: COLOR.warn, label: "handed back" },
   success: { glyph: "\u2713", color: COLOR.ok, label: "done" },
   failed: { glyph: "\u2717", color: COLOR.error, label: "failed" },
   // Stopped, not broken: a filled square reads as "halted" and shares the muted
@@ -857,11 +813,55 @@ function reduceEvent(state, event) {
         }
       };
     }
+    case "agent:session": {
+      const { record, action } = event.payload;
+      const existing = state.agents[record.agentId];
+      const isCurrentWork = record.workId ? state.work?.id === record.workId : state.leaderIds.includes(record.agentId);
+      const startsBinding = action === "opening" || action === "load_requested";
+      const matchesBinding = !existing?.session || existing.session.bindingId === record.bindingId || startsBinding;
+      const history = state.history.map((turn) => {
+        if (!record.workId || turn.work?.id !== record.workId) return turn;
+        const member = turn.work.agents.find((item) => item.agentId === record.agentId);
+        if (member?.session?.bindingId !== record.bindingId) return turn;
+        return {
+          ...turn,
+          agents: turn.agents[record.agentId]?.session?.bindingId === record.bindingId ? {
+            ...turn.agents,
+            [record.agentId]: { ...turn.agents[record.agentId], session: record }
+          } : turn.agents,
+          work: {
+            ...turn.work,
+            agents: turn.work.agents.map(
+              (item) => item.agentId === record.agentId ? { ...item, session: record } : item
+            )
+          }
+        };
+      });
+      const updatesCurrent = isCurrentWork && matchesBinding && existing;
+      const work = updatesCurrent && state.work && state.work.id === record.workId ? {
+        ...state.work,
+        agents: state.work.agents.map(
+          (item) => item.agentId === record.agentId ? {
+            ...item,
+            session: record.sessionId || !item.session?.sessionId || record.failure?.code === "cleanup_failed" ? record : item.session
+          } : item
+        )
+      } : state.work;
+      return {
+        ...state,
+        work,
+        history,
+        sessionEvents: [...state.sessionEvents ?? [], event.payload],
+        agents: updatesCurrent ? { ...state.agents, [record.agentId]: { ...existing, session: record } } : state.agents
+      };
+    }
+    case "agent:handed-back":
     case "agent:complete":
     case "agent:failed": {
       const result = event.payload;
       const patch = {
         status: result.status,
+        handoffReason: result.handoffReason,
         duration: result.duration,
         attempts: result.attempts,
         retry: void 0,
@@ -870,18 +870,25 @@ function reduceEvent(state, event) {
         costUsd: result.costUsd,
         // Present only on the success path; a failed agent has no session to
         // continue, so `/retry` re-runs it cold.
-        sessionId: result.sessionId
+        session: result.session ?? state.agents[result.agentId]?.session
       };
       const existing = state.agents[result.agentId];
       const next = existing ? { ...existing, ...patch } : blankAgent(result.agentId, result.agentName, patch);
+      if (event.type === "agent:handed-back")
+        next.logs = appendLog(next.logs, "[handed back] " + result.handoffReason, "system");
       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 } };
+      return {
+        ...state,
+        agentResults: [...state.agentResults ?? [], result],
+        agents: { ...state.agents, [result.agentId]: next }
+      };
     }
     case "agent:skipped": {
       const { agentId, agentName, icon } = event.payload;
@@ -901,6 +908,15 @@ function reduceEvent(state, event) {
       });
       return { ...state, agents: { ...state.agents, [agentId]: next } };
     }
+    case "orchestration:route":
+      return {
+        ...state,
+        routing: event.payload.routing,
+        work: event.payload.work,
+        warning: event.payload.routing.reroutes ? "Worker handed work back \u2014 rerouting once" : state.warning
+      };
+    case "orchestration:routing-error":
+      return { ...state, warning: event.payload.message };
     case "orchestration:warning":
       return { ...state, warning: event.payload.message };
     case "orchestration:complete":
@@ -908,6 +924,10 @@ function reduceEvent(state, event) {
         ...state,
         phase: "complete",
         success: event.payload.success,
+        work: event.payload.work,
+        routing: event.payload.routing,
+        agentResults: event.payload.agentResults,
+        effectiveAgentResults: event.payload.effectiveAgentResults,
         acceptance: event.payload.acceptance,
         cancelled: event.payload.cancelled,
         effectiveRequirement: event.payload.requirement ?? state.effectiveRequirement,
@@ -920,14 +940,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 focusedRowCount(turn, width) {
-  const agent = turn.focusId ? turn.agents[turn.focusId] : void 0;
-  return agent?.logs ? wrapLog(agent.logs, width).length : 0;
+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 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 {
@@ -946,6 +1072,11 @@ function snapshot(state) {
     autoFollow: state.autoFollow,
     scroll: state.scroll,
     success: state.success,
+    work: state.work,
+    routing: state.routing,
+    sessionEvents: state.sessionEvents,
+    agentResults: state.agentResults,
+    effectiveAgentResults: state.effectiveAgentResults,
     acceptance: state.acceptance,
     totalDuration: state.totalDuration,
     totalCostUsd: state.totalCostUsd,
@@ -954,14 +1085,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)] : []];
 }
@@ -970,12 +1093,18 @@ function conversationTurns(state) {
   for (const turn of recordedTurns(state)) {
     if (turn.phase !== "complete" || turn.cancelled || !turn.requirement) continue;
     turns.push(
-      turn.reply ? { requirement: turn.requirement, reply: turn.reply } : { requirement: turn.requirement, outcome: conversationOutcome(turn) }
+      turn.reply ? { requirement: turn.requirement, reply: turn.reply } : { requirement: turn.requirement, outcome: conversationOutcome(turn), work: turn.work }
     );
   }
   return turns;
 }
+function latestWorkFromTurns(turns) {
+  const latest = [...turns].reverse().find((turn) => turn.work || !turn.reply && turn.stages.length > 0);
+  if (!latest?.work || latest.cancelled) return void 0;
+  return { ...latest.work, outcome: conversationOutcome(latest) };
+}
 function conversationOutcome(turn) {
+  if (!turn.interrupted && !turn.cancelled && turn.work?.outcome) return turn.work.outcome;
   const reviewer = turn.acceptance?.reviewer;
   const isWorker = (id) => id !== reviewer && !turn.leaderIds.includes(id);
   const workers = Object.values(turn.agents).filter((agent) => isWorker(agent.id));
@@ -1035,68 +1164,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;
@@ -1108,12 +1224,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":
@@ -1148,7 +1258,6 @@ function seededState(state, agents, leaderIds, history) {
     autoFollow: true,
     scroll: 0,
     history,
-    view: void 0,
     verbose: state.verbose
   };
 }
@@ -1156,6 +1265,7 @@ function stageStatus(stage, agents) {
   if (stage.outcome !== void 0) return stage.outcome;
   const statuses = stage.agents.map((a) => agents[a.id]?.status ?? "pending");
   if (statuses.some((s) => s === "failed")) return "failed";
+  if (statuses.some((s) => s === "handed_back")) return "handed_back";
   if (statuses.some((s) => s === "running" || s === "retrying")) return "running";
   if (statuses.length > 0 && statuses.every((s) => s === "success")) return "success";
   if (statuses.length > 0 && statuses.every((s) => s === "skipped")) return "skipped";
@@ -1163,6 +1273,7 @@ function stageStatus(stage, agents) {
   return "pending";
 }
 var SETTLED = /* @__PURE__ */ new Set([
+  "handed_back",
   "success",
   "failed",
   "cancelled",
@@ -1184,18 +1295,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
@@ -1452,7 +1553,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];
@@ -1480,11 +1581,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"]
     ]
   },
   {
@@ -1583,18 +1684,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,
         {
@@ -1607,7 +1712,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({
@@ -1616,18 +1721,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) }),
@@ -1648,7 +1761,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) {
@@ -1678,6 +1792,7 @@ function detailLines(field, width) {
 }
 
 // src/tui/components/panels.tsx
+import { describeSession } from "@multiclawcli/core";
 import { Box as Box4, Text as Text4 } from "ink";
 import { Fragment, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function rightColumn(agent, now) {
@@ -1766,21 +1881,27 @@ 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: [
         /* @__PURE__ */ jsx4(Text4, { bold: true, children: agent?.name ?? "\u2014" }),
+        agent?.session ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          " \xB7 ",
+          describeSession(agent.session)
+        ] }) : null,
         agent?.model ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
           " \xB7 ",
           agent.model
@@ -1803,6 +1924,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: [
@@ -1813,13 +1939,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
@@ -1996,6 +2123,7 @@ function CommandMenu({ rows, selected }) {
 // src/tui/history.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
+import { describeSession as describeSession2, isSessionEvent, isSessionRecord, isWorkContext } from "@multiclawcli/core";
 
 // src/tui/sessions.ts
 import { randomUUID } from "crypto";
@@ -2094,14 +2222,24 @@ function isAcceptance(value) {
 function isTurnView(value) {
   if (!isObject(value)) return false;
   const turn = value;
-  return typeof turn.turn === "number" && typeof turn.phase === "string" && (turn.cancelled === void 0 || typeof turn.cancelled === "boolean") && (turn.interrupted === void 0 || typeof turn.interrupted === "boolean") && (turn.acceptance === void 0 || isAcceptance(turn.acceptance)) && (turn.effectiveRequirement === void 0 || typeof turn.effectiveRequirement === "string") && isObject(turn.agents) && Object.values(turn.agents).every(isObject) && Array.isArray(turn.stages) && turn.stages.every(
-    (stage) => isObject(stage) && (stage.outcome === void 0 || ["pending", "running", "retrying", "success", "failed", "cancelled", "skipped"].includes(
-      stage.outcome
-    )) && (stage.memberStatuses === void 0 || isObject(stage.memberStatuses) && Object.values(stage.memberStatuses).every(
+  return typeof turn.turn === "number" && typeof turn.phase === "string" && (turn.cancelled === void 0 || typeof turn.cancelled === "boolean") && (turn.interrupted === void 0 || typeof turn.interrupted === "boolean") && (turn.work === void 0 || isWorkContext(turn.work)) && (turn.sessionEvents === void 0 || Array.isArray(turn.sessionEvents) && turn.sessionEvents.every(isSessionEvent)) && (turn.acceptance === void 0 || isAcceptance(turn.acceptance)) && (turn.effectiveRequirement === void 0 || typeof turn.effectiveRequirement === "string") && isObject(turn.agents) && Object.values(turn.agents).every(
+    (agent) => isObject(agent) && (agent.session === void 0 || isSessionRecord(agent.session))
+  ) && Array.isArray(turn.stages) && turn.stages.every(
+    (stage) => isObject(stage) && (stage.outcome === void 0 || [
+      "pending",
+      "running",
+      "retrying",
+      "handed_back",
+      "success",
+      "failed",
+      "cancelled",
+      "skipped"
+    ].includes(stage.outcome)) && (stage.memberStatuses === void 0 || isObject(stage.memberStatuses) && Object.values(stage.memberStatuses).every(
       (status) => typeof status === "string" && [
         "pending",
         "running",
         "retrying",
+        "handed_back",
         "success",
         "failed",
         "cancelled",
@@ -2144,6 +2282,27 @@ async function exportTurn(turn, filePath) {
 function formatTurnMarkdown(turn) {
   const lines = [`# Turn ${turn.turn}`, ""];
   if (turn.requirement) lines.push("## Requirement", "", turn.requirement, "");
+  if (turn.effectiveRequirement && turn.effectiveRequirement !== turn.requirement)
+    lines.push("## Complete requirement", "", turn.effectiveRequirement, "");
+  if (turn.routing) {
+    lines.push(
+      "## Routing",
+      "",
+      "Type: " + turn.routing.mode,
+      "Work: " + (turn.routing.workId ?? "none"),
+      "Reroutes: " + turn.routing.reroutes,
+      ""
+    );
+    if (turn.routing.error) lines.push("Incomplete: " + turn.routing.error, "");
+  }
+  if (turn.agentResults?.length) {
+    lines.push("## Execution attempts", "");
+    for (const result of turn.agentResults)
+      lines.push(
+        "- " + result.agentId + ": " + result.status + (result.handoffReason ? " \u2014 " + result.handoffReason : "") + (result.error ? " \u2014 " + result.error : "")
+      );
+    lines.push("");
+  }
   if (turn.reply) {
     lines.push("## Reply", "", `_${turn.reply.mode}_`, "", turn.reply.message, "");
   } else {
@@ -2164,11 +2323,20 @@ function formatTurnMarkdown(turn) {
       }
     }
   }
+  if (turn.sessionEvents?.length) {
+    lines.push("## Session lifecycle", "");
+    for (const event of turn.sessionEvents)
+      lines.push(
+        "- " + event.record.agentId + ": " + event.action + (event.requestedSessionId ? " target=" + event.requestedSessionId : "") + " \u2014 " + describeSession2(event.record) + (event.reason ? " \u2014 " + event.reason : "")
+      );
+    lines.push("");
+  }
   const agents = Object.values(turn.agents);
   if (agents.length > 0) {
     lines.push("## Agents", "");
     for (const agent of agents) {
       lines.push(`- ${agent.id}: ${agent.name} \u2014 ${agent.status}`);
+      if (agent.session) lines.push("  " + describeSession2(agent.session));
     }
     lines.push("");
     lines.push("## Logs", "");
@@ -2184,6 +2352,7 @@ function formatTurnMarkdown(turn) {
 // src/tui/session.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
+import { isSessionEvent as isSessionEvent2, isSessionRecord as isSessionRecord2, isWorkContext as isWorkContext2 } from "@multiclawcli/core";
 var SESSION_FILE = "session.json";
 var SESSION_VERSION = 1;
 var MAX_JOURNAL_LOG_CHARS = 1200;
@@ -2197,6 +2366,7 @@ var STATUSES = /* @__PURE__ */ new Set([
   "pending",
   "running",
   "retrying",
+  "handed_back",
   "success",
   "failed",
   "cancelled",
@@ -2204,11 +2374,11 @@ var STATUSES = /* @__PURE__ */ new Set([
 ]);
 function isAgentView(value) {
   if (!isObject2(value)) return false;
-  return typeof value.id === "string" && typeof value.name === "string" && Array.isArray(value.logs) && typeof value.status === "string" && STATUSES.has(value.status);
+  return typeof value.id === "string" && typeof value.name === "string" && (value.session === void 0 || isSessionRecord2(value.session)) && Array.isArray(value.logs) && typeof value.status === "string" && STATUSES.has(value.status);
 }
 function isJournalTurn(value) {
   if (!isObject2(value)) return false;
-  return Number.isInteger(value.turn) && typeof value.requirement === "string" && typeof value.savedAt === "number" && Number.isFinite(value.savedAt) && (value.startedAt === void 0 || typeof value.startedAt === "number") && (value.effectiveRequirement === void 0 || typeof value.effectiveRequirement === "string") && (value.reason === void 0 || typeof value.reason === "string") && (value.warning === void 0 || typeof value.warning === "string") && (value.focusId === void 0 || typeof value.focusId === "string") && isObject2(value.agents) && Object.values(value.agents).every(isAgentView) && Array.isArray(value.leaderIds) && value.leaderIds.every((id) => typeof id === "string") && Array.isArray(value.stages) && value.stages.every(isObject2) && (value.pending === void 0 || isObject2(value.pending) && Number.isInteger(value.pending.permissions) && Number.isInteger(value.pending.questions));
+  return Number.isInteger(value.turn) && typeof value.requirement === "string" && typeof value.savedAt === "number" && Number.isFinite(value.savedAt) && (value.work === void 0 || isWorkContext2(value.work)) && (value.sessionEvents === void 0 || Array.isArray(value.sessionEvents) && value.sessionEvents.every(isSessionEvent2)) && (value.startedAt === void 0 || typeof value.startedAt === "number") && (value.effectiveRequirement === void 0 || typeof value.effectiveRequirement === "string") && (value.reason === void 0 || typeof value.reason === "string") && (value.warning === void 0 || typeof value.warning === "string") && (value.focusId === void 0 || typeof value.focusId === "string") && isObject2(value.agents) && Object.values(value.agents).every(isAgentView) && Array.isArray(value.leaderIds) && value.leaderIds.every((id) => typeof id === "string") && Array.isArray(value.stages) && value.stages.every(isObject2) && (value.pending === void 0 || isObject2(value.pending) && Number.isInteger(value.pending.permissions) && Number.isInteger(value.pending.questions));
 }
 function loadJournal(workDir, sessionId) {
   try {
@@ -2256,6 +2426,10 @@ function journalTurn(state, pending) {
   }
   return {
     turn: state.turn,
+    work: state.work,
+    routing: state.routing,
+    sessionEvents: state.sessionEvents,
+    agentResults: state.agentResults,
     requirement: state.requirement ?? "",
     startedAt: state.startedAt,
     effectiveRequirement: state.effectiveRequirement,
@@ -2273,10 +2447,24 @@ var UNSETTLED = /* @__PURE__ */ new Set(["pending", "running", "retrying"]);
 function interruptedTurn(entry) {
   const agents = {};
   for (const [id, agent] of Object.entries(entry.agents)) {
-    agents[id] = UNSETTLED.has(agent.status) ? { ...agent, status: "cancelled" } : { ...agent };
+    agents[id] = {
+      ...agent,
+      ...UNSETTLED.has(agent.status) ? { status: "cancelled" } : {},
+      session: agent.session ? { ...agent.session, state: agent.session.state === "closed" ? "closed" : "unknown" } : void 0
+    };
   }
   return {
     turn: entry.turn,
+    work: entry.work ? {
+      ...entry.work,
+      agents: entry.work.agents.map((agent) => ({
+        ...agent,
+        session: agent.session ? { ...agent.session, state: agent.session.state === "closed" ? "closed" : "unknown" } : void 0
+      }))
+    } : void 0,
+    routing: entry.routing,
+    sessionEvents: entry.sessionEvents,
+    agentResults: entry.agentResults,
     requirement: entry.requirement,
     effectiveRequirement: entry.effectiveRequirement,
     reason: entry.reason,
@@ -2339,6 +2527,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 };
@@ -2352,20 +2550,6 @@ function pickTurn(state, raw, whenEmpty) {
   if (!target.record.requirement) return { error: `turn ${target.record.turn} has no requirement` };
   return { record: target.record, requirement: target.record.requirement };
 }
-function turnSessions(turn) {
-  const sessions = {};
-  for (const agent of Object.values(turn.agents)) {
-    if (agent.sessionId) sessions[agent.id] = agent.sessionId;
-  }
-  return sessions;
-}
-function continuationResume(continuation, live) {
-  if (!continuation) return void 0;
-  const sessions = Object.fromEntries(
-    Object.entries(continuation.sessions).filter(([id]) => !live?.has(id))
-  );
-  return Object.keys(sessions).length > 0 ? { sessions } : void 0;
-}
 function StatusLine({
   state,
   running,
@@ -2382,6 +2566,8 @@ function StatusLine({
     return /* @__PURE__ */ jsx6(Text6, { color: COLOR.warn, wrap: "truncate-end", children: state.warning });
   if ((cancelled || state.cancelled) && !running)
     return /* @__PURE__ */ jsx6(Text6, { color: COLOR.warn, children: "cancelled \xB7 workspace changes are retained" });
+  if (state.routing?.error && !running)
+    return /* @__PURE__ */ jsx6(Text6, { color: COLOR.warn, wrap: "truncate-end", children: state.routing.error });
   if (state.reply) {
     const asking = state.reply.mode === "ask";
     return /* @__PURE__ */ jsx6(Text6, { color: asking ? COLOR.warn : COLOR.ok, wrap: "truncate-end", children: asking ? `${GLYPH.ask} needs your input` : `${STATUS.success.glyph} answered` });
@@ -2470,10 +2656,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 [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([]);
@@ -2484,15 +2679,6 @@ function App({
   const abortRef = useRef(null);
   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 last = history[history.length - 1];
-    if (last) dispatch({ type: "view:open", turn: last.turn });
-    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);
@@ -2563,16 +2749,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 });
     });
   }, []);
@@ -2653,9 +2844,7 @@ function App({
       if (closingRef.current || busyRef.current) return;
       busyRef.current = true;
       setRunning(true);
-      const continuation = opts?.newSession ? null : continuationRef.current;
-      continuationRef.current = null;
-      const resume = opts?.resume ?? continuationResume(continuation, sessionsRef.current);
+      const resume = opts?.resume;
       if (opts?.newSession) {
         try {
           await sessionsRef.current?.reset();
@@ -2689,6 +2878,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",
@@ -2705,8 +2901,18 @@ function App({
         // An answer only reads as a requirement next to the question it answers,
         // so the leader is handed the turns behind this one as well.
         history: earlierTurns,
+        latestWork: opts?.newSession ? void 0 : opts?.work ?? latestWorkFromTurns(recordedTurns(stateRef.current)),
         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
@@ -2771,7 +2977,8 @@ function App({
       requestPermission,
       requestQuestion,
       handleCheckpoint,
-      clearInteractions
+      clearInteractions,
+      permissionMode
     ]
   );
   useEffect(() => {
@@ -2791,21 +2998,16 @@ function App({
         return;
       }
       if (closingRef.current) return;
+      setSearchResult(null);
       const restored2 = restoreConsole(config.workDir, id);
       sessionIdRef.current = id;
       persistedTurnRef.current = restored2.persistedTurn;
-      const resumable = [...restored2.history].reverse().find((turn) => Object.keys(turnSessions(turn)).length > 0);
-      continuationRef.current = resumable ? { turn: resumable.turn, sessions: turnSessions(resumable) } : null;
       dispatch({
         type: "session:load",
         agents: seedAgents(config),
         leaderIds: leaderAgentIds(config),
         history: restored2.history
       });
-      const lastTurn = restored2.history[restored2.history.length - 1];
-      if (lastTurn) {
-        dispatch({ type: "view:open", turn: lastTurn.turn });
-      }
       setQueue(restored2.queue);
       queuePausedRef.current = restored2.queue.length > 0;
       setQueuePaused(restored2.queue.length > 0);
@@ -2813,9 +3015,7 @@ function App({
       setAwaitingAnswer(restored2.awaitingAnswer);
       setError(void 0);
       setCancelled(false);
-      setNotice(
-        restored2.notice ?? (resumable ? `switched session \xB7 continue with your next instruction` : `switched session \xB7 ${restored2.history.length} turn${restored2.history.length === 1 ? "" : "s"}`)
-      );
+      setNotice(restored2.notice ?? "switched session \xB7 route your next instruction");
     },
     [config]
   );
@@ -2885,28 +3085,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 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 && !sessionsOpen && query !== void 0 && matches.length > 0;
-  const argOpen = !helpOpen && !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;
@@ -2931,10 +3135,10 @@ function App({
     queueRows: queue.length,
     interactionRows: interactionRows(interactions, Math.max(MIN_COLUMNS, columns)),
     promptRows,
+    details: !!(state.reason || state.routing),
     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;
@@ -2959,11 +3163,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;
       }
@@ -2971,111 +3175,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;
-          }
-          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;
+            setNotice("usage: /mode auto | ask | deny");
           }
-          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([]);
@@ -3084,15 +3263,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) {
@@ -3103,6 +3273,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");
@@ -3120,56 +3294,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 "sessions": {
           const list = listSessions(config.workDir);
           setSessionList(list);
@@ -3184,38 +3333,45 @@ 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]?.session?.sessionId).map((id) => [id, turn.agents[id].session])
           );
-          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, {
+            work: turn.work,
             resume: {
               agents: ids,
               ...Object.keys(sessions).length > 0 ? { sessions } : {}
@@ -3240,8 +3396,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;
@@ -3266,74 +3422,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);
@@ -3343,7 +3491,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),
@@ -3373,7 +3521,12 @@ 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 (sessionsOpen) {
         setSessionsOpen(false);
@@ -3438,13 +3591,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") {
@@ -3455,9 +3656,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) {
@@ -3489,7 +3697,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({
@@ -3525,8 +3733,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)) {
@@ -3548,15 +3760,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)) {
@@ -3660,12 +3886,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);
@@ -3684,17 +3906,42 @@ function App({
   const handlerRef = useRef(handleKey);
   handlerRef.current = handleKey;
   useInput((char, key) => handlerRef.current(char, key));
-  const keys = 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 /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 }),
@@ -3703,9 +3950,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 || state.routing ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, wrap: "truncate-end", children: (state.routing ? "  route: " + state.routing.mode + " \xB7 " + state.routing.workId + (state.routing.reroutes ? " \xB7 rerouted" : "") : "") + (state.reason ? "  reason: " + state.reason : "") }) : null,
     /* @__PURE__ */ jsx6(
       Box6,
       {
@@ -3724,20 +3971,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,
@@ -3747,7 +3994,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")
@@ -3762,26 +4008,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)
         }
       )
     ] }),
@@ -3872,6 +4099,7 @@ export {
   conversationTurns,
   createInitialState,
   initialState,
+  latestWorkFromTurns,
   leaderAgentIds,
   measureRailRows,
   plannedAgents,
@@ -3881,8 +4109,9 @@ export {
   seedAgents,
   stageStatus,
   startTui,
+  streamMatches,
   stripAnsi,
   tuiReducer,
   turnElapsed,
-  visibleLog
+  visibleTimeline
 };