@ordewell/cli 0.4.5 → 0.4.7

package/dist/main.js

@@ -551,6 +551,11 @@ var ApiClient = class {
     const res = await this.httpRequest("POST", `/api/plans/${sessionId}/stop`);
     return res.data;
   }
+  /** Aborts a planning turn in flight. A harmless no-op when the session isn't planning. */
+  async cancelPlanning(sessionId) {
+    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/planning/stop`);
+    return res.data;
+  }
   async processQueued(sessionId) {
     const res = await this.httpRequest("POST", `/api/plans/${sessionId}/process-queued`);
     if (res.status !== 200) {
@@ -1373,14 +1378,18 @@ function fail(...lines) {
   for (const line of lines) console.error(line);
   process.exit(1);
 }
-async function persistEnv(api, env) {
-  await api.updateSettings({ env });
+function writeEnv(env) {
   const envFile = findEnvFile();
   for (const [key, value] of Object.entries(env)) {
     writeEnvVar(envFile, key, value);
     process.env[key] = value;
   }
 }
+async function persistEnv(api, env) {
+  const settings = await api.updateSettings({ env });
+  writeEnv(env);
+  return settings;
+}
 function toTaskView(task) {
   return {
     id: task.id,
@@ -2124,6 +2133,24 @@ async function handleSessions(subArgs, injectedApi) {
 
 // src/commands/planner.ts
 var import_core4 = require("@ordewell/core");
+
+// src/plannerModelSwitch.ts
+function describePlannerSwitch(settings, provider) {
+  const model = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
+  const effort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
+  if (!model) return { model: "", effort: "", source: "none" };
+  return rememberedModelFor(settings, provider) === model ? { model, effort, source: "remembered" } : { model, effort, source: "catalog-default" };
+}
+function rememberedModelFor(settings, provider) {
+  const map = settings.plannerModels;
+  if (!map || typeof map !== "object") return void 0;
+  const entry = map[provider];
+  if (!entry || typeof entry !== "object") return void 0;
+  const { model } = entry;
+  return typeof model === "string" ? model : void 0;
+}
+
+// src/commands/planner.ts
 var KNOWN_PROVIDERS = Object.keys(import_core4.ALL_PROVIDERS);
 async function handlePlanner(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
@@ -2136,31 +2163,28 @@ async function handlePlanner(subArgs, injectedApi) {
   if (!KNOWN_PROVIDERS.includes(provider)) {
     fail(`Unknown planner: ${provider}`, "Run `ordewell planner` with no arguments to see the list.");
   }
-  const settings = await api.getSettings();
-  const current = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
-  const catalog = await fetchCatalog(api);
-  const env = { AI_PROVIDER: provider };
-  if (current && !stillServes(catalog, provider, current)) {
-    env.ORCHESTRATOR_MODEL = "";
-    env.ORDEWELL_PLANNER_EFFORT = "";
-  }
-  await persistEnv(api, env);
+  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_core4.ALL_PROVIDERS[provider];
-  const cleared = env.ORCHESTRATOR_MODEL === "";
+  const catalog = await fetchCatalog(api);
   console.log(
     (0, import_core4.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
   );
-  if (cleared) {
-    console.log(`  ${current} is not one of its models, so the planner model was cleared.`);
-    console.log("  Pick one with `ordewell model set <id>`, or leave it on the default.");
-  }
+  console.log(plannerModelLine(recall2));
   if (!(0, import_core4.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
     console.log(`  No ${meta.apiKeyEnvVar} configured yet \u2014 set one with \`ordewell key set ${provider} <key>\`.`);
   }
 }
-function stillServes(catalog, provider, modelId) {
-  const runner = (0, import_core4.runnerForProvider)(provider);
-  return runner ? catalog.models.some((m) => m.id === modelId && m.runners?.includes(runner)) : catalog.orchestratorModels.some((m) => m.id === modelId);
+function plannerModelLine(recall2) {
+  switch (recall2.source) {
+    case "remembered":
+      return `  Restored its planner model: ${recall2.model}.`;
+    case "catalog-default":
+      return `  Using ${recall2.model}, its default model \u2014 pick another with \`ordewell model set <id>\`.`;
+    case "none":
+      return "  Pick a model with `ordewell model set <id>`, or leave it on the default.";
+  }
 }
 async function showPlanners(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
@@ -2655,6 +2679,9 @@ Dependencies \xB7 #${task.order} ${task.title}
   });
 }
 
+// src/tui/index.ts
+var import_core10 = require("@ordewell/core");
+
 // src/tui/ansi.ts
 var import_string_width = __toESM(require("string-width"));
 var ANSI = /\x1b\[[0-9;]*m/g;
@@ -2677,6 +2704,9 @@ function truncate(text, max) {
   }
   return out + "\u2026";
 }
+function stripTabs(text) {
+  return text.replace(/\t/g, " ");
+}
 function pad(text, target) {
   const current = width(text);
   if (current > target) return truncate(text, target);
@@ -2914,6 +2944,74 @@ function commit(state) {
   return { text: "", cursor: 0, history, historyIndex: history.length, draft: "" };
 }
 
+// src/tui/slash.ts
+var SLASH_COMMANDS = [
+  // Planning. There is deliberately no `/plan`: typing the goal *is* the way to
+  // start planning, and an alias for it only shadowed `/planner` on completion.
+  { name: "approve", usage: "/approve", description: "Approve the drafted plan", category: "planning" },
+  { name: "run", usage: "/run", description: "Execute the approved plan", category: "planning" },
+  { name: "stop", usage: "/stop", description: "Stop the planner or the running execution, whichever is active", category: "planning" },
+  // Tasks
+  { name: "add-task", usage: "/add-task <title>", description: "Add a task to the current plan", category: "tasks" },
+  { name: "remove-task", usage: "/remove-task <id>", description: "Remove a task from the plan", category: "tasks" },
+  { name: "complete", usage: "/complete <id>", description: "Mark a task complete", category: "tasks" },
+  { name: "uncomplete", usage: "/uncomplete <id>", description: "Mark a completed task not done", category: "tasks" },
+  { name: "skip", usage: "/skip <id>", description: "Skip a task", category: "tasks" },
+  { name: "retry", usage: "/retry <id>", description: "Re-run a failed task", category: "tasks" },
+  { name: "cancel", usage: "/cancel <id>", description: "Kill a running task", category: "tasks" },
+  { name: "force-start", usage: "/force-start <id>", description: "Start a task now, ignoring dependencies", category: "tasks" },
+  { name: "terminal", usage: "/terminal <id>", description: "Open a real terminal attached to a task's runner", category: "tasks" },
+  { name: "task-runner", usage: "/task-runner <id> [runner]", description: "Choose or set a task's executor (re-picks its model and mode)", category: "tasks" },
+  { name: "task-model", usage: "/task-model <id> [model]", description: "Choose or set a task's executor model", category: "tasks" },
+  { name: "task-effort", usage: "/task-effort <id> [level]", description: "Choose or set a task's thinking effort", category: "tasks" },
+  { name: "task-mode", usage: "/task-mode <id> [mode]", description: "Choose or set a task's runner mode", category: "tasks" },
+  { name: "task-deps", usage: "/task-deps <id>", description: "Edit which earlier tasks a task waits for", category: "tasks" },
+  // Models & providers
+  { name: "planner", usage: "/planner [<provider>]", description: "Choose who plans \u2014 an API provider or a coding agent (no API key)", category: "models" },
+  { name: "model", usage: "/model [set <id>]", description: "Show or set the orchestrator model", category: "models" },
+  { name: "planner-effort", usage: "/planner-effort [<level>]", description: "Thinking effort for a coding-agent planner", category: "models" },
+  { name: "key", usage: "/key [set <provider> <key>]", description: "Configure API provider keys", category: "models" },
+  { name: "allowlist", usage: "/allowlist [set <runner> <ids> | clear <runner>]", description: "Limit which models a runner may use", category: "models" },
+  { name: "runners", usage: "/runners [<id> on|off]", description: "Enable or disable runners (claude-code, opencode, codex)", category: "models" },
+  { name: "auto", usage: "/auto [on|off]", description: "Autonomous permission mode for new plans", category: "models" },
+  { name: "refresh", usage: "/refresh", description: "Re-discover runners and model catalogs", category: "models" },
+  // Skills
+  { name: "grill-me", usage: "/grill-me [on|off]", description: "Grill-Me challenge mode \u2014 the planner interrogates the goal", category: "skills" },
+  { name: "tdd", usage: "/tdd [on|off]", description: "Test-Driven Development mode", category: "skills" },
+  { name: "prd", usage: "/prd [on|off]", description: "PRD mode \u2014 write a PRD before the plan", category: "skills" },
+  { name: "review", usage: "/review [on|off]", description: "Review mode \u2014 final opinion-review task with human sign-off", category: "skills" },
+  { name: "verify", usage: "/verify [on|off]", description: "Verification mode \u2014 final evidence-based task that runs the suite", category: "skills" },
+  { name: "research-subagents", usage: "/research-subagents [on|off]", description: "Parallel read-only research subagents during planning", category: "skills" },
+  // Sessions
+  { name: "sessions", usage: "/sessions", description: "List saved sessions", category: "session" },
+  { name: "new", usage: "/new", description: "Start a new session", category: "session" },
+  { name: "save", usage: "/save", description: "Save the current session", category: "session" },
+  { name: "load", usage: "/load <id>", description: "Load a saved session", category: "session" },
+  { name: "delete", usage: "/delete <id>", description: "Delete a saved session", category: "session" },
+  // System
+  { name: "help", usage: "/help", description: "Show available commands", category: "system" },
+  { name: "mouse", usage: "/mouse [on|off]", description: "Wheel scrolling and per-pane drag-select (on), or the terminal's own selection (off)", category: "system" },
+  { name: "quit", usage: "/quit", description: "Exit the TUI", category: "system" }
+];
+var BY_NAME = new Map(SLASH_COMMANDS.map((c) => [c.name, c]));
+function parseSlash(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const parts = trimmed.slice(1).split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return null;
+  return { name: parts[0].toLowerCase(), args: parts.slice(1) };
+}
+function findCommand(name) {
+  return BY_NAME.get(name.replace(/^\//, "").toLowerCase());
+}
+function completions(text) {
+  if (!text.startsWith("/")) return [];
+  const typed = text.slice(1);
+  if (/\s/.test(typed)) return [];
+  const prefix = typed.toLowerCase();
+  return SLASH_COMMANDS.filter((c) => c.name.startsWith(prefix));
+}
+
 // src/tui/markdown.ts
 function renderMarkdown(source, cols) {
   const lines = source.replace(/\r/g, "").replace(/^\n+|\n+$/g, "").split("\n");
@@ -2966,16 +3064,16 @@ function tableAt(lines, start) {
   const rows = [];
   let end = start + 1;
   for (let i = start + 2; i < lines.length && lines[i].includes("|"); i += 1) {
-    const cells = tableCells(lines[i]);
-    if (cells.length !== headers.length) break;
-    rows.push(cells);
+    const cells2 = tableCells(lines[i]);
+    if (cells2.length !== headers.length) break;
+    rows.push(cells2);
     end = i;
   }
   return { headers, rows, end };
 }
 function isTableRule(line) {
-  const cells = tableCells(line);
-  return cells.length >= 2 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+  const cells2 = tableCells(line);
+  return cells2.length >= 2 && cells2.every((cell) => /^:?-{3,}:?$/.test(cell));
 }
 function tableCells(line) {
   return line.trim().replace(/^\||\|$/g, "").split("|").map((cell) => cell.trim());
@@ -2989,8 +3087,8 @@ function renderTable(headers, rows, cols) {
   );
   const columnWidths = fitTableColumns(natural, available);
   if (columnWidths.some((size) => size < 4)) return renderStackedTable(headers, rows, cols);
-  const renderRow = (cells, paint = (text) => text) => {
-    const wrapped = cells.map((cell, index) => wrap(inline(cell), columnWidths[index]));
+  const renderRow = (cells2, paint = (text) => text) => {
+    const wrapped = cells2.map((cell, index) => wrap(inline(cell), columnWidths[index]));
     const height = Math.max(...wrapped.map((cell) => cell.length));
     return Array.from(
       { length: height },
@@ -3025,90 +3123,26 @@ 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/slash.ts
-var SLASH_COMMANDS = [
-  // Planning. There is deliberately no `/plan`: typing the goal *is* the way to
-  // start planning, and an alias for it only shadowed `/planner` on completion.
-  { name: "approve", usage: "/approve", description: "Approve the drafted plan", category: "planning" },
-  { name: "run", usage: "/run", description: "Execute the approved plan", category: "planning" },
-  { name: "stop", usage: "/stop", description: "Stop the running execution", category: "planning" },
-  // Tasks
-  { name: "add-task", usage: "/add-task <title>", description: "Add a task to the current plan", category: "tasks" },
-  { name: "remove-task", usage: "/remove-task <id>", description: "Remove a task from the plan", category: "tasks" },
-  { name: "complete", usage: "/complete <id>", description: "Mark a task complete", category: "tasks" },
-  { name: "uncomplete", usage: "/uncomplete <id>", description: "Mark a completed task not done", category: "tasks" },
-  { name: "skip", usage: "/skip <id>", description: "Skip a task", category: "tasks" },
-  { name: "retry", usage: "/retry <id>", description: "Re-run a failed task", category: "tasks" },
-  { name: "cancel", usage: "/cancel <id>", description: "Kill a running task", category: "tasks" },
-  { name: "force-start", usage: "/force-start <id>", description: "Start a task now, ignoring dependencies", category: "tasks" },
-  { name: "terminal", usage: "/terminal <id>", description: "Open a real terminal attached to a task's runner", category: "tasks" },
-  { name: "task-runner", usage: "/task-runner <id> [runner]", description: "Choose or set a task's executor (re-picks its model and mode)", category: "tasks" },
-  { name: "task-model", usage: "/task-model <id> [model]", description: "Choose or set a task's executor model", category: "tasks" },
-  { name: "task-effort", usage: "/task-effort <id> [level]", description: "Choose or set a task's thinking effort", category: "tasks" },
-  { name: "task-mode", usage: "/task-mode <id> [mode]", description: "Choose or set a task's runner mode", category: "tasks" },
-  { name: "task-deps", usage: "/task-deps <id>", description: "Edit which earlier tasks a task waits for", category: "tasks" },
-  // Models & providers
-  { name: "planner", usage: "/planner [<provider>]", description: "Choose who plans \u2014 an API provider or a coding agent (no API key)", category: "models" },
-  { name: "model", usage: "/model [set <id>]", description: "Show or set the orchestrator model", category: "models" },
-  { name: "planner-effort", usage: "/planner-effort [<level>]", description: "Thinking effort for a coding-agent planner", category: "models" },
-  { name: "key", usage: "/key [set <provider> <key>]", description: "Configure API provider keys", category: "models" },
-  { name: "allowlist", usage: "/allowlist [set <runner> <ids> | clear <runner>]", description: "Limit which models a runner may use", category: "models" },
-  { name: "runners", usage: "/runners [<id> on|off]", description: "Enable or disable runners (claude-code, opencode, codex)", category: "models" },
-  { name: "auto", usage: "/auto [on|off]", description: "Autonomous permission mode for new plans", category: "models" },
-  { name: "refresh", usage: "/refresh", description: "Re-discover runners and model catalogs", category: "models" },
-  // Skills
-  { name: "grill-me", usage: "/grill-me [on|off]", description: "Grill-Me challenge mode \u2014 the planner interrogates the goal", category: "skills" },
-  { name: "tdd", usage: "/tdd [on|off]", description: "Test-Driven Development mode", category: "skills" },
-  { name: "prd", usage: "/prd [on|off]", description: "PRD mode \u2014 write a PRD before the plan", category: "skills" },
-  { name: "review", usage: "/review [on|off]", description: "Review mode \u2014 final opinion-review task with human sign-off", category: "skills" },
-  { name: "verify", usage: "/verify [on|off]", description: "Verification mode \u2014 final evidence-based task that runs the suite", category: "skills" },
-  { name: "research-subagents", usage: "/research-subagents [on|off]", description: "Parallel read-only research subagents during planning", category: "skills" },
-  // Sessions
-  { name: "sessions", usage: "/sessions", description: "List saved sessions", category: "session" },
-  { name: "new", usage: "/new", description: "Start a new session", category: "session" },
-  { name: "save", usage: "/save", description: "Save the current session", category: "session" },
-  { name: "load", usage: "/load <id>", description: "Load a saved session", category: "session" },
-  { name: "delete", usage: "/delete <id>", description: "Delete a saved session", category: "session" },
-  // System
-  { name: "help", usage: "/help", description: "Show available commands", category: "system" },
-  { name: "mouse", usage: "/mouse [on|off]", description: "Wheel scrolling instead of drag-to-select text", category: "system" },
-  { name: "quit", usage: "/quit", description: "Exit the TUI", category: "system" }
-];
-var BY_NAME = new Map(SLASH_COMMANDS.map((c) => [c.name, c]));
-function parseSlash(text) {
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("/")) return null;
-  const parts = trimmed.slice(1).split(/\s+/).filter(Boolean);
-  if (parts.length === 0) return null;
-  return { name: parts[0].toLowerCase(), args: parts.slice(1) };
-}
-function findCommand(name) {
-  return BY_NAME.get(name.replace(/^\//, "").toLowerCase());
-}
-function completions(text) {
-  if (!text.startsWith("/")) return [];
-  const typed = text.slice(1);
-  if (/\s/.test(typed)) return [];
-  const prefix = typed.toLowerCase();
-  return SLASH_COMMANDS.filter((c) => c.name.startsWith(prefix));
-}
-
-// src/tui/reducer.ts
-var import_core7 = require("@ordewell/core");
-var import_plan_utils3 = require("@ordewell/core/plan-utils");
-
 // src/tui/geometry.ts
 var PLAN_MIN_COLS = 32;
 var PLAN_MAX_COLS = 64;
 var PANE_INDENT = 4;
 var CHAT_PROMPT_COLS = 2;
-var COLLAPSED_TASK_ROWS = 4;
-var EXPANDED_TASK_CHROME_ROWS = 6;
 function planPaneWidth(state) {
   if (state.tasks.length === 0) return 0;
   const wanted = Math.min(PLAN_MAX_COLS, Math.floor(state.cols * 0.46));
   return wanted >= PLAN_MIN_COLS && state.cols - wanted > PLAN_MIN_COLS ? wanted : 0;
 }
+function chatPaneWidth(state) {
+  const plan = planPaneWidth(state);
+  return plan === 0 ? state.cols : state.cols - plan - 1;
+}
+function paneColumns(state, pane) {
+  const plan = planPaneWidth(state);
+  if (plan === 0) return { first: 1, last: state.cols };
+  const chat = chatPaneWidth(state);
+  return pane === "chat" ? { first: 1, last: chat } : { first: chat + 2, last: state.cols };
+}
 function paneTextRoom(paneCols) {
   return Math.max(1, paneCols - PANE_INDENT);
 }
@@ -3118,19 +3152,19 @@ function taskEditorRoom(state) {
 function chatEditorRoom(cols, active) {
   return Math.max(1, cols - CHAT_PROMPT_COLS - (active ? 1 : 0));
 }
-function planScrollBound(state) {
-  let rows = state.tasks.length * COLLAPSED_TASK_ROWS;
-  if (state.taskEditor) {
-    rows += EXPANDED_TASK_CHROME_ROWS + wrapLines(state.taskEditor.text, taskEditorRoom(state)).length;
-  }
-  return Math.max(0, rows - 1);
-}
 
 // src/tui/state.ts
 var SKILL_IDS = ["grill-me", "tdd", "prd", "review", "verify", "research-subagents"];
 function noSkills() {
   return { "grill-me": false, tdd: false, prd: false, review: false, verify: false, "research-subagents": false };
 }
+function visibleItems(picker2) {
+  const filter = picker2.filter.trim().toLowerCase();
+  if (!filter) return picker2.items;
+  return picker2.items.filter(
+    (i) => i.id.toLowerCase().includes(filter) || i.label.toLowerCase().includes(filter) || (i.detail ?? "").toLowerCase().includes(filter)
+  );
+}
 var isTaskRunning = (task) => task.status === "in_progress" || task.status === "running";
 var anyTaskRunning = (state) => state.tasks.some(isTaskRunning);
 function initialState(overrides = {}) {
@@ -3149,7 +3183,7 @@ function initialState(overrides = {}) {
     expandedTaskId: null,
     taskEditor: null,
     scroll: 0,
-    planScroll: 0,
+    planScroll: null,
     skills: noSkills(),
     runners: [],
     sessions: [],
@@ -3163,7 +3197,8 @@ function initialState(overrides = {}) {
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
-    mouseCapture: false,
+    mouseCapture: true,
+    selection: null,
     workspace: process.cwd(),
     overlay: null,
     pendingApprovals: [],
@@ -3176,41 +3211,676 @@ function initialState(overrides = {}) {
   };
 }
 
-// src/tui/reducer.ts
-var KNOWN_PROVIDERS2 = Object.keys(import_core7.ALL_PROVIDERS);
-var DEFAULT_EFFORT = "__runner_default__";
-function step(state, effects = []) {
-  return { state, effects };
+// src/tui/layout.ts
+var import_core7 = require("@ordewell/core");
+var CHROME_ROWS = 4;
+function chatInputWrap(state) {
+  const active = state.focus === "chat" && !state.overlay;
+  if (!active) return null;
+  return wrapLines(state.editor.text, chatEditorRoom(state.cols, true));
 }
-function say(state, role, content, research) {
-  const message = { role, content, timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...research ? { research } : {} };
-  return { ...state, messages: [...state.messages, message], scroll: 0 };
+function footerHints(state) {
+  const markHint = state.tasks[state.selectedTask]?.status === "completed" ? "m undone" : "m done";
+  const planning = state.status === "planning" || state.status === "researching";
+  const escHint = planning ? "esc stop planning" : null;
+  if (state.focus === "plan") {
+    if (state.expandedTaskId) {
+      return ["type to edit prompt", "pgup/pgdn scroll", "alt-enter newline", "enter save", "esc cancel"];
+    }
+    return [
+      ...escHint ? [escHint] : [],
+      "enter expand",
+      "R runner",
+      "o model",
+      "e effort",
+      "M mode",
+      "D deps",
+      "f start",
+      "E run plan",
+      "c cancel",
+      markHint,
+      "s skip",
+      "a add",
+      "d remove",
+      "t terminal",
+      "pgup/pgdn scroll",
+      "tab chat"
+    ];
+  }
+  return [
+    "/help",
+    "tab plan",
+    "alt-enter newline",
+    "pgup/pgdn scroll",
+    ...escHint ? [escHint] : [],
+    "ctrl-c quit"
+  ];
 }
-function restoredMessages(history) {
-  return history.map((entry) => ({
-    role: entry.kind === "plan_generated" ? "system" : entry.kind === "system" ? "system" : entry.role,
-    content: entry.kind === "plan_generated" ? "Plan generated." : entry.content,
-    timestamp: entry.timestamp
-  }));
+function packHints(hints, cols) {
+  const lines = [];
+  let current = "";
+  for (const hint of hints) {
+    const next = current ? `${current} \xB7 ${hint}` : hint;
+    if (current && next.length > cols) {
+      lines.push(current);
+      current = hint;
+    } else {
+      current = next;
+    }
+  }
+  lines.push(current);
+  return lines;
 }
-var isPendingResearch = (m) => m.role === "research" && !m.research?.outcome;
-function alreadySpoken(messages, content) {
-  const last = findLastIndex(messages, (m) => m.role === "assistant" || m.role === "user");
-  return last >= 0 && messages[last].role === "assistant" && messages[last].content === content;
+function bodyRows(state) {
+  const input = chatInputWrap(state)?.length ?? 1;
+  const footer = packHints(footerHints(state), state.cols).length;
+  return Math.max(0, state.rows - CHROME_ROWS - input - footer + 2);
 }
-function researchLabel(messages, summary) {
-  const others = messages.filter(isPendingResearch).length - 1;
-  return others > 0 ? `${summary} (+${others} more)` : summary;
+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}`;
 }
-function settleResearchStep(messages, action) {
-  const index = findLastIndex(messages, (m) => isPendingResearch(m) && (action.toolCallId ? m.research?.toolCallId === action.toolCallId : m.content === action.summary));
-  if (index < 0) return messages;
-  const next = [...messages];
-  next[index] = {
-    ...next[index],
-    research: { ...next[index].research, outcome: action.outcome, result: action.result }
-  };
-  return next;
+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 };
+  return lines;
+}
+function chatLayout(state, rows, cols) {
+  const welcome = state.tasks.length === 0;
+  if (welcome && state.messages.length === 0) {
+    return { lines: welcomeLines(state, cols), anchor: "top", maxScroll: 0 };
+  }
+  const body = chatBodyLines(state.messages, cols);
+  const lines = welcome ? [...welcomeLines(state, cols), "", ...body] : body;
+  return { lines, anchor: "bottom", maxScroll: Math.max(0, lines.length - rows) };
+}
+function chatScrollMax(state) {
+  return chatLayout(state, bodyRows(state), chatPaneWidth(state)).maxScroll;
+}
+function plannerSetup(state) {
+  const provider = state.plannerProvider;
+  const registration = import_core7.ALL_PROVIDERS[provider];
+  if (!registration) return { label: "not set", ready: false };
+  const runner = (0, import_core7.runnerForProvider)(provider);
+  const ready = runner ? state.runners.some((r) => r.id === runner) : state.configuredProviders.includes(provider);
+  return { label: registration.label, ready };
+}
+var SETUP_KEY_COLS = 10;
+var SETUP_VALUE_COLS = 32;
+function setupRow(label, value, command, cols) {
+  const gap = " ".repeat(Math.max(2, SETUP_VALUE_COLS - width(value)));
+  const head = `  ${style.grey(pad(label, SETUP_KEY_COLS))}${value}${gap}`;
+  return truncate(`${head}${style.grey(command)}`, cols - 1);
+}
+var ICON = `${style.bold("\u226B")}${style.bold(style.cyan("\u25CF"))}`;
+function boldSans(word) {
+  return [...word].map((ch) => {
+    const code = ch.codePointAt(0);
+    return code >= 97 && code <= 122 ? String.fromCodePoint(120302 + (code - 97)) : ch;
+  }).join("");
+}
+var WORDMARK = boldSans("ordewell");
+var LOCKUP = `${ICON} ${WORDMARK}`;
+var BANNER_ROWS = [
+  { strokes: "\u281A\u283B\u2836\u28A6\u28E4\u2840", dot: "", word: "                   \u28B8\u28FF\u2847                            \u28B8\u28FF  \u28FF\u28FF" },
+  { strokes: "    \u2808\u2819\u28B7\u28E4\u2840", dot: "", word: " \u28C0\u28E4\u28E4\u28E4\u28E4\u2840  \u28E4\u28E4\u2880\u28E4\u2844 \u28C0\u28E4\u28E4\u28E4\u28F8\u28FF\u2847  \u28E0\u28E4\u28E4\u28E4\u28C0 \u28A0\u28E4\u2844  \u28E4\u28E4  \u28E0\u28E4  \u28E0\u28E4\u28E4\u28E4\u28C0  \u28B8\u28FF  \u28FF\u28FF" },
+  { strokes: "\u28C0\u28C0\u28C0\u28C0\u28C0\u28C0\u28C0\u28C8\u28FB\u28F6\u28E4\u28C0\u28C0", dot: "\u28C0\u28F6\u28FF\u28F7\u2844", word: "\u28F0\u28FF\u280F\u2801\u2808\u28BB\u28FF\u2846 \u28FF\u28FF\u281F\u2809\u2801\u28F0\u28FF\u280F\u2809\u2809\u28BB\u28FF\u2847 \u28FE\u285F\u2801 \u2819\u28FF\u2846 \u28FF\u28E7 \u28B8\u287F\u28FF\u2844 \u28FF\u284F \u28FE\u287F\u2801 \u2819\u28FF\u28C6 \u28B8\u28FF  \u28FF\u28FF" },
+  { strokes: "\u2809\u2809\u2809\u2809\u2809\u2809\u2809\u2889\u28FD\u287F\u281B\u280B\u2809", dot: "\u2809\u28BF\u28FF\u287F\u2803", word: "\u28FF\u28FF    \u28FF\u2847 \u28FF\u28FF   \u28FF\u28FF   \u28B8\u28FF\u2847\u28B8\u28FF\u287F\u283F\u283F\u283F\u283F\u281F \u28B8\u28FF\u2840\u28FF\u2807\u28B9\u28C7\u28B8\u28FF\u2801 \u28FF\u287F\u283F\u283F\u283F\u283F\u283F \u28B8\u28FF  \u28FF\u28FF" },
+  { strokes: "    \u2880\u28E0\u2876\u281B\u2801", dot: "", word: "\u2839\u28FF\u28E6\u28C0\u28C0\u28FC\u28FF\u2803 \u28FF\u28FF   \u2838\u28FF\u28E6\u28C0\u28E0\u28FE\u28FF\u2847 \u28BF\u28F7\u28C0\u28C0\u28E0\u28F6\u2806  \u28BF\u28FF\u287F \u2818\u28FF\u28FF\u284F  \u28BB\u28F7\u28C4\u28C0\u28E0\u28F6\u2806 \u28B8\u28FF  \u28FF\u28FF" },
+  { strokes: "\u28A4\u28E4\u2836\u283E\u281B\u2801", dot: "", word: " \u2808\u2819\u281B\u281B\u2809   \u2809\u2809    \u2808\u2819\u281B\u280B\u2808\u2809\u2801  \u2809\u281B\u281B\u280B\u2801   \u2808\u2809\u2801  \u2809\u2809    \u2809\u281B\u281B\u280B\u2801  \u2809\u2809  \u2809\u2809" }
+];
+var BANNER_ICON_COLS = 18;
+var BANNER_GAP = 2;
+var BANNER_COLS = Math.max(
+  ...BANNER_ROWS.map((row) => BANNER_ICON_COLS + BANNER_GAP + width(row.word))
+);
+var BANNER_MIN_ROWS = 24;
+var BANNER_WELL_COL = 30;
+function colorWell(word) {
+  const cells2 = [...word];
+  return cells2.slice(0, BANNER_WELL_COL).join("") + style.cyan(cells2.slice(BANNER_WELL_COL).join(""));
+}
+function bannerLines(rows, cols) {
+  if (cols < BANNER_COLS || rows < BANNER_MIN_ROWS) {
+    const left2 = " ".repeat(Math.max(0, Math.floor((cols - width(LOCKUP)) / 2)));
+    return [left2 + LOCKUP];
+  }
+  const left = " ".repeat(Math.floor((cols - BANNER_COLS) / 2));
+  return BANNER_ROWS.map((row) => {
+    const gap = " ".repeat(BANNER_ICON_COLS + BANNER_GAP - width(row.strokes) - width(row.dot));
+    return left + row.strokes + (row.dot ? style.cyan(row.dot) : "") + gap + colorWell(row.word);
+  });
+}
+function welcomeLines(state, cols) {
+  const planner = plannerSetup(state);
+  const enabledRunners = state.runners.filter((r) => r.enabled).map((r) => r.name);
+  const canPlan = planner.ready || state.runners.length > 0 || state.configuredProviders.length > 0;
+  const plannerValue = planner.ready ? [planner.label, state.orchestratorModel || style.yellow("no model")].join(style.grey(" \xB7 ")) : style.yellow(planner.label === "not set" ? "not set" : `${planner.label} (unavailable)`);
+  const lines = [
+    ...bannerLines(state.rows, cols),
+    "",
+    ...wrap(style.bold("Describe a goal to start planning."), Math.max(1, cols - 1)),
+    ...wrap(
+      style.grey("Ordewell researches your codebase, drafts a task plan, then runs each task in a coding agent."),
+      Math.max(1, cols - 1)
+    ),
+    "",
+    style.bold("Setup"),
+    setupRow("Planner", plannerValue, "/planner \xB7 /model", cols),
+    setupRow(
+      "Runners",
+      enabledRunners.length > 0 ? enabledRunners.join(", ") : style.yellow("none enabled"),
+      "/runners",
+      cols
+    ),
+    ""
+  ];
+  if (!canPlan) {
+    lines.push(
+      ...wrap(
+        style.yellow("Ordewell needs one coding agent installed (Claude Code, Codex, OpenCode) \u2014 or an API key from a provider such as OpenRouter, added with /key."),
+        Math.max(1, cols - 1)
+      ),
+      ""
+    );
+  }
+  lines.push(style.grey("/help   all commands"), style.grey(state.workspace));
+  return lines;
+}
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var STATUS_MARK = {
+  completed: style.green,
+  running: style.yellow,
+  in_progress: style.yellow,
+  failed: style.red,
+  blocked: style.red,
+  awaiting_user: style.yellow,
+  cancelled: style.grey,
+  skipped: style.grey
+};
+var STATUS_ICON = {
+  completed: "\u2713",
+  failed: "\u2717",
+  blocked: "!",
+  awaiting_user: "?",
+  cancelled: "\u2212",
+  skipped: "\u2212",
+  approved: "\xB7",
+  pending: "\xB7"
+};
+function planLayout(state, rows, cols) {
+  const done = state.tasks.filter((t) => t.status === "completed").length;
+  const lines = [style.bold(`Plan ${done}/${state.tasks.length}`), ""];
+  let selectedLine = 2;
+  let editorLine;
+  state.tasks.forEach((task, i) => {
+    const taskStart = lines.length;
+    if (i === state.selectedTask) selectedLine = taskStart;
+    const renderedTask = taskLines(state, task, i, cols);
+    if (task.id === state.expandedTaskId && renderedTask.editorLine !== void 0) {
+      editorLine = taskStart + renderedTask.editorLine;
+    }
+    lines.push(...renderedTask.lines);
+  });
+  const maxScroll = Math.max(0, lines.length - rows);
+  const anchorLine = editorLine ?? selectedLine;
+  return { lines, followOffset: Math.min(maxScroll, Math.max(0, anchorLine - rows + 3)), maxScroll };
+}
+function planOffset(layout, planScroll) {
+  if (planScroll === null) return layout.followOffset;
+  return Math.max(0, Math.min(layout.maxScroll, planScroll));
+}
+function planScrollExtent(state) {
+  const cols = planPaneWidth(state);
+  if (cols === 0) return { followOffset: 0, maxScroll: 0 };
+  const { followOffset, maxScroll } = planLayout(state, bodyRows(state), cols);
+  return { followOffset, maxScroll };
+}
+function taskLines(state, task, index, cols) {
+  const selected = state.focus === "plan" && index === state.selectedTask;
+  const expanded = state.expandedTaskId === task.id;
+  const running = isTaskRunning(task);
+  const paint = STATUS_MARK[task.status] ?? ((t) => t);
+  const rawIcon = running ? SPINNER[state.spinnerFrame % SPINNER.length] : STATUS_ICON[task.status] ?? "\xB7";
+  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 head = `${caret} ${icon} ${String(task.order).padStart(2)} ${kind} `;
+  const titleRoom = Math.max(1, cols - width(head));
+  const wrappedTitle = wrap(task.title, titleRoom);
+  const shownTitle = expanded ? wrappedTitle : wrappedTitle.slice(0, 2);
+  if (!expanded && wrappedTitle.length > shownTitle.length) {
+    const last = shownTitle.length - 1;
+    shownTitle[last] = truncate(`${shownTitle[last]}\u2026`, titleRoom);
+  }
+  const continuation = " ".repeat(width(head));
+  const lines = shownTitle.map((line, lineIndex) => {
+    const prefix = lineIndex === 0 ? head : continuation;
+    return prefix + (selected ? style.bold(line) : line);
+  });
+  const model = task.assignedModel?.modelLabel ?? (task.type === "ai" ? "default model" : "");
+  const effort = task.type === "ai" ? `effort: ${task.assignedModel?.thinkingEffort ?? "default"}` : "";
+  const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}` : "";
+  const runner = task.assignedRunner ?? "";
+  const meta = [running ? "working" : "", runner, model].filter(Boolean).join(" \xB7 ");
+  if (meta) lines.push(style.grey(truncate(`    ${meta}`, cols)));
+  if (effort || mode) lines.push(style.grey(truncate(`    ${[effort, mode].filter(Boolean).join(" \xB7 ")}`, cols)));
+  let editorLine;
+  if (expanded) {
+    lines.push(style.grey(`    ${task.status.replace(/_/g, " ")}`));
+    const editableSeed = task.prompt ?? task.description ?? task.title;
+    if (task.description && task.description !== task.title && task.description !== editableSeed) {
+      lines.push(...taskText("Description", task.description, cols));
+    }
+    if (state.taskEditor) {
+      const room = paneTextRoom(cols);
+      const wrapped = wrapLines(state.taskEditor.text, room);
+      const cp = cursorInLines(wrapped, state.taskEditor.cursor, state.taskEditor.text.length);
+      editorLine = lines.length + 1 + cp.line;
+      lines.push(...taskPromptLines(wrapped, cp));
+    }
+    if (task.dependencies.length > 0) {
+      const orderById = new Map(state.tasks.map((candidate) => [candidate.id, candidate.order]));
+      const dependencies = task.dependencies.map((id) => orderById.has(id) ? `#${orderById.get(id)}` : id).join(", ");
+      lines.push(...taskText("Depends on", dependencies, cols));
+    }
+    lines.push(style.grey("    enter save \xB7 esc cancel"));
+    lines.push(style.grey(truncate("    then R runner \xB7 o model \xB7 e effort \xB7 M mode \xB7 D deps", cols)));
+  }
+  return { lines, editorLine };
+}
+function taskText(label, text, cols) {
+  const room = paneTextRoom(cols);
+  return [
+    style.grey(`    ${label}`),
+    ...wrap(text, room).map((line) => `    ${line}`)
+  ];
+}
+function taskPromptLines(wrapped, cursor) {
+  return [
+    style.grey("    Prompt"),
+    ...wrapped.map(({ line }, i) => {
+      if (i !== cursor.line) return `    ${line}`;
+      const col = cursor.col;
+      return `    ${line.slice(0, col)}${style.inverse(line.slice(col, col + 1) || " ")}${line.slice(col + 1)}`;
+    })
+  ];
+}
+var CATEGORY_TITLE = {
+  planning: "Planning",
+  tasks: "Tasks",
+  models: "Models & providers",
+  skills: "Skills",
+  session: "Sessions",
+  system: "System"
+};
+function helpLayout(rows, cols) {
+  const body = [];
+  for (const [category, title] of Object.entries(CATEGORY_TITLE)) {
+    const commands = SLASH_COMMANDS.filter((c) => c.category === category);
+    if (commands.length === 0) continue;
+    body.push(style.bold(title));
+    for (const command of commands) {
+      body.push(`  ${pad(command.usage, Math.min(38, cols - 6))} ${style.grey(command.description)}`);
+    }
+    body.push("");
+  }
+  body.push(
+    style.grey("tab switches panes \xB7 \u2191\u2193/pgup/pgdn scroll \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);
+  return { lines, room, maxScroll: Math.max(0, lines.length - room) };
+}
+function helpScrollMax(state) {
+  return helpLayout(bodyRows(state), state.cols).maxScroll;
+}
+
+// src/tui/render.ts
+function render(state) {
+  const { rows, cols } = state;
+  const rowsForBody = bodyRows(state);
+  const body = state.overlay ? renderOverlay(state, rowsForBody, cols) : renderBody(state, rowsForBody, cols);
+  const lines = [
+    renderSkills(state, cols),
+    ...body,
+    renderStatus(state, cols),
+    ...renderInput(state, cols),
+    ...renderFooter(state, cols)
+  ];
+  const frame2 = lines.slice(Math.max(0, lines.length - rows)).map((l) => pad(l, cols));
+  return highlightSelection(frame2, state);
+}
+function selectionSpans(state) {
+  const { selection } = state;
+  if (!selection) return [];
+  const { anchor, head } = selection;
+  const forwards = anchor.row < head.row || anchor.row === head.row && anchor.col <= head.col;
+  const [start, end] = forwards ? [anchor, head] : [head, anchor];
+  const { first, last } = paneColumns(state, selection.pane);
+  const spans = [];
+  for (let row = start.row; row <= end.row; row++) {
+    spans.push({
+      row,
+      from: row === start.row ? start.col : first,
+      to: row === end.row ? end.col : last
+    });
+  }
+  return spans;
+}
+function cells(line) {
+  const out = [];
+  for (const char of stripAnsi(line)) {
+    out.push(char);
+    for (let i = 1; i < Math.max(1, width(char)); i++) out.push("");
+  }
+  return out;
+}
+var INVERSE_ON = "\x1B[7m";
+var INVERSE_OFF = "\x1B[27m";
+var SGR_SPLIT = /(\x1b\[[0-9;]*m)/;
+function invertCells(line, from, to) {
+  let out = "";
+  let col = 1;
+  let inside = false;
+  for (const piece of line.split(SGR_SPLIT)) {
+    if (SGR_SPLIT.test(piece)) {
+      out += piece + (inside ? INVERSE_ON : "");
+      continue;
+    }
+    for (const char of piece) {
+      if (inside && col > to) {
+        out += INVERSE_OFF;
+        inside = false;
+      } else if (!inside && col >= from && col <= to) {
+        out += INVERSE_ON;
+        inside = true;
+      }
+      out += char;
+      col += Math.max(1, width(char));
+    }
+  }
+  return inside ? out + INVERSE_OFF : out;
+}
+function highlightSelection(frame2, state) {
+  if (!state.selection || !style.enabled) return frame2;
+  const painted = [...frame2];
+  for (const { row, from, to } of selectionSpans(state)) {
+    const line = painted[row - 1];
+    if (line !== void 0) painted[row - 1] = invertCells(line, from, to);
+  }
+  return painted;
+}
+function selectedText(state) {
+  const spans = selectionSpans(state);
+  if (spans.length === 0) return "";
+  const frame2 = render(state);
+  return spans.map(({ row, from, to }) => cells(frame2[row - 1] ?? "").slice(from - 1, to).join("").replace(/\s+$/, "")).join("\n");
+}
+function fit(lines, rows, anchor) {
+  if (lines.length >= rows) {
+    return anchor === "bottom" ? lines.slice(lines.length - rows) : lines.slice(0, rows);
+  }
+  const blanks = Array(rows - lines.length).fill("");
+  return anchor === "bottom" ? [...blanks, ...lines] : [...lines, ...blanks];
+}
+function renderSkills(state, cols) {
+  const badges = SKILL_IDS.map(
+    (id) => state.skills[id] ? style.green(`\u25CF ${id}`) : style.grey(`\u25CB ${id}`)
+  );
+  const auto = state.autonomous ? style.yellow("\u25CF auto") : style.grey("\u25CB auto");
+  return truncate([...badges, auto].join(" "), cols);
+}
+function scrolledBackMark(state) {
+  if (state.focus === "plan") return state.planScroll === null ? "" : "\u2191 scrolled back \xB7 \u2191\u2193 to follow";
+  return state.scroll > 0 ? "\u2191 scrolled back \xB7 pgdn for live" : "";
+}
+function renderStatus(state, cols) {
+  const mark = scrolledBackMark(state);
+  if (state.status === "idle") {
+    const notes = [mark, state.toast].filter(Boolean).join(" \xB7 ");
+    return notes ? truncate(style.grey(notes), 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);
+}
+function renderInput(state, cols) {
+  const prompt = state.focus === "plan" ? style.grey("\u276F ") : style.cyan("\u276F ");
+  const lines = chatInputWrap(state);
+  const room = chatEditorRoom(cols, lines !== null);
+  const { text, cursor } = state.editor;
+  const continuation = " ".repeat(width(prompt));
+  if (!lines) {
+    const visible = text.replace(/\n/g, "\xB6").replace(/\t/g, " ");
+    return [prompt + visible + suggest(state, room - width(visible))];
+  }
+  const { line: lineIndex, col } = cursorInLines(lines, cursor, text.length);
+  const rawLines = lines.map((l) => l.line);
+  return rawLines.map((raw, i) => {
+    const prefix = i === 0 ? prompt : continuation;
+    const line = raw.replace(/\t/g, " ");
+    const isCursorLine = i === lineIndex;
+    const rendered = isCursorLine ? line.slice(0, col) + style.inverse(line.slice(col, col + 1) || " ") + line.slice(col + 1) : line;
+    const used = width(line) + (isCursorLine && col >= line.length ? 1 : 0);
+    const hint = i === rawLines.length - 1 ? suggest(state, room - used) : "";
+    return prefix + rendered + hint;
+  });
+}
+function suggest(state, room) {
+  if (state.focus === "plan" || room <= 2) return "";
+  const matches = completions(state.editor.text);
+  if (matches.length === 0) return "";
+  const names = matches.map((c) => c.name).join(" ");
+  return style.grey(`  ${truncate(names, Math.max(0, room - 2))}`);
+}
+function renderFooter(state, cols) {
+  return packHints(footerHints(state), cols).map((line) => truncate(style.grey(line), cols));
+}
+function renderBody(state, rows, cols) {
+  const planCols = planPaneWidth(state);
+  if (planCols === 0) return renderChat(state, rows, cols);
+  const chatCols = chatPaneWidth(state);
+  const chat = renderChat(state, rows, chatCols);
+  const plan = renderPlan(state, rows, planCols);
+  return Array.from(
+    { length: rows },
+    (_, i) => `${pad(chat[i] ?? "", chatCols)}${style.grey("\u2502")}${pad(plan[i] ?? "", planCols)}`
+  );
+}
+function renderChat(state, rows, cols) {
+  const { lines, anchor, maxScroll } = chatLayout(state, rows, cols);
+  const back = Math.min(state.scroll, maxScroll);
+  return fit(lines.slice(0, lines.length - back), rows, anchor);
+}
+function renderPlan(state, rows, cols) {
+  const layout = planLayout(state, rows, cols);
+  const offset = planOffset(layout, state.planScroll);
+  return fit([layout.lines[0], ...layout.lines.slice(1 + offset)], rows, "top");
+}
+function renderOverlay(state, rows, cols) {
+  const overlay = state.overlay;
+  if (overlay.kind === "help") return renderHelp(overlay.scroll ?? 0, rows, cols);
+  if (overlay.kind === "approval") {
+    const { request } = overlay;
+    const headline = request.kind === "shell_command" ? "The planner wants to run a command" : request.kind === "url_fetch" ? "The planner wants to fetch a URL" : "The planner wants to read a path outside the workspace";
+    const queued = state.pendingApprovals.length;
+    return frame(
+      "Approval needed",
+      [
+        headline,
+        "",
+        `  ${style.yellow(request.subject)}`,
+        "",
+        // Disambiguates the `external_path` case: an auto-tier command like
+        // `cat` touching an outside path reads identically to a plain
+        // `read_file` without it.
+        ...request.detail ? [style.grey(request.detail), ""] : [],
+        // The grant is wider than the request, so name it rather than letting
+        // the user discover it when the next call silently does not prompt.
+        style.grey(`Approving also allows ${request.scope} for the rest of this session.`),
+        ...queued > 0 ? [style.grey(`${queued} more waiting.`)] : [],
+        "",
+        // 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")
+      ],
+      rows,
+      cols
+    );
+  }
+  if (overlay.kind === "confirm") {
+    return frame(
+      overlay.title,
+      [overlay.message, "", style.grey("enter confirms \xB7 esc cancels")],
+      rows,
+      cols
+    );
+  }
+  if (overlay.kind === "prompt") {
+    const secret = overlay.action.kind === "api-key";
+    const shown = secret ? "\u2022".repeat(overlay.value.length) : overlay.value;
+    return frame(
+      overlay.title,
+      [overlay.hint ? style.grey(overlay.hint) : "", "", `${style.cyan("\u276F")} ${shown}`, "", style.grey("enter confirms \xB7 esc cancels")],
+      rows,
+      cols
+    );
+  }
+  return renderPicker(overlay.picker, rows, cols);
+}
+function renderPicker(picker2, rows, cols) {
+  const items = visibleItems(picker2);
+  const body = [];
+  if (picker2.hint) body.push(style.grey(picker2.hint));
+  body.push(`${style.grey("filter:")} ${picker2.filter}${style.grey("\u258F")}`, "");
+  if (items.length === 0) {
+    body.push(style.grey(picker2.filter ? "Nothing matches that filter." : "Nothing to show yet\u2026"));
+  }
+  const room = Math.max(1, rows - body.length - 3);
+  const start = Math.max(0, Math.min(picker2.index - Math.floor(room / 2), items.length - room));
+  for (const [offset, item] of items.slice(start, start + room).entries()) {
+    const active = start + offset === picker2.index;
+    const mark = picker2.multi ? picker2.chosen.includes(item.id) ? style.green("[\u2713]") : style.grey("[ ]") : item.selected ? style.green("\u25CF") : " ";
+    const caret = active ? style.cyan("\u276F") : " ";
+    const label = truncate(item.label, Math.max(1, cols - 12));
+    const detail = item.detail ? style.grey(` \u2014 ${item.detail}`) : "";
+    const line = item.disabled ? `${caret} ${mark} ${style.grey(label)}${detail}` : `${caret} ${mark} ${active ? style.bold(label) : label}${detail}`;
+    body.push(truncate(line, cols - 2));
+  }
+  body.push("", style.grey(picker2.multi ? "space toggles \xB7 enter confirms \xB7 esc cancels \xB7 type to filter" : "enter selects \xB7 esc cancels \xB7 type to filter"));
+  return frame(picker2.title, body, rows, cols);
+}
+function renderHelp(scroll, rows, cols) {
+  const { lines, room, maxScroll } = helpLayout(rows, cols);
+  const offset = Math.min(scroll, maxScroll);
+  const footer = style.grey(offset < maxScroll ? "\u2191\u2193 scroll \xB7 any other key closes" : "any key closes");
+  return frame("Commands", [...lines.slice(offset, offset + room), footer], rows, cols);
+}
+function frame(title, body, rows, cols) {
+  const inner = Math.max(1, cols - 2);
+  const lines = [
+    style.grey(`\u250C\u2500 ${style.bold(title)} ${"\u2500".repeat(Math.max(0, inner - width(title) - 3))}`),
+    ...body.flatMap((line) => wrap(line, inner)).map((line) => ` ${truncate(line, inner)}`)
+  ];
+  return fit(lines, rows, "top");
+}
+
+// src/tui/reducer.ts
+var import_core8 = require("@ordewell/core");
+var import_plan_utils3 = require("@ordewell/core/plan-utils");
+var KNOWN_PROVIDERS2 = Object.keys(import_core8.ALL_PROVIDERS);
+var DEFAULT_EFFORT = "__runner_default__";
+function step(state, effects = []) {
+  return { state, effects };
+}
+function say(state, role, content, research) {
+  const message = { role, content: stripTabs(content), timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...research ? { research } : {} };
+  return { ...state, messages: [...state.messages, message], scroll: 0 };
+}
+function restoredMessages(history) {
+  return history.map((entry) => ({
+    role: entry.kind === "plan_generated" ? "system" : entry.kind === "system" ? "system" : entry.role,
+    content: stripTabs(entry.kind === "plan_generated" ? "Plan generated." : entry.content),
+    timestamp: entry.timestamp
+  }));
+}
+var isPendingResearch = (m) => m.role === "research" && !m.research?.outcome;
+function alreadySpoken(messages, content) {
+  const last = findLastIndex(messages, (m) => m.role === "assistant" || m.role === "user");
+  return last >= 0 && messages[last].role === "assistant" && messages[last].content === content;
+}
+function researchLabel(messages, summary) {
+  const others = messages.filter(isPendingResearch).length - 1;
+  return others > 0 ? `${summary} (+${others} more)` : summary;
+}
+function settleResearchStep(messages, action) {
+  const summary = stripTabs(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: stripTabs(action.result) }
+  };
+  return next;
 }
 function findLastIndex(items, match) {
   for (let i = items.length - 1; i >= 0; i--) {
@@ -3266,21 +3936,26 @@ function reduce(state, action) {
     case "plannerMessage": {
       if (stale(state, action.sessionId)) return step(state);
       const settled = { ...state, status: "idle", busyLabel: "", thinkingLine: "" };
-      if (alreadySpoken(state.messages, action.content)) return step(settled);
-      return step(say(settled, "assistant", action.content));
+      const content = stripTabs(action.content);
+      if (alreadySpoken(state.messages, content)) return step(settled);
+      return step(say(settled, "assistant", content));
     }
     case "researchStep": {
       if (stale(state, action.sessionId)) return step(state);
-      const spoken = say(state, "research", action.summary, { toolCallId: action.toolCallId });
-      return step({ ...spoken, busyLabel: researchLabel(spoken.messages, action.summary) });
+      const summary = stripTabs(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) });
     }
     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) : ""
       });
     }
@@ -3361,8 +4036,14 @@ function reduce(state, action) {
       return step({ ...say(state, "error", action.message), status: "idle", busyLabel: "", thinkingLine: "" });
     case "notice":
       return step(say(state, "system", action.message));
-    case "resize":
-      return step({ ...state, rows: action.rows, cols: action.cols });
+    case "resize": {
+      const resized = { ...state, rows: action.rows, cols: action.cols, selection: null };
+      return step({
+        ...resized,
+        scroll: clamp(resized.scroll, chatScrollMax(resized)),
+        planScroll: resized.planScroll === null ? null : clamp(resized.planScroll, planScrollExtent(resized).maxScroll)
+      });
+    }
     // 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":
@@ -3434,11 +4115,11 @@ function modelDetail(m) {
 function providerErrorHint(state) {
   const failed = Object.keys(state.providerErrors ?? {});
   if (failed.length === 0) return void 0;
-  const names = failed.map((p) => import_core7.ALL_PROVIDERS[p]?.label ?? p);
+  const names = failed.map((p) => import_core8.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_core7.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core8.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,
@@ -3449,7 +4130,7 @@ function plannerModelItems(state) {
   return items.length > 0 ? items : [{ id: "", label: `No ${runner} models discovered yet`, detail: "run /refresh", disabled: true }];
 }
 function plannerEffortItems(state) {
-  const runner = (0, import_core7.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core8.runnerForProvider)(state.plannerProvider);
   if (!runner) {
     return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
   }
@@ -3548,13 +4229,80 @@ function pickerItemsFor(state, action) {
   }
   return [];
 }
+var WHEEL_NOTCH = 3;
+function pageNotch(viewport) {
+  return Math.max(1, viewport - 1);
+}
+function scrollDelta(key, state) {
+  if (key.name === "scrollup") return WHEEL_NOTCH;
+  if (key.name === "scrolldown") return -WHEEL_NOTCH;
+  if (key.name === "pageup") return pageNotch(bodyRows(state));
+  if (key.name === "pagedown") return -pageNotch(bodyRows(state));
+  return null;
+}
+var isWheel = (key) => key.name === "scrollup" || key.name === "scrolldown";
+function pointerPane(state, key) {
+  if (key.col === void 0 || planPaneWidth(state) === 0) return state.focus;
+  return key.col <= chatPaneWidth(state) ? "chat" : "plan";
+}
+function scrollPointed(state, key) {
+  const delta = key.name === "scrollup" ? WHEEL_NOTCH : -WHEEL_NOTCH;
+  return pointerPane(state, key) === "plan" ? scrollPlan(state, delta) : scrollChat(state, delta);
+}
+var isMouseSelect = (key) => key.name === "mousedown" || key.name === "mousedrag" || key.name === "mouseup";
+function selectionCell(state, pane, key) {
+  const { first, last } = paneColumns(state, pane);
+  return {
+    col: clampRange(key.col ?? first, first, last),
+    row: clampRange(key.row ?? 1, 1, state.rows)
+  };
+}
+function clampRange(value, low, high) {
+  return Math.max(low, Math.min(high, value));
+}
+var isClick = (selection) => selection.anchor.col === selection.head.col && selection.anchor.row === selection.head.row;
+function handleMouseSelect(state, key) {
+  if (key.name === "mousedown") {
+    const pane = pointerPane(state, key);
+    const cell = selectionCell(state, pane, key);
+    return step({ ...state, selection: { anchor: cell, head: cell, pane } });
+  }
+  const { selection } = state;
+  if (!selection) return step(state);
+  const moved = { ...selection, head: selectionCell(state, selection.pane, key) };
+  if (key.name === "mousedrag") return step({ ...state, selection: moved });
+  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 scrollPlan(state, delta) {
+  const { followOffset, maxScroll } = planScrollExtent(state);
+  const from = state.planScroll ?? followOffset;
+  return step({ ...state, planScroll: clamp(from - delta, maxScroll) });
+}
+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 matches = completions(state.editor.text);
     if (matches.length > 0) {
@@ -3566,18 +4314,9 @@ function handleKey2(state, key) {
   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 } });
-  if (key.name === "pageup" || key.name === "pagedown") {
-    const page = Math.max(1, state.rows - 6);
-    const scroll = key.name === "pageup" ? state.scroll + page : Math.max(0, state.scroll - page);
-    return step({ ...state, scroll });
-  }
+  const scroll = scrollDelta(key, state);
+  if (scroll !== null) return scrollChat(state, scroll);
   const multilineEditor = state.editor.text.includes("\n");
-  if (key.name === "scrollup" || key.name === "scrolldown") {
-    const notch = 3;
-    const backward = key.name === "scrollup";
-    const scroll = backward ? state.scroll + notch : Math.max(0, state.scroll - notch);
-    return step({ ...state, scroll });
-  }
   const room = chatEditorRoom(state.cols, true);
   return step({ ...state, editor: applyKey(state.editor, key, multilineEditor ? room : void 0) });
 }
@@ -3604,24 +4343,18 @@ function handlePlanKey(state, key) {
   if (editingTask && state.taskEditor) return handleTaskEditKey(state, editingTask, state.taskEditor, key);
   if (key.name === "escape") return step({ ...state, focus: "chat" });
   if (key.name === "up") {
-    return step({ ...state, selectedTask: Math.max(0, state.selectedTask - 1), expandedTaskId: null, planScroll: 0 });
+    return step({ ...state, selectedTask: Math.max(0, state.selectedTask - 1), expandedTaskId: null, planScroll: null });
   }
   if (key.name === "down") {
     return step({
       ...state,
       selectedTask: Math.min(state.tasks.length - 1, state.selectedTask + 1),
       expandedTaskId: null,
-      planScroll: 0
+      planScroll: null
     });
   }
-  if (key.name === "scrollup" || key.name === "pageup") {
-    const notch = key.name === "pageup" ? 10 : 3;
-    return step({ ...state, planScroll: Math.max(0, state.planScroll - notch) });
-  }
-  if (key.name === "scrolldown" || key.name === "pagedown") {
-    const notch = key.name === "pagedown" ? 10 : 3;
-    return step({ ...state, planScroll: Math.min(planScrollBound(state), state.planScroll + notch) });
-  }
+  const scroll = scrollDelta(key, state);
+  if (scroll !== null) return scrollPlan(state, scroll);
   const task = state.tasks[state.selectedTask];
   if (!task) return step(state);
   if (key.name === "enter" || key.name === "right") {
@@ -3653,14 +4386,8 @@ function handlePlanKey(state, key) {
 function handleTaskEditKey(state, task, editor, key) {
   if (key.name === "enter") return commitTaskEdit(state, task, editor);
   if (key.name === "escape") return step({ ...state, expandedTaskId: null, taskEditor: null });
-  if (key.name === "scrollup" || key.name === "pageup") {
-    const notch = key.name === "pageup" ? 10 : 3;
-    return step({ ...state, planScroll: Math.max(0, state.planScroll - notch) });
-  }
-  if (key.name === "scrolldown" || key.name === "pagedown") {
-    const notch = key.name === "pagedown" ? 10 : 3;
-    return step({ ...state, planScroll: Math.min(planScrollBound(state), state.planScroll + notch) });
-  }
+  const scroll = scrollDelta(key, state);
+  if (scroll !== null) return scrollPlan(state, scroll);
   return step({ ...state, taskEditor: applyKey(editor, key, taskEditorRoom(state)) });
 }
 function commitTaskEdit(state, task, editor) {
@@ -3705,6 +4432,8 @@ function handleApprovalKey(state, overlay, key) {
 }
 function handleOverlayKey(state, overlay, key) {
   if (overlay.kind === "help") return handleHelpKey(state, overlay.scroll ?? 0, key);
+  if (key.name === "wheelignored") return step(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") return step({ ...state, overlay: null });
@@ -3723,17 +4452,18 @@ function handleConfirmKey(state, overlay, key) {
   return step(closed);
 }
 function handleHelpKey(state, scroll, key) {
+  const page = pageNotch(bodyRows(state));
   const move = {
     down: 1,
     up: -1,
-    pagedown: 10,
-    pageup: -10,
-    scrolldown: 3,
-    scrollup: -3
+    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: Math.max(0, scroll + delta) } });
+  return step({ ...state, overlay: { kind: "help", scroll: clamp(scroll + delta, helpScrollMax(state)) } });
 }
 function handlePromptKey(state, overlay, key) {
   if (key.name === "enter") {
@@ -3756,18 +4486,13 @@ function editText(value, key) {
   if (key.name === "ctrl-u") return "";
   return value;
 }
-function visibleItems(picker2) {
-  const filter = picker2.filter.trim().toLowerCase();
-  if (!filter) return picker2.items;
-  return picker2.items.filter(
-    (i) => i.id.toLowerCase().includes(filter) || i.label.toLowerCase().includes(filter) || (i.detail ?? "").toLowerCase().includes(filter)
-  );
-}
 function handlePickerKey(state, picker2, key) {
   const items = visibleItems(picker2);
   const reopen = (next) => step({ ...state, overlay: { kind: "picker", picker: next } });
-  if (key.name === "up") return reopen({ ...picker2, index: Math.max(0, picker2.index - 1) });
-  if (key.name === "down") return reopen({ ...picker2, index: Math.min(items.length - 1, picker2.index + 1) });
+  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);
@@ -3813,11 +4538,8 @@ function choose(state, picker2, item) {
   switch (picker2.action.kind) {
     case "set-model":
       return step(closed, [{ type: "setModel", modelId: item.id }]);
-    case "set-planner": {
-      const runner = (0, import_core7.runnerForProvider)(item.id);
-      const stillValid = runner ? state.models.some((m) => m.id === state.orchestratorModel && m.runners?.includes(runner)) : state.orchestratorModels.some((m) => m.id === state.orchestratorModel);
-      return step(closed, [{ type: "setPlanner", provider: item.id, clearModel: !stillValid }]);
-    }
+    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":
@@ -3911,7 +4633,12 @@ function runCommand(state, { name, args }) {
         (sessionId) => step({ ...state, planApproved: true }, [{ type: "execute", sessionId }])
       );
     case "stop":
-      return withSession(state, (sessionId) => step(state, [{ type: "stopExecution", sessionId }]));
+      return withSession(
+        state,
+        (sessionId) => step(state, [
+          state.status === "planning" || state.status === "researching" ? { type: "cancelPlanning", sessionId } : { type: "stopExecution", sessionId }
+        ])
+      );
     case "model":
       return setModel(state, args);
     case "planner":
@@ -3974,984 +4701,481 @@ function runCommand(state, { name, args }) {
     case "skip":
     case "retry":
     case "cancel":
-    case "force-start":
-      return taskCommand(
-        state,
-        args[0],
-        (sessionId, taskId) => step(state, [taskActionEffect(state, sessionId, taskId, name)])
-      );
-  }
-  return fail2(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 fail2(state, "No active plan \u2014 describe a goal first, or load a session with /sessions.");
-  }
-  return run(state.sessionId);
-}
-function resolveToggle(arg, current) {
-  const value = arg?.toLowerCase();
-  if (value === "on") return true;
-  if (value === "off") return false;
-  if (value === void 0) return !current;
-  return null;
-}
-function toggleSkill(state, skill, arg) {
-  const enabled = resolveToggle(arg, state.skills[skill]);
-  if (enabled === null) return fail2(state, `Usage: /${skill} [on|off]`);
-  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";
-  if (!state.sessionId || !hasContent) return newSession(state);
-  return step({
-    ...state,
-    overlay: {
-      kind: "confirm",
-      title: "Start a new session?",
-      message: "The current plan will be cleared and any running tasks stopped.",
-      action: { kind: "new-session" }
-    }
-  });
-}
-function newSession(state) {
-  const closeEffects = state.sessionId ? [{ type: "closeSession", sessionId: state.sessionId }] : [];
-  return step({
-    ...state,
-    sessionId: null,
-    goal: "",
-    tasks: [],
-    planApproved: false,
-    messages: [],
-    selectedTask: 0,
-    expandedTaskId: null,
-    taskEditor: null,
-    scroll: 0,
-    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: [],
-    overlay: state.overlay?.kind === "approval" ? null : state.overlay
-  }, closeEffects);
-}
-function setModel(state, args) {
-  if (args[0] === "set" && args[1]) {
-    const runner = (0, import_core7.runnerForProvider)(state.plannerProvider);
-    const known = runner ? modelsForRunner(state.models, runner) : [];
-    if (runner && known.length > 0 && !known.some((m) => m.id === args[1])) {
-      return fail2(state, `${args[1]} was not discovered for ${runner}.`);
-    }
-    return step(state, [{ type: "setModel", modelId: args[1] }]);
-  }
-  if (args.length > 0 && args[0] !== "set") return fail2(state, "Usage: /model [set <model-id>]");
-  const items = pickerItemsFor(state, { kind: "set-model" });
-  return step(
-    {
-      ...state,
-      overlay: {
-        kind: "picker",
-        picker: picker("Orchestrator model", items, { kind: "set-model" }, { hint: providerErrorHint(state) })
-      }
-    },
-    [{ type: "loadModels" }]
-  );
-}
-function plannerItems(state) {
-  const installed = new Set(state.runners.map((r) => r.id));
-  const agents = import_core7.CLI_PROVIDERS.map((id) => {
-    const runner = (0, import_core7.runnerForProvider)(id);
-    const ready = installed.has(runner);
-    return {
-      id,
-      label: import_core7.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_core7.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
-    id,
-    label: import_core7.ALL_PROVIDERS[id].label,
-    detail: import_core7.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();
-    if (!KNOWN_PROVIDERS2.includes(id)) {
-      return fail2(state, `Unknown planner: ${id}. Run /planner with no arguments to see the list.`);
-    }
-    return step(state, [{ type: "setPlanner", provider: id }]);
-  }
-  return step({
-    ...state,
-    overlay: {
-      kind: "picker",
-      picker: picker("Planner", plannerItems(state), { kind: "set-planner" }, {
-        hint: "Who researches your goal and writes the plan. Coding agents use their own subscription \u2014 no API key."
-      })
-    }
-  });
-}
-function setPlannerEffort(state, args) {
-  const items = plannerEffortItems(state);
-  if (args[0]) {
-    const wanted = args[0].toLowerCase();
-    const match = items.find((i) => !i.disabled && (i.id === wanted || wanted === "default" && i.id === DEFAULT_EFFORT));
-    if (!match) {
-      const available = items.filter((i) => !i.disabled && i.id !== DEFAULT_EFFORT).map((i) => i.id);
-      return fail2(state, available.length > 0 ? `Unknown effort: ${args[0]}. Available: ${available.join(", ")}, default.` : items[0]?.label ?? "No effort levels available.");
-    }
-    return step(state, [{ type: "setPlannerEffort", effort: match.id === DEFAULT_EFFORT ? "" : match.id }]);
-  }
-  return step({
-    ...state,
-    overlay: {
-      kind: "picker",
-      picker: picker("Planner thinking effort", items, { kind: "set-planner-effort" }, {
-        hint: "How hard the planning agent thinks per turn. Higher costs latency and tokens against your subscription."
-      })
-    }
-  });
-}
-function setKey(state, args) {
-  if (args[0] === "set" && args[1]) {
-    const provider = args[1].toLowerCase();
-    if (!KNOWN_PROVIDERS2.includes(provider)) {
-      return fail2(state, `Unknown provider: ${provider}. Run /key with no arguments to see the list.`);
-    }
-    if (!args[2]) {
-      return step({
-        ...state,
-        overlay: keyPrompt(provider)
-      });
-    }
-    return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
-  }
-  const items = import_core7.PROVIDER_PRIORITY.map((id) => ({
-    id,
-    label: import_core7.ALL_PROVIDERS[id].label,
-    detail: import_core7.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_core7.ALL_PROVIDERS[provider];
-  return {
-    kind: "prompt",
-    title: `${meta.label} API key`,
-    hint: `Stored as ${meta.apiKeyEnvVar} in your .env`,
-    value: "",
-    action: { kind: "api-key", provider, envVar: meta.apiKeyEnvVar }
-  };
-}
-function allowlist(state, args) {
-  const [sub, runner, ...rest] = args;
-  if (sub === "set") {
-    if (!runner || rest.length === 0) return fail2(state, "Usage: /allowlist set <runner> <id1,id2,\u2026>");
-    if (state.runners.length > 0 && !state.runners.some((r) => r.id === runner)) {
-      return fail2(state, `Unknown runner "${runner}".`);
-    }
-    const modelIds = rest.join(" ").split(",").map((s) => s.trim()).filter(Boolean);
-    if (modelIds.length === 0) return fail2(state, "Usage: /allowlist set <runner> <id1,id2,\u2026>");
-    const known = modelsForRunner(state.models, runner);
-    if (state.models.length > 0 && known.length > 0) {
-      const stray = modelIds.filter((id) => !known.some((m) => m.id === id));
-      if (stray.length > 0) {
-        return fail2(state, `Not discovered for ${runner}: ${stray.join(", ")}.`);
-      }
-    }
-    return step(state, [{ type: "setAllowlist", runner, modelIds }]);
-  }
-  if (sub === "clear") {
-    if (!runner) return fail2(state, "Usage: /allowlist clear <runner>");
-    return step(state, [{ type: "setAllowlist", runner, modelIds: [] }]);
-  }
-  if (sub === "show" || sub === void 0) {
-    const items = state.runners.map((r) => ({
-      id: r.id,
-      label: r.name,
-      detail: describeAllowlist(state.allowlist[r.id])
-    }));
-    return step(
-      {
-        ...state,
-        overlay: {
-          kind: "picker",
-          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 fail2(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 fail2(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)
-    })
-  } });
+    case "force-start":
+      return taskCommand(
+        state,
+        args[0],
+        (sessionId, taskId) => step(state, [taskActionEffect(state, sessionId, taskId, name)])
+      );
+  }
+  return fail2(state, `/${name} is not wired up yet.`);
 }
-function setAutonomous(state, arg) {
-  const enabled = resolveToggle(arg, state.autonomous);
-  if (enabled === null) return fail2(state, "Usage: /auto [on|off]");
-  return step({ ...state, autonomous: enabled }, [{ type: "setAutonomous", enabled }]);
+function picker(title, items, action, extra = {}) {
+  return { title, items, filter: "", index: 0, multi: false, chosen: [], action, ...extra };
 }
-function setMouseCapture(state, arg) {
-  const enabled = resolveToggle(arg, state.mouseCapture);
-  if (enabled === null) return fail2(state, "Usage: /mouse [on|off]");
-  const noted = say(
-    { ...state, mouseCapture: enabled },
-    "system",
-    enabled ? "Mouse capture on \u2014 the wheel scrolls, but dragging no longer selects text." : "Mouse capture off \u2014 drag to select and copy; scroll with pgup/pgdn."
-  );
-  return step(noted, [{ type: "setMouseCapture", enabled }]);
+function withSession(state, run) {
+  if (!state.sessionId) {
+    return fail2(state, "No active plan \u2014 describe a goal first, or load a session with /sessions.");
+  }
+  return run(state.sessionId);
 }
-function openTaskRunnerPicker(state, task) {
-  if (task.type !== "ai") return fail2(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."
-        })
-      }
-    }
-  );
+function resolveToggle(arg, current) {
+  const value = arg?.toLowerCase();
+  if (value === "on") return true;
+  if (value === "off") return false;
+  if (value === void 0) return !current;
+  return null;
 }
-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(", ");
+function toggleSkill(state, skill, arg) {
+  const enabled = resolveToggle(arg, state.skills[skill]);
+  if (enabled === null) return fail2(state, `Usage: /${skill} [on|off]`);
+  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";
+  if (!state.sessionId || !hasContent) return newSession(state);
   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 }
+      title: "Start a new session?",
+      message: "The current plan will be cleared and any running tasks stopped.",
+      action: { kind: "new-session" }
     }
   });
 }
-function openTaskDepsPicker(state, task) {
-  const action = { kind: "set-task-deps", taskId: task.id };
-  const items = pickerItemsFor(state, action);
-  if (items.length === 0) return fail2(state, `Nothing runs before #${task.order}, so it has no possible dependencies.`);
+function newSession(state) {
+  const closeEffects = state.sessionId ? [{ type: "closeSession", sessionId: state.sessionId }] : [];
   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))
-      })
-    }
-  });
+    sessionId: null,
+    goal: "",
+    tasks: [],
+    planApproved: false,
+    messages: [],
+    selectedTask: 0,
+    expandedTaskId: null,
+    taskEditor: null,
+    scroll: 0,
+    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: [],
+    overlay: state.overlay?.kind === "approval" ? null : state.overlay
+  }, closeEffects);
 }
-function openTaskModePicker(state, task) {
-  if (task.type !== "ai") return fail2(state, "Manual tasks do not have an executor mode.");
-  const modes = modesForTask(state.modesByRunner, task);
-  if (modes.length === 0) {
-    return fail2(state, `${task.assignedRunner ?? "This runner"} declares no modes.`);
-  }
-  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 setModel(state, args) {
+  if (args[0] === "set" && args[1]) {
+    const runner = (0, import_core8.runnerForProvider)(state.plannerProvider);
+    const known = runner ? modelsForRunner(state.models, runner) : [];
+    if (runner && known.length > 0 && !known.some((m) => m.id === args[1])) {
+      return fail2(state, `${args[1]} was not discovered for ${runner}.`);
     }
-  );
-}
-function openTaskModelPicker(state, task) {
-  if (task.type !== "ai") return fail2(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 fail2(state, "Manual tasks do not have a thinking effort.");
-  if (!task.assignedModel) return fail2(state, "Choose a model for this task before setting its thinking effort.");
-  const action = { kind: "set-task-effort", taskId: task.id };
+    return step(state, [{ type: "setModel", modelId: args[1] }]);
+  }
+  if (args.length > 0 && args[0] !== "set") return fail2(state, "Usage: /model [set <model-id>]");
+  const items = pickerItemsFor(state, { kind: "set-model" });
   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`
-        })
+        picker: picker("Orchestrator model", items, { kind: "set-model" }, { hint: providerErrorHint(state) })
       }
     },
     [{ 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}.`
-  }]);
-}
-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 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 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 taskModelCommand(state, args) {
-  return taskCommand(state, args[0], (sessionId, taskId) => {
-    const task = state.tasks.find((candidate) => candidate.id === 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: []
+function plannerItems(state) {
+  const installed = new Set(state.runners.map((r) => r.id));
+  const agents = import_core8.CLI_PROVIDERS.map((id) => {
+    const runner = (0, import_core8.runnerForProvider)(id);
+    const ready = installed.has(runner);
+    return {
+      id,
+      label: import_core8.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
     };
-    if (!runnerAccepts(task, model)) {
-      return fail2(state, `${model.label} was not discovered for ${task.assignedRunner}.`);
-    }
-    return assignTaskModel(state, sessionId, task, model);
-  });
-}
-function taskRunnerCommand(state, args) {
-  return taskCommand(state, args[0], (sessionId, taskId) => {
-    const task = state.tasks.find((candidate) => candidate.id === taskId);
-    if (!args[1]) return openTaskRunnerPicker(state, task);
-    const runner = state.runners.find((candidate) => candidate.id === args[1]);
-    if (!runner) return fail2(state, `Unknown runner "${args[1]}".`);
-    return assignTaskRunner(state, sessionId, task, runner.id, runner.name);
   });
+  const vendors = import_core8.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
+    id,
+    label: import_core8.ALL_PROVIDERS[id].label,
+    detail: import_core8.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 taskModeCommand(state, args) {
-  return taskCommand(state, args[0], (sessionId, taskId) => {
-    const task = state.tasks.find((candidate) => candidate.id === taskId);
-    if (!args[1]) return openTaskModePicker(state, task);
-    const mode = modesForTask(state.modesByRunner, task).find((candidate) => candidate.id === args[1]);
-    if (!mode) return fail2(state, `Unsupported mode "${args[1]}" for ${task.assignedRunner}.`);
-    return assignTaskMode(state, sessionId, task, mode.id, mode.label);
+function setPlanner(state, args) {
+  if (args[0]) {
+    const id = args[0].toLowerCase();
+    if (!KNOWN_PROVIDERS2.includes(id)) {
+      return fail2(state, `Unknown planner: ${id}. Run /planner with no arguments to see the list.`);
+    }
+    return step(state, [{ type: "setPlanner", provider: id }]);
+  }
+  return step({
+    ...state,
+    overlay: {
+      kind: "picker",
+      picker: picker("Planner", plannerItems(state), { kind: "set-planner" }, {
+        hint: "Who researches your goal and writes the plan. Coding agents use their own subscription \u2014 no API key."
+      })
+    }
   });
 }
-function taskEffortCommand(state, args) {
-  return taskCommand(state, args[0], (sessionId, taskId) => {
-    const task = state.tasks.find((candidate) => candidate.id === taskId);
-    if (!args[1]) return openTaskEffortPicker(state, task);
-    if (!task.assignedModel) return fail2(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 fail2(state, `Unsupported effort "${value}" for ${task.assignedModel.modelLabel}.`);
+function setPlannerEffort(state, args) {
+  const items = plannerEffortItems(state);
+  if (args[0]) {
+    const wanted = args[0].toLowerCase();
+    const match = items.find((i) => !i.disabled && (i.id === wanted || wanted === "default" && i.id === DEFAULT_EFFORT));
+    if (!match) {
+      const available = items.filter((i) => !i.disabled && i.id !== DEFAULT_EFFORT).map((i) => i.id);
+      return fail2(state, available.length > 0 ? `Unknown effort: ${args[0]}. Available: ${available.join(", ")}, default.` : items[0]?.label ?? "No effort levels available.");
+    }
+    return step(state, [{ type: "setPlannerEffort", effort: match.id === DEFAULT_EFFORT ? "" : match.id }]);
+  }
+  return step({
+    ...state,
+    overlay: {
+      kind: "picker",
+      picker: picker("Planner thinking effort", items, { kind: "set-planner-effort" }, {
+        hint: "How hard the planning agent thinks per turn. Higher costs latency and tokens against your subscription."
+      })
     }
-    return assignTaskEffort(state, sessionId, task, value);
   });
 }
-function addTask(state, title) {
-  return withSession(state, (sessionId) => {
-    if (!title) {
+function setKey(state, args) {
+  if (args[0] === "set" && args[1]) {
+    const provider = args[1].toLowerCase();
+    if (!KNOWN_PROVIDERS2.includes(provider)) {
+      return fail2(state, `Unknown provider: ${provider}. Run /key with no arguments to see the list.`);
+    }
+    if (!args[2]) {
       return step({
         ...state,
-        overlay: { kind: "prompt", title: "New task title", value: "", action: { kind: "add-task" } }
+        overlay: keyPrompt(provider)
       });
     }
-    return step(state, [{ type: "addTask", sessionId, title }]);
-  });
-}
-function taskCommand(state, token, run) {
-  return withSession(state, (sessionId) => {
-    if (!token) return fail2(state, "Which task? Pass a task id or its number in the plan.");
-    const taskId = resolveTaskId2(state, token);
-    if (!taskId) return fail2(state, `No task matching "${token}" in the current plan.`);
-    return run(sessionId, taskId);
-  });
-}
-function resolveTaskId2(state, token) {
-  const byId = state.tasks.find((t) => t.id === 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;
+    return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  return null;
+  const items = import_core8.PROVIDER_PRIORITY.map((id) => ({
+    id,
+    label: import_core8.ALL_PROVIDERS[id].label,
+    detail: import_core8.ALL_PROVIDERS[id].apiKeyEnvVar,
+    selected: state.configuredProviders.includes(id)
+  }));
+  return step({ ...state, overlay: { kind: "picker", picker: picker("API provider key", items, { kind: "set-key" }) } });
 }
-
-// src/tui/render.ts
-var import_core8 = require("@ordewell/core");
-var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var CHROME_ROWS = 4;
-function render(state) {
-  const { rows, cols } = state;
-  const input = renderInput(state, cols);
-  const footer = renderFooter(state, cols);
-  const bodyRows = Math.max(0, rows - CHROME_ROWS - input.length - footer.length + 2);
-  const body = state.overlay ? renderOverlay(state, bodyRows, cols) : renderBody(state, bodyRows, cols);
-  const lines = [
-    renderSkills(state, cols),
-    ...body,
-    renderStatus(state, cols),
-    ...input,
-    ...footer
-  ];
-  return lines.slice(Math.max(0, lines.length - rows)).map((l) => pad(l, cols));
+function keyPrompt(provider) {
+  const meta = import_core8.ALL_PROVIDERS[provider];
+  return {
+    kind: "prompt",
+    title: `${meta.label} API key`,
+    hint: `Stored as ${meta.apiKeyEnvVar} in your .env`,
+    value: "",
+    action: { kind: "api-key", provider, envVar: meta.apiKeyEnvVar }
+  };
 }
-function fit(lines, rows, anchor) {
-  if (lines.length >= rows) {
-    return anchor === "bottom" ? lines.slice(lines.length - rows) : lines.slice(0, rows);
+function allowlist(state, args) {
+  const [sub, runner, ...rest] = args;
+  if (sub === "set") {
+    if (!runner || rest.length === 0) return fail2(state, "Usage: /allowlist set <runner> <id1,id2,\u2026>");
+    if (state.runners.length > 0 && !state.runners.some((r) => r.id === runner)) {
+      return fail2(state, `Unknown runner "${runner}".`);
+    }
+    const modelIds = rest.join(" ").split(",").map((s) => s.trim()).filter(Boolean);
+    if (modelIds.length === 0) return fail2(state, "Usage: /allowlist set <runner> <id1,id2,\u2026>");
+    const known = modelsForRunner(state.models, runner);
+    if (state.models.length > 0 && known.length > 0) {
+      const stray = modelIds.filter((id) => !known.some((m) => m.id === id));
+      if (stray.length > 0) {
+        return fail2(state, `Not discovered for ${runner}: ${stray.join(", ")}.`);
+      }
+    }
+    return step(state, [{ type: "setAllowlist", runner, modelIds }]);
   }
-  const blanks = Array(rows - lines.length).fill("");
-  return anchor === "bottom" ? [...blanks, ...lines] : [...lines, ...blanks];
-}
-function renderSkills(state, cols) {
-  const badges = SKILL_IDS.map(
-    (id) => state.skills[id] ? style.green(`\u25CF ${id}`) : style.grey(`\u25CB ${id}`)
-  );
-  const auto = state.autonomous ? style.yellow("\u25CF auto") : style.grey("\u25CB auto");
-  return truncate([...badges, auto].join(" "), cols);
-}
-function renderStatus(state, cols) {
-  if (state.status === "idle") {
-    return state.toast ? truncate(style.grey(state.toast), cols) : "";
+  if (sub === "clear") {
+    if (!runner) return fail2(state, "Usage: /allowlist clear <runner>");
+    return step(state, [{ type: "setAllowlist", runner, modelIds: [] }]);
   }
-  const label = state.busyLabel ? ` ${state.busyLabel}` : "";
-  const verb = state.status === "executing" ? "Executing" : state.status === "researching" ? "Researching" : "Planning";
-  const head = 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);
-}
-function renderInput(state, cols) {
-  const prompt = state.focus === "plan" ? style.grey("\u276F ") : style.cyan("\u276F ");
-  const active = state.focus === "chat" && !state.overlay;
-  const room = chatEditorRoom(cols, active);
-  const { text, cursor } = state.editor;
-  const continuation = " ".repeat(width(prompt));
-  if (!active) {
-    const visible = text.replace(/\n/g, "\xB6").replace(/\t/g, " ");
-    return [prompt + visible + suggest(state, room - width(visible))];
+  if (sub === "show" || sub === void 0) {
+    const items = state.runners.map((r) => ({
+      id: r.id,
+      label: r.name,
+      detail: describeAllowlist(state.allowlist[r.id])
+    }));
+    return step(
+      {
+        ...state,
+        overlay: {
+          kind: "picker",
+          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" }]
+    );
   }
-  const lines = wrapLines(text, room);
-  const { line: lineIndex, col } = cursorInLines(lines, cursor, text.length);
-  const rawLines = lines.map((l) => l.line);
-  return rawLines.map((raw, i) => {
-    const prefix = i === 0 ? prompt : continuation;
-    const line = raw.replace(/\t/g, " ");
-    const isCursorLine = i === lineIndex;
-    const rendered = isCursorLine ? line.slice(0, col) + style.inverse(line.slice(col, col + 1) || " ") + line.slice(col + 1) : line;
-    const used = width(line) + (isCursorLine && col >= line.length ? 1 : 0);
-    const hint = i === rawLines.length - 1 ? suggest(state, room - used) : "";
-    return prefix + rendered + hint;
-  });
-}
-function suggest(state, room) {
-  if (state.focus === "plan" || room <= 2) return "";
-  const matches = completions(state.editor.text);
-  if (matches.length === 0) return "";
-  const names = matches.map((c) => c.name).join(" ");
-  return style.grey(`  ${truncate(names, Math.max(0, room - 2))}`);
+  return fail2(state, "Usage: /allowlist [set <runner> <ids> | clear <runner>]");
 }
-function renderFooter(state, cols) {
-  const markHint = state.tasks[state.selectedTask]?.status === "completed" ? "m undone" : "m done";
-  const hints = state.focus === "plan" ? state.expandedTaskId ? ["type to edit prompt", "pgup/pgdn scroll", "alt-enter newline", "enter save", "esc cancel"] : [
-    "enter expand",
-    "R runner",
-    "o model",
-    "e effort",
-    "M mode",
-    "D deps",
-    "f start",
-    "E run plan",
-    "c cancel",
-    markHint,
-    "s skip",
-    "a add",
-    "d remove",
-    "t terminal",
-    "pgup/pgdn scroll",
-    "tab chat"
-  ] : ["/help", "tab plan", "alt-enter newline", "pgup/pgdn scroll", "ctrl-c quit"];
-  return packHints(hints, cols);
+function describeAllowlist(ids) {
+  if (!ids || ids.length === 0) return "no restriction";
+  return `${ids.length} model${ids.length === 1 ? "" : "s"} allowed`;
 }
-function packHints(hints, cols) {
-  const lines = [];
-  let current = "";
-  for (const hint of hints) {
-    const next = current ? `${current} \xB7 ${hint}` : hint;
-    if (current && next.length > cols) {
-      lines.push(current);
-      current = hint;
-    } else {
-      current = next;
-    }
+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 fail2(state, "Usage: /runners [<runner-id> on|off]");
+    return step(state, [{ type: "setRunnerEnabled", runner, enabled }]);
   }
-  lines.push(current);
-  return lines.map((line) => truncate(style.grey(line), cols));
+  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 renderBody(state, rows, cols) {
-  const planCols = planPaneWidth(state);
-  if (planCols === 0) return renderChat(state, rows, cols);
-  const chatCols = cols - planCols - 1;
-  const chat = renderChat(state, rows, chatCols);
-  const plan = renderPlan(state, rows, planCols);
-  return Array.from(
-    { length: rows },
-    (_, i) => `${pad(chat[i] ?? "", chatCols)}${style.grey("\u2502")}${pad(plan[i] ?? "", planCols)}`
+function setAutonomous(state, arg) {
+  const enabled = resolveToggle(arg, state.autonomous);
+  if (enabled === null) return fail2(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 fail2(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 }]);
 }
-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}`;
+function openTaskRunnerPicker(state, task) {
+  if (task.type !== "ai") return fail2(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 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))}`;
+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 }
+    }
+  });
 }
-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;
+function openTaskDepsPicker(state, task) {
+  const action = { kind: "set-task-deps", taskId: task.id };
+  const items = pickerItemsFor(state, action);
+  if (items.length === 0) return fail2(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 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 };
-  return lines;
+  });
 }
-function renderChat(state, rows, cols) {
-  const welcome = state.tasks.length === 0;
-  if (welcome) {
-    const lines2 = [...renderWelcome(state, cols), ""];
-    if (state.messages.length === 0) return fit(lines2.slice(0, -1), rows, "top");
-    lines2.push(...chatBodyLines(state.messages, cols));
-    const back2 = Math.min(state.scroll, Math.max(0, lines2.length - rows));
-    return fit(lines2.slice(0, lines2.length - back2), rows, "bottom");
+function openTaskModePicker(state, task) {
+  if (task.type !== "ai") return fail2(state, "Manual tasks do not have an executor mode.");
+  const modes = modesForTask(state.modesByRunner, task);
+  if (modes.length === 0) {
+    return fail2(state, `${task.assignedRunner ?? "This runner"} declares no modes.`);
   }
-  const lines = chatBodyLines(state.messages, cols);
-  const back = Math.min(state.scroll, Math.max(0, lines.length - rows));
-  return fit(lines.slice(0, lines.length - back), rows, "bottom");
+  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 plannerSetup(state) {
-  const provider = state.plannerProvider;
-  const registration = import_core8.ALL_PROVIDERS[provider];
-  if (!registration) return { label: "not set", ready: false };
-  const runner = (0, import_core8.runnerForProvider)(provider);
-  const ready = runner ? state.runners.some((r) => r.id === runner) : state.configuredProviders.includes(provider);
-  return { label: registration.label, ready };
+function openTaskModelPicker(state, task) {
+  if (task.type !== "ai") return fail2(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" }]
+  );
 }
-var SETUP_KEY_COLS = 10;
-var SETUP_VALUE_COLS = 32;
-function setupRow(label, value, command, cols) {
-  const gap = " ".repeat(Math.max(2, SETUP_VALUE_COLS - width(value)));
-  const head = `  ${style.grey(pad(label, SETUP_KEY_COLS))}${value}${gap}`;
-  return truncate(`${head}${style.grey(command)}`, cols - 1);
+function openTaskEffortPicker(state, task) {
+  if (task.type !== "ai") return fail2(state, "Manual tasks do not have a thinking effort.");
+  if (!task.assignedModel) return fail2(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" }]
+  );
 }
-var ICON = `${style.bold("\u226B")}${style.bold(style.cyan("\u25CF"))}`;
-function boldSans(word) {
-  return [...word].map((ch) => {
-    const code = ch.codePointAt(0);
-    return code >= 97 && code <= 122 ? String.fromCodePoint(120302 + (code - 97)) : ch;
-  }).join("");
+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}.`
+  }]);
 }
-var WORDMARK = boldSans("ordewell");
-var LOCKUP = `${ICON} ${WORDMARK}`;
-var BANNER_ROWS = [
-  { strokes: "\u281A\u283B\u2836\u28A6\u28E4\u2840", dot: "", word: "                   \u28B8\u28FF\u2847                            \u28B8\u28FF  \u28FF\u28FF" },
-  { strokes: "    \u2808\u2819\u28B7\u28E4\u2840", dot: "", word: " \u28C0\u28E4\u28E4\u28E4\u28E4\u2840  \u28E4\u28E4\u2880\u28E4\u2844 \u28C0\u28E4\u28E4\u28E4\u28F8\u28FF\u2847  \u28E0\u28E4\u28E4\u28E4\u28C0 \u28A0\u28E4\u2844  \u28E4\u28E4  \u28E0\u28E4  \u28E0\u28E4\u28E4\u28E4\u28C0  \u28B8\u28FF  \u28FF\u28FF" },
-  { strokes: "\u28C0\u28C0\u28C0\u28C0\u28C0\u28C0\u28C0\u28C8\u28FB\u28F6\u28E4\u28C0\u28C0", dot: "\u28C0\u28F6\u28FF\u28F7\u2844", word: "\u28F0\u28FF\u280F\u2801\u2808\u28BB\u28FF\u2846 \u28FF\u28FF\u281F\u2809\u2801\u28F0\u28FF\u280F\u2809\u2809\u28BB\u28FF\u2847 \u28FE\u285F\u2801 \u2819\u28FF\u2846 \u28FF\u28E7 \u28B8\u287F\u28FF\u2844 \u28FF\u284F \u28FE\u287F\u2801 \u2819\u28FF\u28C6 \u28B8\u28FF  \u28FF\u28FF" },
-  { strokes: "\u2809\u2809\u2809\u2809\u2809\u2809\u2809\u2889\u28FD\u287F\u281B\u280B\u2809", dot: "\u2809\u28BF\u28FF\u287F\u2803", word: "\u28FF\u28FF    \u28FF\u2847 \u28FF\u28FF   \u28FF\u28FF   \u28B8\u28FF\u2847\u28B8\u28FF\u287F\u283F\u283F\u283F\u283F\u281F \u28B8\u28FF\u2840\u28FF\u2807\u28B9\u28C7\u28B8\u28FF\u2801 \u28FF\u287F\u283F\u283F\u283F\u283F\u283F \u28B8\u28FF  \u28FF\u28FF" },
-  { strokes: "    \u2880\u28E0\u2876\u281B\u2801", dot: "", word: "\u2839\u28FF\u28E6\u28C0\u28C0\u28FC\u28FF\u2803 \u28FF\u28FF   \u2838\u28FF\u28E6\u28C0\u28E0\u28FE\u28FF\u2847 \u28BF\u28F7\u28C0\u28C0\u28E0\u28F6\u2806  \u28BF\u28FF\u287F \u2818\u28FF\u28FF\u284F  \u28BB\u28F7\u28C4\u28C0\u28E0\u28F6\u2806 \u28B8\u28FF  \u28FF\u28FF" },
-  { strokes: "\u28A4\u28E4\u2836\u283E\u281B\u2801", dot: "", word: " \u2808\u2819\u281B\u281B\u2809   \u2809\u2809    \u2808\u2819\u281B\u280B\u2808\u2809\u2801  \u2809\u281B\u281B\u280B\u2801   \u2808\u2809\u2801  \u2809\u2809    \u2809\u281B\u281B\u280B\u2801  \u2809\u2809  \u2809\u2809" }
-];
-var BANNER_ICON_COLS = 18;
-var BANNER_GAP = 2;
-var BANNER_COLS = Math.max(
-  ...BANNER_ROWS.map((row) => BANNER_ICON_COLS + BANNER_GAP + width(row.word))
-);
-var BANNER_MIN_ROWS = 24;
-var BANNER_WELL_COL = 30;
-function colorWell(word) {
-  const cells = [...word];
-  return cells.slice(0, BANNER_WELL_COL).join("") + style.cyan(cells.slice(BANNER_WELL_COL).join(""));
+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 renderBanner(rows, cols) {
-  if (cols < BANNER_COLS || rows < BANNER_MIN_ROWS) {
-    const left2 = " ".repeat(Math.max(0, Math.floor((cols - width(LOCKUP)) / 2)));
-    return [left2 + LOCKUP];
-  }
-  const left = " ".repeat(Math.floor((cols - BANNER_COLS) / 2));
-  return BANNER_ROWS.map((row) => {
-    const gap = " ".repeat(BANNER_ICON_COLS + BANNER_GAP - width(row.strokes) - width(row.dot));
-    return left + row.strokes + (row.dot ? style.cyan(row.dot) : "") + gap + colorWell(row.word);
-  });
+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 renderWelcome(state, cols) {
-  const planner = plannerSetup(state);
-  const enabledRunners = state.runners.filter((r) => r.enabled).map((r) => r.name);
-  const canPlan = planner.ready || state.runners.length > 0 || state.configuredProviders.length > 0;
-  const plannerValue = planner.ready ? [planner.label, state.orchestratorModel || style.yellow("no model")].join(style.grey(" \xB7 ")) : style.yellow(planner.label === "not set" ? "not set" : `${planner.label} (unavailable)`);
-  const lines = [
-    ...renderBanner(state.rows, cols),
-    "",
-    ...wrap(style.bold("Describe a goal to start planning."), Math.max(1, cols - 1)),
-    ...wrap(
-      style.grey("Ordewell researches your codebase, drafts a task plan, then runs each task in a coding agent."),
-      Math.max(1, cols - 1)
-    ),
-    "",
-    style.bold("Setup"),
-    setupRow("Planner", plannerValue, "/planner \xB7 /model", cols),
-    setupRow(
-      "Runners",
-      enabledRunners.length > 0 ? enabledRunners.join(", ") : style.yellow("none enabled"),
-      "/runners",
-      cols
-    ),
-    ""
-  ];
-  if (!canPlan) {
-    lines.push(
-      ...wrap(
-        style.yellow("Ordewell needs one coding agent installed (Claude Code, Codex, OpenCode) \u2014 or an API key from a provider such as OpenRouter, added with /key."),
-        Math.max(1, cols - 1)
-      ),
-      ""
-    );
-  }
-  lines.push(style.grey("/help   all commands"), style.grey(state.workspace));
-  return lines;
+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"}.`
+  }]);
 }
-var STATUS_MARK = {
-  completed: style.green,
-  running: style.yellow,
-  in_progress: style.yellow,
-  failed: style.red,
-  blocked: style.red,
-  awaiting_user: style.yellow,
-  cancelled: style.grey,
-  skipped: style.grey
-};
-var STATUS_ICON = {
-  completed: "\u2713",
-  failed: "\u2717",
-  blocked: "!",
-  awaiting_user: "?",
-  cancelled: "\u2212",
-  skipped: "\u2212",
-  approved: "\xB7",
-  pending: "\xB7"
-};
-function renderPlan(state, rows, cols) {
-  const done = state.tasks.filter((t) => t.status === "completed").length;
-  const header = style.bold(`Plan ${done}/${state.tasks.length}`);
-  const lines = [header, ""];
-  let selectedLine = 2;
-  let editorLine;
-  state.tasks.forEach((task, i) => {
-    const taskStart = lines.length;
-    if (i === state.selectedTask) selectedLine = taskStart;
-    const renderedTask = renderTask(state, task, i, cols);
-    if (task.id === state.expandedTaskId && renderedTask.editorLine !== void 0) {
-      editorLine = taskStart + renderedTask.editorLine;
+function taskModelCommand(state, args) {
+  return taskCommand(state, args[0], (sessionId, taskId) => {
+    const task = state.tasks.find((candidate) => candidate.id === 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 fail2(state, `${model.label} was not discovered for ${task.assignedRunner}.`);
     }
-    lines.push(...renderedTask.lines);
+    return assignTaskModel(state, sessionId, task, model);
   });
-  const overflow = Math.max(0, lines.length - rows);
-  const anchorLine = editorLine ?? selectedLine;
-  const scroll = Math.min(overflow, Math.max(0, anchorLine - rows + 3));
-  const totalScroll = Math.min(overflow, scroll + state.planScroll);
-  return fit([lines[0], ...lines.slice(1 + totalScroll)], rows, "top");
 }
-function renderTask(state, task, index, cols) {
-  const selected = state.focus === "plan" && index === state.selectedTask;
-  const expanded = state.expandedTaskId === task.id;
-  const running = isTaskRunning(task);
-  const paint = STATUS_MARK[task.status] ?? ((t) => t);
-  const rawIcon = running ? SPINNER[state.spinnerFrame % SPINNER.length] : STATUS_ICON[task.status] ?? "\xB7";
-  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 head = `${caret} ${icon} ${String(task.order).padStart(2)} ${kind} `;
-  const titleRoom = Math.max(1, cols - width(head));
-  const wrappedTitle = wrap(task.title, titleRoom);
-  const shownTitle = expanded ? wrappedTitle : wrappedTitle.slice(0, 2);
-  if (!expanded && wrappedTitle.length > shownTitle.length) {
-    const last = shownTitle.length - 1;
-    shownTitle[last] = truncate(`${shownTitle[last]}\u2026`, titleRoom);
-  }
-  const continuation = " ".repeat(width(head));
-  const lines = shownTitle.map((line, lineIndex) => {
-    const prefix = lineIndex === 0 ? head : continuation;
-    return prefix + (selected ? style.bold(line) : line);
+function taskRunnerCommand(state, args) {
+  return taskCommand(state, args[0], (sessionId, taskId) => {
+    const task = state.tasks.find((candidate) => candidate.id === taskId);
+    if (!args[1]) return openTaskRunnerPicker(state, task);
+    const runner = state.runners.find((candidate) => candidate.id === args[1]);
+    if (!runner) return fail2(state, `Unknown runner "${args[1]}".`);
+    return assignTaskRunner(state, sessionId, task, runner.id, runner.name);
   });
-  const model = task.assignedModel?.modelLabel ?? (task.type === "ai" ? "default model" : "");
-  const effort = task.type === "ai" ? `effort: ${task.assignedModel?.thinkingEffort ?? "default"}` : "";
-  const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}` : "";
-  const runner = task.assignedRunner ?? "";
-  const meta = [running ? "working" : "", runner, model].filter(Boolean).join(" \xB7 ");
-  if (meta) lines.push(style.grey(truncate(`    ${meta}`, cols)));
-  if (effort || mode) lines.push(style.grey(truncate(`    ${[effort, mode].filter(Boolean).join(" \xB7 ")}`, cols)));
-  let editorLine;
-  if (expanded) {
-    lines.push(style.grey(`    ${task.status.replace(/_/g, " ")}`));
-    const editableSeed = task.prompt ?? task.description ?? task.title;
-    if (task.description && task.description !== task.title && task.description !== editableSeed) {
-      lines.push(...taskText("Description", task.description, cols));
-    }
-    if (state.taskEditor) {
-      const room = paneTextRoom(cols);
-      const wrapped = wrapLines(state.taskEditor.text, room);
-      const cp = cursorInLines(wrapped, state.taskEditor.cursor, state.taskEditor.text.length);
-      editorLine = lines.length + 1 + cp.line;
-      lines.push(...renderTaskPrompt(wrapped, cp));
-    }
-    if (task.dependencies.length > 0) {
-      const orderById = new Map(state.tasks.map((candidate) => [candidate.id, candidate.order]));
-      const dependencies = task.dependencies.map((id) => orderById.has(id) ? `#${orderById.get(id)}` : id).join(", ");
-      lines.push(...taskText("Depends on", dependencies, cols));
-    }
-    lines.push(style.grey("    enter save \xB7 esc cancel"));
-    lines.push(style.grey(truncate("    then R runner \xB7 o model \xB7 e effort \xB7 M mode \xB7 D deps", cols)));
-  }
-  return { lines, editorLine };
 }
-function taskText(label, text, cols) {
-  const room = paneTextRoom(cols);
-  return [
-    style.grey(`    ${label}`),
-    ...wrap(text, room).map((line) => `    ${line}`)
-  ];
+function taskModeCommand(state, args) {
+  return taskCommand(state, args[0], (sessionId, taskId) => {
+    const task = state.tasks.find((candidate) => candidate.id === taskId);
+    if (!args[1]) return openTaskModePicker(state, task);
+    const mode = modesForTask(state.modesByRunner, task).find((candidate) => candidate.id === args[1]);
+    if (!mode) return fail2(state, `Unsupported mode "${args[1]}" for ${task.assignedRunner}.`);
+    return assignTaskMode(state, sessionId, task, mode.id, mode.label);
+  });
 }
-function renderTaskPrompt(wrapped, cursor) {
-  return [
-    style.grey("    Prompt"),
-    ...wrapped.map(({ line }, i) => {
-      if (i !== cursor.line) return `    ${line}`;
-      const col = cursor.col;
-      return `    ${line.slice(0, col)}${style.inverse(line.slice(col, col + 1) || " ")}${line.slice(col + 1)}`;
-    })
-  ];
+function taskEffortCommand(state, args) {
+  return taskCommand(state, args[0], (sessionId, taskId) => {
+    const task = state.tasks.find((candidate) => candidate.id === taskId);
+    if (!args[1]) return openTaskEffortPicker(state, task);
+    if (!task.assignedModel) return fail2(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 fail2(state, `Unsupported effort "${value}" for ${task.assignedModel.modelLabel}.`);
+    }
+    return assignTaskEffort(state, sessionId, task, value);
+  });
 }
-function renderOverlay(state, rows, cols) {
-  const overlay = state.overlay;
-  if (overlay.kind === "help") return renderHelp(overlay.scroll ?? 0, rows, cols);
-  if (overlay.kind === "approval") {
-    const { request } = overlay;
-    const headline = request.kind === "shell_command" ? "The planner wants to run a command" : request.kind === "url_fetch" ? "The planner wants to fetch a URL" : "The planner wants to read a path outside the workspace";
-    const queued = state.pendingApprovals.length;
-    return frame(
-      "Approval needed",
-      [
-        headline,
-        "",
-        `  ${style.yellow(request.subject)}`,
-        "",
-        // Disambiguates the `external_path` case: an auto-tier command like
-        // `cat` touching an outside path reads identically to a plain
-        // `read_file` without it.
-        ...request.detail ? [style.grey(request.detail), ""] : [],
-        // The grant is wider than the request, so name it rather than letting
-        // the user discover it when the next call silently does not prompt.
-        style.grey(`Approving also allows ${request.scope} for the rest of this session.`),
-        ...queued > 0 ? [style.grey(`${queued} more waiting.`)] : [],
-        "",
-        style.grey("y or enter allows \xB7 n or esc denies")
-      ],
-      rows,
-      cols
-    );
-  }
-  if (overlay.kind === "confirm") {
-    return frame(
-      overlay.title,
-      [overlay.message, "", style.grey("enter confirms \xB7 esc cancels")],
-      rows,
-      cols
-    );
-  }
-  if (overlay.kind === "prompt") {
-    const secret = overlay.action.kind === "api-key";
-    const shown = secret ? "\u2022".repeat(overlay.value.length) : overlay.value;
-    return frame(
-      overlay.title,
-      [overlay.hint ? style.grey(overlay.hint) : "", "", `${style.cyan("\u276F")} ${shown}`, "", style.grey("enter confirms \xB7 esc cancels")],
-      rows,
-      cols
-    );
-  }
-  return renderPicker(overlay.picker, rows, cols);
+function addTask(state, title) {
+  return withSession(state, (sessionId) => {
+    if (!title) {
+      return step({
+        ...state,
+        overlay: { kind: "prompt", title: "New task title", value: "", action: { kind: "add-task" } }
+      });
+    }
+    return step(state, [{ type: "addTask", sessionId, title }]);
+  });
 }
-function renderPicker(picker2, rows, cols) {
-  const items = visibleItems(picker2);
-  const body = [];
-  if (picker2.hint) body.push(style.grey(picker2.hint));
-  body.push(`${style.grey("filter:")} ${picker2.filter}${style.grey("\u258F")}`, "");
-  if (items.length === 0) {
-    body.push(style.grey(picker2.filter ? "Nothing matches that filter." : "Nothing to show yet\u2026"));
-  }
-  const room = Math.max(1, rows - body.length - 3);
-  const start = Math.max(0, Math.min(picker2.index - Math.floor(room / 2), items.length - room));
-  for (const [offset, item] of items.slice(start, start + room).entries()) {
-    const active = start + offset === picker2.index;
-    const mark = picker2.multi ? picker2.chosen.includes(item.id) ? style.green("[\u2713]") : style.grey("[ ]") : item.selected ? style.green("\u25CF") : " ";
-    const caret = active ? style.cyan("\u276F") : " ";
-    const label = truncate(item.label, Math.max(1, cols - 12));
-    const detail = item.detail ? style.grey(` \u2014 ${item.detail}`) : "";
-    const line = item.disabled ? `${caret} ${mark} ${style.grey(label)}${detail}` : `${caret} ${mark} ${active ? style.bold(label) : label}${detail}`;
-    body.push(truncate(line, cols - 2));
-  }
-  body.push("", style.grey(picker2.multi ? "space toggles \xB7 enter confirms \xB7 esc cancels \xB7 type to filter" : "enter selects \xB7 esc cancels \xB7 type to filter"));
-  return frame(picker2.title, body, rows, cols);
+function taskCommand(state, token, run) {
+  return withSession(state, (sessionId) => {
+    if (!token) return fail2(state, "Which task? Pass a task id or its number in the plan.");
+    const taskId = resolveTaskId2(state, token);
+    if (!taskId) return fail2(state, `No task matching "${token}" in the current plan.`);
+    return run(sessionId, taskId);
+  });
 }
-var CATEGORY_TITLE = {
-  planning: "Planning",
-  tasks: "Tasks",
-  models: "Models & providers",
-  skills: "Skills",
-  session: "Sessions",
-  system: "System"
-};
-function renderHelp(scroll, rows, cols) {
-  const body = [];
-  for (const [category, title] of Object.entries(CATEGORY_TITLE)) {
-    const commands = SLASH_COMMANDS.filter((c) => c.category === category);
-    if (commands.length === 0) continue;
-    body.push(style.bold(title));
-    for (const command of commands) {
-      body.push(`  ${pad(command.usage, Math.min(38, cols - 6))} ${style.grey(command.description)}`);
-    }
-    body.push("");
+function resolveTaskId2(state, token) {
+  const byId = state.tasks.find((t) => t.id === 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;
   }
-  body.push(
-    style.grey("tab switches panes \xB7 \u2191\u2193/pgup/pgdn scroll \xB7 ctrl-l clears \xB7 ctrl-c quits")
-  );
-  const wrapped = body.map((line) => truncate(line, Math.max(1, cols - 2)));
-  const room = Math.max(1, rows - 2);
-  const max = Math.max(0, wrapped.length - room);
-  const offset = Math.min(scroll, max);
-  const footer = style.grey(offset < max ? "\u2191\u2193 scroll \xB7 any other key closes" : "any key closes");
-  return frame("Commands", [...wrapped.slice(offset, offset + room), footer], rows, cols);
-}
-function frame(title, body, rows, cols) {
-  const inner = Math.max(1, cols - 2);
-  const lines = [
-    style.grey(`\u250C\u2500 ${style.bold(title)} ${"\u2500".repeat(Math.max(0, inner - width(title) - 3))}`),
-    ...body.flatMap((line) => wrap(line, inner)).map((line) => ` ${truncate(line, inner)}`)
-  ];
-  return fit(lines, rows, "top");
+  return null;
 }
 
 // src/tui/app.ts
@@ -5004,6 +5228,7 @@ function createApp(deps) {
 }
 
 // src/tui/effects.ts
+var import_child_process4 = require("child_process");
 var import_core9 = require("@ordewell/core");
 var import_plan_utils4 = require("@ordewell/core/plan-utils");
 var ConversationQueue = class {
@@ -5077,6 +5302,16 @@ function explain(message) {
 function persistAfterDaemon(deps, env) {
   for (const [key, value] of Object.entries(env)) deps.setEnvVar(key, value);
 }
+function plannerModelNotice(recall2) {
+  switch (recall2.source) {
+    case "remembered":
+      return `Restored ${recall2.model}.`;
+    case "catalog-default":
+      return `Using its default model, ${recall2.model} \u2014 pick another with /model.`;
+    case "none":
+      return "Pick a model with /model.";
+  }
+}
 async function perform(effect, deps) {
   const { api, dispatch, workspace } = deps;
   switch (effect.type) {
@@ -5101,6 +5336,11 @@ async function perform(effect, deps) {
       await api.stopExecution(effect.sessionId);
       dispatch({ type: "notice", message: "Execution stopped." });
       return;
+    case "cancelPlanning": {
+      const { cancelled } = await api.cancelPlanning(effect.sessionId);
+      if (cancelled) dispatch({ type: "notice", message: "Planning stopped." });
+      return;
+    }
     case "processQueued":
       await api.processQueued(effect.sessionId);
       await refreshPlan(deps, effect.sessionId);
@@ -5159,16 +5399,16 @@ async function perform(effect, deps) {
       const meta = import_core9.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown planner: ${effect.provider}`);
       const env = { AI_PROVIDER: effect.provider };
-      if (effect.clearModel) {
-        env.ORCHESTRATOR_MODEL = "";
-        env.ORDEWELL_PLANNER_EFFORT = "";
-      }
-      await api.updateSettings({ env });
-      persistAfterDaemon(deps, env);
-      dispatch({ type: "settingsLoaded", settings: { aiProvider: effect.provider, ...effect.clearModel ? { orchestratorModel: "", plannerThinkingEffort: "" } : {} } });
+      const settings = await api.updateSettings({ env });
+      const recall2 = describePlannerSwitch(settings, effect.provider);
+      persistAfterDaemon(deps, { ...env, ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
+      dispatch({
+        type: "settingsLoaded",
+        settings: { aiProvider: effect.provider, orchestratorModel: recall2.model, plannerThinkingEffort: recall2.effort }
+      });
       dispatch({
         type: "notice",
-        message: (0, import_core9.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.${effect.clearModel ? ` Using its default model; pick another with /model.` : ""}` : `Planner set to ${meta.label}.${effect.clearModel ? " Pick a model with /model." : ""}`
+        message: `${(0, import_core9.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
       });
       await loadModels(deps);
       return;
@@ -5219,6 +5459,9 @@ async function perform(effect, deps) {
       deps.setMouseCapture(effect.enabled);
       deps.setEnvVar("ORDEWELL_TUI_MOUSE", String(effect.enabled));
       return;
+    case "copyText":
+      copySelection(deps, effect.text);
+      return;
     case "loadModels":
       await loadModels(deps);
       return;
@@ -5256,6 +5499,30 @@ async function perform(effect, deps) {
       return;
   }
 }
+var pipeToClipboardDefault = (command, text) => {
+  (0, import_child_process4.execSync)(command, { input: text, stdio: ["pipe", "ignore", "ignore"] });
+};
+function osc52(text) {
+  return `\x1B]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`;
+}
+function copySelection(deps, text) {
+  if (!text) return;
+  const lines = text.split("\n").length;
+  const command = (0, import_core9.clipboardCopyCommand)(deps.hasBin);
+  if (command) {
+    try {
+      (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
+      deps.dispatch({ type: "notice", message: `Copied ${lines} ${lines === 1 ? "line" : "lines"}.` });
+      return;
+    } catch {
+    }
+  }
+  deps.writeTerminal(osc52(text));
+  deps.dispatch({
+    type: "notice",
+    message: `Copied ${lines} ${lines === 1 ? "line" : "lines"} through the terminal \u2014 no clipboard tool here (pbcopy, xclip, xsel or wl-copy), so it only lands if your terminal supports OSC 52.`
+  });
+}
 async function withExecutionStream(deps, sessionId, request) {
   let settleReady = () => {
   };
@@ -5490,37 +5757,72 @@ var ESCAPES = {
   "\x1B\r": "alt-enter",
   "\x1B\n": "alt-enter"
 };
-var MOUSE_WHEEL_UP = 64;
-var MOUSE_WHEEL_DOWN = 65;
-var SGR_MOUSE = /^\x1b\[<(\d+);\d+;\d+[Mm]$/;
+var WHEEL_FLAG = 64;
+var BUTTON_MASK = 3;
+var MOTION_FLAG = 32;
+var MOUSE_MODIFIERS = 4 | 8 | 16 | MOTION_FLAG;
+var LEFT_BUTTON = 0;
+var X10_RELEASE = 3;
+function mouseKey(button, col, row, released = false) {
+  if ((button & WHEEL_FLAG) !== 0) return wheelKey(button, col, row);
+  if (released || (button & BUTTON_MASK) === X10_RELEASE) return { name: "mouseup", col, row };
+  if ((button & BUTTON_MASK) !== LEFT_BUTTON) return { name: "unknown" };
+  return { name: (button & MOTION_FLAG) !== 0 ? "mousedrag" : "mousedown", col, row };
+}
+function wheelKey(button, col, row) {
+  if ((button & WHEEL_FLAG) === 0) return { name: "unknown" };
+  switch (button & ~MOUSE_MODIFIERS & (WHEEL_FLAG | BUTTON_MASK)) {
+    case WHEEL_FLAG:
+      return { name: "scrollup", col, row };
+    case WHEEL_FLAG | 1:
+      return { name: "scrolldown", col, row };
+    // 66/67 are the horizontal wheel. Nothing here scrolls sideways, so they
+    // are dropped on purpose rather than falling through to `unknown`, which
+    // the overlays treat as "some key" and would use to close themselves.
+    default:
+      return { name: "wheelignored" };
+  }
+}
+var SGR_MOUSE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/;
+var URXVT_MOUSE = /^\x1b\[(\d+);(\d+);(\d+)M$/;
+var X10_PREFIX = "\x1B[M";
+var X10_BIAS = 32;
 function decodeMouse(seq) {
-  const match = SGR_MOUSE.exec(seq);
-  if (!match) return void 0;
-  const button = Number(match[1]);
-  if (button === MOUSE_WHEEL_UP) return { name: "scrollup" };
-  if (button === MOUSE_WHEEL_DOWN) return { name: "scrolldown" };
-  return { name: "unknown" };
+  const sgr = SGR_MOUSE.exec(seq);
+  if (sgr) return mouseKey(Number(sgr[1]), Number(sgr[2]), Number(sgr[3]), sgr[4] === "m");
+  const urxvt = URXVT_MOUSE.exec(seq);
+  if (urxvt) return mouseKey(Number(urxvt[1]) - X10_BIAS, Number(urxvt[2]), Number(urxvt[3]));
+  if (seq.startsWith(X10_PREFIX) && seq.length === X10_PREFIX.length + 3) {
+    const bytes = [0, 1, 2].map((n) => seq.charCodeAt(X10_PREFIX.length + n) - X10_BIAS);
+    return mouseKey(bytes[0], bytes[1], bytes[2]);
+  }
+  return void 0;
 }
 function decodeKey(seq) {
   const escaped = ESCAPES[seq];
   if (escaped) return { name: escaped };
   const control = CONTROL[seq];
   if (control) return { name: control };
-  if (seq.startsWith("\x1B[<")) return decodeMouse(seq) ?? { name: "unknown" };
+  if (seq.startsWith("\x1B[")) {
+    const mouse = decodeMouse(seq);
+    if (mouse) return mouse;
+  }
   if (seq.startsWith("\x1B")) return { name: "unknown" };
   return { name: "char", char: seq };
 }
 var PASTE_START = "\x1B[200~";
 var PASTE_END = "\x1B[201~";
 function pasteKey(raw) {
-  const text = raw.replace(/\r\n?/g, "\n").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+  const text = stripTabs(raw.replace(/\r\n?/g, "\n").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, ""));
   return { name: "paste", text };
 }
 function createKeyDecoder() {
   let paste = null;
+  let pending = "";
   return (chunk) => {
     const keys = [];
-    let rest = chunk;
+    let rest = pending + chunk;
+    pending = "";
     while (rest.length > 0) {
       if (paste !== null) {
         const combined = paste + rest;
@@ -5536,7 +5838,9 @@ function createKeyDecoder() {
       }
       const start = rest.indexOf(PASTE_START);
       if (start === -1) {
-        keys.push(...splitKeys(rest));
+        const split = splitPending(rest);
+        keys.push(...split.keys);
+        pending = split.pending;
         return keys;
       }
       if (start > 0) keys.push(...splitKeys(rest.slice(0, start)));
@@ -5546,7 +5850,32 @@ function createKeyDecoder() {
     return keys;
   };
 }
-function splitKeys(chunk) {
+var TWO_BYTE_META = /* @__PURE__ */ new Set(["b", "d", "f", "\x7F", "\b", "\r", "\n"]);
+var CSI_BODY = /[\x20-\x3f]/;
+var CSI_FINAL = /[@-~]/;
+var MAX_PENDING = 32;
+var INCOMPLETE = -1;
+function csiEnd(chars, start, from) {
+  let end = from;
+  while (end < chars.length && !CSI_FINAL.test(chars[end])) {
+    if (!CSI_BODY.test(chars[end])) return end;
+    end += 1;
+  }
+  if (end >= chars.length) return end - start >= MAX_PENDING ? end : INCOMPLETE;
+  return end + 1;
+}
+function sequenceEnd(chars, i) {
+  const next = chars[i + 1];
+  if (next === void 0) return i + 1;
+  if (next === "[" && chars[i + 2] === "M") {
+    return i + X10_PREFIX.length + 3 <= chars.length ? i + X10_PREFIX.length + 3 : INCOMPLETE;
+  }
+  if (next === "[" || next === "O") return csiEnd(chars, i, i + 2);
+  if (TWO_BYTE_META.has(next)) return i + 2;
+  if (next === "\x1B" && (chars[i + 2] === "[" || chars[i + 2] === "O")) return csiEnd(chars, i, i + 3);
+  return i + 1;
+}
+function splitPending(chunk) {
   const keys = [];
   const chars = [...chunk];
   let i = 0;
@@ -5556,21 +5885,16 @@ function splitKeys(chunk) {
       i += 1;
       continue;
     }
-    let end = i + 1;
-    if (chars[end] === "[" || chars[end] === "O") {
-      end += 1;
-      while (end < chars.length && !/[@-~]/.test(chars[end])) end += 1;
-      end += 1;
-    } else if (chars[end] === "b" || chars[end] === "d" || chars[end] === "f" || chars[end] === "\x7F" || chars[end] === "\b" || chars[end] === "\r" || chars[end] === "\n") {
-      end += 1;
-    } else if (chars[end] === "\x1B" && (chars[end + 1] === "[" || chars[end + 1] === "O")) {
-      end += 2;
-      while (end < chars.length && !/[@-~]/.test(chars[end])) end += 1;
-      end += 1;
-    }
+    const end = sequenceEnd(chars, i);
+    if (end === INCOMPLETE) return { keys, pending: chars.slice(i).join("") };
     keys.push(decodeKey(chars.slice(i, end).join("")));
     i = end;
   }
+  return { keys, pending: "" };
+}
+function splitKeys(chunk) {
+  const { keys, pending } = splitPending(chunk);
+  if (pending) keys.push(decodeKey(pending));
   return keys;
 }
 
@@ -5583,13 +5907,17 @@ var PASTE_MODE_ON = "\x1B[?2004h";
 var PASTE_MODE_OFF = "\x1B[?2004l";
 var KITTY_KEYBOARD_ON = "\x1B[>1u";
 var KITTY_KEYBOARD_OFF = "\x1B[<u";
-var MOUSE_TRACKING_ON = "\x1B[?1000h\x1B[?1006h";
-var MOUSE_TRACKING_OFF = "\x1B[?1000l\x1B[?1006l";
+var MOUSE_TRACKING_ON = "\x1B[?1000h\x1B[?1002h\x1B[?1006h";
+var MOUSE_TRACKING_OFF = "\x1B[?1000l\x1B[?1002l\x1B[?1006l";
 var ALT_SCROLL_SAVE = "\x1B[?1007s";
 var ALT_SCROLL_OFF = "\x1B[?1007l";
 var ALT_SCROLL_RESTORE = "\x1B[?1007r";
-var HOME = "\x1B[H";
 var CLEAR = "\x1B[2J";
+var AUTOWRAP_OFF = "\x1B[?7l";
+var AUTOWRAP_ON = "\x1B[?7h";
+function clampToCols(line, cols) {
+  return width(line) > cols ? truncate(line, cols) : line;
+}
 function openTerminal(options) {
   const input = options.input ?? process.stdin;
   const output = options.output ?? process.stdout;
@@ -5598,15 +5926,14 @@ function openTerminal(options) {
   input.resume();
   input.setEncoding("utf8");
   let mouse = options.mouse === true;
-  output.write(
-    ALT_SCREEN_ON + HIDE_CURSOR + PASTE_MODE_ON + KITTY_KEYBOARD_ON + ALT_SCROLL_SAVE + ALT_SCROLL_OFF + (mouse ? MOUSE_TRACKING_ON : "") + CLEAR
-  );
+  const modes = () => ALT_SCREEN_ON + HIDE_CURSOR + PASTE_MODE_ON + KITTY_KEYBOARD_ON + ALT_SCROLL_SAVE + ALT_SCROLL_OFF + (mouse ? MOUSE_TRACKING_ON : "");
+  output.write(modes() + CLEAR);
   const decode = createKeyDecoder();
   const onData = (chunk) => {
     for (const key of decode(chunk)) options.onKey(key);
   };
   const onResize = () => {
-    output.write(CLEAR);
+    output.write(CLEAR + (mouse ? MOUSE_TRACKING_ON : ""));
     const { rows, cols } = size();
     options.onResize(rows, cols);
   };
@@ -5620,13 +5947,19 @@ function openTerminal(options) {
     size,
     draw(frame2) {
       if (closed) return;
-      output.write(HOME + frame2.join("\n"));
+      const { cols } = size();
+      const rows = frame2.map((line, i) => `\x1B[${i + 1};1H${clampToCols(line, cols)}\x1B[K`).join("");
+      output.write(AUTOWRAP_OFF + rows + AUTOWRAP_ON);
     },
     setMouse(enabled) {
       if (closed || enabled === mouse) return;
       mouse = enabled;
       output.write(enabled ? MOUSE_TRACKING_ON : MOUSE_TRACKING_OFF);
     },
+    reset() {
+      if (closed) return;
+      output.write(modes() + CLEAR);
+    },
     close() {
       if (closed) return;
       closed = true;
@@ -5635,7 +5968,7 @@ function openTerminal(options) {
       if (input.isTTY) input.setRawMode(false);
       input.pause();
       output.write(
-        MOUSE_TRACKING_OFF + ALT_SCROLL_RESTORE + KITTY_KEYBOARD_OFF + PASTE_MODE_OFF + SHOW_CURSOR + ALT_SCREEN_OFF
+        MOUSE_TRACKING_OFF + ALT_SCROLL_RESTORE + KITTY_KEYBOARD_OFF + PASTE_MODE_OFF + AUTOWRAP_ON + SHOW_CURSOR + ALT_SCREEN_OFF
       );
     }
   };
@@ -5648,13 +5981,23 @@ async function handleTui(subArgs) {
     process.exit(1);
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
+  try {
+    (0, import_core10.assertWorkspaceExists)(workspace);
+  } catch {
+    console.error(
+      `Workspace "${workspace}" does not exist.
+
+cd into a directory that exists, or pass --workspace <path> naming one that does.`
+    );
+    process.exit(1);
+  }
   const { port, owned: ownedAtLaunch } = await ensureDaemonOwned(resolvePort(subArgs), { detached: false });
   let owned = ownedAtLaunch;
   const api = new ApiClient(port);
   const conversationQueue = new ConversationQueue();
   let terminal;
   const autoMode = process.env.ORDEWELL_AUTONOMOUS_MODE;
-  const mouseCapture = process.env.ORDEWELL_TUI_MOUSE === "true" || process.env.ORDEWELL_TUI_MOUSE === "1";
+  const mouseCapture = process.env.ORDEWELL_TUI_MOUSE !== "false" && process.env.ORDEWELL_TUI_MOUSE !== "0";
   const app = createApp({
     initial: { workspace, autonomous: autoMode !== "false" && autoMode !== "0", mouseCapture },
     draw: (frame2) => terminal?.draw(frame2),
@@ -5671,6 +6014,9 @@ async function handleTui(subArgs) {
       },
       openTerminal: (sessionId, taskId) => openTaskTerminal(port, sessionId, taskId),
       setMouseCapture: (enabled) => terminal?.setMouse(enabled),
+      // The alt screen is up with the cursor hidden, so an OSC 52 write shows
+      // nothing — the terminal reads it and answers by taking the clipboard.
+      writeTerminal: (data) => process.stdout.write(data),
       reviveDaemon: async () => {
         const { owned: freshlyOwned } = await ensureDaemonOwned(port, { detached: false, quiet: true });
         if (freshlyOwned) owned = true;
@@ -5697,6 +6043,11 @@ async function handleTui(subArgs) {
   process.on("SIGINT", () => shutdown(0));
   process.on("SIGTERM", () => shutdown(0));
   process.on("SIGHUP", () => shutdown(0));
+  process.on("SIGCONT", () => {
+    terminal?.reset();
+    const { rows: r, cols: c } = terminal?.size() ?? { rows: 24, cols: 80 };
+    app.dispatch({ type: "resize", rows: r, cols: c });
+  });
   process.on("uncaughtException", (err) => {
     console.error(`Fatal: ${err.message}`);
     shutdown(1);