@multiclawcli/dashboard 0.5.0 → 0.6.0

package/dist/tui.js

@@ -1,13 +1,44 @@
 // src/tui/index.ts
+import { AgentSessionManager as AgentSessionManager2 } from "@multiclawcli/core";
 import { render } from "ink";
 import { createElement } from "react";
 
 // src/tui/App.tsx
-import * as path2 from "path";
-import { describeResumePlan, isAbortError, Orchestrator } from "@multiclawcli/core";
+import * as path4 from "path";
+import {
+  AgentSessionManager,
+  describeResumePlan,
+  isAbortError,
+  Orchestrator,
+  validateRuntimeQuestionContent
+} from "@multiclawcli/core";
 import { Box as Box5, Text as Text5, useApp, useInput, useWindowSize } from "ink";
 import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
 
+// src/tui/atomic.ts
+import * as fs from "fs";
+import * as path from "path";
+var writes = /* @__PURE__ */ new Map();
+function writeJsonFile(target, json) {
+  const write = (writes.get(target) ?? Promise.resolve()).catch(() => {
+  }).then(async () => {
+    await fs.promises.mkdir(path.dirname(target), { recursive: true });
+    const tmp = `${target}.tmp`;
+    await fs.promises.writeFile(tmp, json, "utf-8");
+    await fs.promises.rename(tmp, target);
+  });
+  writes.set(target, write);
+  void write.finally(() => {
+    if (writes.get(target) === write) writes.delete(target);
+  }).catch(() => {
+  });
+  return write;
+}
+function pendingWrite(target) {
+  return (writes.get(target) ?? Promise.resolve()).catch(() => {
+  });
+}
+
 // src/tui/commands.ts
 var COMMANDS = [
   { name: "agents", description: "List the configured team", availability: "always" },
@@ -69,6 +100,60 @@ var COMMANDS = [
     description: "Cancel the running turn and its queue",
     availability: "running"
   },
+  {
+    name: "task",
+    args: "<requirement>",
+    description: "Start a new task with fresh agent sessions",
+    availability: "idle"
+  },
+  {
+    name: "steer",
+    args: "<text>",
+    description: "Send a message into the agents running right now",
+    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: "continue", description: "Resume queued turns after a checkpoint", availability: "idle" },
+  {
+    name: "respond",
+    args: "<question id> <JSON object>",
+    description: "Respond to a structured tool question",
+    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: "<request id> <option number>",
+    description: "Choose an offered permission option explicitly",
+    availability: "always"
+  },
+  {
+    name: "deny",
+    args: "<request id>",
+    description: "Deny a pending permission request",
+    availability: "always"
+  },
   { name: "help", description: "Show the key map", availability: "always" },
   { name: "quit", description: "Exit the console", availability: "always" }
 ];
@@ -254,6 +339,29 @@ function formatCost(usd) {
   if (usd < 0.01) return "<$0.01";
   return `$${usd.toFixed(2)}`;
 }
+function describeSteering(reports) {
+  const names = (list) => list.map((report) => report.agentId).join(", ");
+  const of = (status) => reports.filter((report) => report.status === status);
+  const injected = of("injected");
+  const idle = of("idle");
+  const unsupported = of("unsupported");
+  const failed = of("error");
+  const why = failed.find((report) => report.error)?.error ?? "unknown error";
+  if (injected.length > 0) {
+    const parts = [`steered ${names(injected)}`];
+    if (idle.length > 0) {
+      parts.push(`${names(idle)} ${idle.length === 1 ? "was" : "were"} between turns`);
+    }
+    if (unsupported.length > 0) parts.push(`${names(unsupported)} cannot take mid-turn input`);
+    if (failed.length > 0) parts.push(`${names(failed)} could not take it: ${why}`);
+    return parts.join(" \xB7 ");
+  }
+  if (failed.length > 0) return `could not reach ${names(failed)}: ${why} \u2014 queued as a follow-up`;
+  if (unsupported.length > 0) {
+    return "no running agent can take mid-turn input \u2014 queued as a follow-up";
+  }
+  return "no agent was mid-turn \u2014 queued as a follow-up";
+}
 
 // src/tui/layout.ts
 var MIN_COLUMNS = 40;
@@ -395,8 +503,8 @@ function Header({ name, right }) {
 function Rule({ width }) {
   return /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: COLOR.muted, dimColor: true, children: "\u2500".repeat(Math.max(0, width)) }) });
 }
-function Chip({ agent, fallbackName, spinner }) {
-  const status = agent?.status ?? "pending";
+function Chip({ agent, fallbackName, spinner, statusOverride }) {
+  const status = statusOverride ?? agent?.status ?? "pending";
   const style = STATUS[status];
   const glyph = status === "running" ? spinner : style.glyph;
   return /* @__PURE__ */ jsx(Box, { marginRight: 1, children: /* @__PURE__ */ jsxs(Text, { color: style.color, dimColor: style.dim, children: [
@@ -443,10 +551,11 @@ function PipelineRail({ turn, spinner }) {
           Chip,
           {
             agent: turn.agents[agent.id],
+            statusOverride: stage.memberStatuses?.[agent.id],
             fallbackName: agent.name,
             spinner
           },
-          agent.id
+          `${stage.stageIndex}-${agent.id}`
         )
       );
     }
@@ -579,7 +688,7 @@ function reduceEvent(state, event) {
         ...state,
         phase: "running",
         name: event.payload.name,
-        requirement: event.payload.requirement ?? state.requirement,
+        effectiveRequirement: event.payload.requirement ?? state.effectiveRequirement,
         reason: event.payload.selectionReason,
         stages: event.payload.stages,
         agents: mergeStageAgents(state.agents, event.payload.stages)
@@ -591,15 +700,29 @@ function reduceEvent(state, event) {
     case "orchestration:stages": {
       return {
         ...state,
-        stages: event.payload.stages,
+        stages: event.payload.stages.map((stage) => {
+          const previous = state.stages.find((previous2) => previous2.stageIndex === stage.stageIndex);
+          return previous?.outcome === void 0 ? stage : { ...stage, outcome: previous.outcome, memberStatuses: previous.memberStatuses };
+        }),
         agents: mergeStageAgents(state.agents, event.payload.stages)
       };
     }
-    // Stage boundaries carry no state of their own — the per-agent statuses
-    // derived from them already drive the pipeline bar.
     case "stage:start":
-    case "stage:complete":
       return state;
+    case "stage:complete": {
+      const stage = state.stages.find((stage2) => stage2.stageIndex === event.payload.stageIndex);
+      if (!stage || stage.outcome !== void 0) return state;
+      const outcome2 = stageStatus(stage, state.agents);
+      const memberStatuses = Object.fromEntries(
+        stage.agents.map((agent) => [agent.id, state.agents[agent.id]?.status ?? "pending"])
+      );
+      return {
+        ...state,
+        stages: state.stages.map(
+          (entry) => entry === stage ? { ...entry, outcome: outcome2, memberStatuses } : entry
+        )
+      };
+    }
     case "agent:start": {
       const { agentId, agentName, icon, model, taskTitle } = event.payload;
       const existing = state.agents[agentId];
@@ -611,7 +734,14 @@ function reduceEvent(state, event) {
         model: model ?? existing.model,
         taskTitle: taskTitle ?? existing.taskTitle,
         status: "running",
-        startedAt: startedAt ?? existing.startedAt
+        startedAt: startedAt ?? existing.startedAt,
+        duration: void 0,
+        attempts: void 0,
+        retry: void 0,
+        error: void 0,
+        usage: void 0,
+        costUsd: void 0,
+        logs: existing.startedAt !== void 0 && existing.logs ? appendLog(existing.logs, "\n[agent restarted]\n") : existing.logs
       } : blankAgent(agentId, agentName, {
         icon,
         model,
@@ -648,6 +778,7 @@ function reduceEvent(state, event) {
         status: result.status,
         duration: result.duration,
         attempts: result.attempts,
+        retry: void 0,
         error: result.error,
         usage: result.usage,
         costUsd: result.costUsd,
@@ -657,6 +788,14 @@ function reduceEvent(state, event) {
       };
       const existing = state.agents[result.agentId];
       const next = existing ? { ...existing, ...patch } : blankAgent(result.agentId, result.agentName, patch);
+      if (event.type === "agent:failed") {
+        if (next.logs === "" && result.output) next.logs = appendLog("", result.output);
+        if (result.error && !next.logs.includes(stripAnsi(result.error))) {
+          next.logs = appendLog(next.logs, `
+[error] ${result.error}
+`);
+        }
+      }
       return { ...state, agents: { ...state.agents, [result.agentId]: next } };
     }
     case "agent:skipped": {
@@ -682,6 +821,9 @@ function reduceEvent(state, event) {
         ...state,
         phase: "complete",
         success: event.payload.success,
+        acceptance: event.payload.acceptance,
+        cancelled: event.payload.cancelled,
+        effectiveRequirement: event.payload.requirement ?? state.effectiveRequirement,
         totalDuration: event.payload.totalDuration,
         totalCostUsd: event.payload.totalCostUsd,
         endedAt: epoch(event.timestamp) ?? Date.now(),
@@ -702,6 +844,9 @@ function snapshot(state) {
   return {
     turn: state.turn,
     requirement: state.requirement,
+    effectiveRequirement: state.effectiveRequirement,
+    cancelled: state.cancelled,
+    interrupted: state.interrupted,
     phase: state.phase,
     startedAt: state.startedAt,
     endedAt: state.endedAt,
@@ -712,6 +857,7 @@ function snapshot(state) {
     autoFollow: state.autoFollow,
     scroll: state.scroll,
     success: state.success,
+    acceptance: state.acceptance,
     totalDuration: state.totalDuration,
     totalCostUsd: state.totalCostUsd,
     reason: state.reason,
@@ -733,7 +879,7 @@ function recordedTurns(state) {
 function conversationTurns(state) {
   const turns = [];
   for (const turn of recordedTurns(state)) {
-    if (turn.phase !== "complete" || !turn.requirement) continue;
+    if (turn.phase !== "complete" || turn.cancelled || !turn.requirement) continue;
     turns.push(
       turn.reply ? { requirement: turn.requirement, reply: turn.reply } : { requirement: turn.requirement }
     );
@@ -824,6 +970,19 @@ function tuiReducer(state, action) {
         if (!id || !agent) return turn;
         return { ...turn, agents: { ...turn.agents, [id]: { ...agent, logs: "" } }, scroll: 0 };
       });
+    case "stream:note": {
+      const agent = state.agents[action.agentId];
+      if (!agent) return state;
+      return {
+        ...state,
+        agents: {
+          ...state.agents,
+          [action.agentId]: { ...agent, logs: appendLog(agent.logs, `
+${action.text}
+`) }
+        }
+      };
+    }
     case "view:open": {
       const record = state.history.find((turn) => turn.turn === action.turn);
       return record ? { ...state, view: record } : state;
@@ -835,6 +994,7 @@ function tuiReducer(state, action) {
   }
 }
 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 === "running" || s === "retrying")) return "running";
@@ -886,7 +1046,7 @@ var HELP_GROUPS = [
     title: "prompt",
     rows: [
       ["enter", "Run the requirement"],
-      ["enter (busy)", "Queue it to run next"],
+      ["enter (busy)", "Queue only; /approve tools, /respond questions"],
       ["esc", "Clear the line, close an overlay"],
       ["\u2190 \u2192 home end", "Move the caret"]
     ]
@@ -906,7 +1066,7 @@ var HELP_GROUPS = [
     rows: [
       ["/", "Command menu"],
       ["?", "This help"],
-      ["ctrl+c", "Cancel the turn and its queue \xB7 again to quit"],
+      ["ctrl+c", "Cancel turn and queue \xB7 idle exits after cleanup"],
       ["/<command>", `All ${COMMANDS.length} commands \u2014 type / to browse`]
     ]
   }
@@ -941,11 +1101,115 @@ function HelpOverlay({ width, maxRows }) {
     /* @__PURE__ */ jsx2(Box2, { marginTop: gap, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "esc or ? to close" }) })
   ] });
 }
+function PermissionOverlay({
+  request,
+  shortId,
+  queued,
+  width,
+  maxRows
+}) {
+  const clean = (value) => stripAnsi(value).replace(/\p{Cc}/gu, " ");
+  const input = request.input === void 0 ? "(no input)" : JSON.stringify(request.input) ?? "(no input)";
+  const inputRows = Math.max(1, Math.min(3, maxRows - request.options.length - 7));
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexShrink: 0, paddingLeft: 2, width, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: COLOR.warn, wrap: "truncate-end", children: `PERMISSION ${shortId} \xB7 ${queued} pending \xB7 ${clean(request.agentId)}` }),
+    /* @__PURE__ */ jsx2(Text2, { wrap: "truncate-end", children: clean(request.title) }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, wrap: "truncate-end", children: `request ${clean(request.requestId)} \xB7 ${clean(request.toolName ?? request.kind ?? request.toolCallId)}` }),
+    /* @__PURE__ */ jsx2(Text2, { color: COLOR.accent, wrap: "truncate-end", children: `/approve ${shortId} <number> \xB7 /deny ${shortId}` }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, wrap: "truncate-end", children: "Ordinary text queues a follow-up; it never grants permission." }),
+    /* @__PURE__ */ jsx2(Box2, { height: inputRows, overflow: "hidden", flexShrink: 0, children: /* @__PURE__ */ jsx2(Text2, { children: `input: ${clean(input)}` }) }),
+    request.options.map((option, index) => /* @__PURE__ */ jsx2(Text2, { wrap: "truncate-end", children: `${index + 1}. ${clean(option.name)} (${option.kind})` }, option.optionId))
+  ] });
+}
+function questionLines(request, width) {
+  const lines = [request.message, `request ${request.requestId}`];
+  for (const [key, field] of Object.entries(request.requestedSchema.properties ?? {})) {
+    const schema = field;
+    const items = schema.items;
+    const choices = schema.oneOf ?? schema.enum ?? items?.anyOf ?? items?.enum;
+    lines.push(
+      `${key}${request.requestedSchema.required?.includes(key) ? " *" : ""}: ${typeof schema.title === "string" ? schema.title : key} (${field.type})`
+    );
+    if (typeof schema.description === "string") lines.push(schema.description);
+    const limits = [
+      "minimum",
+      "maximum",
+      "exclusiveMinimum",
+      "exclusiveMaximum",
+      "minLength",
+      "maxLength",
+      "minItems",
+      "maxItems",
+      "uniqueItems"
+    ].filter((limit) => schema[limit] !== void 0 && schema[limit] !== null).map((limit) => `${limit}=${schema[limit]}`);
+    if (limits.length) lines.push(limits.join(" \xB7 "));
+    for (const choice of choices ?? []) {
+      lines.push(
+        typeof choice === "string" ? JSON.stringify(choice) : `${JSON.stringify(choice.const)} \u2014 ${choice.title ?? choice.const}${choice.description ? `: ${choice.description}` : ""}`
+      );
+    }
+  }
+  return lines.flatMap(
+    (line) => wrapLine(stripAnsi(line).replace(/\p{Cc}/gu, " "), Math.max(1, width - 2))
+  );
+}
+function QuestionOverlay({
+  request,
+  shortId,
+  queued,
+  width,
+  maxRows,
+  offset
+}) {
+  const lines = questionLines(request, width);
+  const capacity = Math.max(1, maxRows - 4);
+  const start = Math.min(offset, Math.max(0, lines.length - capacity));
+  const visible = lines.slice(start, start + capacity);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexShrink: 0, paddingLeft: 2, width, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: COLOR.warn, wrap: "truncate-end", children: `QUESTION ${shortId} \xB7 ${queued} pending \xB7 ${stripAnsi(request.agentId)}` }),
+    /* @__PURE__ */ jsx2(Text2, { color: COLOR.accent, wrap: "truncate-end", children: `/respond ${shortId} <JSON object>` }),
+    /* @__PURE__ */ jsx2(
+      Text2,
+      {
+        dimColor: true,
+        wrap: "truncate-end",
+        children: `/skip ${shortId} declines \xB7 /dismiss ${shortId} cancels`
+      }
+    ),
+    visible.map((line, index) => (
+      // biome-ignore lint/suspicious/noArrayIndexKey: immutable text rows are identified by their absolute form offset.
+      /* @__PURE__ */ jsx2(Text2, { wrap: "truncate-end", children: line }, `${start + index}-${line}`)
+    )),
+    /* @__PURE__ */ jsx2(
+      Text2,
+      {
+        dimColor: true,
+        wrap: "truncate-end",
+        children: `\u2191\u2193 / pgup pgdn form \xB7 ${start + 1}\u2013${start + visible.length}/${lines.length} \xB7 ordinary text queues`
+      }
+    )
+  ] });
+}
 function outcome(turn) {
   if (turn.reply) {
     return turn.reply.mode === "ask" ? { text: `${GLYPH.ask} needs input`, color: COLOR.warn } : { text: `${STATUS.success.glyph} answered`, color: COLOR.ok };
   }
-  if (turn.phase !== "complete") return { text: "interrupted", color: COLOR.warn };
+  if (turn.interrupted || turn.phase !== "complete") {
+    return { text: "interrupted", color: COLOR.warn };
+  }
+  if (turn.acceptance) {
+    switch (turn.acceptance.status) {
+      case "approved":
+        return { text: `${STATUS.success.glyph} approved`, color: COLOR.ok };
+      case "changes_required":
+        return { text: `${GLYPH.warn} changes required`, color: COLOR.warn };
+      case "failed":
+        return { text: `${STATUS.failed.glyph} acceptance failed`, color: COLOR.error };
+      case "cancelled":
+        return { text: `${STATUS.cancelled.glyph} acceptance cancelled`, color: COLOR.warn };
+    }
+  }
+  if (turn.cancelled) return { text: `${STATUS.cancelled.glyph} cancelled`, color: COLOR.warn };
   return turn.success ? { text: `${STATUS.success.glyph} done`, color: COLOR.ok } : { text: `${STATUS.failed.glyph} failed`, color: COLOR.error };
 }
 function HistoryOverlay({
@@ -1238,7 +1502,7 @@ function Prompt({
   const ghost = value === "";
   const before = shown.slice(0, cursor);
   const cell = ghost ? placeholder.slice(0, 1) : shown.slice(cursor, cursor + 1);
-  const tail = ghost ? placeholder.slice(1) : shown.slice(cursor + 1);
+  const tail2 = ghost ? placeholder.slice(1) : shown.slice(cursor + 1);
   return /* @__PURE__ */ jsxs4(Box4, { flexShrink: 0, children: [
     /* @__PURE__ */ jsxs4(Text4, { color: COLOR.accent, children: [
       GLYPH.caret,
@@ -1246,7 +1510,7 @@ function Prompt({
     ] }),
     /* @__PURE__ */ jsx4(Text4, { dimColor: ghost, children: before }),
     /* @__PURE__ */ jsx4(Text4, { inverse: caretVisible, dimColor: !caretVisible && ghost, children: cell || " " }),
-    /* @__PURE__ */ jsx4(Text4, { dimColor: ghost, children: tail })
+    /* @__PURE__ */ jsx4(Text4, { dimColor: ghost, children: tail2 })
   ] });
 }
 function CommandMenu({ rows, selected }) {
@@ -1273,25 +1537,45 @@ function CommandMenu({ rows, selected }) {
 }
 
 // src/tui/history.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 var CONSOLE_DIR = "console";
 var HISTORY_FILE = "history.json";
 var EXPORT_DIR = "exports";
 function historyPath(workDir) {
-  return path.join(workDir, ".multiclaw", CONSOLE_DIR, HISTORY_FILE);
+  return path2.join(workDir, ".multiclaw", CONSOLE_DIR, HISTORY_FILE);
 }
 function isObject(value) {
   return typeof value === "object" && value !== null;
 }
+function isAcceptance(value) {
+  if (!isObject(value)) return false;
+  return typeof value.status === "string" && ["approved", "changes_required", "failed", "cancelled"].includes(value.status) && typeof value.reviewer === "string" && Number.isInteger(value.repairRounds) && value.repairRounds >= 0 && (value.reason === void 0 || typeof value.reason === "string") && Array.isArray(value.reviews) && value.reviews.every(
+    (review) => isObject(review) && (review.verdict === "approved" || review.verdict === "changes_required") && typeof review.summary === "string" && Array.isArray(review.issues) && review.issues.every((issue) => typeof issue === "string")
+  );
+}
 function isTurnView(value) {
   if (!isObject(value)) return false;
   const turn = value;
-  return typeof turn.turn === "number" && typeof turn.phase === "string" && isObject(turn.agents) && Object.values(turn.agents).every(isObject) && Array.isArray(turn.stages) && turn.stages.every(isObject) && Array.isArray(turn.leaderIds);
+  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(
+      (status) => typeof status === "string" && [
+        "pending",
+        "running",
+        "retrying",
+        "success",
+        "failed",
+        "cancelled",
+        "skipped"
+      ].includes(status)
+    ))
+  ) && Array.isArray(turn.leaderIds);
 }
 function loadHistory(workDir) {
   try {
-    const raw = fs.readFileSync(historyPath(workDir), "utf-8");
+    const raw = fs2.readFileSync(historyPath(workDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
     return parsed.filter(isTurnView).slice(-MAX_HISTORY);
@@ -1299,19 +1583,15 @@ function loadHistory(workDir) {
     return [];
   }
 }
-async function saveHistory(workDir, turns) {
-  const target = historyPath(workDir);
-  await fs.promises.mkdir(path.dirname(target), { recursive: true });
-  const tmp = `${target}.tmp`;
-  await fs.promises.writeFile(tmp, JSON.stringify(turns), "utf-8");
-  await fs.promises.rename(tmp, target);
+function saveHistory(workDir, turns) {
+  return writeJsonFile(historyPath(workDir), JSON.stringify(turns));
 }
 function exportPath(workDir, turn) {
-  return path.join(workDir, ".multiclaw", CONSOLE_DIR, EXPORT_DIR, `turn-${turn}.md`);
+  return path2.join(workDir, ".multiclaw", CONSOLE_DIR, EXPORT_DIR, `turn-${turn}.md`);
 }
 async function exportTurn(turn, filePath) {
-  await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.promises.writeFile(filePath, formatTurnMarkdown(turn), "utf-8");
+  await fs2.promises.mkdir(path2.dirname(filePath), { recursive: true });
+  await fs2.promises.writeFile(filePath, formatTurnMarkdown(turn), "utf-8");
 }
 function formatTurnMarkdown(turn) {
   const lines = [`# Turn ${turn.turn}`, ""];
@@ -1319,7 +1599,22 @@ function formatTurnMarkdown(turn) {
   if (turn.reply) {
     lines.push("## Reply", "", `_${turn.reply.mode}_`, "", turn.reply.message, "");
   } else {
-    lines.push("## Result", "", `Status: ${turn.success ? "success" : "failed"}`, "");
+    const acceptance = turn.acceptance;
+    const status = turn.interrupted ? "interrupted" : acceptance ? acceptance.status === "failed" ? "acceptance failed" : acceptance.status === "cancelled" ? "acceptance cancelled" : acceptance.status.replace("_", " ") : turn.cancelled ? "cancelled" : turn.success ? "success" : "failed";
+    lines.push("## Result", "", `Status: ${status}`, "");
+    if (acceptance) {
+      lines.push(
+        `Reviewer: ${acceptance.reviewer}`,
+        `Repair rounds: ${acceptance.repairRounds}`,
+        ""
+      );
+      if (acceptance.reason) lines.push(acceptance.reason, "");
+      for (const review of acceptance.reviews) {
+        lines.push(`### Review: ${review.verdict.replace("_", " ")}`, "", review.summary, "");
+        for (const issue of review.issues) lines.push(`- ${issue}`);
+        lines.push("");
+      }
+    }
   }
   const agents = Object.values(turn.agents);
   if (agents.length > 0) {
@@ -1337,11 +1632,147 @@ function formatTurnMarkdown(turn) {
 `;
 }
 
+// src/tui/session.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var SESSION_FILE = "session.json";
+var SESSION_VERSION = 1;
+var MAX_JOURNAL_LOG_CHARS = 1200;
+function sessionPath(workDir) {
+  return path3.join(workDir, ".multiclaw", CONSOLE_DIR, SESSION_FILE);
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null;
+}
+var STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "running",
+  "retrying",
+  "success",
+  "failed",
+  "cancelled",
+  "skipped"
+]);
+function isAgentView(value) {
+  if (!isObject2(value)) return false;
+  return typeof value.id === "string" && typeof value.name === "string" && typeof value.logs === "string" && 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));
+}
+function loadJournal(workDir) {
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(sessionPath(workDir), "utf-8"));
+    if (!isObject2(parsed) || parsed.version !== SESSION_VERSION) return void 0;
+    const queue = Array.isArray(parsed.queue) ? parsed.queue.filter((item) => typeof item === "string" && item !== "") : [];
+    return {
+      version: SESSION_VERSION,
+      ...Number.isInteger(parsed.taskStart) && parsed.taskStart >= 0 ? { taskStart: parsed.taskStart } : {},
+      ...queue.length > 0 ? { queue } : {},
+      ...isJournalTurn(parsed.inFlight) ? { inFlight: parsed.inFlight } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function isEmpty(journal) {
+  return journal.inFlight === void 0 && journal.queue === void 0 && !journal.taskStart;
+}
+function saveJournal(workDir, journal) {
+  const target = sessionPath(workDir);
+  if (isEmpty(journal) && !fs3.existsSync(target)) return Promise.resolve();
+  return writeJsonFile(target, JSON.stringify(journal));
+}
+function tail(text, max) {
+  return text.length > max ? `\u2026${text.slice(text.length - max)}` : text;
+}
+function journalTurn(state, pending) {
+  const agents = {};
+  for (const [id, agent] of Object.entries(state.agents)) {
+    agents[id] = { ...agent, logs: tail(agent.logs, MAX_JOURNAL_LOG_CHARS) };
+  }
+  return {
+    turn: state.turn,
+    requirement: state.requirement ?? "",
+    startedAt: state.startedAt,
+    effectiveRequirement: state.effectiveRequirement,
+    reason: state.reason,
+    warning: state.warning,
+    savedAt: Date.now(),
+    leaderIds: state.leaderIds,
+    focusId: state.focusId,
+    stages: state.stages,
+    agents,
+    pending
+  };
+}
+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 };
+  }
+  return {
+    turn: entry.turn,
+    requirement: entry.requirement,
+    effectiveRequirement: entry.effectiveRequirement,
+    reason: entry.reason,
+    warning: entry.warning,
+    phase: "complete",
+    interrupted: true,
+    success: false,
+    startedAt: entry.startedAt,
+    endedAt: entry.savedAt,
+    stages: entry.stages.map((stage) => ({ stageIndex: stage.stageIndex, agents: stage.agents })),
+    agents,
+    leaderIds: entry.leaderIds,
+    focusId: entry.focusId,
+    autoFollow: false,
+    scroll: 0
+  };
+}
+function plural(count, word) {
+  return count === 1 ? word : `${word}s`;
+}
+function restoreConsole(workDir) {
+  const history = loadHistory(workDir);
+  const journal = loadJournal(workDir);
+  const inFlight = journal?.inFlight;
+  const last = history[history.length - 1];
+  const parts = [];
+  if (inFlight && (!last || inFlight.turn > last.turn)) {
+    history.push(interruptedTurn(inFlight));
+    parts.push(`turn ${inFlight.turn} was interrupted by a restart`);
+    const pending = (inFlight.pending?.permissions ?? 0) + (inFlight.pending?.questions ?? 0);
+    if (pending > 0) {
+      parts.push(`${pending} pending ${plural(pending, "decision")} discarded`);
+    }
+  }
+  const queue = journal?.queue ?? [];
+  if (queue.length > 0) {
+    parts.push(
+      `${queue.length} queued ${plural(queue.length, "follow-up")} restored \u2014 /continue resumes ${queue.length === 1 ? "it" : "them"}`
+    );
+  }
+  const restored = history.slice(-MAX_HISTORY);
+  return {
+    history: restored,
+    queue,
+    taskStart: journal?.taskStart ?? 0,
+    // Read from the *final* last turn: a recovered interrupted turn has no
+    // reply, so it correctly clears the "waiting for an answer" state.
+    awaitingAnswer: restored[restored.length - 1]?.reply?.mode === "ask",
+    ...parts.length > 0 ? { notice: parts.join(" \xB7 ") } : {}
+  };
+}
+
 // src/tui/App.tsx
 import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var FLUSH_INTERVAL_MS = 80;
 var SPINNER_INTERVAL_MS = 110;
 var BLINK_INTERVAL_MS = 530;
+var 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 };
@@ -1372,7 +1803,8 @@ function StatusLine({
     return /* @__PURE__ */ jsx5(Text5, { color: COLOR.error, wrap: "truncate-end", children: error });
   if (state.warning && state.phase !== "complete")
     return /* @__PURE__ */ jsx5(Text5, { color: COLOR.warn, wrap: "truncate-end", children: state.warning });
-  if (cancelled && !running) return /* @__PURE__ */ jsx5(Text5, { color: COLOR.warn, children: "cancelled" });
+  if ((cancelled || state.cancelled) && !running)
+    return /* @__PURE__ */ jsx5(Text5, { color: COLOR.warn, children: "cancelled \xB7 workspace changes are retained" });
   if (state.reply) {
     const asking = state.reply.mode === "ask";
     return /* @__PURE__ */ jsx5(Text5, { color: asking ? COLOR.warn : COLOR.ok, wrap: "truncate-end", children: asking ? `${GLYPH.ask} needs your input` : `${STATUS.success.glyph} answered` });
@@ -1394,7 +1826,7 @@ function StatusLine({
   }
   if (state.phase === "complete") {
     const time = state.totalDuration === void 0 ? "" : ` ${formatDuration(state.totalDuration)}`;
-    const outcome2 = state.success ? `${STATUS.success.glyph} done${time}` : `${STATUS.failed.glyph} finished with failures${time}`;
+    const outcome2 = state.acceptance ? `${state.success ? STATUS.success.glyph : STATUS.failed.glyph} ${state.acceptance.status === "approved" ? "delivery approved" : state.acceptance.status === "changes_required" ? "changes required" : "acceptance failed"}${time}` : state.success ? `${STATUS.success.glyph} done${time}` : `${STATUS.failed.glyph} finished with failures${time}`;
     const cost = state.totalCostUsd === void 0 ? "" : ` \xB7 ${formatCost(state.totalCostUsd)}`;
     return /* @__PURE__ */ jsxs5(Text5, { color: state.success ? COLOR.ok : COLOR.error, wrap: "truncate-end", children: [
       outcome2,
@@ -1410,13 +1842,16 @@ function StatusLine({
     stages > 0 ? ` \xB7 ${stages} stages` : ""
   ] });
 }
-function App({ config, onTurnStart }) {
+function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }) {
   const { exit } = useApp();
   const { columns, rows } = useWindowSize();
+  const restoredRef = useRef(null);
+  if (!restoredRef.current) restoredRef.current = restoreConsole(config.workDir);
+  const restored = restoredRef.current;
   const [state, dispatch] = useReducer(
     tuiReducer,
     config,
-    (c) => createInitialState(c, loadHistory(c.workDir))
+    (c) => createInitialState(c, restored.history)
   );
   const stateRef = useRef(state);
   stateRef.current = state;
@@ -1424,10 +1859,12 @@ function App({ config, onTurnStart }) {
   const [caretOn, setCaretOn] = useState(true);
   const [tick, setTick] = useState(0);
   const [running, setRunning] = useState(false);
-  const [queue, setQueue] = useState([]);
+  const [queue, setQueue] = useState(restored.queue);
+  const queueRef = useRef(queue);
+  queueRef.current = queue;
   const [cancelled, setCancelled] = useState(false);
   const [error, setError] = useState();
-  const [notice, setNotice] = useState();
+  const [notice, setNotice] = useState(restored.notice);
   const [helpOpen, setHelpOpen] = useState(false);
   const [historyOpen, setHistoryOpen] = useState(false);
   const [historyCursor, setHistoryCursor] = useState(0);
@@ -1436,7 +1873,73 @@ function App({ config, onTurnStart }) {
     index: 0
   });
   const abortRef = useRef(null);
+  const sessionsRef = useRef(null);
+  if (!sessionsRef.current) sessionsRef.current = providedSessions ?? new AgentSessionManager();
+  const activeTurnRef = useRef(null);
+  const reporterErrorRef = useRef(null);
+  const closingRef = useRef(false);
+  const shutdownRef = useRef(null);
+  const busyRef = useRef(false);
+  const taskStartRef = useRef(restored.taskStart);
+  const turnSerialRef = useRef(0);
+  const [awaitingAnswer, setAwaitingAnswer] = useState(restored.awaitingAnswer);
+  const [queuePaused, setQueuePaused] = useState(restored.queue.length > 0);
+  const awaitingAnswerRef = useRef(restored.awaitingAnswer);
+  const queuePausedRef = useRef(restored.queue.length > 0);
   const pending = useRef([]);
+  const permissionSerialRef = useRef(0);
+  const questionSerialRef = useRef(0);
+  const mountedRef = useRef(true);
+  const interactionsRef = useRef([]);
+  const [interactions, setInteractions] = useState([]);
+  const [questionScroll, setQuestionScroll] = useState({ id: "", offset: 0 });
+  const requestPermission = useCallback((request, signal) => {
+    if (closingRef.current || signal.aborted) return Promise.resolve(void 0);
+    const shortId = `p${++permissionSerialRef.current}`;
+    return new Promise((resolve2) => {
+      const entry = {
+        kind: "permission",
+        request,
+        shortId,
+        settle: (optionId) => {
+          if (!interactionsRef.current.includes(entry)) return;
+          signal.removeEventListener("abort", onAbort);
+          interactionsRef.current = interactionsRef.current.filter((item) => item !== entry);
+          if (mountedRef.current) setInteractions([...interactionsRef.current]);
+          resolve2(optionId);
+        }
+      };
+      const onAbort = () => entry.settle();
+      interactionsRef.current.push(entry);
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (mountedRef.current) setInteractions([...interactionsRef.current]);
+    });
+  }, []);
+  const requestQuestion = useCallback((request, signal) => {
+    if (closingRef.current || signal.aborted) return Promise.resolve({ action: "cancel" });
+    const shortId = `q${++questionSerialRef.current}`;
+    return new Promise((resolve2) => {
+      const entry = {
+        kind: "question",
+        request,
+        shortId,
+        settle: (response = { action: "cancel" }) => {
+          if (!interactionsRef.current.includes(entry)) return;
+          signal.removeEventListener("abort", onAbort);
+          interactionsRef.current = interactionsRef.current.filter((item) => item !== entry);
+          if (mountedRef.current) setInteractions([...interactionsRef.current]);
+          resolve2(response);
+        }
+      };
+      const onAbort = () => entry.settle();
+      interactionsRef.current.push(entry);
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (mountedRef.current) setInteractions([...interactionsRef.current]);
+    });
+  }, []);
+  const clearInteractions = useCallback(() => {
+    for (const entry of [...interactionsRef.current]) entry.settle();
+  }, []);
   const flush = useCallback(() => {
     const batch = pending.current;
     if (batch.length === 0) return;
@@ -1467,12 +1970,75 @@ function App({ config, onTurnStart }) {
       (err) => setNotice(`history not saved: ${err.message}`)
     );
   }, [state.history, state.phase]);
+  const persistSession = useCallback(() => {
+    if (closingRef.current) return;
+    const current = stateRef.current;
+    const waiting = { permissions: 0, questions: 0 };
+    for (const entry of interactionsRef.current) {
+      if (entry.kind === "permission") waiting.permissions += 1;
+      else waiting.questions += 1;
+    }
+    const journal = {
+      version: SESSION_VERSION,
+      taskStart: taskStartRef.current,
+      ...queueRef.current.length > 0 ? { queue: [...queueRef.current] } : {},
+      // Only a turn that is actually running is in flight. Writing one for an
+      // idle console would invent work the next session would then "recover".
+      ...current.phase === "running" && current.requirement !== void 0 ? { inFlight: journalTurn(current, waiting) } : {}
+    };
+    void saveJournal(config.workDir, journal).catch((err) => {
+      if (mountedRef.current) setNotice(`session not saved: ${err.message}`);
+    });
+  }, [config.workDir]);
+  const journalSettled = useRef(false);
+  useEffect(() => {
+    if (!journalSettled.current) {
+      journalSettled.current = true;
+      return;
+    }
+    persistSession();
+  }, [state.history, state.phase, queue, persistSession]);
+  useEffect(() => {
+    if (!running) return;
+    const timer = setInterval(persistSession, SESSION_SAVE_INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, [running, persistSession]);
   const startTurn = useCallback(
     async (requirement, opts) => {
+      if (closingRef.current || busyRef.current) return;
+      busyRef.current = true;
+      setRunning(true);
+      if (opts?.newTask) {
+        try {
+          await sessionsRef.current?.reset();
+          if (closingRef.current) {
+            busyRef.current = false;
+            setRunning(false);
+            return;
+          }
+          taskStartRef.current = stateRef.current.turn;
+        } catch (err) {
+          busyRef.current = false;
+          setRunning(false);
+          setError(`session reset failed: ${err.message}`);
+          return;
+        }
+      }
+      if (closingRef.current) {
+        busyRef.current = false;
+        setRunning(false);
+        return;
+      }
+      awaitingAnswerRef.current = false;
+      setAwaitingAnswer(false);
       setError(void 0);
       setCancelled(false);
       setNotice(void 0);
-      const earlierTurns = conversationTurns(stateRef.current);
+      const earlierTurns = conversationTurns({
+        ...stateRef.current,
+        history: stateRef.current.history.filter((turn) => turn.turn > taskStartRef.current),
+        ...stateRef.current.turn <= taskStartRef.current ? { phase: "idle" } : {}
+      });
       dispatch({
         type: "turn:start",
         requirement,
@@ -1480,8 +2046,8 @@ function App({ config, onTurnStart }) {
         leaderIds: leaderAgentIds(config),
         startedAt: Date.now()
       });
-      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const logDir = path2.join(config.workDir, ".multiclaw", "runs", `run-${stamp}`, "logs");
+      const stamp = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${++turnSerialRef.current}`;
+      const logDir = path4.join(config.workDir, ".multiclaw", "runs", `run-${stamp}`, "logs");
       const runConfig = {
         ...config,
         context: { ...config.context, requirement },
@@ -1489,39 +2055,118 @@ function App({ config, onTurnStart }) {
         // so the leader is handed the turns behind this one as well.
         history: earlierTurns,
         logDir,
+        permissions: !config.permissions || config.permissions.mode === "ask" ? { mode: "ask", onRequest: requestPermission } : config.permissions,
+        questions: config.questions?.onRequest ? config.questions : { onRequest: requestQuestion },
         // Only a retry carries this; a normal turn lets the leader route.
         ...opts?.resume ? { resume: opts.resume } : {}
       };
       const controller = new AbortController();
       abortRef.current = controller;
       setRunning(true);
-      const orchestrator = new Orchestrator(runConfig);
-      const unsubscribe = orchestrator.eventBus.subscribe((event) => {
-        pending.current.push(event);
-      });
-      onTurnStart?.(orchestrator.eventBus, logDir);
+      let unsubscribe;
+      let disposeReporter;
       const timer = setInterval(flush, FLUSH_INTERVAL_MS);
+      let finishTurn;
+      activeTurnRef.current = new Promise((resolve2) => {
+        finishTurn = resolve2;
+      });
       try {
-        await orchestrator.run({ signal: controller.signal });
+        const orchestrator = new Orchestrator(runConfig, sessionsRef.current ?? void 0);
+        unsubscribe = orchestrator.eventBus.subscribe((event) => {
+          pending.current.push(event);
+        });
+        const reporter = onTurnStart?.(orchestrator.eventBus, logDir);
+        if (reporter) disposeReporter = reporter;
+        const result = await orchestrator.run({ signal: controller.signal });
+        const asks = result.reply?.mode === "ask";
+        awaitingAnswerRef.current = asks;
+        setAwaitingAnswer(asks);
+        if (asks || !result.success || result.cancelled) {
+          queuePausedRef.current = true;
+          setQueuePaused(true);
+        }
+        if (result.cancelled) setCancelled(true);
       } catch (err) {
+        queuePausedRef.current = true;
+        setQueuePaused(true);
         if (isAbortError(err)) setCancelled(true);
         else setError(err.message);
       } finally {
+        clearInteractions();
         clearInterval(timer);
         flush();
-        unsubscribe();
+        unsubscribe?.();
+        try {
+          await disposeReporter?.();
+        } catch (err) {
+          queuePausedRef.current = true;
+          setQueuePaused(true);
+          reporterErrorRef.current = err instanceof Error ? err : new Error(String(err));
+          setError(`log cleanup failed: ${reporterErrorRef.current.message}`);
+        }
         abortRef.current = null;
+        busyRef.current = false;
         setRunning(false);
+        finishTurn();
+        activeTurnRef.current = null;
       }
     },
-    [config, flush, onTurnStart]
+    [config, flush, onTurnStart, requestPermission, requestQuestion, clearInteractions]
   );
   useEffect(() => {
-    if (running || queue.length === 0) return;
+    if (running || busyRef.current || closingRef.current || queuePaused || awaitingAnswer || queue.length === 0)
+      return;
     const [next, ...rest] = queue;
     setQueue(rest);
     void startTurn(next);
-  }, [running, queue, startTurn]);
+  }, [running, queue, queuePaused, awaitingAnswer, startTurn]);
+  const cleanup = useCallback(async () => {
+    closingRef.current = true;
+    abortRef.current?.abort();
+    clearInteractions();
+    await activeTurnRef.current;
+    await sessionsRef.current?.close();
+    await Promise.all([
+      pendingWrite(historyPath(config.workDir)),
+      pendingWrite(sessionPath(config.workDir))
+    ]);
+    if (reporterErrorRef.current) throw reporterErrorRef.current;
+  }, [clearInteractions, config.workDir]);
+  useEffect(() => {
+    mountedRef.current = true;
+    onCleanupReady?.(cleanup);
+    return () => {
+      mountedRef.current = false;
+      void cleanup().catch(() => {
+      });
+    };
+  }, [cleanup, onCleanupReady]);
+  const shutdown = useCallback(() => {
+    if (shutdownRef.current) return shutdownRef.current;
+    closingRef.current = true;
+    const leftover = [...queueRef.current];
+    queuePausedRef.current = true;
+    setQueuePaused(true);
+    setQueue([]);
+    setNotice("closing sessions\u2026");
+    abortRef.current?.abort();
+    shutdownRef.current = (async () => {
+      try {
+        await cleanup();
+        const turns = recordedTurns(stateRef.current).slice(-MAX_HISTORY);
+        if (turns.length) await saveHistory(config.workDir, turns);
+        await saveJournal(config.workDir, {
+          version: SESSION_VERSION,
+          taskStart: taskStartRef.current,
+          ...leftover.length > 0 ? { queue: leftover } : {}
+        });
+        exit();
+      } catch (err) {
+        setError(`shutdown failed: ${err.message}`);
+      }
+    })();
+    return shutdownRef.current;
+  }, [config.workDir, exit, cleanup]);
   const query = menuQuery(line.text);
   const matches = useMemo(
     () => query === void 0 ? [] : matchCommands(query, running),
@@ -1553,20 +2198,168 @@ function App({ config, onTurnStart }) {
     overlay: helpOpen || historyOpen,
     menuRows: paletteOpen ? paletteTotal : 0,
     queueRows: queue.length,
-    notice: notice !== void 0,
+    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)
   });
+  const steerRunningAgents = useCallback(async (text) => {
+    const manager = sessionsRef.current;
+    if (!manager) {
+      setNotice("no live sessions to steer");
+      return;
+    }
+    setNotice("steering\u2026");
+    let reports;
+    try {
+      reports = await manager.supplement(text);
+    } catch (error2) {
+      if (mountedRef.current) setNotice(`steering failed: ${error2.message}`);
+      return;
+    }
+    if (!mountedRef.current || closingRef.current) return;
+    const injected = reports.filter((report) => report.status === "injected");
+    if (injected.length === 0) setQueue((current) => [...current, text]);
+    for (const report of injected) {
+      dispatch({ type: "stream:note", agentId: report.agentId, text: `[steer] ${text}` });
+    }
+    setNotice(describeSteering(reports));
+  }, []);
   const runCommand = useCallback(
-    (name, args) => {
+    (name, args, rawText) => {
       setLine(EMPTY_LINE);
       if (!canRun(name, running)) {
         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 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 (!validateRuntimeQuestionContent(entry.request.requestedSchema, content)) {
+            setNotice(
+              "response does not match the question schema; check required fields and choices"
+            );
+            return;
+          }
+          entry.settle({
+            action: "accept",
+            content
+          });
+          setNotice(`responded to ${entry.shortId}`);
+          return;
+        }
+        case "approve":
+        case "deny": {
+          const [id, number] = args;
+          if (!id || (name === "approve" ? args.length !== 2 : args.length !== 1)) {
+            setNotice(
+              name === "approve" ? "usage: /approve <request id> <option number>" : "usage: /deny <request id>"
+            );
+            return;
+          }
+          const matches2 = interactionsRef.current.filter(
+            (entry2) => entry2.request.requestId === id || entry2.shortId === id
+          );
+          if (matches2.length !== 1) {
+            setNotice(`unknown or stale permission request: ${id}`);
+            return;
+          }
+          const entry = matches2[0];
+          if (entry.kind !== "permission") {
+            setNotice(`not a permission request: ${id}`);
+            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;
+          }
+          entry.settle(option.optionId);
+          setNotice(`selected ${option.name} for ${entry.shortId}`);
+          return;
+        }
+        case "task": {
+          const text = args.join(" ");
+          if (!text) {
+            setNotice("usage: /task <new requirement> \u2014 closes prior agent sessions");
+            return;
+          }
+          setQueue([]);
+          queuePausedRef.current = false;
+          setQueuePaused(false);
+          void startTurn(text, { newTask: 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) {
+            setNotice("usage: /steer <text> \u2014 delivered to the agents running now");
+            return;
+          }
+          void steerRunningAgents(text);
+          return;
+        }
+        case "pause":
+          queuePausedRef.current = true;
+          setQueuePaused(true);
+          setNotice("queue paused \u2014 the active turn continues");
+          return;
+        case "continue":
+          if (awaitingAnswerRef.current) {
+            setNotice("answer the leader first; queued input is not an answer");
+            return;
+          }
+          queuePausedRef.current = false;
+          setQueuePaused(false);
+          setNotice("queue resumed");
+          return;
         case "agents":
           setNotice(
             `team: ${plannedAgents(config).map((agent) => agent.id).join(", ")}`
@@ -1614,7 +2407,11 @@ function App({ config, onTurnStart }) {
             return;
           }
           let ids;
-          if (args[0]) {
+          if (state.acceptance && state.acceptance.status !== "approved" && (!args[0] || args[0] === state.acceptance.reviewer)) {
+            ids = [
+              ...new Set(state.stages.flatMap((stage) => stage.agents.map((agent) => agent.id)))
+            ].filter((id) => id !== state.acceptance?.reviewer);
+          } else if (args[0]) {
             const resolved = resolveAgentId(args[0], Object.keys(state.agents));
             if ("error" in resolved) {
               setNotice(resolved.error);
@@ -1631,7 +2428,12 @@ function App({ config, onTurnStart }) {
           const sessions = Object.fromEntries(
             ids.filter((id) => state.agents[id]?.sessionId).map((id) => [id, state.agents[id].sessionId])
           );
-          void startTurn(state.requirement, {
+          if (ids.some((id) => state.leaderIds.includes(id))) {
+            void startTurn(state.requirement);
+            setNotice("retrying leader routing");
+            return;
+          }
+          void startTurn(state.effectiveRequirement ?? state.requirement, {
             resume: {
               agents: ids,
               ...Object.keys(sessions).length > 0 ? { sessions } : {}
@@ -1672,7 +2474,7 @@ function App({ config, onTurnStart }) {
             setNotice(target.error);
             return;
           }
-          const file = args[1] ? path2.resolve(config.workDir, args[1]) : exportPath(config.workDir, target.record.turn);
+          const file = args[1] ? path4.resolve(config.workDir, args[1]) : exportPath(config.workDir, target.record.turn);
           void exportTurn(target.record, file).then(() => setNotice(`exported turn ${target.record.turn} to ${file}`)).catch((err) => setNotice(`export failed: ${err.message}`));
           return;
         }
@@ -1702,6 +2504,7 @@ function App({ config, onTurnStart }) {
           }
           const dropped = queue.length;
           abortRef.current.abort();
+          clearInteractions();
           setQueue([]);
           setCancelled(true);
           setNotice(dropped > 0 ? `cancelling\u2026 \xB7 dropped ${dropped} queued` : "cancelling\u2026");
@@ -1712,25 +2515,36 @@ function App({ config, onTurnStart }) {
           setHelpOpen(true);
           return;
         case "quit":
-          exit();
+          void shutdown();
           return;
         default:
           setNotice(`unknown command: /${name}`);
       }
     },
-    [config, exit, layout.logViewport, layout.streamWidth, queue.length, running, state, startTurn]
+    [
+      config,
+      shutdown,
+      clearInteractions,
+      layout.logViewport,
+      layout.streamWidth,
+      queue.length,
+      running,
+      state,
+      startTurn,
+      steerRunningAgents
+    ]
   );
   const submit = useCallback(() => {
     const text = line.text.trim();
-    if (!text) return;
+    if (!text || closingRef.current) return;
     const command = parseCommand(text);
     if (command) {
-      runCommand(command.name, command.args);
+      runCommand(command.name, command.args, text);
       return;
     }
     setLine(EMPTY_LINE);
     setNotice(void 0);
-    if (running) {
+    if (running || busyRef.current) {
       setQueue((pending2) => [...pending2, text]);
       return;
     }
@@ -1771,13 +2585,14 @@ function App({ config, onTurnStart }) {
         setHistoryOpen(false);
       } else if (abortRef.current) {
         abortRef.current.abort();
+        clearInteractions();
         setNotice(queue.length > 0 ? `cancelling\u2026 \xB7 dropped ${queue.length} queued` : "cancelling\u2026");
         setQueue([]);
         setCancelled(true);
       } else if (line.text) {
         setLine(EMPTY_LINE);
       } else {
-        exit();
+        void shutdown();
       }
       return;
     }
@@ -1807,7 +2622,7 @@ function App({ config, onTurnStart }) {
       return;
     }
     if (key.ctrl && char === "d") {
-      if (!line.text) exit();
+      if (!line.text) void shutdown();
       return;
     }
     if (key.ctrl && char === "l") {
@@ -1846,6 +2661,20 @@ function App({ config, onTurnStart }) {
         return;
       }
     }
+    if (interactions[0]?.kind === "question" && (key.upArrow || key.downArrow || key.pageUp || key.pageDown)) {
+      const entry = interactions[0];
+      const capacity = Math.max(1, layout.bodyHeight - 4);
+      const maxOffset = Math.max(0, questionLines(entry.request, layout.columns).length - capacity);
+      const delta = key.pageDown ? capacity : key.pageUp ? -capacity : key.downArrow ? 1 : -1;
+      setQuestionScroll((scroll) => ({
+        id: entry.shortId,
+        offset: Math.min(
+          maxOffset,
+          Math.max(0, (scroll.id === entry.shortId ? scroll.offset : 0) + delta)
+        )
+      }));
+      return;
+    }
     if (key.upArrow) {
       dispatch({
         type: "stream:scroll",
@@ -1932,7 +2761,7 @@ function App({ config, onTurnStart }) {
   const handlerRef = useRef(handleKey);
   handlerRef.current = handleKey;
   useInput((char, key) => handlerRef.current(char, key));
-  const keys = helpOpen ? "esc close" : historyOpen ? "\u2191\u2193 select \xB7 enter open \xB7 esc close" : argOpen ? `\u2191\u2193 select \xB7 enter ${arg?.command.name} \xB7 esc close` : menuOpen ? "\u2191\u2193 select \xB7 enter run \xB7 esc close" : running ? "enter queues \xB7 ctrl+c cancel" : state.view ? "esc live \xB7 tab agent \xB7 ? help" : state.reply ? "enter sends \xB7 / commands \xB7 ? help" : "tab switch \xB7 / commands \xB7 ? help";
+  const keys = helpOpen ? "esc close" : historyOpen ? "\u2191\u2193 select \xB7 enter open \xB7 esc close" : argOpen ? `\u2191\u2193 select \xB7 enter ${arg?.command.name} \xB7 esc close` : menuOpen ? "\u2191\u2193 select \xB7 enter run \xB7 esc close" : running ? interactions.length > 0 ? interactions[0].kind === "question" ? "/respond <id> <JSON> \xB7 /skip <id> \xB7 /dismiss <id>" : "/approve <id> <number> \xB7 /deny <id> \xB7 ctrl+c cancel" : "enter queues \xB7 ctrl+c cancel" : state.view ? "esc live \xB7 tab agent \xB7 ? help" : state.reply ? "enter sends \xB7 / commands \xB7 ? help" : "tab switch \xB7 / commands \xB7 ? help";
   return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", height: layout.rows, children: [
     /* @__PURE__ */ jsx5(
       Header,
@@ -1966,6 +2795,25 @@ function App({ config, onTurnStart }) {
             width: layout.columns,
             maxRows: layout.bodyHeight
           }
+        ) : interactions[0]?.kind === "question" ? /* @__PURE__ */ jsx5(
+          QuestionOverlay,
+          {
+            request: interactions[0].request,
+            shortId: interactions[0].shortId,
+            queued: interactions.length,
+            width: layout.columns,
+            maxRows: layout.bodyHeight,
+            offset: questionScroll.id === interactions[0].shortId ? questionScroll.offset : 0
+          }
+        ) : interactions[0]?.kind === "permission" ? /* @__PURE__ */ jsx5(
+          PermissionOverlay,
+          {
+            request: interactions[0].request,
+            shortId: interactions[0].shortId,
+            queued: interactions.length,
+            width: layout.columns,
+            maxRows: layout.bodyHeight
+          }
         ) : layout.welcome ? /* @__PURE__ */ jsx5(WelcomePanel, { turn: state, width: layout.columns }) : error ? (
           // The error wins over a reply: a run that stopped with an error is the
           // most urgent thing on screen, and a stale answer underneath it would
@@ -1990,9 +2838,9 @@ function App({ config, onTurnStart }) {
       }
     ),
     state.view ? /* @__PURE__ */ jsx5(Text5, { color: COLOR.warn, wrap: "truncate-end", children: `  viewing turn ${shown.turn} \xB7 ${shown.requirement ?? "(no requirement)"} \xB7 esc to return` }) : null,
-    notice ? /* @__PURE__ */ jsxs5(Text5, { dimColor: true, wrap: "truncate-end", children: [
+    notice || queuePaused && queue.length > 0 ? /* @__PURE__ */ jsxs5(Text5, { dimColor: true, wrap: "truncate-end", children: [
       "  ",
-      notice
+      notice ?? (awaitingAnswer ? "queue paused \u2014 answer the leader first" : "queue paused \u2014 /continue resumes it")
     ] }) : null,
     /* @__PURE__ */ jsx5(QueueStrip, { items: queue, max: layout.queueRows }),
     paletteOpen ? /* @__PURE__ */ jsx5(CommandMenu, { rows: paletteWindow, selected: paletteSelected }) : null,
@@ -2002,7 +2850,7 @@ function App({ config, onTurnStart }) {
         value: line.text,
         cursor: line.cursor,
         caretVisible: caretOn,
-        placeholder: running ? RUNNING_PLACEHOLDER : INPUT_PLACEHOLDER
+        placeholder: running ? RUNNING_PLACEHOLDER : awaitingAnswer ? "answer the leader\u2026 \xB7 /task starts a new task" : INPUT_PLACEHOLDER
       }
     ),
     /* @__PURE__ */ jsx5(
@@ -2036,12 +2884,24 @@ async function startTui(options) {
   const restore = () => process.stdout.write("\x1B[?25h\x1B[?1049l");
   process.stdout.write("\x1B[?1049h\x1B[?25l");
   process.on("exit", restore);
+  const sessions = new AgentSessionManager2();
+  let cleanup;
+  const onCleanupReady = (callback) => {
+    cleanup = callback;
+  };
   try {
-    const app = render(createElement(App, options), { exitOnCtrlC: false });
+    const app = render(createElement(App, { ...options, sessions, onCleanupReady }), {
+      exitOnCtrlC: false
+    });
     await app.waitUntilExit();
   } finally {
-    process.off("exit", restore);
-    restore();
+    try {
+      if (cleanup) await cleanup();
+      else await sessions.close();
+    } finally {
+      process.off("exit", restore);
+      restore();
+    }
   }
 }
 export {