@ordewell/cli 0.5.4 → 0.5.5

package/dist/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/main.ts
-var import_core23 = require("@ordewell/core");
+var import_core30 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -825,6 +825,11 @@ var ApiClient = class _ApiClient {
    */
   streamPlanning(sessionId, onEvent) {
     const socket = this.openSessionSocket(sessionId);
+    const ready = new Promise((resolve3) => {
+      socket.once("open", () => resolve3());
+      socket.once("error", () => resolve3());
+      socket.once("close", () => resolve3());
+    });
     socket.on("message", (data) => {
       try {
         onEvent(JSON.parse(data.toString()));
@@ -833,7 +838,7 @@ var ApiClient = class _ApiClient {
     });
     socket.on("error", () => {
     });
-    return { close: () => socket.close() };
+    return { ready, close: () => socket.close() };
   }
   async getCommands() {
     const res = await this.httpRequest("GET", "/api/commands");
@@ -1043,7 +1048,7 @@ ${describeApproval(event)}
 }
 
 // src/commands/researchLog.ts
-var import_plan_utils = require("@ordewell/core/plan-utils");
+var import_core6 = require("@ordewell/core");
 var OUTCOME_MARK = {
   success: "\u2713",
   failure: "\u2717",
@@ -1054,37 +1059,58 @@ var OUTCOME_MARK = {
 var RESULT_CHARS = 160;
 var VERBOSE_RESULT_CHARS = 600;
 var THINKING_CHARS = 300;
+function summarize(tool, args, toolLabel) {
+  const { name, keyArg } = (0, import_core6.toolHeadline)(tool, args, toolLabel);
+  return `${name}(${keyArg})`;
+}
 function oneLine(text, max) {
   const collapsed = text.replace(/\s+/g, " ").trim();
   return collapsed.length > max ? `${collapsed.slice(0, max)}\u2026` : collapsed;
 }
 function formatStepLine(event, options = {}) {
   if (event.type === "research_step") {
-    const summary = (0, import_plan_utils.summarizeToolCall)(String(event.tool), String(event.args || "{}"), event.toolLabel);
+    const summary = summarize(event.tool, event.args || "{}", event.toolLabel);
     return event.subagentId ? `  \u21B3 ${summary}` : summary;
   }
   if (event.type === "research_step_done") {
     const step2 = event.step;
     if (!step2) return null;
     const mark = OUTCOME_MARK[step2.outcome] ?? "\u2713";
-    const summary = (0, import_plan_utils.summarizeToolCall)(step2.tool, step2.args, step2.toolLabel);
+    const summary = summarize(step2.tool, step2.args, step2.toolLabel);
     const result = oneLine(step2.result ?? "", options.verbose ? VERBOSE_RESULT_CHARS : RESULT_CHARS);
     const indent = event.subagentId ? "  \u21B3 " : "";
     return result ? `${indent}${mark} ${summary} \u2192 ${result}` : `${indent}${mark} ${summary}`;
   }
-  if (event.type === "plan_thinking") {
-    if (!options.verbose) return null;
-    const text = oneLine(String(event.text ?? ""), THINKING_CHARS);
-    return text ? `  \xB7 ${text}` : null;
-  }
   return null;
 }
 function isTransient(event) {
   return event.type === "research_step";
 }
+function createStepLog(options = {}) {
+  let held = null;
+  const flush = () => {
+    const text = held ? oneLine(held.text, THINKING_CHARS) : "";
+    held = null;
+    return text ? [{ text: `  \xB7 ${text}`, transient: false }] : [];
+  };
+  return {
+    push(event) {
+      if (event.type === "planner_thinking_delta") {
+        if (!options.verbose) return [];
+        const thinker = `${event.turnId}|${event.segmentId}|${event.subagentId}`;
+        const done = held && held.thinker !== thinker ? flush() : [];
+        held = { thinker, text: (held?.text ?? "") + event.text };
+        return done;
+      }
+      const line = formatStepLine(event, options);
+      return line === null ? [] : [...flush(), { text: line, transient: isTransient(event) }];
+    },
+    flush
+  };
+}
 
 // src/commands/plan.ts
-var import_core6 = require("@ordewell/core");
+var import_core7 = require("@ordewell/core");
 function planTasks(plan) {
   return plan ? allTasksOf(plan) : [];
 }
@@ -1160,11 +1186,11 @@ Plan: ${tasks.length} task${tasks.length === 1 ? "" : "s"} (${aiCount} AI, ${man
   for (const t of tasks) {
     const typeIcon = t.type === "user" ? "[MAN]" : "[ AI]";
     const deps = t.dependencies?.length ? ` \u2190 ${t.dependencies.join(", ")}` : "";
-    console.log(`  ${(0, import_core6.taskOrderLabel)(t).padStart(2)}. ${typeIcon} ${t.title}${modelSuffix(t)}${deps}`);
+    console.log(`  ${(0, import_core7.taskOrderLabel)(t).padStart(2)}. ${typeIcon} ${t.title}${modelSuffix(t)}${deps}`);
     for (const sub of t.subtasks || []) {
       const subTypeIcon = sub.type === "user" ? "[MAN]" : "[ AI]";
       const subDeps = sub.dependencies?.length ? ` \u2190 ${sub.dependencies.join(", ")}` : "";
-      console.log(`    ${(0, import_core6.taskOrderLabel)(sub, t)}. ${subTypeIcon} ${sub.title}${modelSuffix(sub)}${subDeps}`);
+      console.log(`    ${(0, import_core7.taskOrderLabel)(sub, t)}. ${subTypeIcon} ${sub.title}${modelSuffix(sub)}${subDeps}`);
     }
   }
   if (manCount > 0) {
@@ -1211,25 +1237,31 @@ async function handlePlan(subArgs, deps = {}) {
     runners2 = runnerFlags;
   }
   console.error(`Generating plan for: "${goal}"...`);
-  const sessionId = (0, import_core6.mintSessionId)();
+  const sessionId = (0, import_core7.mintSessionId)();
   const isTty = !!process.stderr.isTTY;
   let lastLineLength = 0;
-  function renderStep(event) {
-    const line = formatStepLine(event, { verbose });
-    if (line === null) return;
+  const stepLog = createStepLog({ verbose });
+  function renderLine({ text, transient }) {
     if (isTty) {
-      process.stderr.write(`\r\x1B[2K${line}`);
-      if (isTransient(event)) {
-        lastLineLength = line.length;
+      process.stderr.write(`\r\x1B[2K${text}`);
+      if (transient) {
+        lastLineLength = text.length;
       } else {
         process.stderr.write("\n");
         lastLineLength = 0;
       }
     } else {
-      process.stderr.write(`${line}
+      process.stderr.write(`${text}
 `);
     }
   }
+  function renderStep(event) {
+    stepLog.push(event).forEach(renderLine);
+  }
+  function closeStream() {
+    stream.close();
+    stepLog.flush().forEach(renderLine);
+  }
   let reader = deps.reader;
   const handleApproval = createApprovalHandler(sessionId, {
     respond: (sessionId2, approvalId, granted) => api.respondToApproval(sessionId2, approvalId, granted),
@@ -1246,6 +1278,7 @@ async function handlePlan(subArgs, deps = {}) {
     void handleApproval(event);
   });
   try {
+    await stream.ready;
     let plan;
     let models = [];
     if (oneShot) {
@@ -1261,6 +1294,7 @@ async function handlePlan(subArgs, deps = {}) {
         () => api.startConversation(sessionId, goal, runners2, workspace)
       );
       while (!hasCommittedPlan(plan)) {
+        stepLog.flush().forEach(renderLine);
         console.log(`
 ${lastPlannerMessage(plan)}
 `);
@@ -1286,7 +1320,7 @@ ${lastPlannerMessage(plan)}
       }
       reader?.close();
     }
-    stream.close();
+    closeStream();
     if (isTty && lastLineLength > 0) process.stderr.write("\r\x1B[2K");
     process.stderr.write("\n");
     printPlan(plan, sessionId, runners2, models);
@@ -1295,7 +1329,7 @@ ${lastPlannerMessage(plan)}
   Run 'ordewell run' to execute, 'ordewell status' to inspect, or 'ordewell tui' for the full UI.`);
   } catch (err) {
     reader?.close();
-    stream.close();
+    closeStream();
     if (isTty && lastLineLength > 0) process.stderr.write("\r\x1B[2K");
     process.stderr.write("\n");
     console.error(`Plan generation failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -1304,7 +1338,7 @@ ${lastPlannerMessage(plan)}
 }
 
 // src/isolation.ts
-var import_core7 = require("@ordewell/core");
+var import_core8 = require("@ordewell/core");
 var STATE_OF = {
   active: "active",
   merged: "integrated",
@@ -1388,7 +1422,7 @@ function repairedLanded(handoff) {
 function repairedNotice(handoff) {
   const repaired = repairedLanded(handoff);
   if (repaired.length === 0) return "";
-  const named = repaired.map((t) => `${t.title} (${(0, import_core7.capConflictFiles)(t.repairedFiles)})`);
+  const named = repaired.map((t) => `${t.title} (${(0, import_core8.capConflictFiles)(t.repairedFiles)})`);
   const list = named.length === 1 ? named[0] : `${named.slice(0, -1).join(", ")} and ${named[named.length - 1]}`;
   return ` ${list} landed through ${repaired.length === 1 ? "a conflict repair" : "conflict repairs"}.`;
 }
@@ -1406,7 +1440,7 @@ function mergeOutcome(result, branch, group, repaired = []) {
   if (!group && result.outcome === "conflict") {
     return { ok, message: `Merging ${branch} conflicted, so it was aborted \u2014 your tree is as it was. Merge it with git and resolve the conflict there.` };
   }
-  const { message } = (0, import_core7.describeMergeResult)(result, branch, group, repaired);
+  const { message } = (0, import_core8.describeMergeResult)(result, branch, group, repaired);
   return { ok, message: ok || !group ? message : `${message} Each repository's ${branch} is a plain branch you can merge by hand.` };
 }
 
@@ -1427,24 +1461,23 @@ function iconFor(status) {
 }
 
 // src/commands/run.ts
-var import_core8 = require("@ordewell/core");
+var import_core9 = require("@ordewell/core");
 
 // src/catalog.ts
 function normalizeCatalog(result) {
   const runnersByModel = /* @__PURE__ */ new Map();
   for (const [runner, entries] of Object.entries(result.modelsByRunner ?? {})) {
     for (const entry of entries ?? []) {
-      const id = String(entry.modelId ?? entry.id);
+      const id = String(entry.modelId);
       runnersByModel.set(id, [.../* @__PURE__ */ new Set([...runnersByModel.get(id) ?? [], runner])]);
     }
   }
   const models = (result.models ?? []).map((m) => {
-    const id = String(m.modelId ?? m.id);
+    const id = String(m.modelId);
     return {
       id,
-      label: String(m.modelLabel ?? m.label ?? id),
-      provider: String(m.runnerProviderLabel ?? m.runnerProvider ?? m.provider ?? ""),
-      pricing: m.pricing ? `$${m.pricing}/MTok` : void 0,
+      label: String(m.modelLabel ?? id),
+      provider: String(m.runnerProviderLabel ?? m.runnerProvider ?? ""),
       variants: Array.isArray(m.variants) ? m.variants.map((v) => ({ id: String(v.id), label: String(v.label ?? v.id) })) : [],
       runners: runnersByModel.get(id) ?? []
     };
@@ -1564,11 +1597,11 @@ async function followExecution(api, sessionId, start, onBlocked) {
   });
   const stream = api.streamExecution(sessionId, (event) => {
     if (event.type === "task_started") {
-      process.stderr.write(`[${event.order}/${event.title}] Started: ${event.runner} / ${event.modelId}
+      process.stderr.write(`\xB7 ${(0, import_core9.taskStartedNotice)(event.title, event.runner)}
 `);
     }
     if (event.type === "checkpoint") {
-      process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core8.truncateCheckpointSummary)(event.summary)}
+      process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core9.truncateCheckpointSummary)(event.summary)}
 `);
     }
     if (event.type === "status_update" && event.tasks) {
@@ -1637,7 +1670,7 @@ async function handleRun(subArgs, injectedApi) {
 
 // src/commands/status.ts
 var import_fs4 = require("fs");
-var import_core9 = require("@ordewell/core");
+var import_core10 = require("@ordewell/core");
 async function handleStatus(subArgs, injectedApi) {
   const sessionId = flag(subArgs, "--session-id");
   const workspace = flag(subArgs, "--workspace") || process.cwd();
@@ -1708,12 +1741,12 @@ function printOneSession(sessionId, meta, plan) {
     const icon = iconFor(t.status);
     const model = t.assignedModel ? ` (${t.assignedModel.modelLabel})` : "";
     const shortId = (t.id ?? "").slice(-8);
-    console.log(`  ${(0, import_core9.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
+    console.log(`  ${(0, import_core10.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
     for (const sub of t.subtasks || []) {
       const subIcon = iconFor(sub.status);
       const subModel = sub.assignedModel ? ` (${sub.assignedModel.modelLabel})` : "";
       const subShortId = (sub.id ?? "").slice(-8);
-      console.log(`    ${(0, import_core9.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
+      console.log(`    ${(0, import_core10.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
     }
   }
 }
@@ -1765,10 +1798,10 @@ async function handleWeb(subArgs) {
 }
 
 // src/commands/models.ts
-var import_core11 = require("@ordewell/core");
+var import_core12 = require("@ordewell/core");
 
 // src/commands/model.ts
-var import_core10 = require("@ordewell/core");
+var import_core11 = require("@ordewell/core");
 var USAGE = "Usage: ordewell model [show | set <model-id>]";
 async function handleModel(subArgs, injectedApi) {
   const [action, modelId] = positionals(subArgs);
@@ -1783,7 +1816,7 @@ async function handleModel(subArgs, injectedApi) {
   if (!modelId) fail(USAGE);
   const settings = await api.getSettings();
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
-  const runner = (0, import_core10.runnerForProvider)(provider);
+  const runner = (0, import_core11.runnerForProvider)(provider);
   if (runner) {
     const known = (await fetchCatalog(api)).models.filter((m) => m.runners?.includes(runner));
     if (known.length > 0 && !known.some((m) => m.id === modelId)) {
@@ -1802,7 +1835,7 @@ async function showModels(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   const current = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
-  const runner = (0, import_core10.runnerForProvider)(provider);
+  const runner = (0, import_core11.runnerForProvider)(provider);
   const options = runner ? catalog.models.filter((m) => m.runners?.includes(runner)) : catalog.orchestratorModels;
   console.log(`
 Planner model: ${current || "(backend default)"}`);
@@ -1836,8 +1869,8 @@ async function handleModels(subArgs) {
     const rest = subArgs.filter((_, i) => i !== setIdx && i !== setIdx + 1);
     return handleModel(["set", subArgs[setIdx + 1], ...rest]);
   }
-  const config = new import_core11.EnvConfig();
-  const providers = (0, import_core11.configuredProviders)(config);
+  const config = new import_core12.EnvConfig();
+  const providers = (0, import_core12.configuredProviders)(config);
   if (providers.length === 0) {
     console.error("No providers configured. Set an API key for a provider, e.g.:");
     console.error("  OPENROUTER_API_KEY=...   (OpenRouter)");
@@ -1846,19 +1879,19 @@ async function handleModels(subArgs) {
     console.error("  OPENAI_COMPATIBLE_BASE_URL=...  (self-hosted / OpenAI-compatible)");
     process.exit(1);
   }
-  const { apiKeys, baseUrls } = (0, import_core11.collectProviderCredentials)(config);
+  const { apiKeys, baseUrls } = (0, import_core12.collectProviderCredentials)(config);
   let models;
   let errors;
   try {
-    const result = await (0, import_core11.fetchAllProviderModels)({ apiKeys, baseUrls });
-    models = (0, import_core11.toOrchestratorOptions)(result.models, import_core11.ORCHESTRATOR_SHORTCUTS);
+    const result = await (0, import_core12.fetchAllProviderModels)({ apiKeys, baseUrls });
+    models = (0, import_core12.toOrchestratorOptions)(result.models, import_core12.ORCHESTRATOR_SHORTCUTS);
     errors = result.errors;
   } catch (err) {
     console.error(`Failed to fetch models: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
     return;
   }
-  const providerLabel = (p) => (0, import_core11.getProviderMeta)(p)?.label ?? p;
+  const providerLabel = (p) => (0, import_core12.getProviderMeta)(p)?.label ?? p;
   console.log(
     `
 Available models (${models.length}) across ${providers.length} configured provider(s):`
@@ -1975,9 +2008,9 @@ function handleSetup(subArgs) {
 }
 
 // src/commands/plugins.ts
-var import_core12 = require("@ordewell/core");
+var import_core13 = require("@ordewell/core");
 function handlePlugins(subArgs) {
-  const registry = new import_core12.RunnerRegistry();
+  const registry = new import_core13.RunnerRegistry();
   registry.loadUserPlugins();
   const sub = subArgs[0];
   if (sub === "list" || !sub) {
@@ -2013,7 +2046,7 @@ ${plugins.length} plugin(s):
       process.exit(1);
     }
     try {
-      const resolved = (0, import_core12.classifyPluginSource)(source);
+      const resolved = (0, import_core13.classifyPluginSource)(source);
       const manifest = resolved.kind === "git" ? registry.installFromGit(resolved.url) : registry.installFromPath(resolved.path);
       console.log(`Installed plugin: ${manifest.name} v${manifest.version}`);
     } catch (err) {
@@ -2115,7 +2148,7 @@ async function rejectStrayIds(runner, ids, api) {
   let discovered = [];
   try {
     const { modelsByRunner } = await api.getModels();
-    discovered = (modelsByRunner?.[runner] ?? []).map((m) => String(m.modelId ?? m.id));
+    discovered = (modelsByRunner?.[runner] ?? []).map((m) => String(m.modelId));
   } catch {
     return;
   }
@@ -2481,6 +2514,30 @@ async function handleRewind(subArgs, injectedApi) {
 // src/commands/handoff.ts
 var import_readline2 = require("readline");
 
+// src/tui/transcript.ts
+var import_core14 = require("@ordewell/core");
+function show(state, { view: conversation, gate: turnGate }) {
+  const gated = turnGate === state.turnGate ? state : { ...state, turnGate };
+  if (conversation === state.conversation) return gated;
+  const scroll = conversation.nextId > state.conversation.nextId ? 0 : state.scroll;
+  return { ...gated, conversation, scroll };
+}
+function fold(state, input) {
+  return show(state, { view: (0, import_core14.reduceConversation)(state.conversation, input), gate: state.turnGate });
+}
+function say(state, role, text) {
+  return fold(state, { type: "local_entry", role, text });
+}
+function hear(state, message) {
+  return show(state, (0, import_core14.followTurn)(state.conversation, state.turnGate, message));
+}
+function cutTurn(state) {
+  return show(state, (0, import_core14.stopTurn)(state.conversation, state.turnGate));
+}
+function wiped(view) {
+  return { ...view, blocks: view.blocks.filter((b) => b.type === "usage") };
+}
+
 // src/tui/ansi.ts
 var import_string_width = __toESM(require("string-width"));
 var ESCAPE = /\x1b(?:\][\s\S]*?(?:\x07|\x1b\\|$)|[P^_][\s\S]*?(?:\x1b\\|$)|\[[0-?]*[ -/]*[@-~]?|[ -/]*[0-~]?)/g;
@@ -2623,18 +2680,6 @@ var style = {
   grey: colour("90")
 };
 
-// src/tui/transcript.ts
-function say(state, role, content, research, extra) {
-  const message = {
-    role,
-    content: sanitize(content),
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    ...research ? { research } : {},
-    ...extra
-  };
-  return { ...state, messages: [...state.messages, message], scroll: 0 };
-}
-
 // src/tui/handoff.ts
 var HANDOFF_ACTIONS = [
   { id: "review", label: "Review diff", hint: "the branch against the commit it forked from" },
@@ -2882,7 +2927,7 @@ async function handleHandoff(subArgs, injectedApi, confirm = askYesNo) {
 }
 
 // src/commands/planner.ts
-var import_core13 = require("@ordewell/core");
+var import_core15 = require("@ordewell/core");
 
 // src/plannerModelSwitch.ts
 function describePlannerSwitch(settings, provider) {
@@ -2901,7 +2946,7 @@ function rememberedModelFor(settings, provider) {
 }
 
 // src/commands/planner.ts
-var KNOWN_PROVIDERS = Object.keys(import_core13.ALL_PROVIDERS);
+var KNOWN_PROVIDERS = Object.keys(import_core15.ALL_PROVIDERS);
 async function handlePlanner(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
   const [wanted] = positionals(subArgs);
@@ -2916,13 +2961,13 @@ async function handlePlanner(subArgs, injectedApi) {
   const settings = await persistEnv(api, { AI_PROVIDER: provider });
   const recall2 = describePlannerSwitch(settings, provider);
   writeEnv({ ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
-  const meta = import_core13.ALL_PROVIDERS[provider];
+  const meta = import_core15.ALL_PROVIDERS[provider];
   const catalog = await fetchCatalog(api);
   console.log(
-    (0, import_core13.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
+    (0, import_core15.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
   );
   console.log(plannerModelLine(recall2));
-  if (!(0, import_core13.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
+  if (!(0, import_core15.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
     console.log(`  No ${meta.apiKeyEnvVar} configured yet \u2014 set one with \`ordewell key set ${provider} <key>\`.`);
   }
 }
@@ -2940,15 +2985,15 @@ async function showPlanners(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
   const current = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   console.log("\nCoding agents (no API key \u2014 they use their own subscription)");
-  for (const id of import_core13.CLI_PROVIDERS) {
-    const runner = (0, import_core13.runnerForProvider)(id);
+  for (const id of import_core15.CLI_PROVIDERS) {
+    const runner = (0, import_core15.runnerForProvider)(id);
     const discovered = runner ? catalog.models.some((m) => m.runners?.includes(runner)) : false;
-    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core13.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
+    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core15.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
   }
   console.log("\nAPI providers");
-  for (const id of import_core13.PROVIDER_PRIORITY) {
+  for (const id of import_core15.PROVIDER_PRIORITY) {
     const configured = catalog.providers.includes(id);
-    const meta = import_core13.ALL_PROVIDERS[id];
+    const meta = import_core15.ALL_PROVIDERS[id];
     console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${meta.label}${configured ? "" : `  (no ${meta.apiKeyEnvVar})`}`);
   }
   console.log(`
@@ -2965,7 +3010,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   const modelId = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
   const currentEffort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
-  const runner = (0, import_core13.runnerForProvider)(provider);
+  const runner = (0, import_core15.runnerForProvider)(provider);
   if (!runner) {
     fail(
       "Thinking effort applies to a coding-agent planner.",
@@ -3005,7 +3050,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
 }
 
 // src/commands/parallel.ts
-var import_core14 = require("@ordewell/core");
+var import_core16 = require("@ordewell/core");
 var USAGE5 = "Usage: ordewell parallel [<number of tasks, 1 or more>]";
 async function handleParallel(subArgs, injectedApi) {
   const [wanted] = positionals(subArgs);
@@ -3015,14 +3060,14 @@ async function handleParallel(subArgs, injectedApi) {
     console.log(`Up to ${String(settings.maxParallel ?? "?")} AI tasks run at once. Change with: ordewell parallel <n>`);
     return;
   }
-  const limit = (0, import_core14.parseMaxParallel)(wanted);
+  const limit = (0, import_core16.parseMaxParallel)(wanted);
   if (limit === null) fail(`"${wanted}" is not a number of tasks (1 or more).`, USAGE5);
   await persistEnv(api, { ORDEWELL_MAX_PARALLEL: String(limit) });
   console.log(`Up to ${limit} AI task${limit === 1 ? "" : "s"} now run at once.`);
 }
 
 // src/commands/key.ts
-var import_core15 = require("@ordewell/core");
+var import_core17 = require("@ordewell/core");
 var USAGE6 = "Usage: ordewell key [list | set <provider> <key>]";
 async function handleKey(subArgs, injectedApi) {
   const [action, provider, ...keyParts] = positionals(subArgs);
@@ -3033,8 +3078,8 @@ async function handleKey(subArgs, injectedApi) {
   if (action !== "set") {
     const catalog = await fetchCatalog(api);
     console.log("\nAPI provider keys\n");
-    for (const id2 of import_core15.PROVIDER_PRIORITY) {
-      const meta2 = import_core15.ALL_PROVIDERS[id2];
+    for (const id2 of import_core17.PROVIDER_PRIORITY) {
+      const meta2 = import_core17.ALL_PROVIDERS[id2];
       const configured = catalog.providers.includes(id2);
       console.log(`  ${configured ? "\u2713" : " "} ${id2.padEnd(14)} ${meta2.apiKeyEnvVar.padEnd(28)} ${meta2.label}`);
     }
@@ -3044,7 +3089,7 @@ async function handleKey(subArgs, injectedApi) {
   }
   if (!provider) fail(USAGE6);
   const id = provider.toLowerCase();
-  const meta = import_core15.ALL_PROVIDERS[id];
+  const meta = import_core17.ALL_PROVIDERS[id];
   if (!meta) {
     fail(`Unknown provider: ${provider}`, "Run `ordewell key` to see the list.");
   }
@@ -3125,7 +3170,7 @@ async function handleApprove(subArgs, injectedApi) {
 // src/tui/terminalLauncher.ts
 var import_child_process3 = require("child_process");
 var import_util = require("util");
-var import_core16 = require("@ordewell/core");
+var import_core18 = require("@ordewell/core");
 var execFileAsync = (0, import_util.promisify)(import_child_process3.execFile);
 var defaultExecFile = async (command, args) => {
   const { stdout, stderr } = await execFileAsync(command, args);
@@ -3145,16 +3190,16 @@ var defaultWhich = (bin) => {
 async function openTaskTerminal(port, planSessionId, taskId, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const env = deps.env ?? process.env;
-  const hasTmuxImpl = deps.hasTmuxImpl ?? import_core16.hasTmux;
+  const hasTmuxImpl = deps.hasTmuxImpl ?? import_core18.hasTmux;
   const execFileImpl = deps.execFileImpl ?? defaultExecFile;
   const spawnImpl = deps.spawnImpl ?? defaultSpawn;
   const which = deps.which ?? defaultWhich;
   if (!hasTmuxImpl()) {
     return { ok: false, message: "tmux is not installed \u2014 install it to get a real terminal per task." };
   }
-  const session = (0, import_core16.tmuxSessionName)(port);
-  const socket = (0, import_core16.tmuxSocketName)(port);
-  const base = (0, import_core16.tmuxWindowName)(taskId, planSessionId);
+  const session = (0, import_core18.tmuxSessionName)(port);
+  const socket = (0, import_core18.tmuxSocketName)(port);
+  const base = (0, import_core18.tmuxWindowName)(taskId, planSessionId);
   let windows;
   try {
     const { stdout } = await execFileImpl("tmux", ["-L", socket, "list-windows", "-t", session, "-F", "#{window_name}"]);
@@ -3246,7 +3291,7 @@ async function handleTerminal(subArgs, injectedApi) {
 }
 
 // src/commands/task-assign.ts
-var import_plan_utils2 = require("@ordewell/core/plan-utils");
+var import_plan_utils = require("@ordewell/core/plan-utils");
 
 // src/tui/taskAssignment.ts
 function runnerServes(runner, model) {
@@ -3423,7 +3468,7 @@ Mode \xB7 #${task.order} ${task.title}${task.assignedRunner ? ` (${task.assigned
 var DEPS_USAGE = "Usage: ordewell task-deps <task-id-or-order> [<id,id,\u2026>|none] [--session-id <id>]";
 async function handleTaskDeps(subArgs, injectedApi) {
   await withTask(subArgs, DEPS_USAGE, injectedApi, async (api, sessionId, task, tasks, value) => {
-    const candidates = (0, import_plan_utils2.dependencyCandidates)(tasks, task.id);
+    const candidates = (0, import_plan_utils.dependencyCandidates)(tasks, task.id);
     if (!value) {
       console.log(`
 Dependencies \xB7 #${task.order} ${task.title}
@@ -3440,7 +3485,7 @@ Dependencies \xB7 #${task.order} ${task.title}
       return;
     }
     const dependencies = value.toLowerCase() === "none" ? [] : value.split(",").map((s) => s.trim()).filter(Boolean).map((token) => tasks.find((t) => t.id === token || String(t.order) === token)?.id ?? token);
-    const check = (0, import_plan_utils2.canSetDependencies)(tasks, task.id, dependencies);
+    const check = (0, import_plan_utils.canSetDependencies)(tasks, task.id, dependencies);
     if (!check.ok) fail(check.error ?? "Invalid dependencies.");
     await api.updateTask(sessionId, task.id, { dependencies });
     console.log(dependencies.length > 0 ? `Task #${task.order} now depends on ${dependencies.length} task${dependencies.length === 1 ? "" : "s"}.` : `Task #${task.order} no longer depends on anything.`);
@@ -3448,7 +3493,7 @@ Dependencies \xB7 #${task.order} ${task.title}
 }
 
 // src/tui/index.ts
-var import_core22 = require("@ordewell/core");
+var import_core29 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -3693,6 +3738,9 @@ function tokenCompletions(token) {
   return pool.filter((c) => c.name.startsWith(token.name));
 }
 
+// src/tui/blocks.ts
+var import_core19 = require("@ordewell/core");
+
 // src/tui/markdown.ts
 function renderMarkdown(source, cols) {
   const lines = source.replace(/\r/g, "").replace(/^\n+|\n+$/g, "").split("\n");
@@ -3804,6 +3852,227 @@ function inline(text) {
   return text.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\(([^\s)]+)(?:\s+[^)]*)?\)/g, "$1 ($2)").replace(/\*\*([^*]+)\*\*/g, (_, bold) => style.bold(bold)).replace(/__([^_]+)__/g, (_, bold) => style.bold(bold)).replace(/(^|[^\w])\*([^*]+)\*(?![\w*])/g, (_, prefix, italic) => `${prefix}${style.italic(italic)}`).replace(/(^|[^\w])_([^_]+)_(?![\w_])/g, (_, prefix, italic) => `${prefix}${style.italic(italic)}`).replace(/`([^`]+)`/g, (_, code) => style.cyan(code));
 }
 
+// src/tui/blocks.ts
+function countOf(n, noun) {
+  return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+function firstLine(text) {
+  return sanitize(text).trim().split("\n")[0].trim();
+}
+function tailOf(text, max) {
+  const chars = [...text];
+  let out = "";
+  let used = 0;
+  for (let i = chars.length - 1; i >= 0 && used + width(chars[i]) <= max; i--) {
+    out = chars[i] + out;
+    used += width(chars[i]);
+  }
+  return out;
+}
+var ROLE_PREFIX = {
+  user: (t) => `${style.cyan("\u276F")} ${t}`,
+  planner: (t) => `${style.magenta("\u25C6")} ${t}`,
+  system: (t) => style.grey(`\xB7 ${t}`),
+  error: (t) => `${style.red("\u2717")} ${style.red(t)}`
+};
+function messageLines(block, cols) {
+  const text = sanitize(block.text);
+  const room = Math.max(1, cols - 2);
+  const wrapped = block.role === "planner" ? renderMarkdown(text, room) : wrap(text, room);
+  return wrapped.map((line, i) => i === 0 ? ROLE_PREFIX[block.role](line) : `  ${line}`);
+}
+function thinkingLines(block, cols, detailAll) {
+  const text = sanitize(block.text).trim();
+  const head = `\u2234 Thinking (${countOf(text ? text.split(/\s+/).length : 0, "word")})`;
+  if (detailAll) {
+    const body = text ? wrap(text, Math.max(1, cols - 2)).map((line) => style.grey(`  ${line}`)) : [];
+    return [style.grey(truncate(head, cols)), ...body];
+  }
+  const latest = block.streaming ? (text.split("\n").at(-1) ?? "").trim() : "";
+  const room = cols - width(`${head} \xB7 `);
+  if (!latest || room < 2) return [style.grey(truncate(head, cols))];
+  const shown = width(latest) > room ? `\u2026${tailOf(latest, room - 1)}` : latest;
+  return [style.grey(`${head} \xB7 ${shown}`)];
+}
+var OUTPUT_HEAD = "  \u23BF  ";
+var OUTPUT_INDENT = "     ";
+var PREVIEW_LINES = 3;
+function underHeader(lines) {
+  return lines.map((line, i) => `${i === 0 ? style.grey(OUTPUT_HEAD) : OUTPUT_INDENT}${line}`);
+}
+function unsettledOutcome(block) {
+  switch (block.status) {
+    case "error":
+      return { label: "Error", paint: style.red };
+    case "denied":
+      return { label: block.outcome === "refused" ? "Refused" : "Denied", paint: style.yellow };
+    case "interrupted":
+      return { label: "Interrupted", paint: style.grey };
+    default:
+      return null;
+  }
+}
+function commandMark(block) {
+  if (block.status === "pending") return style.grey("\u25CB");
+  return (unsettledOutcome(block)?.paint ?? style.green)("\u25CF");
+}
+function commandHeader(block, cols, detailAll) {
+  const name = sanitize(block.headline.name);
+  const keyArg = sanitize(block.headline.keyArg);
+  if (detailAll) {
+    return wrap(`${name}(${keyArg})`, Math.max(1, cols - 2)).map((line, i) => i === 0 ? `${commandMark(block)} ${line}` : `  ${line}`);
+  }
+  const open = `\u25CF ${name}(`;
+  const room = cols - width(open) - 1;
+  const text = room > 1 ? `${open}${truncate(keyArg, room)})` : truncate(`${open}${keyArg})`, cols);
+  return [`${commandMark(block)}${text.slice(1)}`];
+}
+function argumentLines(args) {
+  if (!args.trim()) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(args);
+  } catch {
+    return sanitize(args).split("\n");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return sanitize(args).split("\n");
+  return Object.entries(parsed).flatMap(([key, value]) => {
+    const [first, ...rest] = sanitize(typeof value === "string" ? value : JSON.stringify(value)).split("\n");
+    return [`${key}: ${first}`, ...rest];
+  });
+}
+function resultLines(block, room, detailAll) {
+  if (block.status === "pending") return [style.grey("Running\u2026")];
+  const fit2 = (line) => detailAll ? wrap(line, room) : [truncate(line, room)];
+  const outcome = unsettledOutcome(block);
+  if (outcome) {
+    const [reason, ...rest] = (0, import_core19.outputLines)(block.output).map(sanitize);
+    const status = fit2(reason ? `${outcome.label}: ${reason}` : outcome.label).map(outcome.paint);
+    return detailAll ? [...status, ...rest.flatMap(fit2).map(style.grey)] : status;
+  }
+  if (detailAll) {
+    const lines2 = (0, import_core19.outputLines)(block.output).map(sanitize);
+    const note = lines2.length > PREVIEW_LINES ? ["\u2026 (ctrl+o to collapse)"] : [];
+    return lines2.length > 0 ? [...lines2.flatMap(fit2), ...note].map(style.grey) : [style.grey("(no output)")];
+  }
+  const { lines, hiddenLineCount } = (0, import_core19.outputPreview)(block.output, PREVIEW_LINES);
+  if (lines.length === 0) return [style.grey("(no output)")];
+  const more = hiddenLineCount > 0 ? [`\u2026 +${countOf(hiddenLineCount, "line")} (ctrl+o to expand)`] : [];
+  return [...lines.map(sanitize), ...more].map((line) => style.grey(truncate(line, room)));
+}
+function toolLines(block, cols, detailAll) {
+  const room = Math.max(1, cols - OUTPUT_INDENT.length);
+  const args = detailAll ? argumentLines(block.args).flatMap((line) => wrap(line, room)).map((line) => OUTPUT_INDENT + style.grey(line)) : [];
+  return [...commandHeader(block, cols, detailAll), ...args, ...underHeader(resultLines(block, room, detailAll))];
+}
+var SUBAGENT_PAINT = {
+  running: style.yellow,
+  done: style.green,
+  failed: style.red,
+  stopped: style.grey
+};
+var CHILD_INDENT = "    ";
+function subagentHeader(block, cols) {
+  const brief = firstLine(block.brief);
+  const steps = block.children.filter((c) => c.type === "tool").length;
+  const status = block.status === "running" && steps > 0 ? `running \xB7 ${countOf(steps, "step")}` : block.status;
+  const head = brief ? " Agent: " : " Agent";
+  const briefRoom = cols - width(`\u25C6${head}  ${status}`);
+  if (briefRoom < 4) return truncate(`\u25C6${head}${brief}  ${status}`, cols);
+  const named = `${style.cyan("\u25C6")}${head}${truncate(brief, briefRoom)}  ${SUBAGENT_PAINT[block.status](status)}`;
+  const digest = firstLine(block.digest);
+  const digestRoom = cols - width(named) - width(" \xB7 ");
+  return digest && digestRoom >= 4 ? `${named}${style.grey(` \xB7 ${truncate(digest, digestRoom)}`)}` : named;
+}
+function subagentLines(block, cols, detailAll) {
+  const header = subagentHeader(block, cols);
+  if (!detailAll) return [header];
+  const childCols = Math.max(1, cols - CHILD_INDENT.length);
+  const children = block.children.flatMap((child) => blockLines(child, childCols, true).map((line) => CHILD_INDENT + line));
+  const digest = sanitize(block.digest).trim();
+  const handedBack = digest ? underHeader(wrap(digest, Math.max(1, cols - OUTPUT_INDENT.length)).map(style.grey)) : [];
+  return [header, ...children, ...handedBack];
+}
+var APPROVAL_KIND = {
+  shell_command: "Run a command",
+  url_fetch: "Fetch a URL",
+  external_path: "Read outside the workspace"
+};
+var DECIDED_BY = {
+  "pre-approved": "pre-approved",
+  remembered: "remembered",
+  mode: "policy",
+  "no-channel": "no approval channel"
+};
+function approvalLine(block, cols) {
+  const policy = block.decidedBy && block.decidedBy !== "asked" ? DECIDED_BY[block.decidedBy] : void 0;
+  const [mark, status, paint] = block.status === "pending" ? ["?", "Waiting for you", style.yellow] : block.status === "granted" ? ["\u2713", policy ? `Auto-approved (${policy})` : "Approved", style.green] : ["\u2298", policy ? `Auto-denied (${policy})` : "Denied", style.yellow];
+  const line = `${mark} ${status} \xB7 ${APPROVAL_KIND[block.kind]}: ${firstLine(block.subject)}`;
+  return `${paint(mark)}${truncate(line, cols).slice(mark.length)}`;
+}
+function planLine(block, cols) {
+  const count = block.taskCount === void 0 ? "" : ` (${countOf(block.taskCount, "task")})`;
+  const text = block.status === "building" ? "Building plan\u2026" : `Plan ${block.status}${count}`;
+  return `${style.cyan("\u25C7")}${truncate(`\u25C7 ${text}`, cols).slice(1)}`;
+}
+function blockLines(block, cols, detailAll) {
+  switch (block.type) {
+    case "message":
+      return messageLines(block, cols);
+    case "thinking":
+      return thinkingLines(block, cols, detailAll);
+    case "tool":
+      return toolLines(block, cols, detailAll);
+    case "subagent":
+      return subagentLines(block, cols, detailAll);
+    case "approval":
+      return [approvalLine(block, cols)];
+    case "plan":
+      return [planLine(block, cols)];
+    // Pinned under the pane rather than drawn in it — see `tokenLine`.
+    case "usage":
+      return [];
+  }
+}
+var drawnBlocks = /* @__PURE__ */ new WeakMap();
+function drawn(block, cols, detailAll) {
+  const cached = drawnBlocks.get(block);
+  if (cached && cached.cols === cols && cached.detailAll === detailAll) return cached.lines;
+  const lines = blockLines(block, cols, detailAll);
+  drawnBlocks.set(block, { cols, detailAll, lines });
+  return lines;
+}
+function conversationLines(blocks, cols, detailAll) {
+  const lines = [];
+  for (const block of blocks) {
+    if (block.type === "usage") continue;
+    lines.push(...drawn(block, cols, detailAll), "");
+  }
+  return lines;
+}
+function compactCount(n) {
+  if (n < 1e3) return String(n);
+  const [value, unit] = n < 999950 ? [n / 1e3, "k"] : [n / 1e6, "M"];
+  return `${value.toFixed(1).replace(/\.0$/, "")}${unit}`;
+}
+function formatCost(currency, amount) {
+  const [whole, frac = ""] = amount.toFixed(4).replace(/0+$/, "").split(".");
+  const value = `${whole}.${frac.padEnd(2, "0")}`;
+  return currency.toLowerCase() === "usd" ? `$${value}` : `${value} ${currency.toUpperCase()}`;
+}
+function tokenLine(blocks, cols) {
+  const usage = blocks[blocks.length - 1];
+  if (usage?.type !== "usage") return null;
+  const { totals, contextFill } = usage;
+  const parts = [
+    ...totals.inputTokens !== void 0 ? [`${compactCount(totals.inputTokens)} in`] : [],
+    ...totals.outputTokens !== void 0 ? [`${compactCount(totals.outputTokens)} out`] : [],
+    ...contextFill ? [`${Math.round(contextFill.usedTokens / contextFill.windowTokens * 100)}% ctx`] : [],
+    ...Object.entries(totals.reportedCost ?? {}).map(([currency, amount]) => formatCost(currency, amount))
+  ];
+  return parts.length > 0 ? style.grey(truncate(parts.join(" \xB7 "), cols)) : null;
+}
+
 // src/tui/geometry.ts
 var PLAN_MIN_COLS = 32;
 var PLAN_MAX_COLS = 64;
@@ -3835,7 +4104,7 @@ function chatEditorRoom(cols, active) {
 }
 
 // src/tui/state.ts
-var import_core17 = require("@ordewell/core");
+var import_core20 = require("@ordewell/core");
 var SKILL_IDS = ["tdd", "verify"];
 function noSkills() {
   return { tdd: false, verify: false };
@@ -3849,6 +4118,7 @@ function visibleItems(picker2) {
 }
 var isTaskRunning = (task) => task.status === "in_progress" || task.status === "running";
 var anyTaskRunning = (state) => state.tasks.some(isTaskRunning);
+var plannerInFlight = (state) => state.status === "planning" || state.status === "researching";
 function planRows(state) {
   const rows = [];
   for (const task of state.tasks) {
@@ -3875,10 +4145,11 @@ function findTask(tasks, id) {
 function initialState(overrides = {}) {
   return {
     editor: emptyEditor(),
-    messages: [],
+    conversation: import_core20.EMPTY_CONVERSATION,
+    turnGate: import_core20.NO_TURN,
+    detailAll: false,
     status: "idle",
     busyLabel: "",
-    thinkingLine: "",
     sessionId: null,
     goal: "",
     tasks: [],
@@ -3900,7 +4171,7 @@ function initialState(overrides = {}) {
     orchestratorModel: "",
     plannerProvider: "",
     plannerEffort: "",
-    maxParallel: import_core17.DEFAULT_MAX_PARALLEL,
+    maxParallel: import_core20.DEFAULT_MAX_PARALLEL,
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
@@ -3910,6 +4181,10 @@ function initialState(overrides = {}) {
     handoff: null,
     overlay: null,
     pendingApprovals: [],
+    queuedPrompts: import_core20.EMPTY_HOLD,
+    stopArmed: false,
+    stopArmToken: 0,
+    stopRequested: false,
     toast: "",
     rows: 24,
     cols: 80,
@@ -3920,7 +4195,7 @@ function initialState(overrides = {}) {
 }
 
 // src/tui/layout.ts
-var import_core18 = require("@ordewell/core");
+var import_core21 = require("@ordewell/core");
 var CHROME_ROWS = 4;
 function chatInputWrap(state) {
   const active = state.focus === "chat" && !state.overlay;
@@ -3931,8 +4206,8 @@ function footerHints(state) {
   const selected = selectedPlanRow(state)?.task;
   const markHint = selected?.status === "completed" ? "m undone" : "m done";
   const resolveHint = selected?.isolation?.state === "conflict" ? ["x resolve conflict"] : [];
-  const planning = state.status === "planning" || state.status === "researching";
-  const escHint = planning ? "esc stop planning" : null;
+  const planning = plannerInFlight(state);
+  const escHint = !planning ? null : state.queuedPrompts.length > 0 ? "esc unsend" : "esc \xD72 stop planning";
   if (state.focus === "plan") {
     if (state.taskEditor) {
       return ["type to edit prompt", "pgup/pgdn scroll", "alt-enter newline", "enter save", "esc cancel"];
@@ -3947,6 +4222,7 @@ function footerHints(state) {
       "D deps",
       "f start",
       "E run plan",
+      "S stop",
       "c cancel",
       markHint,
       "s skip",
@@ -3958,15 +4234,27 @@ function footerHints(state) {
       "tab chat"
     ];
   }
+  const detailHint = (0, import_core21.hasHiddenDetail)(state.conversation.blocks) ? [state.detailAll ? "ctrl-o collapse all" : "ctrl-o expand all"] : [];
   return [
     "/help",
     "tab plan",
     "alt-enter newline",
     "pgup/pgdn scroll",
+    ...detailHint,
     ...escHint ? [escHint] : [],
     "ctrl-c quit"
   ];
 }
+function queuedPromptRows(state, cols) {
+  return state.queuedPrompts.flatMap((text) => queuedBubble(text, cols));
+}
+function queuedBubble(text, cols) {
+  const room = Math.max(1, cols - width("\u25C7  \xB7 queued \xB7 esc to unsend"));
+  return wrap(text, room).map((line, i) => i === 0 ? truncate(`${style.grey(`\u25C7 ${line}`)} \xB7 queued \xB7 esc to unsend`, cols) : truncate(style.grey(`  ${line}`), cols));
+}
+function stopHint(state) {
+  return plannerInFlight(state) && state.stopArmed ? "Press Esc again to stop" : "";
+}
 function packHints(hints, cols) {
   const lines = [];
   let current = "";
@@ -3987,78 +4275,33 @@ function bodyRows(state) {
   const footer = packHints(footerHints(state), state.cols).length;
   return Math.max(0, state.rows - CHROME_ROWS - input - footer + 2);
 }
-var ROLE_PREFIX = {
-  user: (t) => `${style.cyan("\u276F")} ${t}`,
-  assistant: (t) => `${style.magenta("\u25C6")} ${t}`,
-  system: (t) => style.grey(`\xB7 ${t}`),
-  error: (t) => `${style.red("\u2717")} ${style.red(t)}`,
-  // Research rows go through `researchRow`, which paints the outcome mark
-  // separately; this entry only exists to keep the role map total.
-  research: (t) => style.grey(`  \u21B3 ${t}`)
-};
-var OUTCOME_MARK2 = {
-  success: "\u2713",
-  failure: "\u2717",
-  refused: "\u2298",
-  denied: "\u2298",
-  not_executed: "\u2013"
-};
-var OUTCOME_PAINT = {
-  success: style.grey,
-  failure: style.red,
-  refused: style.yellow,
-  denied: style.yellow,
-  not_executed: style.grey
-};
-var RESEARCH_RESULT_CHARS = 90;
-function researchLine(message) {
-  const meta = message.research;
-  if (!meta?.outcome) return `\u22EF ${message.content}`;
-  const result = (meta.result ?? "").replace(/\s+/g, " ").trim();
-  const preview = result.length > RESEARCH_RESULT_CHARS ? `${result.slice(0, RESEARCH_RESULT_CHARS)}\u2026` : result;
-  const mark = OUTCOME_MARK2[meta.outcome];
-  return preview ? `${mark} ${message.content} \u2192 ${preview}` : `${mark} ${message.content}`;
-}
-var RESEARCH_INDENT = "  \u21B3 ";
-function researchRow(message, cols) {
-  const text = truncate(researchLine(message), Math.max(1, cols - width(RESEARCH_INDENT)));
-  const paint = OUTCOME_PAINT[message.research?.outcome ?? "success"];
-  const space = text.indexOf(" ");
-  if (space < 0) return style.grey(`${RESEARCH_INDENT}${text}`);
-  return `${style.grey("  \u21B3")} ${paint(text.slice(0, space))} ${style.grey(text.slice(space + 1))}`;
-}
 var chatBodyMemo = null;
-function chatBodyLines(messages, cols) {
-  if (chatBodyMemo && chatBodyMemo.messages === messages && chatBodyMemo.cols === cols) {
-    return chatBodyMemo.lines;
-  }
-  const lines = [];
-  for (const message of messages) {
-    if (message.role === "research") {
-      lines.push(researchRow(message, cols));
-      continue;
-    }
-    const wrapped = message.role === "assistant" ? renderMarkdown(message.content, Math.max(1, cols - 2)) : wrap(message.content, Math.max(1, cols - 2));
-    lines.push(...wrapped.map((line, i) => i === 0 ? ROLE_PREFIX[message.role](line) : `  ${line}`));
-    lines.push("");
-  }
-  chatBodyMemo = { messages, cols, lines };
+function chatBodyLines(blocks, cols, detailAll) {
+  const memo = chatBodyMemo;
+  if (memo && memo.blocks === blocks && memo.cols === cols && memo.detailAll === detailAll) return memo.lines;
+  const lines = conversationLines(blocks, cols, detailAll);
+  chatBodyMemo = { blocks, cols, detailAll, lines };
   return lines;
 }
 function chatLayout(state, rows, cols) {
   const welcome = state.tasks.length === 0;
-  const body = chatBodyLines(state.messages, cols);
-  const lines = !welcome ? body : state.messages.length === 0 ? welcomeLines(state, cols) : [...welcomeLines(state, cols), "", ...body];
-  return { lines, anchor: lines.length > rows ? "bottom" : "top", maxScroll: Math.max(0, lines.length - rows) };
+  const body = chatBodyLines(state.conversation.blocks, cols, state.detailAll);
+  const transcript = !welcome ? body : body.length === 0 ? welcomeLines(state, cols) : [...welcomeLines(state, cols), "", ...body];
+  const bubbles = queuedPromptRows(state, cols);
+  const lines = [...transcript, ...bubbles.length > 0 ? ["", ...bubbles] : []];
+  const usage = rows > 1 ? tokenLine(state.conversation.blocks, cols) : null;
+  const footer = usage ? [usage] : [];
+  const room = rows - footer.length;
+  return { lines, footer, anchor: lines.length > room ? "bottom" : "top", maxScroll: Math.max(0, lines.length - room) };
 }
 function chatScrollMax(state) {
   return chatLayout(state, bodyRows(state), chatPaneWidth(state)).maxScroll;
 }
 function plannerSetup(state) {
   const provider = state.plannerProvider;
-  const registration = import_core18.ALL_PROVIDERS[provider];
+  const registration = import_core21.ALL_PROVIDERS[provider];
   if (!registration) return { label: "not set", ready: false };
-  const runner = (0, import_core18.runnerForProvider)(provider);
+  const runner = (0, import_core21.runnerForProvider)(provider);
   const ready = runner ? state.runners.some((r) => r.id === runner) : state.configuredProviders.includes(provider);
   return { label: registration.label, ready };
 }
@@ -4241,7 +4484,7 @@ function taskLines(state, row, index, cols) {
   const icon = paint(rawIcon);
   const kind = running ? style.yellow("RUN") : task.type === "user" ? style.yellow("MAN") : style.grey(" AI");
   const caret = selected ? style.cyan("\u276F") : " ";
-  const orderLabel = parent ? (0, import_core18.taskOrderLabel)(task, parent) : String(task.order).padStart(2);
+  const orderLabel = parent ? (0, import_core21.taskOrderLabel)(task, parent) : String(task.order).padStart(2);
   const indent = parent ? "  " : "";
   const head = `${indent}${caret} ${icon} ${orderLabel} ${kind} `;
   const titleRoom = Math.max(1, cols - width(head));
@@ -4268,16 +4511,16 @@ function taskLines(state, row, index, cols) {
   if (effort || mode) lines.push(style.grey(truncate(`${bodyPad}${[effort, mode].filter(Boolean).join(" \xB7 ")}`, cols)));
   if (task.isolation?.state === "conflict") {
     const where = task.isolation.conflictRepo && task.isolation.conflictRepo !== "." ? ` in ${task.isolation.conflictRepo}` : "";
-    const files = task.isolation.conflictFiles?.length ? ` (${(0, import_core18.capConflictFiles)(task.isolation.conflictFiles)})` : "";
+    const files = task.isolation.conflictFiles?.length ? ` (${(0, import_core21.capConflictFiles)(task.isolation.conflictFiles)})` : "";
     lines.push(style.red(truncate(`${bodyPad}\u26A0 merge conflict${where}${files} \u2014 its work is kept on its own branch`, cols)));
   }
   if (task.isolation?.state === "repairing") {
-    const files = task.isolation.conflictFiles?.length ? ` in ${(0, import_core18.capConflictFiles)(task.isolation.conflictFiles)}` : "";
+    const files = task.isolation.conflictFiles?.length ? ` in ${(0, import_core21.capConflictFiles)(task.isolation.conflictFiles)}` : "";
     const attempt = task.isolation.repair ? ` (attempt ${task.isolation.repair.attempt}/${task.isolation.repair.limit})` : "";
     lines.push(style.yellow(truncate(`${bodyPad}\u21BB repairing conflict${files}${attempt}`, cols)));
   }
   if (task.isolation?.state === "integrated" && task.isolation.repairedFiles?.length) {
-    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${(0, import_core18.capConflictFiles)(task.isolation.repairedFiles)}`, cols)));
+    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${(0, import_core21.capConflictFiles)(task.isolation.repairedFiles)}`, cols)));
   }
   let editorLine;
   if (expanded) {
@@ -4351,7 +4594,7 @@ function helpLayout(rows, cols) {
     body.push("");
   }
   body.push(
-    style.grey("tab switches panes \xB7 \u2191\u2193/pgup/pgdn scroll \xB7 ctrl-l clears \xB7 ctrl-c quits")
+    style.grey("tab switches panes \xB7 pgup/pgdn scroll \xB7 ctrl-o toggles full detail \xB7 esc takes back a queued prompt, otherwise esc twice stops \xB7 ctrl-l clears \xB7 ctrl-c quits")
   );
   const lines = body.map((line) => truncate(line, Math.max(1, cols - 2)));
   const room = Math.max(1, rows - 2);
@@ -4362,7 +4605,7 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
-var import_core19 = require("@ordewell/core");
+var import_core22 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
@@ -4465,20 +4708,16 @@ function scrolledBackMark(state) {
 }
 function renderStatus(state, cols) {
   const mark = scrolledBackMark(state);
+  const armed = stopHint(state);
   if (state.status === "idle") {
     const notes = [mark, state.toast].filter(Boolean).join(" \xB7 ");
     return notes ? truncate(style.grey(notes), cols) : "";
   }
+  if (armed) return truncate(style.red(armed), cols);
   const scrolled = mark ? style.grey(`${mark} \xB7 `) : "";
   const label = state.busyLabel ? ` ${state.busyLabel}` : "";
   const verb = state.status === "executing" ? "Executing" : state.status === "researching" ? "Researching" : "Planning";
-  const head = scrolled + style.yellow(`\u25CF ${verb}\u2026${label}`);
-  const thinking = state.thinkingLine.replace(/\s+/g, " ").trim();
-  if (!thinking) return truncate(head, cols);
-  const room = cols - width(head) - 3;
-  if (room < 12) return truncate(head, cols);
-  const tail = thinking.length > room ? `\u2026${thinking.slice(-(room - 1)).trimStart()}` : thinking;
-  return truncate(`${head}${style.grey(` \xB7 ${tail}`)}`, cols);
+  return truncate(scrolled + style.yellow(`\u25CF ${verb}\u2026${label}`), cols);
 }
 function highlightSpans(text) {
   const spans = [];
@@ -4560,9 +4799,9 @@ function renderBody(state, rows, cols) {
   );
 }
 function renderChat(state, rows, cols) {
-  const { lines, anchor, maxScroll } = chatLayout(state, rows, cols);
+  const { lines, footer, anchor, maxScroll } = chatLayout(state, rows, cols);
   const back = Math.min(state.scroll, maxScroll);
-  return fit(lines.slice(0, lines.length - back), rows, anchor);
+  return [...fit(lines.slice(0, lines.length - back), rows - footer.length, anchor), ...footer];
 }
 function renderPlan(state, rows, cols) {
   const layout = planLayout(state, rows, cols);
@@ -4595,7 +4834,9 @@ function renderOverlay(state, rows, cols) {
         // ESC is not "deny" while a turn is in flight — it kills the turn and
         // takes this prompt with it. Offering it as the deny key there would
         // teach the wrong thing about the most destructive key on the sheet.
-        style.grey(state.status === "planning" || state.status === "researching" ? "y or enter allows \xB7 n denies \xB7 esc stops planning" : "y or enter allows \xB7 n or esc denies")
+        // With a prompt queued the first ESC unsends that instead, so the hint
+        // names the take-back rather than the twice-to-stop.
+        style.grey(plannerInFlight(state) ? state.queuedPrompts.length > 0 ? "y or enter allows \xB7 n denies \xB7 esc takes back the queued prompt" : "y or enter allows \xB7 n denies \xB7 esc twice stops planning" : "y or enter allows \xB7 n or esc denies")
       ],
       rows,
       cols
@@ -4626,7 +4867,7 @@ function renderHandoff(state, overlay, rows, cols) {
     return frame(`Diff \u2014 ${handoffBranch(handoff)}`, [...shown, "", style.grey(`${more}enter or esc goes back`)], rows, cols);
   }
   const landed = handoff.landed.length === 0 ? [style.grey("Nothing landed on it.")] : handoff.landed.map((task) => {
-    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core19.capConflictFiles)(task.repairedFiles)})`) : "";
+    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core22.capConflictFiles)(task.repairedFiles)})`) : "";
     return `  ${style.green("\u2713")} #${task.order} ${task.title}${repaired}`;
   });
   const actions = handoffActions(handoff).map((action, index) => {
@@ -4716,412 +4957,111 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core20 = require("@ordewell/core");
-var import_plan_utils3 = require("@ordewell/core/plan-utils");
-var KNOWN_PROVIDERS2 = Object.keys(import_core20.ALL_PROVIDERS);
-var DEFAULT_EFFORT = "__runner_default__";
+var import_core26 = require("@ordewell/core");
+
+// src/tui/reducers/shared.ts
 function step(state, effects = []) {
   return { state, effects };
 }
-function restoredMessages(history) {
-  return history.map((entry) => ({
-    role: entry.kind === "plan_generated" || entry.kind === "system" || entry.kind === "compaction" ? "system" : entry.role,
-    content: sanitize(entry.kind === "plan_generated" ? "Plan generated." : entry.content),
-    timestamp: entry.timestamp
-  }));
+var fail3 = (state, message) => step(say(state, "error", message));
+var stale = (state, sessionId) => sessionId !== void 0 && sessionId !== state.sessionId;
+function clamp(value, max) {
+  return Math.max(0, Math.min(max, value));
 }
-var isPendingResearch = (m) => m.role === "research" && !m.research?.outcome;
-function alreadySpoken(messages, content) {
-  const last = findLastIndex(messages, (m) => m.role === "assistant" || m.role === "user");
-  const spoken = last >= 0 && messages[last].role === "assistant" && messages[last].content === content;
-  const redrawn = messages.at(-1)?.role === "system" && messages.at(-1)?.content === content;
-  return spoken || redrawn;
+function clampSelection(index, rows) {
+  return Math.max(0, Math.min(index, rows - 1));
 }
-function runLabel(tasks) {
-  const running = tasks.filter(isTaskRunning);
-  if (running.length > 0) {
-    const [first] = running;
-    const name = first.assignedRunner ? `${first.title} \xB7 ${first.assignedRunner}` : first.title;
-    return running.length > 1 ? `${name} (+${running.length - 1} more)` : name;
+function withSession(state, run) {
+  if (!state.sessionId) {
+    return fail3(state, "No active plan \u2014 describe a goal first, or load a session with /sessions.");
   }
-  const waiting = tasks.filter((t) => t.status === "awaiting_user").length;
-  if (waiting === 0) return "";
-  return waiting === 1 ? "1 task waits for you" : `${waiting} tasks wait for you`;
+  return run(state.sessionId);
 }
-function researchLabel(messages, summary) {
-  const others = messages.filter(isPendingResearch).length - 1;
-  return others > 0 ? `${summary} (+${others} more)` : summary;
-}
-function settleResearchStep(messages, action) {
-  const summary = sanitize(action.summary);
-  const index = findLastIndex(messages, (m) => isPendingResearch(m) && (action.toolCallId ? m.research?.toolCallId === action.toolCallId : m.content === summary));
-  if (index < 0) return messages;
-  const next = [...messages];
-  next[index] = {
-    ...next[index],
-    research: { ...next[index].research, outcome: action.outcome, result: sanitize(action.result) }
-  };
-  return next;
+
+// src/tui/reducers/approvals.ts
+function enqueueApproval(state, request) {
+  const open = state.overlay?.kind === "approval" ? state.overlay.request : null;
+  if (open?.id === request.id) return state;
+  if (state.pendingApprovals.some((p) => p.id === request.id)) return state;
+  if (open) return { ...state, pendingApprovals: [...state.pendingApprovals, request] };
+  return { ...state, overlay: { kind: "approval", request } };
+}
+function dropApproval(state, approvalId) {
+  const pending = state.pendingApprovals.filter((p) => p.id !== approvalId);
+  const open = state.overlay?.kind === "approval" ? state.overlay.request : null;
+  if (open?.id !== approvalId) return { ...state, pendingApprovals: pending };
+  return showNextApproval({ ...state, pendingApprovals: pending, overlay: null });
+}
+function showNextApproval(state) {
+  const [next, ...rest] = state.pendingApprovals;
+  if (!next) return { ...state, overlay: null };
+  return { ...state, overlay: { kind: "approval", request: next }, pendingApprovals: rest };
+}
+function handleApprovalKey(state, overlay, key) {
+  const grant = key.name === "enter" || key.char === "y" || key.char === "Y";
+  const deny = key.name === "escape" || key.char === "n" || key.char === "N";
+  if (!grant && !deny) return step(state);
+  const { request } = overlay;
+  return step(showNextApproval({ ...state, overlay: null }), state.sessionId ? [{ type: "respondApproval", sessionId: state.sessionId, approvalId: request.id, granted: grant }] : []);
+}
+
+// src/tui/reducers/commands.ts
+var import_core25 = require("@ordewell/core");
+
+// src/tui/reducers/pickers.ts
+var import_core23 = require("@ordewell/core");
+var import_plan_utils2 = require("@ordewell/core/plan-utils");
+var DEFAULT_EFFORT = "__runner_default__";
+function picker(title, items, action, extra = {}) {
+  return { title, items, filter: "", index: 0, multi: false, chosen: [], action, ...extra };
+}
+function refillPicker(state, kinds) {
+  const overlay = state.overlay;
+  if (overlay?.kind !== "picker" || !kinds.includes(overlay.picker.action.kind)) return state;
+  const items = pickerItemsFor(state, overlay.picker.action);
+  const hint = overlay.picker.action.kind === "set-model" ? providerErrorHint(state) : overlay.picker.hint;
+  return { ...state, overlay: { kind: "picker", picker: { ...overlay.picker, items, hint, index: 0 } } };
+}
+function modelDetail(m) {
+  return [m.provider, m.pricing].filter(Boolean).join(" \xB7 ") || void 0;
+}
+function providerErrorHint(state) {
+  const failed = Object.keys(state.providerErrors ?? {});
+  if (failed.length === 0) return void 0;
+  const names = failed.map((p) => import_core23.ALL_PROVIDERS[p]?.label ?? p);
+  return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")} \u2014 showing working providers only.`;
+}
+function plannerModelItems(state) {
+  const runner = (0, import_core23.runnerForProvider)(state.plannerProvider);
+  if (!runner) return state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m) }));
+  const items = state.models.filter((m) => m.runners?.includes(runner)).map((m) => ({
+    id: m.id,
+    label: m.label,
+    detail: [
+      m.provider,
+      m.variants?.length ? `${m.variants.length} effort level${m.variants.length === 1 ? "" : "s"}` : "runner default effort"
+    ].filter(Boolean).join(" \xB7 "),
+    selected: m.id === state.orchestratorModel
+  }));
+  return items.length > 0 ? items : [{ id: "", label: `No ${runner} models discovered yet`, detail: "run /refresh", disabled: true }];
 }
-function findLastIndex(items, match) {
-  for (let i = items.length - 1; i >= 0; i--) {
-    if (match(items[i])) return i;
+function plannerEffortItems(state) {
+  const runner = (0, import_core23.runnerForProvider)(state.plannerProvider);
+  if (!runner) {
+    return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
+  }
+  const model = state.models.find((m) => m.id === state.orchestratorModel && m.runners?.includes(runner));
+  if (!model) {
+    return [{ id: "", label: "No planner model selected", detail: "pick one with /model", disabled: true }];
+  }
+  const variants = model.variants ?? [];
+  if (variants.length === 0) {
+    return [{ id: "", label: `${model.label} exposes no effort levels`, detail: "it always runs at the agent's default", disabled: true }];
   }
-  return -1;
-}
-var THINKING_TAIL = 400;
-var fail3 = (state, message) => step(say(state, "error", message));
-var stale = (state, sessionId) => sessionId !== void 0 && sessionId !== state.sessionId;
-function reduce(state, action) {
-  switch (action.type) {
-    case "key":
-      return handleKey2(state, action.key);
-    // Isolation belongs to one session's plan, and task ids repeat across
-    // sessions, so nothing of the last one's may carry over into this.
-    case "sessionStarted":
-      return step(clearIsolation({ ...state, sessionId: action.sessionId, goal: action.goal }));
-    // The daemon registers a session only once planning succeeds; when it does
-    // not, holding on to the id would send every next message to a session the
-    // server never had.
-    case "sessionCleared":
-      return step({
-        ...clearIsolation(state),
-        sessionId: null,
-        goal: "",
-        pendingApprovals: [],
-        overlay: state.overlay?.kind === "approval" ? null : state.overlay
-      });
-    case "approvalRequested": {
-      if (stale(state, action.sessionId)) return step(state);
-      return step(enqueueApproval(state, action.request));
-    }
-    case "approvalSettled": {
-      if (stale(state, action.sessionId)) return step(state);
-      return step(dropApproval(state, action.approvalId));
-    }
-    case "chatRestored":
-      if (stale(state, action.sessionId)) return step(state);
-      return step({ ...state, messages: restoredMessages(action.history), scroll: 0 });
-    case "planUpdated": {
-      if (stale(state, action.sessionId)) return step(state);
-      const isolation = isolationOfPlan(action.plan);
-      const tasks = isolationForPlan(normalizeTasks(action.plan), isolation, state.tasks);
-      const expandedTaskId = state.expandedTaskId && findTask(tasks, state.expandedTaskId) ? state.expandedTaskId : null;
-      const next = {
-        ...state,
-        tasks,
-        handoff: isolation ? isolation.handoff : state.handoff,
-        status: state.status === "planning" || state.status === "researching" ? "idle" : state.status,
-        busyLabel: "",
-        thinkingLine: "",
-        expandedTaskId,
-        taskEditor: expandedTaskId !== null ? state.taskEditor : null
-      };
-      const selectedTask = clampSelection(state.selectedTask, planRows(next).length);
-      return step(settlePlan({ ...next, selectedTask, focus: tasks.length === 0 ? "chat" : state.focus }));
-    }
-    case "plannerMessage": {
-      if (stale(state, action.sessionId)) return step(state);
-      const settled = { ...state, status: "idle", busyLabel: "", thinkingLine: "" };
-      const content = sanitize(action.content);
-      const last = state.messages.at(-1);
-      if (last?.role === "assistant" && last.streaming) {
-        const messages = [...state.messages];
-        messages[messages.length - 1] = { ...last, content, streaming: void 0 };
-        return step({ ...settled, messages });
-      }
-      if (alreadySpoken(state.messages, content)) return step(settled);
-      return step(say(settled, "assistant", content));
-    }
-    case "plannerToken": {
-      if (stale(state, action.sessionId)) return step(state);
-      const text = sanitize(action.text);
-      const last = state.messages.at(-1);
-      if (last?.role === "assistant" && last.streaming) {
-        const messages = [...state.messages];
-        messages[messages.length - 1] = { ...last, content: last.content + text };
-        return step({ ...state, messages });
-      }
-      return step(say(state, "assistant", text, void 0, { streaming: true }));
-    }
-    case "researchStep": {
-      if (stale(state, action.sessionId)) return step(state);
-      const summary = sanitize(action.summary);
-      const spoken = say(state, "research", summary, { toolCallId: action.toolCallId });
-      const status = state.status === "planning" ? "researching" : state.status;
-      return step({ ...spoken, status, busyLabel: researchLabel(spoken.messages, summary) });
-    }
-    // A settled transcript line, not a research step: nothing ever settles a
-    // task's start, so as a step it stayed "⋯" forever and was counted into
-    // the planner's next "(+N more)".
-    case "taskStarted": {
-      if (stale(state, action.sessionId)) return step(state);
-      const tasks = state.tasks.map((t) => t.id === action.taskId && !isTaskRunning(t) ? { ...t, status: "in_progress" } : t);
-      const who = action.runner ? ` \xB7 ${action.runner}` : "";
-      const spoken = say(state, "system", sanitize(`Started "${action.title}"${who}`));
-      return step({ ...spoken, tasks, status: "executing", busyLabel: runLabel(tasks) });
-    }
-    case "researchStepDone": {
-      if (stale(state, action.sessionId)) return step(state);
-      const messages = settleResearchStep(state.messages, action);
-      const pending = messages.filter(isPendingResearch);
-      const status = pending.length === 0 && state.status === "researching" ? "planning" : state.status;
-      return step({
-        ...state,
-        messages,
-        status,
-        busyLabel: pending.length > 0 ? researchLabel(messages, pending[pending.length - 1].content) : ""
-      });
-    }
-    case "plannerThinking": {
-      if (stale(state, action.sessionId)) return step(state);
-      return step({ ...state, thinkingLine: (state.thinkingLine + sanitize(action.text)).slice(-THINKING_TAIL) });
-    }
-    case "taskStatus": {
-      if (stale(state, action.sessionId) || !state.tasks.some((t) => t.id === action.taskId)) return step(state);
-      return step({
-        ...state,
-        status: "executing",
-        tasks: state.tasks.map((t) => t.id === action.taskId ? { ...t, status: action.status } : t)
-      });
-    }
-    case "tasksStatus": {
-      if (stale(state, action.sessionId)) return step(state);
-      const updates = action.updates;
-      let changed = false;
-      const tasks = state.tasks.map((t) => {
-        const update = updates[t.id];
-        if (update === void 0) return t;
-        const idleSince = update.idleSince ?? null;
-        const isolation = update.isolation ?? t.isolation;
-        if (update.status !== t.status || idleSince !== (t.idleSince ?? null) || !sameIsolation(isolation, t.isolation)) {
-          changed = true;
-          return { ...t, status: update.status, idleSince, isolation };
-        }
-        return t;
-      });
-      if (!changed) return step(state);
-      return step({ ...state, status: "executing", tasks, busyLabel: runLabel(tasks) });
-    }
-    case "queueReady": {
-      if (stale(state, action.sessionId)) return step(state);
-      const sessionId = action.sessionId ?? state.sessionId;
-      if (sessionId === null) return step(state);
-      return step(state, [{ type: "processQueued", sessionId }]);
-    }
-    case "isolationBlocked": {
-      if (stale(state, action.sessionId)) return step(state);
-      return step(blockedPicker(state, action.message, action.repos));
-    }
-    case "isolationHandoff": {
-      if (stale(state, action.sessionId)) return step(state);
-      return step(handoffArrived(state, action.handoff));
-    }
-    case "handoffDiff": {
-      if (stale(state, action.sessionId)) return step(state);
-      return step(showDiff(state, action.diff));
-    }
-    case "runCleared": {
-      if (stale(state, action.sessionId)) return step(state);
-      const overlay = state.overlay?.kind === "handoff" ? null : state.overlay;
-      return step({ ...clearIsolation(state), overlay });
-    }
-    case "executionComplete": {
-      if (stale(state, action.sessionId)) return step(state);
-      const { completed, total, failed } = action.summary ?? {
-        completed: state.tasks.filter((t) => t.status === "completed").length,
-        total: state.tasks.length,
-        failed: state.tasks.filter((t) => t.status === "failed").length
-      };
-      const failures = failed > 0 ? ` \xB7 ${failed} failed` : "";
-      const verb = action.stopped ? "stopped" : "finished";
-      return step({
-        ...say(state, "system", `Execution ${verb} \u2014 ${completed}/${total} tasks complete${failures}.`),
-        status: "idle",
-        busyLabel: "",
-        thinkingLine: ""
-      });
-    }
-    case "settingsLoaded":
-      return step(applySettings(state, action.settings));
-    case "modelsLoaded":
-      return step(
-        refillPicker(
-          {
-            ...state,
-            models: action.models,
-            orchestratorModels: action.orchestratorModels ?? state.orchestratorModels,
-            configuredProviders: action.providers ?? state.configuredProviders,
-            providerErrors: action.providerErrors ?? state.providerErrors,
-            modesByRunner: action.modesByRunner ?? state.modesByRunner
-          },
-          ["set-model", "set-planner", "set-task-model", "set-task-effort", "set-task-mode"]
-        )
-      );
-    case "sessionsLoaded":
-      return step(refillPicker({ ...state, sessions: action.sessions }, ["load-session", "delete-session"]));
-    case "rewindTargetsLoaded":
-      if (stale(state, action.sessionId)) return step(state);
-      if (action.pick !== void 0) return pickRewindTarget({ ...state, rewindTargets: action.targets }, action.pick);
-      return step(refillPicker({ ...state, rewindTargets: action.targets }, ["rewind"]));
-    // A fork holds no run, whatever the session it came from was doing — the
-    // original keeps its run, and its events are stale from here on.
-    case "sessionForked":
-      return step({
-        ...clearIsolation(state),
-        sessionId: action.sessionId,
-        goal: action.goal,
-        status: "idle",
-        busyLabel: "",
-        thinkingLine: "",
-        planApproved: false,
-        pendingApprovals: [],
-        overlay: state.overlay?.kind === "approval" ? null : state.overlay
-      });
-    // The rewound message comes back as a draft to edit and resend, so it lands
-    // as if just typed: history is not being browsed, and nothing is parked.
-    case "inputPrefilled":
-      if (stale(state, action.sessionId)) return step(state);
-      return step({
-        ...state,
-        focus: "chat",
-        editor: { ...state.editor, text: action.text, cursor: action.text.length, historyIndex: state.editor.history.length, draft: "" }
-      });
-    case "runnersLoaded":
-      return step(refillPicker({
-        ...state,
-        runners: action.runners,
-        orchestratorModel: action.orchestratorModel ?? state.orchestratorModel
-      }, ["set-planner", "set-task-runner"]));
-    case "failed":
-      return step({ ...say(state, "error", action.message), status: "idle", busyLabel: "", thinkingLine: "" });
-    case "workspaceNeedsInit":
-      return step({
-        ...state,
-        status: "idle",
-        busyLabel: "",
-        thinkingLine: "",
-        overlay: {
-          kind: "confirm",
-          title: "Initialize new workspace?",
-          message: `"${action.workspace}" isn't a recognized project yet (no .git or manifest found). Start a new ordewell workspace here?`,
-          action: { kind: "init-workspace", goal: action.goal, workspace: action.workspace }
-        }
-      });
-    case "notice":
-      return step(say(state, "system", action.message));
-    case "resize": {
-      const resized = { ...state, rows: action.rows, cols: action.cols, selection: null };
-      return step(settlePlan({ ...resized, scroll: clamp(resized.scroll, chatScrollMax(resized)) }));
-    }
-    // Whether there is anything to animate is the app loop's call (it owns the
-    // timer); a tick that arrives simply advances the frame.
-    case "spinnerTick":
-      return step({ ...state, spinnerFrame: (state.spinnerFrame + 1) % 10 });
-  }
-}
-var planText = (value, fallback = "") => sanitize(String(value ?? fallback));
-var planLabel = (value, fallback = "") => planText(value, fallback).replace(/\n+/g, " ");
-function normalizeTasks(plan) {
-  const source = plan;
-  const byId = /* @__PURE__ */ new Map();
-  for (const list of [source?.pendingTasks, source?.executionLog]) {
-    for (const task of list ?? []) {
-      byId.set(String(task.id), task);
-    }
-  }
-  const raw = byId.size > 0 ? [...byId.values()].sort((a, b) => (a.order ?? 0) - (b.order ?? 0)) : source?.tasks ?? [];
-  return raw.map((t, i) => toTaskView2(t, i));
-}
-function toTaskView2(t, index) {
-  return {
-    id: String(t.id ?? `task-${index + 1}`),
-    order: typeof t.order === "number" ? t.order : index + 1,
-    title: planLabel(t.title, "Untitled task"),
-    description: planText(t.description ?? t.title),
-    prompt: typeof t.prompt === "string" ? sanitize(t.prompt) : void 0,
-    type: t.type === "user" ? "user" : "ai",
-    status: planLabel(t.status, "pending"),
-    dependencies: Array.isArray(t.dependencies) ? t.dependencies.map((id) => planLabel(id)) : [],
-    assignedRunner: typeof t.assignedRunner === "string" ? planLabel(t.assignedRunner) : void 0,
-    taskMode: typeof t.taskMode === "string" ? planLabel(t.taskMode) : void 0,
-    assignedModel: t.assignedModel && typeof t.assignedModel === "object" ? {
-      modelId: planLabel(t.assignedModel.modelId),
-      modelLabel: planLabel(t.assignedModel.modelLabel ?? t.assignedModel.modelId),
-      thinkingEffort: typeof t.assignedModel.thinkingEffort === "string" ? planLabel(t.assignedModel.thinkingEffort) : typeof t.thinkingEffort === "string" ? planLabel(t.thinkingEffort) : void 0,
-      availableVariants: Array.isArray(t.assignedModel.availableVariants) ? t.assignedModel.availableVariants.map((variant) => planLabel(variant)) : void 0
-    } : void 0,
-    subtasks: Array.isArray(t.subtasks) ? [...t.subtasks].sort((a, b) => (a.order ?? 0) - (b.order ?? 0)).map((s, i) => toTaskView2(s, i)) : void 0
-  };
-}
-var enabledFlag = (value) => typeof value?.enabled === "boolean" ? value.enabled : void 0;
-function applySettings(state, settings) {
-  const sources = {
-    tdd: settings.tdd,
-    verify: settings.verification
-  };
-  const skills = { ...state.skills };
-  for (const id of SKILL_IDS) {
-    const flag2 = enabledFlag(sources[id]);
-    if (flag2 !== void 0) skills[id] = flag2;
-  }
-  return {
-    ...state,
-    skills,
-    orchestratorModel: typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : state.orchestratorModel,
-    plannerProvider: typeof settings.aiProvider === "string" ? settings.aiProvider : state.plannerProvider,
-    plannerEffort: typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : state.plannerEffort,
-    maxParallel: typeof settings.maxParallel === "number" ? settings.maxParallel : state.maxParallel,
-    allowlist: settings.modelAllowlist && typeof settings.modelAllowlist === "object" ? settings.modelAllowlist : state.allowlist
-  };
-}
-function refillPicker(state, kinds) {
-  const overlay = state.overlay;
-  if (overlay?.kind !== "picker" || !kinds.includes(overlay.picker.action.kind)) return state;
-  const items = pickerItemsFor(state, overlay.picker.action);
-  const hint = overlay.picker.action.kind === "set-model" ? providerErrorHint(state) : overlay.picker.hint;
-  return { ...state, overlay: { kind: "picker", picker: { ...overlay.picker, items, hint, index: 0 } } };
-}
-function modelDetail(m) {
-  return [m.provider, m.pricing].filter(Boolean).join(" \xB7 ") || void 0;
-}
-function providerErrorHint(state) {
-  const failed = Object.keys(state.providerErrors ?? {});
-  if (failed.length === 0) return void 0;
-  const names = failed.map((p) => import_core20.ALL_PROVIDERS[p]?.label ?? p);
-  return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")} \u2014 showing working providers only.`;
-}
-function plannerModelItems(state) {
-  const runner = (0, import_core20.runnerForProvider)(state.plannerProvider);
-  if (!runner) return state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m) }));
-  const items = state.models.filter((m) => m.runners?.includes(runner)).map((m) => ({
-    id: m.id,
-    label: m.label,
-    detail: [
-      m.provider,
-      m.variants?.length ? `${m.variants.length} effort level${m.variants.length === 1 ? "" : "s"}` : "runner default effort"
-    ].filter(Boolean).join(" \xB7 "),
-    selected: m.id === state.orchestratorModel
-  }));
-  return items.length > 0 ? items : [{ id: "", label: `No ${runner} models discovered yet`, detail: "run /refresh", disabled: true }];
-}
-function plannerEffortItems(state) {
-  const runner = (0, import_core20.runnerForProvider)(state.plannerProvider);
-  if (!runner) {
-    return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
-  }
-  const model = state.models.find((m) => m.id === state.orchestratorModel && m.runners?.includes(runner));
-  if (!model) {
-    return [{ id: "", label: "No planner model selected", detail: "pick one with /model", disabled: true }];
-  }
-  const variants = model.variants ?? [];
-  if (variants.length === 0) {
-    return [{ id: "", label: `${model.label} exposes no effort levels`, detail: "it always runs at the agent's default", disabled: true }];
-  }
-  return [
-    { id: DEFAULT_EFFORT, label: "Runner default", detail: "Let the agent choose", selected: !state.plannerEffort },
-    ...variants.map((v) => ({ id: v.id, label: v.label, selected: v.id === state.plannerEffort }))
-  ];
+  return [
+    { id: DEFAULT_EFFORT, label: "Runner default", detail: "Let the agent choose", selected: !state.plannerEffort },
+    ...variants.map((v) => ({ id: v.id, label: v.label, selected: v.id === state.plannerEffort }))
+  ];
 }
 function pickerItemsFor(state, action) {
   if (action.kind === "set-model") {
@@ -5168,7 +5108,7 @@ function pickerItemsFor(state, action) {
     }));
   }
   if (action.kind === "set-task-deps") {
-    return (0, import_plan_utils3.dependencyCandidates)(state.tasks, action.taskId).map((candidate) => ({
+    return (0, import_plan_utils2.dependencyCandidates)(state.tasks, action.taskId).map((candidate) => ({
       id: candidate.id,
       label: `#${candidate.order} ${candidate.title}`,
       detail: candidate.status === "completed" ? "already completed" : void 0
@@ -5213,6 +5153,29 @@ function pickerItemsFor(state, action) {
   }
   return [];
 }
+function plannerItems(state) {
+  const installed = new Set(state.runners.map((r) => r.id));
+  const agents = import_core23.CLI_PROVIDERS.map((id) => {
+    const runner = (0, import_core23.runnerForProvider)(id);
+    const ready = installed.has(runner);
+    return {
+      id,
+      label: import_core23.ALL_PROVIDERS[id].label,
+      detail: ready ? "coding agent \xB7 no API key needed" : "CLI not installed or not on PATH",
+      selected: state.plannerProvider === id,
+      disabled: !ready
+    };
+  });
+  const vendors = import_core23.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
+    id,
+    label: import_core23.ALL_PROVIDERS[id].label,
+    detail: import_core23.ALL_PROVIDERS[id].apiKeyEnvVar,
+    selected: state.plannerProvider === id
+  }));
+  return vendors.length > 0 ? [...agents, ...vendors] : [...agents, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
+}
+
+// src/tui/reducers/pointer.ts
 var WHEEL_NOTCH = 3;
 function pageNotch(viewport) {
   return Math.max(1, viewport - 1);
@@ -5225,6 +5188,7 @@ function scrollDelta(key, state) {
   return null;
 }
 var isWheel = (key) => key.name === "scrollup" || key.name === "scrolldown";
+var isMouseSelect = (key) => key.name === "mousedown" || key.name === "mousedrag" || key.name === "mouseup";
 function pointerPane(state, key) {
   if (key.col === void 0 || planPaneWidth(state) === 0) return state.focus;
   return key.col <= chatPaneWidth(state) ? "chat" : "plan";
@@ -5233,7 +5197,34 @@ function scrollPointed(state, key) {
   const delta = key.name === "scrollup" ? WHEEL_NOTCH : -WHEEL_NOTCH;
   return pointerPane(state, key) === "plan" ? scrollPlan(state, delta, false) : scrollChat(state, delta);
 }
-var isMouseSelect = (key) => key.name === "mousedown" || key.name === "mousedrag" || key.name === "mouseup";
+function scrollChat(state, delta) {
+  return step({ ...state, scroll: clamp(state.scroll + delta, chatScrollMax(state)) });
+}
+function toggleDetail(state) {
+  const flipped = { ...state, detailAll: !state.detailAll };
+  const bound = chatScrollMax(state);
+  const expanded = chatScrollMax(flipped);
+  const scroll = flipped.scroll === 0 ? 0 : clamp(flipped.scroll + expanded - bound, expanded);
+  return step({ ...flipped, scroll });
+}
+function settlePlan(state) {
+  if (planPaneWidth(state) === 0) return state;
+  const layout = planScrollExtent(state);
+  return { ...state, planScroll: revealOffset(layout, planOffset(layout, state.planScroll), layout.anchor) };
+}
+function scrollPlan(state, delta, paged) {
+  const layout = planScrollExtent(state);
+  const from = planOffset(layout, state.planScroll);
+  const to = clamp(from - delta, layout.maxScroll);
+  const scrolled = { ...state, planScroll: to };
+  if (state.taskEditor || layout.rowSpans.length === 0) return step(scrolled);
+  const back = delta > 0;
+  if (!paged) {
+    return step({ ...scrolled, selectedTask: rowNearestView(layout, to, state.selectedTask) });
+  }
+  if (to === from) return step({ ...scrolled, selectedTask: back ? 0 : layout.rowSpans.length - 1 });
+  return step({ ...scrolled, selectedTask: back ? bottomRowInView(layout, to) : topRowInView(layout, to) });
+}
 function selectionCell(state, pane, key) {
   const { first, last } = paneColumns(state, pane);
   return {
@@ -5258,393 +5249,358 @@ function handleMouseSelect(state, key) {
   if (isClick(moved)) return step({ ...state, selection: null });
   return step({ ...state, selection: null }, [{ type: "copyText", text: selectedText({ ...state, selection: moved }) }]);
 }
-function clamp(value, max) {
-  return Math.max(0, Math.min(max, value));
-}
-function scrollChat(state, delta) {
-  return step({ ...state, scroll: clamp(state.scroll + delta, chatScrollMax(state)) });
-}
-function settlePlan(state) {
-  if (planPaneWidth(state) === 0) return state;
-  const layout = planScrollExtent(state);
-  return { ...state, planScroll: revealOffset(layout, planOffset(layout, state.planScroll), layout.anchor) };
-}
-function scrollPlan(state, delta, paged) {
-  const layout = planScrollExtent(state);
-  const from = planOffset(layout, state.planScroll);
-  const to = clamp(from - delta, layout.maxScroll);
-  const scrolled = { ...state, planScroll: to };
-  if (state.taskEditor || layout.rowSpans.length === 0) return step(scrolled);
-  const back = delta > 0;
-  if (!paged) {
-    return step({ ...scrolled, selectedTask: rowNearestView(layout, to, state.selectedTask) });
-  }
-  if (to === from) return step({ ...scrolled, selectedTask: back ? 0 : layout.rowSpans.length - 1 });
-  return step({ ...scrolled, selectedTask: back ? bottomRowInView(layout, to) : topRowInView(layout, to) });
-}
-var plannerInFlight = (state) => state.status === "planning" || state.status === "researching";
-function stopPlanning(state, sessionId) {
-  const dismissed = state.overlay?.kind === "approval" ? { ...state, overlay: null, pendingApprovals: [] } : state;
-  return step(dismissed, [{ type: "cancelPlanning", sessionId }]);
-}
-function handleKey2(state, key) {
-  if (key.name === "ctrl-c") return interrupt(state);
-  if (key.name === "ctrl-d" && !state.editor.text && !state.overlay) {
-    return step({ ...state, exiting: true }, [{ type: "exit" }]);
-  }
-  if (key.name === "ctrl-l") return step({ ...state, messages: [] });
-  if (key.name === "escape" && plannerInFlight(state) && state.sessionId && (!state.overlay || state.overlay.kind === "approval")) {
-    return stopPlanning(state, state.sessionId);
-  }
-  if (state.overlay) return handleOverlayKey(state, state.overlay, key);
-  if (isWheel(key)) return scrollPointed(state, key);
-  if (isMouseSelect(key)) return handleMouseSelect(state, key);
-  if (key.name === "wheelignored") return step(state);
-  if (key.name === "tab" && state.focus === "chat") {
-    const token = activeToken(state.editor.text, state.editor.cursor);
-    const matches = token ? tokenCompletions(token) : [];
-    if (token && matches.length > 0) {
-      const { text: full } = state.editor;
-      const completed = `/${matches[0].name} `;
-      const text = full.slice(0, token.start) + completed + full.slice(token.end);
-      return step({ ...state, editor: { ...state.editor, text, cursor: token.start + completed.length } });
+
+// src/tui/reducers/taskEdits.ts
+var import_plan_utils3 = require("@ordewell/core/plan-utils");
+function openTaskRunnerPicker(state, task) {
+  if (task.type !== "ai") return fail3(state, "Manual tasks do not run on an executor, so they have no runner.");
+  const action = { kind: "set-task-runner", taskId: task.id };
+  return step(
+    {
+      ...state,
+      overlay: {
+        kind: "picker",
+        picker: picker(`Runner \xB7 #${task.order} ${task.title}`, pickerItemsFor(state, action), action, {
+          hint: "Changing the runner re-picks this task model, effort and mode for it."
+        })
+      }
     }
-  }
-  if (key.name === "tab") {
-    if (state.focus === "chat" && state.tasks.length === 0) return step(state);
-    return step({ ...state, focus: state.focus === "chat" ? "plan" : "chat" });
-  }
-  if (state.focus === "plan") return handlePlanKey(state, key);
-  if (key.name === "enter") return submit(state);
-  if (key.name === "escape") return step({ ...state, editor: { ...state.editor, text: "", cursor: 0 } });
-  const scroll = scrollDelta(key, state);
-  if (scroll !== null) return scrollChat(state, scroll);
-  const multilineEditor = state.editor.text.includes("\n");
-  const room = chatEditorRoom(state.cols, true);
-  return step({ ...state, editor: applyKey(state.editor, key, multilineEditor ? room : void 0) });
-}
-function interrupt(state) {
-  if (state.overlay) return step({ ...state, overlay: null });
-  if (state.editor.text) return step({ ...state, editor: { ...state.editor, text: "", cursor: 0 } });
-  return step({ ...state, exiting: true }, [{ type: "exit" }]);
-}
-var PLAN_SHORTCUTS = {
-  c: "cancel",
-  f: "force-start",
-  s: "skip"
-};
-var SPAWNS_RUNNER = ["force-start", "retry"];
-function taskActionEffect(state, sessionId, taskId, action) {
-  const watch = SPAWNS_RUNNER.includes(action) && state.status !== "executing";
-  return watch ? { type: "taskAction", sessionId, taskId, action, watch: true } : { type: "taskAction", sessionId, taskId, action };
+  );
 }
-function markAction(task) {
-  return task.status === "completed" ? "uncomplete" : "complete";
+function confirmRemoveTask(state, task) {
+  const dependents = (0, import_plan_utils3.dependentsOf)(state.tasks, task.id);
+  const named = dependents.map((t) => `#${t.order} ${t.title}`).join(", ");
+  return step({
+    ...state,
+    overlay: {
+      kind: "confirm",
+      title: `Remove #${task.order} ${task.title}?`,
+      message: dependents.length > 0 ? `${dependents.length === 1 ? "1 task depends" : `${dependents.length} tasks depend`} on it and will lose that dependency: ${named}.` : "This cannot be undone.",
+      action: { kind: "remove-task", taskId: task.id }
+    }
+  });
 }
-function handlePlanKey(state, key) {
-  const editingTask = state.expandedTaskId ? findTask(state.tasks, state.expandedTaskId) : void 0;
-  if (editingTask && state.taskEditor) return handleTaskEditKey(state, editingTask, state.taskEditor, key);
-  if (key.name === "escape") {
-    if (state.expandedTaskId) return step(settlePlan({ ...state, expandedTaskId: null }));
-    return step({ ...state, focus: "chat" });
-  }
-  if (key.name === "up") {
-    return step(settlePlan({ ...state, selectedTask: Math.max(0, state.selectedTask - 1) }));
-  }
-  if (key.name === "down") {
-    return step(settlePlan({ ...state, selectedTask: clampSelection(state.selectedTask + 1, planRows(state).length) }));
-  }
-  const scroll = scrollDelta(key, state);
-  if (scroll !== null) return scrollPlan(state, scroll, true);
-  if (key.name === "char" && key.char === "a") return addTask(state, "");
-  const row = selectedPlanRow(state);
-  if (!row) return step(state);
-  const task = row.task;
-  if (key.name === "enter" || key.name === "right") {
-    const hasSubtasks = (task.subtasks?.length ?? 0) > 0;
-    if (hasSubtasks && state.expandedTaskId !== task.id) {
-      return step(settlePlan({ ...state, expandedTaskId: task.id, taskEditor: null }));
+function openTaskDepsPicker(state, task) {
+  const action = { kind: "set-task-deps", taskId: task.id };
+  const items = pickerItemsFor(state, action);
+  if (items.length === 0) return fail3(state, `Nothing runs before #${task.order}, so it has no possible dependencies.`);
+  return step({
+    ...state,
+    overlay: {
+      kind: "picker",
+      picker: picker(`Depends on \xB7 #${task.order} ${task.title}`, items, action, {
+        hint: "Only tasks earlier in the plan can be dependencies.",
+        multi: true,
+        chosen: task.dependencies.filter((id) => items.some((i) => i.id === id))
+      })
     }
-    const text = task.prompt ?? task.description ?? task.title;
-    return step(settlePlan({
-      ...state,
-      expandedTaskId: task.id,
-      taskEditor: { ...emptyEditor(), text, cursor: text.length }
-    }));
-  }
-  if (!state.sessionId || key.name !== "char") return step(state);
-  if (key.char === "E") return step(state, [{ type: "execute", sessionId: state.sessionId }]);
-  const action = key.char === "m" ? markAction(task) : PLAN_SHORTCUTS[key.char ?? ""];
-  if (action) {
-    return step(state, [taskActionEffect(state, state.sessionId, task.id, action)]);
-  }
-  if (key.char === "d") return confirmRemoveTask(state, task);
-  if (key.char === "t") {
-    return step(state, [{ type: "openTaskTerminal", sessionId: state.sessionId, taskId: task.id }]);
-  }
-  if (key.char === "x" && task.isolation?.state === "conflict") {
-    return step(state, [{ type: "resolveConflict", sessionId: state.sessionId, taskId: task.id }]);
+  });
+}
+function openTaskModePicker(state, task) {
+  if (task.type !== "ai") return fail3(state, "Manual tasks do not have an executor mode.");
+  const modes = modesForTask(state.modesByRunner, task);
+  if (modes.length === 0) {
+    return fail3(state, `${task.assignedRunner ?? "This runner"} declares no modes.`);
   }
-  if (key.char === "R") return openTaskRunnerPicker(state, task);
-  if (key.char === "o") return openTaskModelPicker(state, task);
-  if (key.char === "e") return openTaskEffortPicker(state, task);
-  if (key.char === "M") return openTaskModePicker(state, task);
-  if (key.char === "D") return openTaskDepsPicker(state, task);
-  return step(state);
+  const action = { kind: "set-task-mode", taskId: task.id };
+  return step(
+    {
+      ...state,
+      overlay: {
+        kind: "picker",
+        picker: picker(`Mode \xB7 #${task.order}`, pickerItemsFor(state, action), action, {
+          hint: `Modes declared by ${task.assignedRunner}.`
+        })
+      }
+    }
+  );
 }
-function handleTaskEditKey(state, task, editor, key) {
-  if (key.name === "enter") return commitTaskEdit(state, task, editor);
-  if (key.name === "escape") return step(settlePlan({ ...state, expandedTaskId: null, taskEditor: null }));
-  const scroll = scrollDelta(key, state);
-  if (scroll !== null) return scrollPlan(state, scroll, true);
-  return step(settlePlan({ ...state, taskEditor: applyKey(editor, key, taskEditorRoom(state)) }));
+function openTaskModelPicker(state, task) {
+  if (task.type !== "ai") return fail3(state, "Manual tasks do not have an executor model.");
+  const action = { kind: "set-task-model", taskId: task.id };
+  return step(
+    {
+      ...state,
+      overlay: {
+        kind: "picker",
+        picker: picker(`Model \xB7 #${task.order} ${task.title}`, pickerItemsFor(state, action), action, {
+          hint: task.assignedRunner ? `Showing models discovered for ${task.assignedRunner}.` : "Choose the model this task will run with."
+        })
+      }
+    },
+    [{ type: "loadModels" }]
+  );
 }
-function commitTaskEdit(state, task, editor) {
-  const collapsed = settlePlan({ ...state, expandedTaskId: null, taskEditor: null });
-  const prompt = editor.text.trim();
-  const original = task.prompt ?? task.description ?? task.title;
-  if (!prompt || prompt === original || !state.sessionId) return step(collapsed);
-  return step(collapsed, [{
+function openTaskEffortPicker(state, task) {
+  if (task.type !== "ai") return fail3(state, "Manual tasks do not have a thinking effort.");
+  if (!task.assignedModel) return fail3(state, "Choose a model for this task before setting its thinking effort.");
+  const action = { kind: "set-task-effort", taskId: task.id };
+  return step(
+    {
+      ...state,
+      overlay: {
+        kind: "picker",
+        picker: picker(`Thinking effort \xB7 #${task.order}`, pickerItemsFor(state, action), action, {
+          hint: `${task.assignedModel.modelLabel} \xB7 choose runner default or a supported effort`
+        })
+      }
+    },
+    [{ type: "loadModels" }]
+  );
+}
+function assignTaskModel(state, sessionId, task, model) {
+  const assignedModel = assignedModelFor(model, task.assignedModel?.thinkingEffort);
+  return step(state, [{
     type: "updateTask",
-    sessionId: state.sessionId,
+    sessionId,
     taskId: task.id,
-    changes: { prompt },
-    message: `Task #${task.order} prompt updated.`
+    // JSON drops `undefined`; null is intentional here so changing models can
+    // also clear a stale legacy top-level effort on the persisted task.
+    changes: { assignedModel, thinkingEffort: assignedModel.thinkingEffort ?? null },
+    message: `Task #${task.order} model set to ${model.label}.`
   }]);
 }
-function enqueueApproval(state, request) {
-  const open = state.overlay?.kind === "approval" ? state.overlay.request : null;
-  if (open?.id === request.id) return state;
-  if (state.pendingApprovals.some((p) => p.id === request.id)) return state;
-  if (open) return { ...state, pendingApprovals: [...state.pendingApprovals, request] };
-  return { ...state, overlay: { kind: "approval", request } };
+function assignTaskRunner(state, sessionId, task, runner, runnerLabel) {
+  return step(state, [{
+    type: "updateTask",
+    sessionId,
+    taskId: task.id,
+    changes: { assignedRunner: runner },
+    message: `Task #${task.order} runner set to ${runnerLabel}.`
+  }]);
 }
-function dropApproval(state, approvalId) {
-  const pending = state.pendingApprovals.filter((p) => p.id !== approvalId);
-  const open = state.overlay?.kind === "approval" ? state.overlay.request : null;
-  if (open?.id !== approvalId) return { ...state, pendingApprovals: pending };
-  return showNextApproval({ ...state, pendingApprovals: pending, overlay: null });
+function assignTaskMode(state, sessionId, task, mode, modeLabel) {
+  return step(state, [{
+    type: "updateTask",
+    sessionId,
+    taskId: task.id,
+    changes: { taskMode: mode },
+    message: `Task #${task.order} mode set to ${modeLabel}.`
+  }]);
 }
-function showNextApproval(state) {
-  const [next, ...rest] = state.pendingApprovals;
-  if (!next) return { ...state, overlay: null };
-  return { ...state, overlay: { kind: "approval", request: next }, pendingApprovals: rest };
+function assignTaskEffort(state, sessionId, task, thinkingEffort) {
+  const assignedModel = task.assignedModel ? { ...task.assignedModel, thinkingEffort } : void 0;
+  return step(state, [{
+    type: "updateTask",
+    sessionId,
+    taskId: task.id,
+    changes: { assignedModel, thinkingEffort: thinkingEffort ?? null },
+    message: `Task #${task.order} thinking effort set to ${thinkingEffort ?? "runner default"}.`
+  }]);
 }
-function handleApprovalKey(state, overlay, key) {
-  const grant = key.name === "enter" || key.char === "y" || key.char === "Y";
-  const deny = key.name === "escape" || key.char === "n" || key.char === "N";
-  if (!grant && !deny) return step(state);
-  const { request } = overlay;
-  const verdict = grant ? "approved" : "denied";
-  const noted = say(showNextApproval({ ...state, overlay: null }), "system", `Approval ${verdict}: ${request.subject}`);
-  return step(noted, state.sessionId ? [{ type: "respondApproval", sessionId: state.sessionId, approvalId: request.id, granted: grant }] : []);
+function taskModelCommand(state, args) {
+  return taskCommand(state, args[0], (sessionId, taskId) => {
+    const task = findTask(state.tasks, taskId);
+    if (!args[1]) return openTaskModelPicker(state, task);
+    const model = state.models.find((candidate) => candidate.id === args[1]) ?? {
+      id: args[1],
+      label: args[1],
+      provider: "",
+      variants: []
+    };
+    if (!runnerAccepts(task, model)) {
+      return fail3(state, `${model.label} was not discovered for ${task.assignedRunner}.`);
+    }
+    return assignTaskModel(state, sessionId, task, model);
+  });
 }
-function handleOverlayKey(state, overlay, key) {
-  if (overlay.kind === "help") return handleHelpKey(state, overlay.scroll ?? 0, key);
-  if (key.name === "wheelignored") return step(state);
-  if (overlay.kind === "handoff") return handleHandoffKey(state, overlay, key, bodyRows(state));
-  if (isWheel(key) && overlay.kind !== "picker") return scrollPointed(state, key);
-  if (overlay.kind === "approval") return handleApprovalKey(state, overlay, key);
-  if (overlay.kind === "confirm") return handleConfirmKey(state, overlay, key);
-  if (key.name === "escape" && overlay.kind === "picker" && overlay.picker.action.kind === "isolation-blocked") {
-    return chooseBlocked(state, "cancel");
-  }
-  if (key.name === "escape") return step({ ...state, overlay: null });
-  if (overlay.kind === "prompt") return handlePromptKey(state, overlay, key);
-  return handlePickerKey(state, overlay.picker, key);
+function taskRunnerCommand(state, args) {
+  return taskCommand(state, args[0], (sessionId, taskId) => {
+    const task = findTask(state.tasks, taskId);
+    if (!args[1]) return openTaskRunnerPicker(state, task);
+    const runner = state.runners.find((candidate) => candidate.id === args[1]);
+    if (!runner) return fail3(state, `Unknown runner "${args[1]}".`);
+    return assignTaskRunner(state, sessionId, task, runner.id, runner.name);
+  });
 }
-function handleConfirmKey(state, overlay, key) {
-  if (key.name === "escape") return step({ ...state, overlay: null });
-  const { choice } = overlay;
-  if (!choice) return key.name === "enter" ? runConfirm(state, overlay) : step(state);
-  if (key.name === "up" || key.name === "down") {
-    const index = clamp(choice.index + (key.name === "down" ? 1 : -1), choice.options.length - 1);
-    return step({ ...state, overlay: { ...overlay, choice: { ...choice, index } } });
-  }
-  const chosen = key.name === "enter" ? choice.index : key.name === "char" ? Number(key.char) - 1 : -1;
-  const option = choice.options[chosen];
-  if (!option) return step(state);
-  return option.confirms ? runConfirm(state, overlay) : step({ ...state, overlay: null });
+function taskModeCommand(state, args) {
+  return taskCommand(state, args[0], (sessionId, taskId) => {
+    const task = findTask(state.tasks, taskId);
+    if (!args[1]) return openTaskModePicker(state, task);
+    const mode = modesForTask(state.modesByRunner, task).find((candidate) => candidate.id === args[1]);
+    if (!mode) return fail3(state, `Unsupported mode "${args[1]}" for ${task.assignedRunner}.`);
+    return assignTaskMode(state, sessionId, task, mode.id, mode.label);
+  });
 }
-function runConfirm(state, overlay) {
-  const closed = { ...state, overlay: null };
-  if (overlay.action.kind === "new-session") return newSession(closed);
-  if (overlay.action.kind === "remove-task") {
-    if (!state.sessionId) return step(closed);
-    return step(closed, [{ type: "removeTask", sessionId: state.sessionId, taskId: overlay.action.taskId }]);
-  }
-  if (overlay.action.kind === "merge-run" || overlay.action.kind === "discard-run") {
-    return confirmedHandoff(state, overlay.action.kind);
+function taskEffortCommand(state, args) {
+  return taskCommand(state, args[0], (sessionId, taskId) => {
+    const task = findTask(state.tasks, taskId);
+    if (!args[1]) return openTaskEffortPicker(state, task);
+    if (!task.assignedModel) return fail3(state, "Choose a model for this task before setting its thinking effort.");
+    const effort = args[1].toLowerCase();
+    const value = effort === "default" || effort === "none" ? void 0 : args[1];
+    const supported = effortsForTask(state.models, task);
+    if (value && supported.length > 0 && !supported.some((variant) => variant.id === value)) {
+      return fail3(state, `Unsupported effort "${value}" for ${task.assignedModel.modelLabel}.`);
+    }
+    return assignTaskEffort(state, sessionId, task, value);
+  });
+}
+function addTask(state, title) {
+  if (!state.sessionId) {
+    return fail3(state, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
   }
-  if (overlay.action.kind === "init-workspace") {
-    return step({ ...closed, status: "planning" }, [{ type: "startConversation", goal: overlay.action.goal, allowInit: true }]);
+  if (!title) {
+    return step({
+      ...state,
+      overlay: { kind: "prompt", title: "New task title", value: "", action: { kind: "add-task" } }
+    });
   }
-  const { index } = overlay.action;
-  return withIdlePlanner(closed, (sessionId) => step(closed, [{ type: "rewindConversation", sessionId, index }]));
+  return step(state, [{ type: "addTask", sessionId: state.sessionId, title }]);
 }
-function handleHelpKey(state, scroll, key) {
-  const page = pageNotch(bodyRows(state));
-  const move = {
-    down: 1,
-    up: -1,
-    pagedown: page,
-    pageup: -page,
-    scrolldown: WHEEL_NOTCH,
-    scrollup: -WHEEL_NOTCH
-  };
-  const delta = move[key.name];
-  if (delta === void 0) return step({ ...state, overlay: null });
-  return step({ ...state, overlay: { kind: "help", scroll: clamp(scroll + delta, helpScrollMax(state)) } });
+function taskCommand(state, token, run) {
+  return withSession(state, (sessionId) => {
+    if (!token) return fail3(state, "Which task? Pass a task id or its number in the plan.");
+    const taskId = resolveTaskId2(state, token);
+    if (!taskId) return fail3(state, `No task matching "${token}" in the current plan.`);
+    return run(sessionId, taskId);
+  });
 }
-function handlePromptKey(state, overlay, key) {
-  if (key.name === "enter") {
-    const value2 = overlay.value.trim();
-    const closed = { ...state, overlay: null };
-    if (!value2) return step(closed);
-    if (overlay.action.kind === "api-key") {
-      return step(closed, [{ type: "setApiKey", provider: overlay.action.provider, key: value2 }]);
-    }
-    if (!state.sessionId) return fail3(closed, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
-    return step(closed, [{ type: "addTask", sessionId: state.sessionId, title: value2 }]);
+function resolveTaskId2(state, token) {
+  const byId = findTask(state.tasks, token);
+  if (byId) return byId.id;
+  const order = Number(token);
+  if (Number.isInteger(order)) {
+    const byOrder = state.tasks.find((t) => t.order === order);
+    if (byOrder) return byOrder.id;
   }
-  const value = editText(overlay.value, key);
-  return step({ ...state, overlay: { ...overlay, value } });
+  return null;
+}
+
+// src/tui/reducers/planPane.ts
+var PLAN_SHORTCUTS = {
+  c: "cancel",
+  f: "force-start",
+  s: "skip"
+};
+var SPAWNS_RUNNER = ["force-start", "retry"];
+function taskActionEffect(state, sessionId, taskId, action) {
+  const watch = SPAWNS_RUNNER.includes(action) && state.status !== "executing";
+  return watch ? { type: "taskAction", sessionId, taskId, action, watch: true } : { type: "taskAction", sessionId, taskId, action };
 }
-function editText(value, key) {
-  if (key.name === "char") return value + (key.char ?? "");
-  if (key.name === "paste") return value + (key.text ?? "").replace(/\n/g, " ");
-  if (key.name === "backspace") return value.slice(0, -1);
-  if (key.name === "ctrl-u") return "";
-  return value;
+function markAction(task) {
+  return task.status === "completed" ? "uncomplete" : "complete";
 }
-function handlePickerKey(state, picker2, key) {
-  const items = visibleItems(picker2);
-  const reopen = (next) => step({ ...state, overlay: { kind: "picker", picker: next } });
-  if (key.name === "up" || key.name === "scrollup") return reopen({ ...picker2, index: Math.max(0, picker2.index - 1) });
-  if (key.name === "down" || key.name === "scrolldown") {
-    return reopen({ ...picker2, index: Math.min(items.length - 1, picker2.index + 1) });
+function handlePlanKey(state, key) {
+  const editingTask = state.expandedTaskId ? findTask(state.tasks, state.expandedTaskId) : void 0;
+  if (editingTask && state.taskEditor) return handleTaskEditKey(state, editingTask, state.taskEditor, key);
+  if (key.name === "escape") {
+    if (state.expandedTaskId) return step(settlePlan({ ...state, expandedTaskId: null }));
+    return step({ ...state, focus: "chat" });
   }
-  if (picker2.multi && key.name === "char" && key.char === " ") {
-    const item = items[picker2.index];
-    if (!item) return reopen(picker2);
-    const chosen = picker2.chosen.includes(item.id) ? picker2.chosen.filter((id) => id !== item.id) : [...picker2.chosen, item.id];
-    return reopen({ ...picker2, chosen });
+  if (key.name === "up") {
+    return step(settlePlan({ ...state, selectedTask: Math.max(0, state.selectedTask - 1) }));
   }
-  if (key.name === "enter") return choose(state, picker2, items[picker2.index]);
-  const filter = editText(picker2.filter, key);
-  if (filter === picker2.filter) return reopen(picker2);
-  return reopen({ ...picker2, filter, index: 0 });
-}
-function choose(state, picker2, item) {
-  const closed = { ...state, overlay: null };
-  if (picker2.action.kind === "isolation-blocked") return chooseBlocked(state, item?.id ?? "cancel");
-  if (picker2.action.kind === "set-allowlist") {
-    return step(closed, [{ type: "setAllowlist", runner: picker2.action.runner, modelIds: picker2.chosen }]);
+  if (key.name === "down") {
+    return step(settlePlan({ ...state, selectedTask: clampSelection(state.selectedTask + 1, planRows(state).length) }));
   }
-  if (picker2.action.kind === "set-runners") {
-    const changes = state.runners.filter((runner) => runner.enabled !== picker2.chosen.includes(runner.id)).map((runner) => ({ runner: runner.id, enabled: !runner.enabled }));
-    if (changes.length === 0) return step(closed);
-    const names = state.runners.filter((r) => picker2.chosen.includes(r.id)).map((r) => r.name);
-    return step(closed, [{
-      type: "setRunners",
-      changes,
-      message: names.length > 0 ? `Runners enabled: ${names.join(", ")}.` : "No runners enabled \u2014 the planner has nothing to assign work to."
-    }]);
+  const scroll = scrollDelta(key, state);
+  if (scroll !== null) return scrollPlan(state, scroll, true);
+  if (key.name === "char" && key.char === "a") return addTask(state, "");
+  const row = selectedPlanRow(state);
+  if (!row) return step(state);
+  const task = row.task;
+  if (key.name === "enter" || key.name === "right") {
+    const hasSubtasks = (task.subtasks?.length ?? 0) > 0;
+    if (hasSubtasks && state.expandedTaskId !== task.id) {
+      return step(settlePlan({ ...state, expandedTaskId: task.id, taskEditor: null }));
+    }
+    const text = task.prompt ?? task.description ?? task.title;
+    return step(settlePlan({
+      ...state,
+      expandedTaskId: task.id,
+      taskEditor: { ...emptyEditor(), text, cursor: text.length }
+    }));
   }
-  if (picker2.action.kind === "set-task-deps") {
-    const taskId = picker2.action.taskId;
-    const task = findTask(state.tasks, taskId);
-    if (!task || !state.sessionId) return step(closed);
-    return step(closed, [{
-      type: "updateTask",
-      sessionId: state.sessionId,
-      taskId: task.id,
-      changes: { dependencies: picker2.chosen },
-      message: picker2.chosen.length > 0 ? `Task #${task.order} now depends on ${picker2.chosen.length} task${picker2.chosen.length === 1 ? "" : "s"}.` : `Task #${task.order} no longer depends on anything.`
-    }]);
+  if (!state.sessionId || key.name !== "char") return step(state);
+  if (key.char === "E") return step(state, [{ type: "execute", sessionId: state.sessionId }]);
+  if (key.char === "S") return step(state, [{ type: "stopExecution", sessionId: state.sessionId }]);
+  const action = key.char === "m" ? markAction(task) : PLAN_SHORTCUTS[key.char ?? ""];
+  if (action) {
+    return step(state, [taskActionEffect(state, state.sessionId, task.id, action)]);
   }
-  if (!item) return step(state);
-  if (item.disabled) {
-    return step(say(state, "error", item.detail ? `${item.label} \u2014 ${item.detail}` : `${item.label} is not available.`));
+  if (key.char === "d") return confirmRemoveTask(state, task);
+  if (key.char === "t") {
+    return step(state, [{ type: "openTaskTerminal", sessionId: state.sessionId, taskId: task.id }]);
   }
-  switch (picker2.action.kind) {
-    case "set-model":
-      return step(closed, [{ type: "setModel", modelId: item.id }]);
-    case "set-planner":
-      return step(closed, [{ type: "setPlanner", provider: item.id }]);
-    case "set-planner-effort":
-      return step(closed, [{ type: "setPlannerEffort", effort: item.id === DEFAULT_EFFORT ? "" : item.id }]);
-    case "load-session":
-      return step(closed, [{ type: "loadSession", sessionId: item.id }]);
-    case "rewind":
-      return pickRewindTarget(state, Number(item.id));
-    case "delete-session":
-      return step(closed, [{ type: "deleteSession", sessionId: item.id }]);
-    case "set-key":
-      return step({ ...state, overlay: keyPrompt(item.id) });
-    case "choose-allowlist-runner": {
-      const action = { kind: "set-allowlist", runner: item.id };
-      const items = pickerItemsFor(state, action);
-      if (items.length === 0) {
-        return step(say(state, "error", `No models discovered for ${item.label}. Run /refresh, then try again.`));
-      }
-      return step({
-        ...state,
-        overlay: {
-          kind: "picker",
-          picker: {
-            title: `Models allowed for ${item.label}`,
-            hint: "An empty selection lifts the restriction.",
-            items,
-            filter: "",
-            index: 0,
-            multi: true,
-            // Ids this runner doesn't serve can be sitting in a settings file
-            // written before the list was scoped; dropping them here means
-            // confirming the picker also repairs the stored allowlist.
-            chosen: (state.allowlist[item.id] ?? []).filter((id) => items.some((i) => i.id === id)),
-            action
-          }
-        }
-      });
-    }
-    case "set-task-runner": {
-      const taskId = picker2.action.taskId;
-      const task = findTask(state.tasks, taskId);
-      if (!task || !state.sessionId) return step(closed);
-      return assignTaskRunner(closed, state.sessionId, task, item.id, item.label);
-    }
-    case "set-task-mode": {
-      const taskId = picker2.action.taskId;
-      const task = findTask(state.tasks, taskId);
-      if (!task || !state.sessionId) return step(closed);
-      return assignTaskMode(closed, state.sessionId, task, item.id, item.label);
-    }
-    case "set-task-model": {
-      const taskId = picker2.action.taskId;
-      const task = findTask(state.tasks, taskId);
-      const model = state.models.find((candidate) => candidate.id === item.id);
-      if (!task || !model || !state.sessionId) return step(closed);
-      return assignTaskModel(closed, state.sessionId, task, model);
-    }
-    case "set-task-effort": {
-      const taskId = picker2.action.taskId;
-      const task = findTask(state.tasks, taskId);
-      if (!task || !state.sessionId) return step(closed);
-      return assignTaskEffort(closed, state.sessionId, task, item.id === DEFAULT_EFFORT ? void 0 : item.id);
-    }
+  if (key.char === "x" && task.isolation?.state === "conflict") {
+    return step(state, [{ type: "resolveConflict", sessionId: state.sessionId, taskId: task.id }]);
   }
+  if (key.char === "R") return openTaskRunnerPicker(state, task);
+  if (key.char === "o") return openTaskModelPicker(state, task);
+  if (key.char === "e") return openTaskEffortPicker(state, task);
+  if (key.char === "M") return openTaskModePicker(state, task);
+  if (key.char === "D") return openTaskDepsPicker(state, task);
+  return step(state);
 }
-function submit(state) {
-  const text = state.editor.text.trim();
-  if (!text) return step(state);
-  const cleared = { ...state, editor: commit(state.editor) };
-  const command = parseSlash(text);
-  if (command && findCommand(command.name)?.source !== "skill") return runCommand(cleared, command);
-  const spoken = say(cleared, "user", text);
-  const effect = state.sessionId ? { type: "sendMessage", sessionId: state.sessionId, message: text } : { type: "startConversation", goal: text };
-  return step({ ...spoken, status: "planning" }, [effect]);
+function handleTaskEditKey(state, task, editor, key) {
+  if (key.name === "enter") return commitTaskEdit(state, task, editor);
+  if (key.name === "escape") return step(settlePlan({ ...state, expandedTaskId: null, taskEditor: null }));
+  const scroll = scrollDelta(key, state);
+  if (scroll !== null) return scrollPlan(state, scroll, true);
+  return step(settlePlan({ ...state, taskEditor: applyKey(editor, key, taskEditorRoom(state)) }));
+}
+function commitTaskEdit(state, task, editor) {
+  const collapsed = settlePlan({ ...state, expandedTaskId: null, taskEditor: null });
+  const prompt = editor.text.trim();
+  const original = task.prompt ?? task.description ?? task.title;
+  if (!prompt || prompt === original || !state.sessionId) return step(collapsed);
+  return step(collapsed, [{
+    type: "updateTask",
+    sessionId: state.sessionId,
+    taskId: task.id,
+    changes: { prompt },
+    message: `Task #${task.order} prompt updated.`
+  }]);
+}
+
+// src/tui/reducers/turnQueue.ts
+var import_core24 = require("@ordewell/core");
+function drainQueue(state, settled) {
+  const next = (0, import_core24.drainNext)(state.queuedPrompts);
+  const ended = disarmStop({ ...settled, stopRequested: false });
+  if (!next) return step(ended);
+  const spoken = say(ended, "user", next.text);
+  const effect = state.sessionId ? { type: "sendMessage", sessionId: state.sessionId, message: next.text } : null;
+  return step(
+    { ...spoken, queuedPrompts: next.rest, status: "planning", busyLabel: "" },
+    effect ? [effect] : []
+  );
+}
+function disarmStop(state) {
+  return state.stopArmed ? { ...state, stopArmed: false } : state;
+}
+var STOP_ARM_MS = 2e3;
+function stopPlanning(state, sessionId) {
+  const dismissed = state.overlay?.kind === "approval" ? { ...state, overlay: null, pendingApprovals: [] } : state;
+  return step(queueToEditor(cutTurn({ ...dismissed, stopArmed: false, stopRequested: true })), [{ type: "cancelPlanning", sessionId }]);
+}
+function queueToEditor(state) {
+  const all = (0, import_core24.unsendAll)(state.queuedPrompts);
+  if (!all) return state;
+  return { ...state, queuedPrompts: all.rest, editor: { ...state.editor, text: all.text, cursor: all.text.length } };
+}
+function unsendLatest(state) {
+  const latest = (0, import_core24.unsendLatest)(state.queuedPrompts);
+  if (!latest) return step(state);
+  const text = (0, import_core24.aheadOfDraft)(latest.text, state.editor.text);
+  return step({
+    ...state,
+    queuedPrompts: latest.rest,
+    stopArmed: false,
+    editor: { ...state.editor, text, cursor: latest.text.length, historyIndex: state.editor.history.length, draft: "" }
+  });
+}
+function plannerEscape(state) {
+  if (!plannerInFlight(state) || !state.sessionId || state.overlay && state.overlay.kind !== "approval") return null;
+  if (state.queuedPrompts.length > 0) return unsendLatest(state);
+  if (state.stopArmed) return stopPlanning(state, state.sessionId);
+  const arm = state.stopArmToken + 1;
+  return step({ ...state, stopArmed: true, stopArmToken: arm }, [{ type: "disarmStop", afterMs: STOP_ARM_MS, arm }]);
 }
+
+// src/tui/reducers/commands.ts
+var KNOWN_PROVIDERS2 = Object.keys(import_core25.ALL_PROVIDERS);
 function runCommand(state, { name, args }) {
   if (!findCommand(name)) {
     return fail3(state, `Unknown command: /${name} \u2014 type /help to see what's available.`);
@@ -5669,9 +5625,7 @@ function runCommand(state, { name, args }) {
     case "stop":
       return withSession(
         state,
-        (sessionId) => step(state, [
-          state.status === "planning" || state.status === "researching" ? { type: "cancelPlanning", sessionId } : { type: "stopExecution", sessionId }
-        ])
+        (sessionId) => plannerInFlight(state) ? stopPlanning(state, sessionId) : step(state, [{ type: "stopExecution", sessionId }])
       );
     case "model":
       return setModel(state, args);
@@ -5757,55 +5711,12 @@ function runCommand(state, { name, args }) {
   }
   return fail3(state, `/${name} is not wired up yet.`);
 }
-function picker(title, items, action, extra = {}) {
-  return { title, items, filter: "", index: 0, multi: false, chosen: [], action, ...extra };
-}
-function withSession(state, run) {
-  if (!state.sessionId) {
-    return fail3(state, "No active plan \u2014 describe a goal first, or load a session with /sessions.");
-  }
-  return run(state.sessionId);
-}
 function withIdlePlanner(state, run) {
   return withSession(
     state,
-    (sessionId) => state.status === "planning" || state.status === "researching" ? fail3(state, "The planner is still answering \u2014 wait for its reply, or /stop it first.") : run(sessionId)
+    (sessionId) => plannerInFlight(state) ? fail3(state, "The planner is still answering \u2014 wait for its reply, or /stop it first.") : run(sessionId)
   );
 }
-function rewind(state, arg) {
-  return withIdlePlanner(state, (sessionId) => {
-    if (arg === void 0) {
-      return step(
-        { ...state, rewindTargets: null, overlay: { kind: "picker", picker: picker("Rewind to before\u2026", [], { kind: "rewind" }, { hint: "Rewinding forks the conversation from just before the chosen message; the original is kept and the tasks ride along." }) } },
-        [{ type: "loadRewindTargets", sessionId }]
-      );
-    }
-    if (!/^\d+$/.test(arg)) return fail3(state, "Usage: /rewind [<message>] \u2014 or /rewind alone to pick one.");
-    return step(state, [{ type: "loadRewindTargets", sessionId, pick: Number(arg) }]);
-  });
-}
-var REWIND_OPTIONS = [
-  { label: "Restore Conversation", confirms: true },
-  { label: "Never mind", confirms: false }
-];
-function pickRewindTarget(state, index) {
-  return withIdlePlanner({ ...state, overlay: null }, () => {
-    const target = state.rewindTargets?.find((t) => t.index === index);
-    if (!target) return fail3({ ...state, overlay: null }, `No message ${index} to rewind to \u2014 /rewind alone lists them.`);
-    return step({
-      ...state,
-      overlay: {
-        kind: "confirm",
-        title: "Rewind",
-        message: "Confirm you want to restore to the point before you sent this message:",
-        quote: target.content,
-        note: "The conversation will be forked.\nThe code will be unchanged.",
-        action: { kind: "rewind", index },
-        choice: { options: REWIND_OPTIONS, index: 0 }
-      }
-    });
-  });
-}
 function resolveToggle(arg, current) {
   const value = arg?.toLowerCase();
   if (value === "on") return true;
@@ -5819,7 +5730,7 @@ function toggleSkill(state, skill, arg) {
   return step(state, [{ type: "command", name: skill, action: enabled ? "on" : "off" }]);
 }
 function requestNewSession(state) {
-  const hasContent = state.tasks.length > 0 || state.messages.length > 0 || state.goal !== "" || state.status !== "idle";
+  const hasContent = state.tasks.length > 0 || state.conversation.blocks.length > 0 || state.goal !== "" || state.status !== "idle";
   if (!state.sessionId || !hasContent) return newSession(state);
   return step({
     ...state,
@@ -5840,7 +5751,8 @@ function newSession(state) {
     goal: "",
     tasks: [],
     planApproved: false,
-    messages: [],
+    conversation: import_core25.EMPTY_CONVERSATION,
+    turnGate: import_core25.NO_TURN,
     selectedTask: 0,
     expandedTaskId: null,
     taskEditor: null,
@@ -5848,16 +5760,17 @@ function newSession(state) {
     planScroll: null,
     status: "idle",
     busyLabel: "",
-    thinkingLine: "",
     // Prompts belong to the session that raised them; the old planner is gone
     // and its pending requests deny on their own timeout.
     pendingApprovals: [],
+    queuedPrompts: import_core25.EMPTY_HOLD,
+    stopArmed: false,
     overlay: state.overlay?.kind === "approval" ? null : state.overlay
   }, closeEffects);
 }
 function setModel(state, args) {
   if (args[0] === "set" && args[1]) {
-    const runner = (0, import_core20.runnerForProvider)(state.plannerProvider);
+    const runner = (0, import_core25.runnerForProvider)(state.plannerProvider);
     const known = runner ? modelsForRunner(state.models, runner) : [];
     if (runner && known.length > 0 && !known.some((m) => m.id === args[1])) {
       return fail3(state, `${args[1]} was not discovered for ${runner}.`);
@@ -5877,27 +5790,6 @@ function setModel(state, args) {
     [{ type: "loadModels" }]
   );
 }
-function plannerItems(state) {
-  const installed = new Set(state.runners.map((r) => r.id));
-  const agents = import_core20.CLI_PROVIDERS.map((id) => {
-    const runner = (0, import_core20.runnerForProvider)(id);
-    const ready = installed.has(runner);
-    return {
-      id,
-      label: import_core20.ALL_PROVIDERS[id].label,
-      detail: ready ? "coding agent \xB7 no API key needed" : "CLI not installed or not on PATH",
-      selected: state.plannerProvider === id,
-      disabled: !ready
-    };
-  });
-  const vendors = import_core20.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
-    id,
-    label: import_core20.ALL_PROVIDERS[id].label,
-    detail: import_core20.ALL_PROVIDERS[id].apiKeyEnvVar,
-    selected: state.plannerProvider === id
-  }));
-  return vendors.length > 0 ? [...agents, ...vendors] : [...agents, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
-}
 function setPlanner(state, args) {
   if (args[0]) {
     const id = args[0].toLowerCase();
@@ -5951,16 +5843,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core20.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core25.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core20.ALL_PROVIDERS[id].label,
-    detail: import_core20.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core25.ALL_PROVIDERS[id].label,
+    detail: import_core25.ALL_PROVIDERS[id].apiKeyEnvVar,
     selected: state.configuredProviders.includes(id)
   }));
   return step({ ...state, overlay: { kind: "picker", picker: picker("API provider key", items, { kind: "set-key" }) } });
 }
 function keyPrompt(provider) {
-  const meta = import_core20.ALL_PROVIDERS[provider];
+  const meta = import_core25.ALL_PROVIDERS[provider];
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -6002,279 +5894,675 @@ function allowlist(state, args) {
         ...state,
         overlay: {
           kind: "picker",
-          picker: picker("Limit models for which runner?", items, { kind: "choose-allowlist-runner" })
+          picker: picker("Limit models for which runner?", items, { kind: "choose-allowlist-runner" })
+        }
+      },
+      // The model list the next picker is built from must be the runner's real
+      // one; refresh it while the user is still choosing a runner.
+      [{ type: "loadModels" }]
+    );
+  }
+  return fail3(state, "Usage: /allowlist [set <runner> <ids> | clear <runner>]");
+}
+function describeAllowlist(ids) {
+  if (!ids || ids.length === 0) return "no restriction";
+  return `${ids.length} model${ids.length === 1 ? "" : "s"} allowed`;
+}
+function runners(state, args) {
+  const [runner, arg] = args;
+  if (runner) {
+    const known = state.runners.find((r) => r.id === runner);
+    const enabled = resolveToggle(arg, known?.enabled ?? true);
+    if (enabled === null) return fail3(state, "Usage: /runners [<runner-id> on|off]");
+    return step(state, [{ type: "setRunnerEnabled", runner, enabled }]);
+  }
+  const action = { kind: "set-runners" };
+  const items = pickerItemsFor(state, action);
+  return step({ ...state, overlay: {
+    kind: "picker",
+    picker: picker("Runners", items, action, {
+      hint: "Enabled runners are the ones the planner may assign work to.",
+      multi: true,
+      chosen: state.runners.filter((r) => r.enabled).map((r) => r.id)
+    })
+  } });
+}
+function setMaxParallel(state, arg) {
+  if (!arg) return step(say(state, "system", `Up to ${state.maxParallel} AI task${state.maxParallel === 1 ? "" : "s"} run at once \u2014 /parallel <n> changes it.`));
+  const limit = (0, import_core25.parseMaxParallel)(arg);
+  if (limit === null) return fail3(state, "Usage: /parallel [<number of tasks, 1 or more>]");
+  return step({ ...state, maxParallel: limit }, [{ type: "setMaxParallel", limit }]);
+}
+function setAutonomous(state, arg) {
+  const enabled = resolveToggle(arg, state.autonomous);
+  if (enabled === null) return fail3(state, "Usage: /auto [on|off]");
+  return step({ ...state, autonomous: enabled }, [{ type: "setAutonomous", enabled }]);
+}
+function setMouseCapture(state, arg) {
+  const enabled = resolveToggle(arg, state.mouseCapture);
+  if (enabled === null) return fail3(state, "Usage: /mouse [on|off]");
+  const noted = say(
+    // A selection made under capture is meaningless once the terminal owns the
+    // mouse again, and its highlight would sit on screen with nothing able to
+    // move it.
+    { ...state, mouseCapture: enabled, selection: null },
+    "system",
+    enabled ? "Mouse capture on \u2014 the wheel scrolls, and dragging selects within one pane and copies on release." : "Mouse capture off \u2014 the terminal's own drag-select is back, across both panes; scroll with pgup/pgdn."
+  );
+  return step(noted, [{ type: "setMouseCapture", enabled }]);
+}
+function rewind(state, arg) {
+  return withIdlePlanner(state, (sessionId) => {
+    if (arg === void 0) {
+      return step(
+        { ...state, rewindTargets: null, overlay: { kind: "picker", picker: picker("Rewind to before\u2026", [], { kind: "rewind" }, { hint: "Rewinding forks the conversation from just before the chosen message; the original is kept and the tasks ride along." }) } },
+        [{ type: "loadRewindTargets", sessionId }]
+      );
+    }
+    if (!/^\d+$/.test(arg)) return fail3(state, "Usage: /rewind [<message>] \u2014 or /rewind alone to pick one.");
+    return step(state, [{ type: "loadRewindTargets", sessionId, pick: Number(arg) }]);
+  });
+}
+var REWIND_OPTIONS = [
+  { label: "Restore Conversation", confirms: true },
+  { label: "Never mind", confirms: false }
+];
+function pickRewindTarget(state, index) {
+  return withIdlePlanner({ ...state, overlay: null }, () => {
+    const target = state.rewindTargets?.find((t) => t.index === index);
+    if (!target) return fail3({ ...state, overlay: null }, `No message ${index} to rewind to \u2014 /rewind alone lists them.`);
+    return step({
+      ...state,
+      overlay: {
+        kind: "confirm",
+        title: "Rewind",
+        message: "Confirm you want to restore to the point before you sent this message:",
+        quote: target.content,
+        note: "The conversation will be forked.\nThe code will be unchanged.",
+        action: { kind: "rewind", index },
+        choice: { options: REWIND_OPTIONS, index: 0 }
+      }
+    });
+  });
+}
+
+// src/tui/reducers/overlays.ts
+function handleOverlayKey(state, overlay, key) {
+  if (overlay.kind === "help") return handleHelpKey(state, overlay.scroll ?? 0, key);
+  if (key.name === "wheelignored") return step(state);
+  if (overlay.kind === "handoff") return handleHandoffKey(state, overlay, key, bodyRows(state));
+  if (isWheel(key) && overlay.kind !== "picker") return scrollPointed(state, key);
+  if (overlay.kind === "approval") return handleApprovalKey(state, overlay, key);
+  if (overlay.kind === "confirm") return handleConfirmKey(state, overlay, key);
+  if (key.name === "escape" && overlay.kind === "picker" && overlay.picker.action.kind === "isolation-blocked") {
+    return chooseBlocked(state, "cancel");
+  }
+  if (key.name === "escape") return step({ ...state, overlay: null });
+  if (overlay.kind === "prompt") return handlePromptKey(state, overlay, key);
+  return handlePickerKey(state, overlay.picker, key);
+}
+function handleConfirmKey(state, overlay, key) {
+  if (key.name === "escape") return step({ ...state, overlay: null });
+  const { choice } = overlay;
+  if (!choice) return key.name === "enter" ? runConfirm(state, overlay) : step(state);
+  if (key.name === "up" || key.name === "down") {
+    const index = clamp(choice.index + (key.name === "down" ? 1 : -1), choice.options.length - 1);
+    return step({ ...state, overlay: { ...overlay, choice: { ...choice, index } } });
+  }
+  const chosen = key.name === "enter" ? choice.index : key.name === "char" ? Number(key.char) - 1 : -1;
+  const option = choice.options[chosen];
+  if (!option) return step(state);
+  return option.confirms ? runConfirm(state, overlay) : step({ ...state, overlay: null });
+}
+function runConfirm(state, overlay) {
+  const closed = { ...state, overlay: null };
+  if (overlay.action.kind === "new-session") return newSession(closed);
+  if (overlay.action.kind === "remove-task") {
+    if (!state.sessionId) return step(closed);
+    return step(closed, [{ type: "removeTask", sessionId: state.sessionId, taskId: overlay.action.taskId }]);
+  }
+  if (overlay.action.kind === "merge-run" || overlay.action.kind === "discard-run") {
+    return confirmedHandoff(state, overlay.action.kind);
+  }
+  if (overlay.action.kind === "init-workspace") {
+    return step({ ...closed, status: "planning" }, [{ type: "startConversation", goal: overlay.action.goal, allowInit: true }]);
+  }
+  const { index } = overlay.action;
+  return withIdlePlanner(closed, (sessionId) => step(closed, [{ type: "rewindConversation", sessionId, index }]));
+}
+function handleHelpKey(state, scroll, key) {
+  const page = pageNotch(bodyRows(state));
+  const move = {
+    down: 1,
+    up: -1,
+    pagedown: page,
+    pageup: -page,
+    scrolldown: WHEEL_NOTCH,
+    scrollup: -WHEEL_NOTCH
+  };
+  const delta = move[key.name];
+  if (delta === void 0) return step({ ...state, overlay: null });
+  return step({ ...state, overlay: { kind: "help", scroll: clamp(scroll + delta, helpScrollMax(state)) } });
+}
+function handlePromptKey(state, overlay, key) {
+  if (key.name === "enter") {
+    const value2 = overlay.value.trim();
+    const closed = { ...state, overlay: null };
+    if (!value2) return step(closed);
+    if (overlay.action.kind === "api-key") {
+      return step(closed, [{ type: "setApiKey", provider: overlay.action.provider, key: value2 }]);
+    }
+    if (!state.sessionId) return fail3(closed, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
+    return step(closed, [{ type: "addTask", sessionId: state.sessionId, title: value2 }]);
+  }
+  const value = editText(overlay.value, key);
+  return step({ ...state, overlay: { ...overlay, value } });
+}
+function editText(value, key) {
+  if (key.name === "char") return value + (key.char ?? "");
+  if (key.name === "paste") return value + (key.text ?? "").replace(/\n/g, " ");
+  if (key.name === "backspace") return value.slice(0, -1);
+  if (key.name === "ctrl-u") return "";
+  return value;
+}
+function handlePickerKey(state, picker2, key) {
+  const items = visibleItems(picker2);
+  const reopen = (next) => step({ ...state, overlay: { kind: "picker", picker: next } });
+  if (key.name === "up" || key.name === "scrollup") return reopen({ ...picker2, index: Math.max(0, picker2.index - 1) });
+  if (key.name === "down" || key.name === "scrolldown") {
+    return reopen({ ...picker2, index: Math.min(items.length - 1, picker2.index + 1) });
+  }
+  if (picker2.multi && key.name === "char" && key.char === " ") {
+    const item = items[picker2.index];
+    if (!item) return reopen(picker2);
+    const chosen = picker2.chosen.includes(item.id) ? picker2.chosen.filter((id) => id !== item.id) : [...picker2.chosen, item.id];
+    return reopen({ ...picker2, chosen });
+  }
+  if (key.name === "enter") return choose(state, picker2, items[picker2.index]);
+  const filter = editText(picker2.filter, key);
+  if (filter === picker2.filter) return reopen(picker2);
+  return reopen({ ...picker2, filter, index: 0 });
+}
+function choose(state, picker2, item) {
+  const closed = { ...state, overlay: null };
+  if (picker2.action.kind === "isolation-blocked") return chooseBlocked(state, item?.id ?? "cancel");
+  if (picker2.action.kind === "set-allowlist") {
+    return step(closed, [{ type: "setAllowlist", runner: picker2.action.runner, modelIds: picker2.chosen }]);
+  }
+  if (picker2.action.kind === "set-runners") {
+    const changes = state.runners.filter((runner) => runner.enabled !== picker2.chosen.includes(runner.id)).map((runner) => ({ runner: runner.id, enabled: !runner.enabled }));
+    if (changes.length === 0) return step(closed);
+    const names = state.runners.filter((r) => picker2.chosen.includes(r.id)).map((r) => r.name);
+    return step(closed, [{
+      type: "setRunners",
+      changes,
+      message: names.length > 0 ? `Runners enabled: ${names.join(", ")}.` : "No runners enabled \u2014 the planner has nothing to assign work to."
+    }]);
+  }
+  if (picker2.action.kind === "set-task-deps") {
+    const taskId = picker2.action.taskId;
+    const task = findTask(state.tasks, taskId);
+    if (!task || !state.sessionId) return step(closed);
+    return step(closed, [{
+      type: "updateTask",
+      sessionId: state.sessionId,
+      taskId: task.id,
+      changes: { dependencies: picker2.chosen },
+      message: picker2.chosen.length > 0 ? `Task #${task.order} now depends on ${picker2.chosen.length} task${picker2.chosen.length === 1 ? "" : "s"}.` : `Task #${task.order} no longer depends on anything.`
+    }]);
+  }
+  if (!item) return step(state);
+  if (item.disabled) {
+    return step(say(state, "error", item.detail ? `${item.label} \u2014 ${item.detail}` : `${item.label} is not available.`));
+  }
+  switch (picker2.action.kind) {
+    case "set-model":
+      return step(closed, [{ type: "setModel", modelId: item.id }]);
+    case "set-planner":
+      return step(closed, [{ type: "setPlanner", provider: item.id }]);
+    case "set-planner-effort":
+      return step(closed, [{ type: "setPlannerEffort", effort: item.id === DEFAULT_EFFORT ? "" : item.id }]);
+    case "load-session":
+      return step(closed, [{ type: "loadSession", sessionId: item.id }]);
+    case "rewind":
+      return pickRewindTarget(state, Number(item.id));
+    case "delete-session":
+      return step(closed, [{ type: "deleteSession", sessionId: item.id }]);
+    case "set-key":
+      return step({ ...state, overlay: keyPrompt(item.id) });
+    case "choose-allowlist-runner": {
+      const action = { kind: "set-allowlist", runner: item.id };
+      const items = pickerItemsFor(state, action);
+      if (items.length === 0) {
+        return step(say(state, "error", `No models discovered for ${item.label}. Run /refresh, then try again.`));
+      }
+      return step({
+        ...state,
+        overlay: {
+          kind: "picker",
+          picker: {
+            title: `Models allowed for ${item.label}`,
+            hint: "An empty selection lifts the restriction.",
+            items,
+            filter: "",
+            index: 0,
+            multi: true,
+            // Ids this runner doesn't serve can be sitting in a settings file
+            // written before the list was scoped; dropping them here means
+            // confirming the picker also repairs the stored allowlist.
+            chosen: (state.allowlist[item.id] ?? []).filter((id) => items.some((i) => i.id === id)),
+            action
+          }
         }
-      },
-      // The model list the next picker is built from must be the runner's real
-      // one; refresh it while the user is still choosing a runner.
-      [{ type: "loadModels" }]
-    );
-  }
-  return fail3(state, "Usage: /allowlist [set <runner> <ids> | clear <runner>]");
-}
-function describeAllowlist(ids) {
-  if (!ids || ids.length === 0) return "no restriction";
-  return `${ids.length} model${ids.length === 1 ? "" : "s"} allowed`;
-}
-function runners(state, args) {
-  const [runner, arg] = args;
-  if (runner) {
-    const known = state.runners.find((r) => r.id === runner);
-    const enabled = resolveToggle(arg, known?.enabled ?? true);
-    if (enabled === null) return fail3(state, "Usage: /runners [<runner-id> on|off]");
-    return step(state, [{ type: "setRunnerEnabled", runner, enabled }]);
+      });
+    }
+    case "set-task-runner": {
+      const taskId = picker2.action.taskId;
+      const task = findTask(state.tasks, taskId);
+      if (!task || !state.sessionId) return step(closed);
+      return assignTaskRunner(closed, state.sessionId, task, item.id, item.label);
+    }
+    case "set-task-mode": {
+      const taskId = picker2.action.taskId;
+      const task = findTask(state.tasks, taskId);
+      if (!task || !state.sessionId) return step(closed);
+      return assignTaskMode(closed, state.sessionId, task, item.id, item.label);
+    }
+    case "set-task-model": {
+      const taskId = picker2.action.taskId;
+      const task = findTask(state.tasks, taskId);
+      const model = state.models.find((candidate) => candidate.id === item.id);
+      if (!task || !model || !state.sessionId) return step(closed);
+      return assignTaskModel(closed, state.sessionId, task, model);
+    }
+    case "set-task-effort": {
+      const taskId = picker2.action.taskId;
+      const task = findTask(state.tasks, taskId);
+      if (!task || !state.sessionId) return step(closed);
+      return assignTaskEffort(closed, state.sessionId, task, item.id === DEFAULT_EFFORT ? void 0 : item.id);
+    }
   }
-  const action = { kind: "set-runners" };
-  const items = pickerItemsFor(state, action);
-  return step({ ...state, overlay: {
-    kind: "picker",
-    picker: picker("Runners", items, action, {
-      hint: "Enabled runners are the ones the planner may assign work to.",
-      multi: true,
-      chosen: state.runners.filter((r) => r.enabled).map((r) => r.id)
-    })
-  } });
-}
-function setMaxParallel(state, arg) {
-  if (!arg) return step(say(state, "system", `Up to ${state.maxParallel} AI task${state.maxParallel === 1 ? "" : "s"} run at once \u2014 /parallel <n> changes it.`));
-  const limit = (0, import_core20.parseMaxParallel)(arg);
-  if (limit === null) return fail3(state, "Usage: /parallel [<number of tasks, 1 or more>]");
-  return step({ ...state, maxParallel: limit }, [{ type: "setMaxParallel", limit }]);
-}
-function setAutonomous(state, arg) {
-  const enabled = resolveToggle(arg, state.autonomous);
-  if (enabled === null) return fail3(state, "Usage: /auto [on|off]");
-  return step({ ...state, autonomous: enabled }, [{ type: "setAutonomous", enabled }]);
 }
-function setMouseCapture(state, arg) {
-  const enabled = resolveToggle(arg, state.mouseCapture);
-  if (enabled === null) return fail3(state, "Usage: /mouse [on|off]");
-  const noted = say(
-    // A selection made under capture is meaningless once the terminal owns the
-    // mouse again, and its highlight would sit on screen with nothing able to
-    // move it.
-    { ...state, mouseCapture: enabled, selection: null },
-    "system",
-    enabled ? "Mouse capture on \u2014 the wheel scrolls, and dragging selects within one pane and copies on release." : "Mouse capture off \u2014 the terminal's own drag-select is back, across both panes; scroll with pgup/pgdn."
-  );
-  return step(noted, [{ type: "setMouseCapture", enabled }]);
+
+// src/tui/reducers/incoming.ts
+var planText = (value, fallback = "") => sanitize(String(value ?? fallback));
+var planLabel = (value, fallback = "") => planText(value, fallback).replace(/\n+/g, " ");
+var asRecord = (value) => typeof value === "object" && value !== null ? value : {};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
 }
-function openTaskRunnerPicker(state, task) {
-  if (task.type !== "ai") return fail3(state, "Manual tasks do not run on an executor, so they have no runner.");
-  const action = { kind: "set-task-runner", taskId: task.id };
-  return step(
-    {
-      ...state,
-      overlay: {
-        kind: "picker",
-        picker: picker(`Runner \xB7 #${task.order} ${task.title}`, pickerItemsFor(state, action), action, {
-          hint: "Changing the runner re-picks this task model, effort and mode for it."
-        })
-      }
+var wireOrder = (value) => Number(asRecord(value).order ?? 0);
+function normalizeTasks(plan) {
+  const source = plan;
+  const byId = /* @__PURE__ */ new Map();
+  for (const list of [source?.pendingTasks, source?.executionLog]) {
+    for (const task of list ?? []) {
+      const record = asRecord(task);
+      byId.set(String(record.id), record);
     }
-  );
+  }
+  const raw = byId.size > 0 ? [...byId.values()].sort((a, b) => wireOrder(a) - wireOrder(b)) : (source?.tasks ?? []).map(asRecord);
+  return raw.map((t, i) => toTaskView2(t, i));
 }
-function confirmRemoveTask(state, task) {
-  const dependents = (0, import_plan_utils3.dependentsOf)(state.tasks, task.id);
-  const named = dependents.map((t) => `#${t.order} ${t.title}`).join(", ");
-  return step({
-    ...state,
-    overlay: {
-      kind: "confirm",
-      title: `Remove #${task.order} ${task.title}?`,
-      message: dependents.length > 0 ? `${dependents.length === 1 ? "1 task depends" : `${dependents.length} tasks depend`} on it and will lose that dependency: ${named}.` : "This cannot be undone.",
-      action: { kind: "remove-task", taskId: task.id }
-    }
-  });
+function toTaskView2(t, index) {
+  const model = asRecord(t.assignedModel);
+  const assigned = isRecord(t.assignedModel);
+  return {
+    id: String(t.id ?? `task-${index + 1}`),
+    order: typeof t.order === "number" ? t.order : index + 1,
+    title: planLabel(t.title, "Untitled task"),
+    description: planText(t.description ?? t.title),
+    prompt: typeof t.prompt === "string" ? sanitize(t.prompt) : void 0,
+    type: t.type === "user" ? "user" : "ai",
+    status: planLabel(t.status, "pending"),
+    dependencies: Array.isArray(t.dependencies) ? t.dependencies.map((id) => planLabel(id)) : [],
+    assignedRunner: typeof t.assignedRunner === "string" ? planLabel(t.assignedRunner) : void 0,
+    taskMode: typeof t.taskMode === "string" ? planLabel(t.taskMode) : void 0,
+    assignedModel: assigned ? {
+      modelId: planLabel(model.modelId),
+      modelLabel: planLabel(model.modelLabel ?? model.modelId),
+      thinkingEffort: typeof model.thinkingEffort === "string" ? planLabel(model.thinkingEffort) : typeof t.thinkingEffort === "string" ? planLabel(t.thinkingEffort) : void 0,
+      availableVariants: Array.isArray(model.availableVariants) ? model.availableVariants.map((variant) => planLabel(variant)) : void 0
+    } : void 0,
+    subtasks: Array.isArray(t.subtasks) ? [...t.subtasks].sort((a, b) => wireOrder(a) - wireOrder(b)).map((s, i) => toTaskView2(asRecord(s), i)) : void 0
+  };
 }
-function openTaskDepsPicker(state, task) {
-  const action = { kind: "set-task-deps", taskId: task.id };
-  const items = pickerItemsFor(state, action);
-  if (items.length === 0) return fail3(state, `Nothing runs before #${task.order}, so it has no possible dependencies.`);
-  return step({
+var enabledFlag = (value) => typeof value?.enabled === "boolean" ? value.enabled : void 0;
+function applySettings(state, settings) {
+  const sources = {
+    tdd: settings.tdd,
+    verify: settings.verification
+  };
+  const skills = { ...state.skills };
+  for (const id of SKILL_IDS) {
+    const flag2 = enabledFlag(sources[id]);
+    if (flag2 !== void 0) skills[id] = flag2;
+  }
+  return {
     ...state,
-    overlay: {
-      kind: "picker",
-      picker: picker(`Depends on \xB7 #${task.order} ${task.title}`, items, action, {
-        hint: "Only tasks earlier in the plan can be dependencies.",
-        multi: true,
-        chosen: task.dependencies.filter((id) => items.some((i) => i.id === id))
-      })
-    }
-  });
+    skills,
+    orchestratorModel: typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : state.orchestratorModel,
+    plannerProvider: typeof settings.aiProvider === "string" ? settings.aiProvider : state.plannerProvider,
+    plannerEffort: typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : state.plannerEffort,
+    maxParallel: typeof settings.maxParallel === "number" ? settings.maxParallel : state.maxParallel,
+    allowlist: settings.modelAllowlist && typeof settings.modelAllowlist === "object" ? settings.modelAllowlist : state.allowlist
+  };
 }
-function openTaskModePicker(state, task) {
-  if (task.type !== "ai") return fail3(state, "Manual tasks do not have an executor mode.");
-  const modes = modesForTask(state.modesByRunner, task);
-  if (modes.length === 0) {
-    return fail3(state, `${task.assignedRunner ?? "This runner"} declares no modes.`);
+function runLabel(tasks) {
+  const running = tasks.filter(isTaskRunning);
+  if (running.length > 0) {
+    const [first] = running;
+    const name = first.assignedRunner ? `${first.title} \xB7 ${first.assignedRunner}` : first.title;
+    return running.length > 1 ? `${name} (+${running.length - 1} more)` : name;
   }
-  const action = { kind: "set-task-mode", taskId: task.id };
-  return step(
-    {
-      ...state,
-      overlay: {
-        kind: "picker",
-        picker: picker(`Mode \xB7 #${task.order}`, pickerItemsFor(state, action), action, {
-          hint: `Modes declared by ${task.assignedRunner}.`
-        })
-      }
-    }
-  );
-}
-function openTaskModelPicker(state, task) {
-  if (task.type !== "ai") return fail3(state, "Manual tasks do not have an executor model.");
-  const action = { kind: "set-task-model", taskId: task.id };
-  return step(
-    {
-      ...state,
-      overlay: {
-        kind: "picker",
-        picker: picker(`Model \xB7 #${task.order} ${task.title}`, pickerItemsFor(state, action), action, {
-          hint: task.assignedRunner ? `Showing models discovered for ${task.assignedRunner}.` : "Choose the model this task will run with."
-        })
-      }
-    },
-    [{ type: "loadModels" }]
-  );
-}
-function openTaskEffortPicker(state, task) {
-  if (task.type !== "ai") return fail3(state, "Manual tasks do not have a thinking effort.");
-  if (!task.assignedModel) return fail3(state, "Choose a model for this task before setting its thinking effort.");
-  const action = { kind: "set-task-effort", taskId: task.id };
-  return step(
-    {
-      ...state,
-      overlay: {
-        kind: "picker",
-        picker: picker(`Thinking effort \xB7 #${task.order}`, pickerItemsFor(state, action), action, {
-          hint: `${task.assignedModel.modelLabel} \xB7 choose runner default or a supported effort`
-        })
-      }
-    },
-    [{ type: "loadModels" }]
-  );
-}
-function assignTaskModel(state, sessionId, task, model) {
-  const assignedModel = assignedModelFor(model, task.assignedModel?.thinkingEffort);
-  return step(state, [{
-    type: "updateTask",
-    sessionId,
-    taskId: task.id,
-    // JSON drops `undefined`; null is intentional here so changing models can
-    // also clear a stale legacy top-level effort on the persisted task.
-    changes: { assignedModel, thinkingEffort: assignedModel.thinkingEffort ?? null },
-    message: `Task #${task.order} model set to ${model.label}.`
-  }]);
+  const waiting = tasks.filter((t) => t.status === "awaiting_user").length;
+  if (waiting === 0) return "";
+  return waiting === 1 ? "1 task waits for you" : `${waiting} tasks wait for you`;
 }
-function assignTaskRunner(state, sessionId, task, runner, runnerLabel) {
-  return step(state, [{
-    type: "updateTask",
-    sessionId,
-    taskId: task.id,
-    changes: { assignedRunner: runner },
-    message: `Task #${task.order} runner set to ${runnerLabel}.`
-  }]);
+var statusText = (text) => sanitize(text).replace(/\s+/g, " ").trim();
+function inFlight(blocks) {
+  return blocks.flatMap((block) => {
+    if (block.type === "tool") return block.status === "pending" ? [statusText(`${block.headline.name}(${block.headline.keyArg})`)] : [];
+    if (block.type !== "subagent" || block.status !== "running") return [];
+    return [statusText(`Agent(${block.brief})`), ...inFlight(block.children)];
+  });
 }
-function assignTaskMode(state, sessionId, task, mode, modeLabel) {
-  return step(state, [{
-    type: "updateTask",
-    sessionId,
-    taskId: task.id,
-    changes: { taskMode: mode },
-    message: `Task #${task.order} mode set to ${modeLabel}.`
-  }]);
+function turnActivity(state) {
+  if (!plannerInFlight(state)) return state;
+  const open = inFlight(state.conversation.blocks);
+  const status = open.length > 0 ? "researching" : "planning";
+  const newest = open.at(-1) ?? "";
+  const busyLabel = open.length > 1 ? `${newest} (+${open.length - 1} more)` : newest;
+  return status === state.status && busyLabel === state.busyLabel ? state : { ...state, status, busyLabel };
 }
-function assignTaskEffort(state, sessionId, task, thinkingEffort) {
-  const assignedModel = task.assignedModel ? { ...task.assignedModel, thinkingEffort } : void 0;
-  return step(state, [{
-    type: "updateTask",
-    sessionId,
-    taskId: task.id,
-    changes: { assignedModel, thinkingEffort: thinkingEffort ?? null },
-    message: `Task #${task.order} thinking effort set to ${thinkingEffort ?? "runner default"}.`
-  }]);
+function followSession(state, message) {
+  const heard = turnActivity(hear(state, message));
+  if (message.type === "approval_request") {
+    const { id, kind, subject, scope, detail } = message;
+    return enqueueApproval(heard, { id, kind, subject, scope, ...detail ? { detail } : {} });
+  }
+  return message.type === "approval_settled" ? dropApproval(heard, message.id) : heard;
 }
-function taskModelCommand(state, args) {
-  return taskCommand(state, args[0], (sessionId, taskId) => {
-    const task = findTask(state.tasks, taskId);
-    if (!args[1]) return openTaskModelPicker(state, task);
-    const model = state.models.find((candidate) => candidate.id === args[1]) ?? {
-      id: args[1],
-      label: args[1],
-      provider: "",
-      variants: []
-    };
-    if (!runnerAccepts(task, model)) {
-      return fail3(state, `${model.label} was not discovered for ${task.assignedRunner}.`);
+
+// src/tui/reducer.ts
+function reduce(state, action) {
+  switch (action.type) {
+    case "key":
+      return handleKey2(state, action.key);
+    // Isolation belongs to one session's plan, and task ids repeat across
+    // sessions, so nothing of the last one's may carry over into this.
+    case "sessionStarted":
+      return step(clearIsolation({ ...state, sessionId: action.sessionId, goal: action.goal }));
+    // The daemon registers a session only once planning succeeds; when it does
+    // not, holding on to the id would send every next message to a session the
+    // server never had.
+    case "sessionCleared":
+      return step({
+        ...clearIsolation(state),
+        sessionId: null,
+        goal: "",
+        pendingApprovals: [],
+        queuedPrompts: import_core26.EMPTY_HOLD,
+        stopArmed: false,
+        overlay: state.overlay?.kind === "approval" ? null : state.overlay
+      });
+    case "chatRestored":
+      if (stale(state, action.sessionId)) return step(state);
+      return step({ ...state, conversation: (0, import_core26.fromTranscript)(action.history, action.researchLog, action.plannerUsage), scroll: 0 });
+    case "planUpdated": {
+      if (stale(state, action.sessionId)) return step(state);
+      const isolation = isolationOfPlan(action.plan);
+      const tasks = isolationForPlan(normalizeTasks(action.plan), isolation, state.tasks);
+      const expandedTaskId = state.expandedTaskId && findTask(tasks, state.expandedTaskId) ? state.expandedTaskId : null;
+      const next = {
+        ...state,
+        tasks,
+        handoff: isolation ? isolation.handoff : state.handoff,
+        status: plannerInFlight(state) ? "idle" : state.status,
+        busyLabel: "",
+        expandedTaskId,
+        taskEditor: expandedTaskId !== null ? state.taskEditor : null
+      };
+      const selectedTask = clampSelection(state.selectedTask, planRows(next).length);
+      const settled = settlePlan({
+        ...next,
+        selectedTask,
+        focus: tasks.length === 0 ? "chat" : state.focus
+      });
+      if (!plannerInFlight(state)) {
+        return step(settled);
+      }
+      return drainQueue(state, settled);
     }
-    return assignTaskModel(state, sessionId, task, model);
-  });
+    // A message never ends a turn: `planUpdated` does (see `converse`), so a
+    // queued prompt drains onto a settled state. Until then the status only
+    // says whether a call is out.
+    case "sessionMessage":
+      if (stale(state, action.sessionId)) return step(state);
+      return step(followSession(state, action.message));
+    // A settled transcript line, not a research step: nothing ever settles a
+    // task's start, so as a step it stayed "⋯" forever and was counted into
+    // the planner's next "(+N more)".
+    case "taskStarted": {
+      if (stale(state, action.sessionId)) return step(state);
+      const existing = findTask(state.tasks, action.taskId);
+      if (existing && isTaskRunning(existing)) return step(state);
+      const tasks = state.tasks.map((t) => t.id === action.taskId && !isTaskRunning(t) ? { ...t, status: "in_progress" } : t);
+      const spoken = say(state, "system", (0, import_core26.taskStartedNotice)(action.title, action.runner));
+      return step({ ...spoken, tasks, status: "executing", busyLabel: runLabel(tasks) });
+    }
+    case "taskStatus": {
+      if (stale(state, action.sessionId) || !state.tasks.some((t) => t.id === action.taskId)) return step(state);
+      const tasks = state.tasks.map((t) => t.id === action.taskId ? { ...t, status: action.status } : t);
+      const status = runStatus(state, tasks);
+      return step({ ...state, status, tasks, busyLabel: status === "executing" ? runLabel(tasks) : state.busyLabel });
+    }
+    case "tasksStatus": {
+      if (stale(state, action.sessionId)) return step(state);
+      const updates = action.updates;
+      let changed = false;
+      const tasks = state.tasks.map((t) => {
+        const update = updates[t.id];
+        if (update === void 0) return t;
+        const idleSince = update.idleSince ?? null;
+        const isolation = update.isolation ?? t.isolation;
+        if (update.status !== t.status || idleSince !== (t.idleSince ?? null) || !sameIsolation(isolation, t.isolation)) {
+          changed = true;
+          return { ...t, status: update.status, idleSince, isolation };
+        }
+        return t;
+      });
+      if (!changed) return step(state);
+      const status = runStatus(state, tasks);
+      return step({ ...state, status, tasks, busyLabel: status === "executing" ? runLabel(tasks) : state.busyLabel });
+    }
+    case "queueReady": {
+      if (stale(state, action.sessionId)) return step(state);
+      const sessionId = action.sessionId ?? state.sessionId;
+      if (sessionId === null) return step(state);
+      return step(state, [{ type: "processQueued", sessionId }]);
+    }
+    case "isolationBlocked": {
+      if (stale(state, action.sessionId)) return step(state);
+      return step(blockedPicker(state, action.message, action.repos));
+    }
+    case "isolationHandoff": {
+      if (stale(state, action.sessionId)) return step(state);
+      return step(handoffArrived(state, action.handoff));
+    }
+    case "handoffDiff": {
+      if (stale(state, action.sessionId)) return step(state);
+      return step(showDiff(state, action.diff));
+    }
+    case "runCleared": {
+      if (stale(state, action.sessionId)) return step(state);
+      const overlay = state.overlay?.kind === "handoff" ? null : state.overlay;
+      return step({ ...clearIsolation(state), overlay });
+    }
+    case "executionComplete": {
+      if (stale(state, action.sessionId)) return step(state);
+      const { completed, total, failed } = action.summary ?? {
+        completed: state.tasks.filter((t) => t.status === "completed").length,
+        total: state.tasks.length,
+        failed: state.tasks.filter((t) => t.status === "failed").length
+      };
+      const failures = failed > 0 ? ` \xB7 ${failed} failed` : "";
+      const verb = action.stopped ? "stopped" : "finished";
+      return step({
+        ...say(state, "system", `Execution ${verb} \u2014 ${completed}/${total} tasks complete${failures}.`),
+        status: "idle",
+        busyLabel: ""
+      });
+    }
+    case "settingsLoaded":
+      return step(applySettings(state, action.settings));
+    case "modelsLoaded":
+      return step(
+        refillPicker(
+          {
+            ...state,
+            models: action.models,
+            orchestratorModels: action.orchestratorModels ?? state.orchestratorModels,
+            configuredProviders: action.providers ?? state.configuredProviders,
+            providerErrors: action.providerErrors ?? state.providerErrors,
+            modesByRunner: action.modesByRunner ?? state.modesByRunner
+          },
+          ["set-model", "set-planner", "set-task-model", "set-task-effort", "set-task-mode"]
+        )
+      );
+    case "sessionsLoaded":
+      return step(refillPicker({ ...state, sessions: action.sessions }, ["load-session", "delete-session"]));
+    case "rewindTargetsLoaded":
+      if (stale(state, action.sessionId)) return step(state);
+      if (action.pick !== void 0) return pickRewindTarget({ ...state, rewindTargets: action.targets }, action.pick);
+      return step(refillPicker({ ...state, rewindTargets: action.targets }, ["rewind"]));
+    // A fork holds no run, whatever the session it came from was doing — the
+    // original keeps its run, and its events are stale from here on.
+    case "sessionForked":
+      return step({
+        ...clearIsolation(state),
+        sessionId: action.sessionId,
+        goal: action.goal,
+        status: "idle",
+        busyLabel: "",
+        planApproved: false,
+        pendingApprovals: [],
+        queuedPrompts: import_core26.EMPTY_HOLD,
+        stopArmed: false,
+        overlay: state.overlay?.kind === "approval" ? null : state.overlay
+      });
+    // The rewound message comes back as a draft to edit and resend, so it lands
+    // as if just typed: history is not being browsed, and nothing is parked.
+    case "inputPrefilled":
+      if (stale(state, action.sessionId)) return step(state);
+      return step({
+        ...state,
+        focus: "chat",
+        editor: { ...state.editor, text: action.text, cursor: action.text.length, historyIndex: state.editor.history.length, draft: "" }
+      });
+    case "runnersLoaded":
+      return step(refillPicker({
+        ...state,
+        runners: action.runners,
+        orchestratorModel: action.orchestratorModel ?? state.orchestratorModel
+      }, ["set-planner", "set-task-runner"]));
+    case "failed": {
+      const quiet = plannerInFlight(state) && state.stopRequested;
+      const reported = { ...quiet ? state : say(state, "error", action.message), status: "idle", busyLabel: "" };
+      if (!plannerInFlight(state)) return step(reported);
+      return drainQueue(state, reported);
+    }
+    case "workspaceNeedsInit":
+      return step({
+        ...state,
+        status: "idle",
+        busyLabel: "",
+        overlay: {
+          kind: "confirm",
+          title: "Initialize new workspace?",
+          message: `"${action.workspace}" isn't a recognized project yet (no .git or manifest found). Start a new ordewell workspace here?`,
+          action: { kind: "init-workspace", goal: action.goal, workspace: action.workspace }
+        }
+      });
+    case "notice":
+      return step(say(state, action.level === "error" ? "error" : "system", action.message));
+    case "resize": {
+      const resized = { ...state, rows: action.rows, cols: action.cols, selection: null };
+      return step(settlePlan({ ...resized, scroll: clamp(resized.scroll, chatScrollMax(resized)) }));
+    }
+    // Whether there is anything to animate is the app loop's call (it owns the
+    // timer); a tick that arrives simply advances the frame.
+    case "spinnerTick":
+      return step({ ...state, spinnerFrame: (state.spinnerFrame + 1) % 10 });
+    // The scheduled expiry of an armed stop; a token that is no longer the live
+    // arm is a stale timer (the user disarmed and re-armed in between) and is
+    // ignored, so it cannot cut a newer arm short.
+    case "stopDisarmed":
+      if (!state.stopArmed || action.arm !== state.stopArmToken) return step(state);
+      return step(disarmStop(state));
+  }
 }
-function taskRunnerCommand(state, args) {
-  return taskCommand(state, args[0], (sessionId, taskId) => {
-    const task = findTask(state.tasks, taskId);
-    if (!args[1]) return openTaskRunnerPicker(state, task);
-    const runner = state.runners.find((candidate) => candidate.id === args[1]);
-    if (!runner) return fail3(state, `Unknown runner "${args[1]}".`);
-    return assignTaskRunner(state, sessionId, task, runner.id, runner.name);
-  });
+function runStatus(state, tasks) {
+  if (tasks.some(isTaskRunning)) return "executing";
+  if (tasks.some((t) => t.status === "awaiting_user")) return "executing";
+  return plannerInFlight(state) ? state.status : "idle";
 }
-function taskModeCommand(state, args) {
-  return taskCommand(state, args[0], (sessionId, taskId) => {
-    const task = findTask(state.tasks, taskId);
-    if (!args[1]) return openTaskModePicker(state, task);
-    const mode = modesForTask(state.modesByRunner, task).find((candidate) => candidate.id === args[1]);
-    if (!mode) return fail3(state, `Unsupported mode "${args[1]}" for ${task.assignedRunner}.`);
-    return assignTaskMode(state, sessionId, task, mode.id, mode.label);
-  });
+function interrupt(state) {
+  if (state.overlay) return step({ ...state, overlay: null });
+  if (state.editor.text) return step({ ...state, editor: { ...state.editor, text: "", cursor: 0 } });
+  return step({ ...state, exiting: true }, [{ type: "exit" }]);
 }
-function taskEffortCommand(state, args) {
-  return taskCommand(state, args[0], (sessionId, taskId) => {
-    const task = findTask(state.tasks, taskId);
-    if (!args[1]) return openTaskEffortPicker(state, task);
-    if (!task.assignedModel) return fail3(state, "Choose a model for this task before setting its thinking effort.");
-    const effort = args[1].toLowerCase();
-    const value = effort === "default" || effort === "none" ? void 0 : args[1];
-    const supported = effortsForTask(state.models, task);
-    if (value && supported.length > 0 && !supported.some((variant) => variant.id === value)) {
-      return fail3(state, `Unsupported effort "${value}" for ${task.assignedModel.modelLabel}.`);
+function handleKey2(state, key) {
+  if (state.stopArmed && key.name !== "escape") state = disarmStop(state);
+  if (key.name === "ctrl-c") return interrupt(state);
+  if (key.name === "ctrl-d" && !state.editor.text && !state.overlay) {
+    return step({ ...state, exiting: true }, [{ type: "exit" }]);
+  }
+  if (key.name === "ctrl-l") return step({ ...state, conversation: wiped(state.conversation), scroll: 0 });
+  if (key.name === "ctrl-o" && state.focus === "chat" && !state.overlay) return toggleDetail(state);
+  if (key.name === "escape") {
+    const stopped = plannerEscape(state);
+    if (stopped) return stopped;
+  }
+  if (state.overlay) return handleOverlayKey(state, state.overlay, key);
+  if (isWheel(key)) return scrollPointed(state, key);
+  if (isMouseSelect(key)) return handleMouseSelect(state, key);
+  if (key.name === "wheelignored") return step(state);
+  if (key.name === "tab" && state.focus === "chat") {
+    const token = activeToken(state.editor.text, state.editor.cursor);
+    const matches = token ? tokenCompletions(token) : [];
+    if (token && matches.length > 0) {
+      const { text: full } = state.editor;
+      const completed = `/${matches[0].name} `;
+      const text = full.slice(0, token.start) + completed + full.slice(token.end);
+      return step({ ...state, editor: { ...state.editor, text, cursor: token.start + completed.length } });
     }
-    return assignTaskEffort(state, sessionId, task, value);
-  });
-}
-function clampSelection(index, rows) {
-  return Math.max(0, Math.min(index, rows - 1));
-}
-function addTask(state, title) {
-  if (!state.sessionId) {
-    return fail3(state, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
   }
-  if (!title) {
-    return step({
-      ...state,
-      overlay: { kind: "prompt", title: "New task title", value: "", action: { kind: "add-task" } }
-    });
+  if (key.name === "tab") {
+    if (state.focus === "chat" && state.tasks.length === 0) return step(state);
+    return step({ ...state, focus: state.focus === "chat" ? "plan" : "chat" });
   }
-  return step(state, [{ type: "addTask", sessionId: state.sessionId, title }]);
-}
-function taskCommand(state, token, run) {
-  return withSession(state, (sessionId) => {
-    if (!token) return fail3(state, "Which task? Pass a task id or its number in the plan.");
-    const taskId = resolveTaskId2(state, token);
-    if (!taskId) return fail3(state, `No task matching "${token}" in the current plan.`);
-    return run(sessionId, taskId);
-  });
+  if (state.focus === "plan") return handlePlanKey(state, key);
+  if (key.name === "enter") return submit(state);
+  if (key.name === "escape") return step({ ...state, editor: { ...state.editor, text: "", cursor: 0 } });
+  const scroll = scrollDelta(key, state);
+  if (scroll !== null) return scrollChat(state, scroll);
+  const multilineEditor = state.editor.text.includes("\n");
+  const room = chatEditorRoom(state.cols, true);
+  return step({ ...state, editor: applyKey(state.editor, key, multilineEditor ? room : void 0) });
 }
-function resolveTaskId2(state, token) {
-  const byId = findTask(state.tasks, token);
-  if (byId) return byId.id;
-  const order = Number(token);
-  if (Number.isInteger(order)) {
-    const byOrder = state.tasks.find((t) => t.order === order);
-    if (byOrder) return byOrder.id;
+function submit(state) {
+  const text = state.editor.text.trim();
+  if (!text) return step(state);
+  const cleared = { ...state, editor: commit(state.editor) };
+  const command = parseSlash(text);
+  if (command && findCommand(command.name)?.source !== "skill") return runCommand(cleared, command);
+  if (plannerInFlight(state)) {
+    return step({ ...cleared, queuedPrompts: (0, import_core26.holdPrompt)(state.queuedPrompts, text) });
   }
-  return null;
+  const spoken = say(cleared, "user", text);
+  const effect = state.sessionId ? { type: "sendMessage", sessionId: state.sessionId, message: text } : { type: "startConversation", goal: text };
+  return step({ ...spoken, status: "planning", stopRequested: false }, [effect]);
 }
 
 // src/tui/app.ts
@@ -6330,40 +6618,286 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process4 = require("child_process");
-var import_core21 = require("@ordewell/core");
-var import_plan_utils4 = require("@ordewell/core/plan-utils");
-var ConversationQueue = class {
-  tail = Promise.resolve();
-  active = false;
-  enqueue(work) {
-    const run = () => {
-      try {
-        return Promise.resolve(work());
-      } catch (error) {
-        return Promise.reject(error);
-      }
-    };
-    const result = this.active ? this.tail.then(run) : run();
-    this.active = true;
-    const settled = result.then(
-      () => void 0,
-      () => void 0
-    );
-    this.tail = settled;
-    void settled.then(() => {
-      if (this.tail === settled) this.active = false;
-    });
-    return result;
+var import_core28 = require("@ordewell/core");
+
+// src/tui/inbound.ts
+var import_core27 = require("@ordewell/core");
+var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
+  "planner_message",
+  "planner_turn_started",
+  "planner_turn_ended",
+  "planner_text_delta",
+  "planner_thinking_delta",
+  "planner_text_retracted",
+  "plan_token",
+  "plan_generated",
+  "research_step",
+  "research_step_done",
+  "subagent_started",
+  "subagent_finished",
+  "planner_usage",
+  "planner_liveness",
+  "approval_request",
+  "approval_settled",
+  "approval_decided"
+]);
+function isStreamed(event) {
+  return event.type === "planner_text_delta" || event.type === "planner_thinking_delta" || event.type === "plan_token";
+}
+function isConversation(event) {
+  return CONVERSATION_TYPES.has(event.type);
+}
+function joinStreamed(held, next) {
+  if (held.type === "planner_text_delta" && next.type === "planner_text_delta") {
+    return held.turnId === next.turnId && held.segmentId === next.segmentId ? { ...held, text: held.text + next.text } : null;
+  }
+  if (held.type === "planner_thinking_delta" && next.type === "planner_thinking_delta") {
+    const same = held.turnId === next.turnId && held.segmentId === next.segmentId && held.subagentId === next.subagentId;
+    return same ? { ...held, text: held.text + next.text } : null;
+  }
+  if (held.type === "plan_token" && next.type === "plan_token") {
+    return held.turnId === next.turnId && held.segmentId === next.segmentId ? { ...held, token: held.token + next.token } : null;
+  }
+  return null;
+}
+function identity(event) {
+  if (event.type === "planner_message") return replyKey(event.content, event.timestamp);
+  if (event.type === "approval_request" || event.type === "approval_settled") return `${event.type}:${event.id}`;
+  return JSON.stringify(event);
+}
+function replyKey(content, timestamp) {
+  return timestamp ? `planner_message:${timestamp}:${content}` : `planner_message:content:${content}`;
+}
+var Copies = class {
+  constructor(cap) {
+    this.cap = cap;
+  }
+  cap;
+  counts = /* @__PURE__ */ new Map();
+  order = [];
+  /** Whether this delivery is the first copy of a new broadcast, whichever subscription carried it. */
+  first(id, key) {
+    let highest = 0;
+    for (const count of this.counts.get(key)?.values() ?? []) {
+      if (count > highest) highest = count;
+    }
+    return this.bump(id, key) === highest + 1;
+  }
+  /** Account for a copy already shown (a redrawn transcript's entry), so its counterparts are recognized. */
+  credit(id, key) {
+    this.bump(id, key);
+  }
+  bump(id, key) {
+    let keyed = this.counts.get(key);
+    if (!keyed) {
+      keyed = /* @__PURE__ */ new Map();
+      this.counts.set(key, keyed);
+      this.order.push(key);
+      if (this.order.length > this.cap) this.counts.delete(this.order.shift());
+    }
+    const count = (keyed.get(id) ?? 0) + 1;
+    keyed.set(id, count);
+    return count;
   }
 };
-async function runEffect(effect, deps) {
-  const isConversationTurn = effect.type === "startConversation" || effect.type === "sendMessage";
-  const run = () => {
-    const work = () => perform(effect, deps);
-    return isConversationTurn ? deps.conversationQueue.enqueue(work) : work();
+var WindowSet = class {
+  constructor(cap) {
+    this.cap = cap;
+  }
+  cap;
+  items = /* @__PURE__ */ new Set();
+  order = [];
+  add(value) {
+    if (this.items.has(value)) return;
+    this.items.add(value);
+    this.order.push(value);
+    if (this.order.length > this.cap) this.items.delete(this.order.shift());
+  }
+  has(value) {
+    return this.items.has(value);
+  }
+  /** Removes the value and answers whether it was there. */
+  take(value) {
+    if (!this.items.has(value)) return false;
+    this.items.delete(value);
+    return true;
+  }
+};
+var inbounds = /* @__PURE__ */ new WeakMap();
+function inboundFor(api, dispatch, sessionId) {
+  let sessions = inbounds.get(api);
+  if (!sessions) {
+    sessions = /* @__PURE__ */ new Map();
+    inbounds.set(api, sessions);
+  }
+  let inbound = sessions.get(sessionId);
+  if (!inbound) {
+    inbound = createInbound(dispatch, sessionId);
+    sessions.set(sessionId, inbound);
+  }
+  return inbound;
+}
+function createInbound(dispatch, sessionId) {
+  const copies = new Copies(64);
+  const shown = new WindowSet(64);
+  const pending = new WindowSet(16);
+  const DELTA_DEBOUNCE_MS = 75;
+  let held = null;
+  let timer = null;
+  const flush = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (held === null) return;
+    const message = held;
+    held = null;
+    dispatch({ type: "sessionMessage", message, sessionId });
+  };
+  const hold = (event) => {
+    const joined = held && joinStreamed(held, event);
+    if (joined) {
+      held = joined;
+      return;
+    }
+    flush();
+    held = event;
+    timer = setTimeout(flush, DELTA_DEBOUNCE_MS);
+  };
+  const showReply = (message) => {
+    shown.add(message.content);
+    dispatch({ type: "sessionMessage", message, sessionId });
+  };
+  const acceptReply = (id, event) => {
+    const key = replyKey(event.content, event.timestamp);
+    if (pending.take(key)) {
+      copies.credit(id, key);
+      return;
+    }
+    if (!copies.first(id, key)) return;
+    showReply(event);
+  };
+  const deliverConversation = (kind, id, event) => {
+    if (event.type === "planner_message") {
+      acceptReply(id, event);
+      return;
+    }
+    if (!copies.first(id, identity(event))) return;
+    if (event.type === "plan_generated") {
+      dispatch({ type: "sessionMessage", message: event, sessionId });
+      if (kind === "execution") dispatch({ type: "planUpdated", plan: event.plan, sessionId });
+      return;
+    }
+    dispatch({ type: "sessionMessage", message: event, sessionId });
+  };
+  const receive = (kind, id, event) => {
+    if (isStreamed(event)) {
+      if (kind === "planning") hold(event);
+      return;
+    }
+    flush();
+    if (isConversation(event)) {
+      deliverConversation(kind, id, event);
+      return;
+    }
+    if (!copies.first(id, identity(event))) return;
+    dispatchLifecycle(dispatch, event, sessionId);
+  };
+  let subscription = 0;
+  return {
+    planning: () => {
+      const id = `p${++subscription}`;
+      return (event) => receive("planning", id, event);
+    },
+    execution: () => {
+      const id = `e${++subscription}`;
+      return (event) => receive("execution", id, event);
+    },
+    backfill: (content, timestamp) => {
+      if (shown.has(content)) return;
+      const message = { type: "planner_message", content, timestamp: timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
+      showReply(message);
+      if (timestamp) pending.add(replyKey(content, timestamp));
+    },
+    redrawn: (content, timestamp) => {
+      shown.add(content);
+      pending.add(replyKey(content, timestamp));
+    },
+    flush
   };
+}
+function dispatchLifecycle(dispatch, event, sessionId) {
+  switch (event.type) {
+    case "status_update": {
+      const updates = {};
+      for (const task of event.tasks ?? []) {
+        updates[String(task.id)] = { status: String(task.status), idleSince: task.idleSince ?? null, isolation: task.isolation };
+      }
+      dispatch({ type: "tasksStatus", updates, sessionId });
+      return;
+    }
+    case "task_started":
+      dispatch({ type: "taskStarted", taskId: String(event.taskId), title: String(event.title ?? event.taskId), runner: event.runner, sessionId });
+      return;
+    // The extension shows these in its checkpoint panel; here they are
+    // transcript lines, which is the TUI's equivalent surface.
+    case "checkpoint":
+      dispatch({ type: "notice", message: `\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core27.truncateCheckpointSummary)(event.summary)}` });
+      return;
+    case "review_needed":
+      dispatch({ type: "notice", message: "Plan needs your sign-off \u2014 /approve to continue." });
+      return;
+    case "review_approved":
+      dispatch({ type: "notice", message: "Plan approved." });
+      return;
+    // The orchestrator paused fan-out because a structural edit is queued; drain
+    // it so the planner reconciles the plan and dependents resume spawning.
+    // Dropped on the floor, the queue suppresses every later tick() — which is
+    // exactly "tasks did not fan out when the dependent ones finished."
+    case "queue_ready":
+      dispatch({ type: "queueReady", sessionId });
+      return;
+    case "execution_complete":
+      dispatch({ type: "executionComplete", summary: event.summary, sessionId });
+      return;
+    // A stop carries no tally — the reducer counts the pane instead.
+    case "execution_stopped":
+      dispatch({ type: "executionComplete", stopped: true, sessionId });
+      return;
+    // Nothing started; the user chooses how to go on.
+    case "isolation_blocked":
+      dispatch({ type: "isolationBlocked", message: event.message, ...event.repos ? { repos: event.repos } : {}, sessionId });
+      return;
+    // How the run isolates. The daemon has no toast channel, so this is the only place the user hears it.
+    case "notice":
+      dispatch({ type: "notice", message: event.message, level: event.level });
+      return;
+    case "isolation_handoff":
+      dispatch({ type: "isolationHandoff", handoff: { repos: event.repos, landed: event.landed }, sessionId });
+      return;
+    // Raw runner chatter. Listed rather than defaulted, so a new lifecycle
+    // variant fails to compile here until someone decides what a run's watcher
+    // does with it.
+    case "task_updated":
+    case "task_output":
+      return;
+    // Its asker already has the words, from the merge request itself; a
+    // viewer that did not ask still has to drop a run that is gone.
+    case "isolation_merge":
+      if (event.result.outcome === "merged") dispatch({ type: "runCleared", sessionId });
+      return;
+    default: {
+      const unhandled = event;
+      void unhandled;
+      return;
+    }
+  }
+}
+
+// src/tui/effects.ts
+async function runEffect(effect, deps) {
   try {
-    await run();
+    await perform(effect, deps);
   } catch (err) {
     if (!isConnectionRefused(err)) {
       const message = err instanceof Error ? err.message : String(err);
@@ -6382,7 +6916,7 @@ async function runEffect(effect, deps) {
     }
     deps.dispatch({ type: "notice", message: "The server had stopped; started a new one and retried." });
     try {
-      await run();
+      await perform(effect, deps);
     } catch (retryErr) {
       const message = retryErr instanceof Error ? retryErr.message : String(retryErr);
       deps.dispatch({
@@ -6446,6 +6980,14 @@ async function perform(effect, deps) {
       if (cancelled) dispatch({ type: "notice", message: "Planning stopped." });
       return;
     }
+    // The arm's expiry is the runtime's to schedule: the reducer is pure, so
+    // it names the delay and this owns the timer that ends the arming. Unref'd,
+    // so a pending arm never holds the process open on its way out.
+    case "disarmStop": {
+      const timer = setTimeout(() => dispatch({ type: "stopDisarmed", arm: effect.arm }), effect.afterMs);
+      timer.unref?.();
+      return;
+    }
     case "processQueued":
       await api.processQueued(effect.sessionId);
       await refreshPlan(deps, effect.sessionId);
@@ -6501,7 +7043,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Orchestrator model set to ${effect.modelId}.` });
       return;
     case "setPlanner": {
-      const meta = import_core21.ALL_PROVIDERS[effect.provider];
+      const meta = import_core28.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown planner: ${effect.provider}`);
       const env = { AI_PROVIDER: effect.provider };
       const settings = await api.updateSettings({ env });
@@ -6513,7 +7055,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core21.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
+        message: `${(0, import_core28.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
       });
       await loadModels(deps);
       return;
@@ -6525,7 +7067,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Planner effort set to ${effect.effort || "the runner default"}.` });
       return;
     case "setApiKey": {
-      const meta = import_core21.ALL_PROVIDERS[effect.provider];
+      const meta = import_core28.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown provider: ${effect.provider}`);
       await api.updateSettings({ env: { [meta.apiKeyEnvVar]: effect.key } });
       deps.setEnvVar(meta.apiKeyEnvVar, effect.key);
@@ -6581,7 +7123,7 @@ async function perform(effect, deps) {
     case "loadSession": {
       const { plan, goal } = await api.adoptSession(effect.sessionId, workspace);
       dispatch({ type: "sessionStarted", sessionId: effect.sessionId, goal });
-      dispatch({ type: "chatRestored", history: plan.conversationHistory ?? [], sessionId: effect.sessionId });
+      dispatch(restoredChat(plan, effect.sessionId));
       dispatch({ type: "planUpdated", plan, sessionId: effect.sessionId });
       dispatch({ type: "notice", message: `Loaded "${goal || effect.sessionId}".` });
       return;
@@ -6591,7 +7133,7 @@ async function perform(effect, deps) {
     case "forkConversation": {
       const fork = await api.forkConversation(effect.sessionId);
       dispatch({ type: "sessionForked", sessionId: fork.sessionId, goal: fork.goal });
-      dispatch({ type: "chatRestored", history: fork.plan.conversationHistory ?? [], sessionId: fork.sessionId });
+      dispatch(restoredChat(fork.plan, fork.sessionId));
       dispatch({ type: "planUpdated", plan: fork.plan, sessionId: fork.sessionId });
       dispatch({ type: "notice", message: `Forked ${effect.sessionId} into ${fork.sessionId} \u2014 you are in the fork now. /sessions to go back.` });
       return;
@@ -6610,17 +7152,22 @@ async function perform(effect, deps) {
     case "rewindConversation": {
       const fork = await api.rewindConversation(effect.sessionId, effect.index);
       dispatch({ type: "sessionForked", sessionId: fork.sessionId, goal: fork.goal });
-      dispatch({ type: "chatRestored", history: fork.plan.conversationHistory ?? [], sessionId: fork.sessionId });
+      dispatch(restoredChat(fork.plan, fork.sessionId));
       dispatch({ type: "planUpdated", plan: fork.plan, sessionId: fork.sessionId });
       dispatch({ type: "inputPrefilled", text: fork.rewoundMessage, sessionId: fork.sessionId });
       dispatch({ type: "notice", message: `Forked ${effect.sessionId} into ${fork.sessionId} from before that message \u2014 the original is kept (/sessions to go back). The message is ready to edit and resend.` });
       return;
     }
     // The redrawn transcript opens with the summary entry, which is what the
-    // user gets to read — no separate notice to repeat it.
+    // user gets to read — no separate notice to repeat it. The daemon also
+    // broadcast that summary; `redrawn` keeps a late socket copy of it from
+    // landing as a second, spoken turn.
     case "compactConversation": {
       const { plan } = await api.compactConversation(effect.sessionId);
-      dispatch({ type: "chatRestored", history: plan.conversationHistory ?? [], sessionId: effect.sessionId });
+      const inbound = inboundFor(deps.api, deps.dispatch, effect.sessionId);
+      dispatch(restoredChat(plan, effect.sessionId));
+      const summary = compactionSummary(plan);
+      if (summary) inbound.redrawn(summary.content, summary.timestamp);
       dispatch({ type: "planUpdated", plan, sessionId: effect.sessionId });
       return;
     }
@@ -6691,7 +7238,7 @@ function osc52(text) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core21.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core28.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -6712,194 +7259,52 @@ async function withExecutionStream(deps, sessionId, request) {
   const streamReady = new Promise((resolve3, reject) => {
     settleReady = (error) => error ? reject(error) : resolve3();
   });
-  const stream = deps.api.streamExecution(
-    sessionId,
-    (event) => onExecutionEvent(deps.dispatch, event, sessionId),
-    settleReady
-  );
+  const inbound = inboundFor(deps.api, deps.dispatch, sessionId);
+  const stream = deps.api.streamExecution(sessionId, inbound.execution(), settleReady);
   void stream.catch(settleReady);
   await streamReady;
   await request();
   await stream;
 }
 async function converse(deps, sessionId, call) {
-  let streamed = null;
-  const TOKEN_DEBOUNCE_MS = 75;
-  let tokenBuffer = "";
-  let tokenTimer = null;
-  const flushTokens = () => {
-    if (tokenTimer !== null) {
-      clearTimeout(tokenTimer);
-      tokenTimer = null;
-    }
-    if (!tokenBuffer) return;
-    const text = tokenBuffer;
-    tokenBuffer = "";
-    deps.dispatch({ type: "plannerToken", text, sessionId });
-  };
-  const stream = deps.api.streamPlanning(sessionId, (event) => {
-    if (event?.type === "plan_token" && event.token) {
-      tokenBuffer += event.token;
-      if (tokenTimer === null) {
-        tokenTimer = setTimeout(flushTokens, TOKEN_DEBOUNCE_MS);
-      }
-      return;
-    }
-    flushTokens();
-    if (event?.type === "approval_request") {
-      deps.dispatch({
-        type: "approvalRequested",
-        sessionId,
-        request: { id: event.id, kind: event.kind, subject: event.subject, scope: event.scope, detail: event.detail }
-      });
-      return;
-    }
-    if (event?.type === "approval_settled") {
-      deps.dispatch({ type: "approvalSettled", sessionId, approvalId: event.id });
-      return;
-    }
-    if (event?.type === "approval_decided") {
-      deps.dispatch({ type: "notice", message: describeApprovalDecision2(event) });
-      return;
-    }
-    if (event?.type === "research_step") {
-      const summary = (0, import_plan_utils4.summarizeToolCall)(event.tool, event.args || "{}", event.toolLabel);
-      deps.dispatch({
-        type: "researchStep",
-        summary: event.subagentId ? `\u21B3 ${summary}` : summary,
-        toolCallId: event.toolCallId,
-        sessionId
-      });
-      return;
-    }
-    if (event?.type === "research_step_done" && event.step) {
-      const step2 = event.step;
-      const summary = (0, import_plan_utils4.summarizeToolCall)(step2.tool, step2.args, step2.toolLabel);
-      deps.dispatch({
-        type: "researchStepDone",
-        summary: event.subagentId ? `\u21B3 ${summary}` : summary,
-        toolCallId: step2.toolCallId,
-        outcome: step2.outcome,
-        result: step2.result ?? "",
-        sessionId
-      });
-      return;
-    }
-    if (event?.type === "planner_message") {
-      streamed = String(event.content ?? "");
-      deps.dispatch({ type: "plannerMessage", content: streamed, sessionId });
-      return;
-    }
-    if (event?.type === "plan_thinking" && event.text) {
-      deps.dispatch({ type: "plannerThinking", text: event.text, sessionId });
-    }
-  });
+  const inbound = inboundFor(deps.api, deps.dispatch, sessionId);
+  const stream = deps.api.streamPlanning(sessionId, inbound.planning());
   try {
+    await stream.ready;
     const plan = await call();
+    inbound.flush();
+    const reply = lastAssistantMessage(plan);
+    if (reply) inbound.backfill(reply.content, reply.timestamp);
     deps.dispatch({ type: "planUpdated", plan, sessionId });
-    const question = lastAssistantMessage(plan);
-    if (question && question !== streamed) {
-      deps.dispatch({ type: "plannerMessage", content: question, sessionId });
-    }
   } finally {
-    if (tokenTimer !== null) clearTimeout(tokenTimer);
+    inbound.flush();
     stream.close();
   }
 }
-function describeApprovalDecision2(event) {
-  const label = event.source === "pre-approved" ? "pre-approved" : event.source === "remembered" ? "remembered" : event.source === "mode" ? "policy" : "no approval channel";
-  return `${event.granted ? "Auto-approved" : "Auto-denied"} (${label}): ${event.subject}`;
+function restoredChat(plan, sessionId) {
+  const saved = plan;
+  return {
+    type: "chatRestored",
+    history: saved?.conversationHistory ?? [],
+    ...saved?.researchLog ? { researchLog: saved.researchLog } : {},
+    ...saved?.plannerUsage ? { plannerUsage: saved.plannerUsage } : {},
+    sessionId
+  };
 }
 function lastAssistantMessage(plan) {
   const history = plan?.conversationHistory ?? [];
   for (let i = history.length - 1; i >= 0; i--) {
-    if (history[i].role === "assistant") return history[i].content;
+    if (history[i].role === "assistant") {
+      const { content, timestamp } = history[i];
+      return { content, ...timestamp ? { timestamp } : {} };
+    }
   }
   return null;
 }
-function onExecutionEvent(dispatch, event, sessionId) {
-  switch (event?.type) {
-    case "status_update": {
-      const updates = {};
-      for (const task of event.tasks ?? []) {
-        updates[String(task.id)] = { status: String(task.status), idleSince: task.idleSince ?? null, isolation: task.isolation };
-      }
-      dispatch({ type: "tasksStatus", updates, sessionId });
-      return;
-    }
-    case "task_started":
-      dispatch({ type: "taskStarted", taskId: String(event.taskId), title: String(event.title ?? event.taskId), runner: event.runner, sessionId });
-      return;
-    // The extension shows these in its checkpoint panel; here they are
-    // transcript lines, which is the TUI's equivalent surface.
-    case "checkpoint":
-      dispatch({ type: "notice", message: `\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core21.truncateCheckpointSummary)(event.summary)}` });
-      return;
-    case "approval_decided":
-      dispatch({ type: "notice", message: describeApprovalDecision2(event) });
-      return;
-    case "review_needed":
-      dispatch({ type: "notice", message: "Plan needs your sign-off \u2014 /approve to continue." });
-      return;
-    case "review_approved":
-      dispatch({ type: "notice", message: "Plan approved." });
-      return;
-    case "plan_generated":
-      dispatch({ type: "planUpdated", plan: event.plan, sessionId });
-      return;
-    case "planner_message":
-      dispatch({ type: "plannerMessage", content: String(event.content ?? ""), sessionId });
-      return;
-    // The orchestrator paused fan-out because a structural edit is queued; drain
-    // it so the planner reconciles the plan and dependents resume spawning.
-    // Dropped on the floor, the queue suppresses every later tick() — which is
-    // exactly "tasks did not fan out when the dependent ones finished."
-    case "queue_ready":
-      dispatch({ type: "queueReady", sessionId });
-      return;
-    case "execution_complete":
-      dispatch({ type: "executionComplete", summary: event.summary, sessionId });
-      return;
-    // A stop carries no tally — the reducer counts the pane instead.
-    case "execution_stopped":
-      dispatch({ type: "executionComplete", stopped: true, sessionId });
-      return;
-    // Nothing started; the user chooses how to go on.
-    case "isolation_blocked":
-      dispatch({ type: "isolationBlocked", message: event.message, ...event.repos ? { repos: event.repos } : {}, sessionId });
-      return;
-    // How the run isolates. The daemon has no toast channel, so this is the only place the user hears it.
-    case "notice":
-      dispatch({ type: "notice", message: event.message });
-      return;
-    case "isolation_handoff":
-      dispatch({ type: "isolationHandoff", handoff: { repos: event.repos, landed: event.landed }, sessionId });
-      return;
-    // Raw runner chatter, and the planner's own turn: the status line and the
-    // plan pane already say everything the user needs during a run. Listed
-    // rather than defaulted, so a new SessionMessage variant fails to compile
-    // here until someone decides what a run's watcher does with it.
-    case "task_updated":
-    case "task_output":
-    case "plan_thinking":
-    case "planner_liveness":
-    case "research_step":
-    case "plan_token":
-    case "research_step_done":
-    case "approval_request":
-    case "approval_settled":
-      return;
-    // Its asker already has the words, from the merge request itself; a
-    // viewer that did not ask still has to drop a run that is gone.
-    case "isolation_merge":
-      if (event.result.outcome === "merged") dispatch({ type: "runCleared", sessionId });
-      return;
-    default: {
-      const unhandled = event;
-      void unhandled;
-      return;
-    }
-  }
+function compactionSummary(plan) {
+  const history = plan?.conversationHistory ?? [];
+  const entry = history.find((message) => message.kind === "compaction");
+  return entry ? { content: entry.content, ...entry.timestamp ? { timestamp: entry.timestamp } : {} } : null;
 }
 async function refreshPlan(deps, sessionId) {
   const { plan } = await deps.api.getSession(sessionId, deps.workspace);
@@ -6946,6 +7351,7 @@ var CONTROL2 = {
   "\v": "ctrl-k",
   "\f": "ctrl-l",
   "": "ctrl-n",
+  "": "ctrl-o",
   "": "ctrl-p",
   "": "ctrl-u",
   "": "ctrl-w"
@@ -7217,7 +7623,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core22.assertWorkspaceExists)(workspace);
+    (0, import_core29.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -7226,13 +7632,12 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  registerSkillCommands((0, import_core22.createSkillsService)(workspace).listSkills());
+  registerSkillCommands((0, import_core29.createSkillsService)(workspace).listSkills());
   const explicitPort = flag(subArgs, "--port") || process.env.ORDEWELL_PORT;
   const targetPort = explicitPort ? resolvePort(subArgs) : await findFreePort();
   const { port, owned: ownedAtLaunch } = await ensureDaemonOwned(targetPort, { detached: false });
   let owned = ownedAtLaunch;
   const api = new ApiClient(port, workspace);
-  const conversationQueue = new ConversationQueue();
   let terminal;
   const autoMode = process.env.ORDEWELL_AUTONOMOUS_MODE;
   const mouseCapture = process.env.ORDEWELL_TUI_MOUSE !== "false" && process.env.ORDEWELL_TUI_MOUSE !== "0";
@@ -7242,10 +7647,9 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     perform: (effect) => runEffect(effect, {
       api,
       workspace,
-      conversationQueue,
       port,
       dispatch: (action) => app.dispatch(action),
-      newSessionId: () => (0, import_core22.mintSessionId)(),
+      newSessionId: () => (0, import_core29.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
@@ -7366,7 +7770,7 @@ function cliVersion() {
 // src/main.ts
 var TUI_FLAGS = /* @__PURE__ */ new Set(["--workspace", "--port"]);
 async function main() {
-  (0, import_core23.migrateOldConfigDir)();
+  (0, import_core30.migrateOldConfigDir)();
   loadEnvFile();
   const argv = process.argv.slice(2);
   if (TUI_FLAGS.has(argv[0] ?? "")) argv.unshift("tui");