@ordewell/cli 0.10.0 → 0.10.2

package/dist/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/main.ts
-var import_core46 = require("@ordewell/core");
+var import_core49 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -107,6 +107,23 @@ function moveAutonomyToSettings() {
   }
 }
 
+// src/runnerNames.ts
+var import_core2 = require("@ordewell/core");
+function manifests() {
+  return new import_core2.RunnerRegistry().list().map((entry) => entry.manifest);
+}
+function runnerIdList() {
+  return manifests().map((m) => m.name).join(", ");
+}
+function runnerIdChoice() {
+  return manifests().map((m) => m.name).join("|");
+}
+function runnerNamesOr() {
+  const names = manifests().map((m) => m.displayName);
+  if (names.length < 2) return names.join("");
+  return `${names.slice(0, -1).join(", ")} or ${names[names.length - 1]}`;
+}
+
 // src/help.ts
 function printHelp() {
   console.log(`
@@ -157,7 +174,7 @@ Planner, models and runners:
   ordewell model [set <id>]       Show or set the planner model (applies without a restart)
   ordewell planner-effort [lvl]   Thinking effort for a coding-agent planner
   ordewell key [set <p> <key>]    Show which providers have a key, or store one
-  ordewell runners [<id> on|off]  Enable or disable runners (claude-code, opencode, codex)
+  ordewell runners [<id> on|off]  Enable or disable runners (${runnerIdList()})
   ordewell allowlist set|clear|show       Limit which models a runner may use
   ordewell auto [full|guarded]    Autonomy level for new plans: Full or Guarded
   ordewell supervisor [off|watch|act]  Whether the planner watches or acts on your runs (default watch);
@@ -236,13 +253,13 @@ Quick Start:
   then run: ordewell plan --goal "Your task description"
 
   No API key? Plan with a coding agent you already pay for:
-    AI_PROVIDER=claude-code ordewell plan --goal "Your task description"
+    AI_PROVIDER=<runner> ordewell plan --goal "Your task description"
 
 Environment:
   OPENROUTER_API_KEY         OpenRouter API key (recommended)
   GEMINI_API_KEY             Google Gemini API key (alternative)
   AI_PROVIDER                openrouter, google \u2014 auto-detected from keys
-                             claude-code, codex, opencode \u2014 plan with that CLI,
+                             ${runnerIdList()} \u2014 plan with that CLI,
                              no API key (uses its own subscription)
   ORDEWELL_PLANNER_EFFORT    Thinking effort for a coding-agent planner
   ORCHESTRATOR_MODEL         Default: deepseek/deepseek-v4-flash
@@ -275,9 +292,9 @@ var import_os = require("os");
 var import_path2 = require("path");
 var import_http = __toESM(require("http"));
 var import_net = require("net");
-var import_core2 = require("@ordewell/core");
+var import_core3 = require("@ordewell/core");
 var DEFAULT_PORT = 3742;
-var CONFIG_DIR = (0, import_core2.globalDataDir)();
+var CONFIG_DIR = (0, import_core3.globalDataDir)();
 var LEGACY_PID_FILE = (0, import_path2.join)(CONFIG_DIR, "server.pid");
 var OLD_CONFIG_DIR = (0, import_path2.join)((0, import_os.homedir)(), ".config", "ordewell");
 function pidFileFor(port) {
@@ -317,12 +334,12 @@ function getWebServerPath() {
   );
 }
 async function isDaemonRunning(port = DEFAULT_PORT) {
-  const token = (0, import_core2.readDaemonToken)(port);
+  const token = (0, import_core3.readDaemonToken)(port);
   try {
     const res = await httpGet(
       `http://127.0.0.1:${port}/api/workspaces`,
       2e3,
-      token ? { Authorization: (0, import_core2.bearerHeaderValue)(token) } : {}
+      token ? { Authorization: (0, import_core3.bearerHeaderValue)(token) } : {}
     );
     return res.status === 200 || res.status === 401;
   } catch {
@@ -378,7 +395,7 @@ async function stopDaemon(port = DEFAULT_PORT) {
     const pid = parseInt(pidStr, 10);
     if (!pid || isNaN(pid)) {
       (0, import_fs2.unlinkSync)(pidFile);
-      (0, import_core2.clearDaemonToken)(port);
+      (0, import_core3.clearDaemonToken)(port);
       return false;
     }
     process.kill(pid, "SIGTERM");
@@ -391,7 +408,7 @@ async function stopDaemon(port = DEFAULT_PORT) {
         (0, import_fs2.unlinkSync)(pidFile);
       } catch {
       }
-      (0, import_core2.clearDaemonToken)(port);
+      (0, import_core3.clearDaemonToken)(port);
       console.log("Server was not running (stale PID removed).");
       return true;
     }
@@ -444,7 +461,7 @@ function resolvePort(args = []) {
 // src/apiClient.ts
 var import_http2 = __toESM(require("http"));
 var import_ws = __toESM(require("ws"));
-var import_core3 = require("@ordewell/core");
+var import_core4 = require("@ordewell/core");
 var DEFAULT_HTTP_TIMEOUT_MS = 15 * 60 * 1e3;
 var DaemonError = class extends Error {
   constructor(message, status, code) {
@@ -488,7 +505,7 @@ var ApiClient = class _ApiClient {
    * A missing file is not an error here — the daemon's own 401 names the path.
    */
   token() {
-    return (0, import_core3.readDaemonToken)(this.port);
+    return (0, import_core4.readDaemonToken)(this.port);
   }
   /**
    * A daemon holds only the sessions adopted since it started, so after a
@@ -524,7 +541,7 @@ var ApiClient = class _ApiClient {
         method,
         headers: {
           ...body ? { "Content-Type": "application/json" } : {},
-          ...token ? { Authorization: (0, import_core3.bearerHeaderValue)(token) } : {}
+          ...token ? { Authorization: (0, import_core4.bearerHeaderValue)(token) } : {}
         },
         // Planner research on a real repository regularly exceeds two minutes.
         // The benchmark harness uses the same 15-minute default explicitly;
@@ -554,7 +571,7 @@ var ApiClient = class _ApiClient {
       req.end();
     });
   }
-  async generatePlan(goal, runners2, workspace, sessionId = (0, import_core3.mintSessionId)()) {
+  async generatePlan(goal, runners2, workspace, sessionId = (0, import_core4.mintSessionId)()) {
     const { plan, models, modelsByRunner, notes } = await this.call("POST", `/api/plans/${sessionId}/generate`, "Plan generation failed", {
       goal,
       runners: runners2 || void 0,
@@ -789,7 +806,7 @@ var ApiClient = class _ApiClient {
     const token = this.token();
     const socket = new import_ws.default(
       `ws://127.0.0.1:${this.port}/ws/session/${sessionId}`,
-      token ? (0, import_core3.tokenSubprotocols)(token) : void 0
+      token ? (0, import_core4.tokenSubprotocols)(token) : void 0
     );
     socket.on("unexpected-response", (_req, res) => {
       const chunks = [];
@@ -1012,15 +1029,15 @@ function positionals(args) {
 }
 
 // src/utils/tasks.ts
-var import_core4 = require("@ordewell/core");
+var import_core5 = require("@ordewell/core");
 function allTasksOf(plan) {
   const tasks = plan?.pendingTasks || plan?.tasks || [];
   const executionLog = plan?.executionLog || [];
-  return (0, import_core4.rejoinPlanTree)(tasks, executionLog);
+  return (0, import_core5.rejoinPlanTree)(tasks, executionLog);
 }
 function resolveTaskId(plan, identifier) {
   const allTasks = allTasksOf(plan);
-  const byRef = (0, import_core4.resolveTaskRef)(allTasks, identifier);
+  const byRef = (0, import_core5.resolveTaskRef)(allTasks, identifier);
   if (byRef) return byRef.id;
   const prefixMatches = allTasks.filter((t) => typeof t.id === "string" && t.id.startsWith(identifier));
   if (prefixMatches.length === 1) return prefixMatches[0].id;
@@ -1030,13 +1047,13 @@ function resolveTaskId(plan, identifier) {
 // src/utils/session.ts
 var import_fs3 = require("fs");
 var import_path3 = require("path");
-var import_core5 = require("@ordewell/core");
+var import_core6 = require("@ordewell/core");
 var LAST_SESSION_FILENAME = "last-session.json";
 function lastSessionFile(workspace) {
-  return (0, import_path3.join)((0, import_core5.getStateDir)(workspace), LAST_SESSION_FILENAME);
+  return (0, import_path3.join)((0, import_core6.getStateDir)(workspace), LAST_SESSION_FILENAME);
 }
 function saveLastSession(sessionId, goal, runners2, workspace) {
-  const dir = (0, import_core5.getStateDir)(workspace);
+  const dir = (0, import_core6.getStateDir)(workspace);
   if (!(0, import_fs3.existsSync)(dir)) (0, import_fs3.mkdirSync)(dir, { recursive: true });
   (0, import_fs3.writeFileSync)(
     lastSessionFile(workspace),
@@ -1058,14 +1075,14 @@ function expandSessionId(id, workspace) {
   if (id.startsWith(SESSION_PREFIX)) return id;
   let files;
   try {
-    files = (0, import_fs3.readdirSync)((0, import_path3.join)((0, import_core5.getStateDir)(workspace), "sessions")).filter((f) => f.endsWith(".json"));
+    files = (0, import_fs3.readdirSync)((0, import_path3.join)((0, import_core6.getStateDir)(workspace), "sessions")).filter((f) => f.endsWith(".json"));
   } catch {
     return id;
   }
   const matches = /* @__PURE__ */ new Set();
   for (const file of files) {
     try {
-      const full = JSON.parse((0, import_fs3.readFileSync)((0, import_path3.join)((0, import_core5.getStateDir)(workspace), "sessions", file), "utf8"))?.meta?.id;
+      const full = JSON.parse((0, import_fs3.readFileSync)((0, import_path3.join)((0, import_core6.getStateDir)(workspace), "sessions", file), "utf8"))?.meta?.id;
       if (typeof full === "string" && (full.endsWith(id) || full.slice(SESSION_PREFIX.length).startsWith(id))) matches.add(full);
     } catch {
     }
@@ -1136,7 +1153,7 @@ ${describeApproval(event)}
 }
 
 // src/commands/researchLog.ts
-var import_core6 = require("@ordewell/core");
+var import_core7 = require("@ordewell/core");
 var OUTCOME_MARK = {
   success: "\u2713",
   failure: "\u2717",
@@ -1148,7 +1165,7 @@ var RESULT_CHARS = 160;
 var VERBOSE_RESULT_CHARS = 600;
 var THINKING_CHARS = 300;
 function summarize(tool, args, toolLabel) {
-  const { name, keyArg } = (0, import_core6.toolHeadline)(tool, args, toolLabel);
+  const { name, keyArg } = (0, import_core7.toolHeadline)(tool, args, toolLabel);
   return `${name}(${keyArg})`;
 }
 function oneLine(text, max) {
@@ -1198,7 +1215,7 @@ function createStepLog(options = {}) {
 }
 
 // src/commands/plan.ts
-var import_core7 = require("@ordewell/core");
+var import_core8 = require("@ordewell/core");
 function planTasks(plan) {
   return plan ? allTasksOf(plan) : [];
 }
@@ -1282,11 +1299,11 @@ Plan: ${tasks.length} task${tasks.length === 1 ? "" : "s"} (${aiCount} AI, ${man
   for (const t of tasks) {
     const typeIcon = t.type === "user" ? "[MAN]" : t.ops ? "[OPS]" : "[ AI]";
     const deps = t.dependencies?.length ? ` \u2190 ${t.dependencies.join(", ")}` : "";
-    console.log(`  ${(0, import_core7.taskOrderLabel)(t).padStart(2)}. ${typeIcon} ${t.title}${modelSuffix(t)}${deps}`);
+    console.log(`  ${(0, import_core8.taskOrderLabel)(t).padStart(2)}. ${typeIcon} ${t.title}${modelSuffix(t)}${deps}`);
     for (const sub of t.subtasks || []) {
       const subTypeIcon = sub.type === "user" ? "[MAN]" : "[ AI]";
       const subDeps = sub.dependencies?.length ? ` \u2190 ${sub.dependencies.join(", ")}` : "";
-      console.log(`    ${(0, import_core7.taskOrderLabel)(sub, t)}. ${subTypeIcon} ${sub.title}${modelSuffix(sub)}${subDeps}`);
+      console.log(`    ${(0, import_core8.taskOrderLabel)(sub, t)}. ${subTypeIcon} ${sub.title}${modelSuffix(sub)}${subDeps}`);
     }
   }
   if (manCount > 0) {
@@ -1336,7 +1353,7 @@ async function handlePlan(subArgs, deps = {}) {
     runners2 = runnerFlags;
   }
   console.error(`Generating plan for: "${goal}"...`);
-  const sessionId = (0, import_core7.mintSessionId)();
+  const sessionId = (0, import_core8.mintSessionId)();
   const isTty = !!process.stderr.isTTY;
   let lastLineLength = 0;
   const stepLog = createStepLog({ verbose });
@@ -1442,7 +1459,7 @@ ${note}`);
 }
 
 // src/isolation.ts
-var import_core8 = require("@ordewell/core");
+var import_core9 = require("@ordewell/core");
 var STATE_OF = {
   active: "active",
   merged: "integrated",
@@ -1526,9 +1543,9 @@ function repairedLanded(handoff) {
 function repairedNotice(handoff) {
   const repaired = repairedLanded(handoff);
   if (repaired.length === 0) return "";
-  const named = repaired.map((t) => `${t.title} (${(0, import_core8.capConflictFiles)(t.repairedFiles)})`);
-  const list = named.length === 1 ? named[0] : `${named.slice(0, -1).join(", ")} and ${named[named.length - 1]}`;
-  return ` ${list} landed through ${repaired.length === 1 ? "a conflict repair" : "conflict repairs"}.`;
+  const named = repaired.map((t) => `${t.title} (${(0, import_core9.capConflictFiles)(t.repairedFiles)})`);
+  const list2 = named.length === 1 ? named[0] : `${named.slice(0, -1).join(", ")} and ${named[named.length - 1]}`;
+  return ` ${list2} landed through ${repaired.length === 1 ? "a conflict repair" : "conflict repairs"}.`;
 }
 function repoResultLines(handoff) {
   return handoff.repos.map(({ path, landed }) => {
@@ -1541,14 +1558,14 @@ function mergeOutcome(result, branch, group, repaired = []) {
   if (!group && result.outcome === "conflict") {
     return { ok, message: `Merging ${branch} conflicted, so it was aborted \u2014 your tree is as it was. Merge it with git and resolve the conflict there.` };
   }
-  const { message } = (0, import_core8.describeMergeResult)(result, branch, group, repaired);
+  const { message } = (0, import_core9.describeMergeResult)(result, branch, group, repaired);
   return { ok, message: ok || !group ? message : `${message} Each repository's ${branch} is a plain branch you can merge by hand.` };
 }
 
 // src/utils/output.ts
-var import_core9 = require("@ordewell/core");
+var import_core10 = require("@ordewell/core");
 function iconFor(status) {
-  switch ((0, import_core9.taskStatusKind)({ status })) {
+  switch ((0, import_core10.taskStatusKind)({ status })) {
     case "done":
       return "\x1B[32m\u2713\x1B[0m";
     case "running":
@@ -1568,7 +1585,7 @@ function iconFor(status) {
 }
 
 // src/commands/run.ts
-var import_core10 = require("@ordewell/core");
+var import_core11 = require("@ordewell/core");
 
 // src/commands/shared.ts
 var import_readline2 = require("readline");
@@ -1727,11 +1744,11 @@ async function followExecution(api, sessionId, start, onBlocked) {
   });
   const stream = api.streamExecution(sessionId, (event) => {
     if (event.type === "task_started") {
-      process.stderr.write(`\xB7 ${(0, import_core10.taskStartedNotice)(event.title, event.runner)}
+      process.stderr.write(`\xB7 ${(0, import_core11.taskStartedNotice)(event.title, event.runner)}
 `);
     }
     if (event.type === "checkpoint") {
-      process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core10.truncateCheckpointSummary)(event.summary)} \u2014 \`ordewell checkpoint <id> approve|reject [reason]\` answers it
+      process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core11.truncateCheckpointSummary)(event.summary)} \u2014 \`ordewell checkpoint <id> approve|reject [reason]\` answers it
 `);
     }
     if (event.type === "status_update" && event.tasks) {
@@ -1812,7 +1829,7 @@ async function handleRun(subArgs, injectedApi) {
 }
 
 // src/tui/blocks.ts
-var import_core11 = require("@ordewell/core");
+var import_core13 = require("@ordewell/core");
 
 // src/tui/ansi.ts
 var import_string_width = __toESM(require("string-width"));
@@ -2027,94 +2044,191 @@ var style = {
 };
 
 // src/tui/markdown.ts
+var import_core12 = require("@ordewell/core");
 function renderMarkdown(source, cols) {
-  const lines = source.replace(/\r/g, "").replace(/^\n+|\n+$/g, "").split("\n");
+  return blocks((0, import_core12.markdownTokens)(source), { room: Math.max(1, cols), base: [] });
+}
+function closeOf(tokens, open) {
+  const { level } = tokens[open];
+  for (let i = open + 1; i < tokens.length; i += 1) {
+    if (tokens[i].nesting === -1 && tokens[i].level === level) return i;
+  }
+  return tokens.length - 1;
+}
+function lastLine(tokens) {
+  let last = null;
+  for (const token of tokens) {
+    if (token.nesting === 0 && token.map && (last === null || token.map[1] > last)) last = token.map[1];
+  }
+  return last ?? tokens[0]?.map?.[1] ?? null;
+}
+function blocks(tokens, ctx) {
   const out = [];
-  let inCodeBlock = false;
-  for (let i = 0; i < lines.length; i += 1) {
-    const line = lines[i];
-    if (/^\s*```/.test(line)) {
-      inCodeBlock = !inCodeBlock;
-      continue;
-    }
-    if (inCodeBlock) {
-      out.push(...wrap(style.grey(`  ${line}`), cols));
-      continue;
-    }
-    const table = tableAt(lines, i);
-    if (table) {
-      out.push(...renderTable(table.headers, table.rows, cols));
-      i = table.end;
-      continue;
-    }
-    const heading = line.match(/^\s{0,3}(#{1,6})\s+(.+?)\s*#*\s*$/);
-    if (heading) {
-      const paint = heading[1].length <= 2 ? (text) => style.bold(style.brand(text)) : style.bold;
-      out.push(...wrap(paint(inline(heading[2])), cols));
-      continue;
-    }
-    if (/^\s{0,3}(?:[-*_]\s*){3,}$/.test(line)) {
-      out.push(style.grey("\u2500".repeat(Math.max(1, cols))));
-      continue;
-    }
-    const bullet = line.match(/^(\s*)[-*+]\s+(.+)$/);
-    if (bullet) {
-      out.push(...wrap(`${bullet[1]}\u2022 ${inline(bullet[2])}`, cols));
-      continue;
-    }
-    const quote = line.match(/^\s*>\s?(.*)$/);
-    if (quote) {
-      out.push(...wrap(style.grey(`\u2502 ${inline(quote[1])}`), cols));
-      continue;
-    }
-    out.push(...wrap(inline(line), cols));
+  let previousEnd = null;
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i];
+    if (token.nesting === -1) continue;
+    const end = token.nesting === 1 ? closeOf(tokens, i) : i;
+    const children = tokens.slice(i + 1, end);
+    const lines = block(token, children, ctx);
+    const last = lastLine([token, ...children]);
+    i = end;
+    if (lines === null) continue;
+    const start = token.map?.[0] ?? null;
+    if (previousEnd !== null && start !== null && start > previousEnd && out.length > 0) out.push("");
+    previousEnd = last ?? previousEnd;
+    out.push(...lines);
   }
   return out;
 }
-function tableAt(lines, start) {
-  if (!lines[start]?.includes("|") || !isTableRule(lines[start + 1] ?? "")) return null;
-  const headers = tableCells(lines[start]);
-  if (headers.length < 2) return null;
-  const rows = [];
-  let end = start + 1;
-  for (let i = start + 2; i < lines.length && lines[i].includes("|"); i += 1) {
-    const cells2 = tableCells(lines[i]);
-    if (cells2.length !== headers.length) break;
-    rows.push(cells2);
-    end = i;
+function block(token, children, ctx) {
+  switch (token.type) {
+    case "paragraph_open":
+      return wrap(inline(children[0]?.children ?? [], ctx.base, "\n"), ctx.room);
+    case "heading_open": {
+      const level = Number(token.tag.slice(1));
+      const base = level <= 2 ? [style.bold, style.brand] : [style.bold];
+      return wrap(inline(children[0]?.children ?? [], [...ctx.base, ...base], "\n"), ctx.room);
+    }
+    case "fence":
+    case "code_block":
+      return token.content.replace(/\n$/, "").split("\n").flatMap((line) => wrap(`  ${line}`, ctx.room)).map(style.grey);
+    case "hr":
+      return [style.grey("\u2500".repeat(ctx.room))];
+    case "blockquote_open": {
+      const inner = blocks(children, { room: Math.max(1, ctx.room - 2), base: [...ctx.base, style.grey] });
+      return inner.map((line) => `${style.grey("\u2502")} ${line}`);
+    }
+    case "bullet_list_open":
+      return list(children, ctx, () => "\u2022");
+    case "ordered_list_open": {
+      const start = Number(token.attrs?.find(([name]) => name === "start")?.[1] ?? 1);
+      let n = start - 1;
+      return list(children, ctx, (item) => {
+        n += 1;
+        return `${item.info || n}${item.markup || "."}`;
+      });
+    }
+    case "table_open":
+      return table(children, ctx);
+    default:
+      return null;
+  }
+}
+function list(items, ctx, marker2) {
+  const out = [];
+  let previousEnd = null;
+  for (let i = 0; i < items.length; i += 1) {
+    const item = items[i];
+    if (item.type !== "list_item_open") continue;
+    const end = closeOf(items, i);
+    const mark = marker2(item);
+    const hang = " ".repeat(width(mark) + 1);
+    const content = items.slice(i + 1, end);
+    const inner = blocks(content, { ...ctx, room: Math.max(1, ctx.room - hang.length) });
+    i = end;
+    const start = item.map?.[0] ?? null;
+    if (previousEnd !== null && start !== null && start > previousEnd) out.push("");
+    previousEnd = lastLine(content) ?? previousEnd;
+    (inner.length > 0 ? inner : [""]).forEach((line, row) => out.push(row === 0 ? `${mark} ${line}` : line && `${hang}${line}`));
   }
-  return { headers, rows, end };
+  return out;
 }
-function isTableRule(line) {
-  const cells2 = tableCells(line);
-  return cells2.length >= 2 && cells2.every((cell) => /^:?-{3,}:?$/.test(cell));
+function inline(tokens, base, lineBreak) {
+  const active = [...base];
+  const paint = (text) => text.split(" ").map((word) => word ? active.reduce((acc, apply) => apply(acc), word) : word).join(" ");
+  let out = "";
+  let href = null;
+  let linkText = "";
+  const emit = (text) => {
+    out += paint(text);
+    if (href !== null) linkText += text;
+  };
+  for (const token of tokens) {
+    switch (token.type) {
+      case "text":
+      case "image":
+        emit(token.content);
+        break;
+      case "code_inline":
+        active.push(style.brand);
+        emit(token.content);
+        active.pop();
+        break;
+      case "softbreak":
+      case "hardbreak":
+        out += lineBreak;
+        break;
+      case "strong_open":
+        active.push(style.bold);
+        break;
+      case "em_open":
+        active.push(style.italic);
+        break;
+      case "s_open":
+        active.push(style.dim);
+        break;
+      case "link_open":
+        href = token.attrs?.find(([name]) => name === "href")?.[1] ?? null;
+        linkText = "";
+        if (href !== null) active.push(style.underline);
+        break;
+      case "link_close":
+        if (href !== null) {
+          active.pop();
+          if (linkText !== href) out += paint(" ") + style.grey(`(${href})`);
+        }
+        href = null;
+        break;
+      case "strong_close":
+      case "em_close":
+      case "s_close":
+        active.pop();
+        break;
+      default:
+        if (token.content) emit(token.content);
+    }
+  }
+  return out;
 }
-function tableCells(line) {
-  return line.trim().replace(/^\||\|$/g, "").split("|").map((cell) => cell.trim());
+function table(tokens, ctx) {
+  const headers = [];
+  const rows = [];
+  let inHead = false;
+  let row = null;
+  for (const token of tokens) {
+    if (token.type === "thead_open") inHead = true;
+    else if (token.type === "thead_close") inHead = false;
+    else if (token.type === "tr_open") row = [];
+    else if (token.type === "tr_close" && row) {
+      if (inHead) headers.push(...row);
+      else rows.push(row);
+      row = null;
+    } else if (token.type === "inline" && row) {
+      row.push(inline(token.children ?? [], inHead ? [style.bold] : [], " "));
+    }
+  }
+  return renderTable(headers, rows, ctx.room);
 }
 function renderTable(headers, rows, cols) {
   const separator = " \u2502 ";
   const separatorWidth = width(separator);
   const available = Math.max(headers.length, cols - separatorWidth * (headers.length - 1));
   const natural = headers.map(
-    (header, column) => Math.max(width(inline(header)), ...rows.map((row) => width(inline(row[column] ?? ""))))
+    (header, column) => Math.max(width(header), ...rows.map((row) => width(row[column] ?? "")))
   );
   const columnWidths = fitTableColumns(natural, available);
-  if (columnWidths.some((size) => size < 4)) return renderStackedTable(headers, rows, cols);
-  const renderRow = (cells2, paint = (text) => text) => {
-    const wrapped = cells2.map((cell, index) => wrap(inline(cell), columnWidths[index]));
+  if (columnWidths.some((size, index) => size < Math.min(4, natural[index]))) return renderRecords(headers, rows, cols);
+  const renderRow = (cells2) => {
+    const wrapped = headers.map((_, index) => wrap(cells2[index] ?? "", columnWidths[index]));
     const height = Math.max(...wrapped.map((cell) => cell.length));
     return Array.from(
       { length: height },
-      (_, line) => wrapped.map((cell, column) => pad(paint(cell[line] ?? ""), columnWidths[column])).join(separator)
+      (_, line) => wrapped.map((cell, column) => pad(cell[line] ?? "", columnWidths[column])).join(separator)
     );
   };
   const rule = columnWidths.map((size) => style.grey("\u2500".repeat(size))).join(style.grey("\u2500\u253C\u2500"));
-  return [
-    ...renderRow(headers, style.bold),
-    rule,
-    ...rows.flatMap((row) => renderRow(row))
-  ];
+  return [...renderRow(headers), rule, ...rows.flatMap(renderRow)];
 }
 function fitTableColumns(natural, available) {
   const widths = [...natural];
@@ -2127,15 +2241,12 @@ function fitTableColumns(natural, available) {
   }
   return widths;
 }
-function renderStackedTable(headers, rows, cols) {
+function renderRecords(headers, rows, cols) {
   return rows.flatMap((row, rowIndex) => [
-    ...rowIndex === 0 ? [] : [""],
-    ...row.flatMap((cell, column) => wrap(`${style.bold(inline(headers[column]))}: ${inline(cell)}`, cols))
+    ...rowIndex === 0 ? [] : [style.grey("\u2500".repeat(cols))],
+    ...headers.flatMap((header, column) => wrap(`${header}: ${row[column] ?? ""}`, cols))
   ]);
 }
-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.brand(code));
-}
 
 // src/tui/blocks.ts
 function countOf(n, noun) {
@@ -2168,25 +2279,25 @@ var ROLE_CONTINUATION = {
   error: style.red,
   wake_up: style.yellow
 };
-function messageLines(block, cols) {
-  const text = sanitize(block.text);
+function messageLines(block2, cols) {
+  const text = sanitize(block2.text);
   const room = Math.max(1, cols - 2);
-  const wrapped = block.role === "planner" || block.role === "agent" || block.role === "supervisor" ? renderMarkdown(text, room) : block.skills ? skillPaintedLines(text, block.skills, room) : wrap(text, room);
-  const rest = ROLE_CONTINUATION[block.role] ?? ((t) => t);
-  const rows = wrapped.map((line, i) => i === 0 ? ROLE_PREFIX[block.role](line) : rest(`  ${line}`));
-  if (block.role === "user" && block.forced) {
+  const wrapped = block2.role === "planner" || block2.role === "agent" || block2.role === "supervisor" ? renderMarkdown(text, room) : block2.skills ? skillPaintedLines(text, block2.skills, room) : wrap(text, room);
+  const rest = ROLE_CONTINUATION[block2.role] ?? ((t) => t);
+  const rows = wrapped.map((line, i) => i === 0 ? ROLE_PREFIX[block2.role](line) : rest(`  ${line}`));
+  if (block2.role === "user" && block2.forced) {
     const note = style.grey(" \xB7 sent now");
     if (width(rows[0]) + width(note) <= cols) rows[0] += note;
     else rows.push(` ${note}`);
   }
-  return block.role === "user" ? onBand(rows, cols) : rows;
+  return block2.role === "user" ? onBand(rows, cols) : rows;
 }
 function onBand(rows, cols) {
   const band = ["", ...rows, ""];
   return style.enabled ? band.map((row) => style.band(pad(row, cols))) : band;
 }
 function skillPaintedLines(text, skills, room) {
-  const tokens = (0, import_core11.loadedSkillTokens)(text, skills);
+  const tokens = (0, import_core13.loadedSkillTokens)(text, skills);
   return wrapLines(text, room).map(({ line, start }) => {
     let painted = "";
     let at = 0;
@@ -2200,19 +2311,19 @@ function skillPaintedLines(text, skills, room) {
     return painted + line.slice(at);
   });
 }
-function skillLoadLine(block, cols) {
-  const head = block.attaches ? `\u25CF /${sanitize(block.name)} will be attached to fitting tasks \xB7 ` : block.invokedBy === "planner" ? `\u25CF ${sanitize(block.name)} skill loaded by planner \xB7 ` : `\u25CF /${sanitize(block.name)} skill loaded \xB7 `;
-  const line = truncate(`${head}${truncatePath(sanitize(block.path), Math.max(1, cols - width(head)))}`, cols);
+function skillLoadLine(block2, cols) {
+  const head = block2.attaches ? `\u25CF /${sanitize(block2.name)} will be attached to fitting tasks \xB7 ` : block2.invokedBy === "planner" ? `\u25CF ${sanitize(block2.name)} skill loaded by planner \xB7 ` : `\u25CF /${sanitize(block2.name)} skill loaded \xB7 `;
+  const line = truncate(`${head}${truncatePath(sanitize(block2.path), Math.max(1, cols - width(head)))}`, cols);
   return `${style.green("\u25CF")}${style.grey(line.slice(1))}`;
 }
-function thinkingLines(block, cols, detailAll) {
-  const text = sanitize(block.text).trim();
+function thinkingLines(block2, cols, detailAll) {
+  const text = sanitize(block2.text).trim();
   const head = `\u2234 Thinking (${countOf(text ? text.split(/\s+/).length : 0, "word")})`;
   if (detailAll) {
     const body = text ? wrap(text, Math.max(1, cols - 2)).map((line) => style.grey(`  ${line}`)) : [];
     return [style.grey(truncate(head, cols)), ...body];
   }
-  const latest = block.streaming ? (text.split("\n").at(-1) ?? "").trim() : "";
+  const latest = block2.streaming ? (text.split("\n").at(-1) ?? "").trim() : "";
   const room = cols - width(`${head} \xB7 `);
   if (!latest || room < 2) return [style.grey(truncate(head, cols))];
   const shown = width(latest) > room ? `\u2026${tailOf(latest, room - 1)}` : latest;
@@ -2224,21 +2335,21 @@ var PREVIEW_LINES = 3;
 function underHeader(lines) {
   return lines.map((line, i) => `${i === 0 ? style.grey(OUTPUT_HEAD) : OUTPUT_INDENT}${line}`);
 }
-function unsettledOutcome(block) {
-  switch (block.status) {
+function unsettledOutcome(block2) {
+  switch (block2.status) {
     case "error":
       return { label: "Error", paint: style.red };
     case "denied":
-      return { label: block.outcome === "refused" ? "Refused" : "Denied", paint: style.yellow };
+      return { label: block2.outcome === "refused" ? "Refused" : "Denied", paint: style.yellow };
     case "interrupted":
       return { label: "Interrupted", paint: style.grey };
     default:
       return null;
   }
 }
-function commandMark(block) {
-  if (block.status === "pending") return style.grey("\u25CB");
-  return (unsettledOutcome(block)?.paint ?? style.green)("\u25CF");
+function commandMark(block2) {
+  if (block2.status === "pending") return style.grey("\u25CB");
+  return (unsettledOutcome(block2)?.paint ?? style.green)("\u25CF");
 }
 var PATH_LIKE = /^(?![a-z][a-z0-9+.-]*:\/\/)\S*\/\S*$/i;
 function truncatePath(path, max) {
@@ -2251,17 +2362,17 @@ function truncatePath(path, max) {
   const slash = tail.search(/[\\/]/);
   return `\u2026${slash > 0 ? tail.slice(slash) : tail}`;
 }
-function commandHeader(block, cols, detailAll) {
-  const name = sanitize(block.headline.name);
-  const keyArg = sanitize(block.headline.keyArg);
+function commandHeader(block2, cols, detailAll) {
+  const name = sanitize(block2.headline.name);
+  const keyArg = sanitize(block2.headline.keyArg);
   if (detailAll) {
-    return wrap(`${name}(${keyArg})`, Math.max(1, cols - 2)).map((line, i) => i === 0 ? `${commandMark(block)} ${line}` : `  ${line}`);
+    return wrap(`${name}(${keyArg})`, Math.max(1, cols - 2)).map((line, i) => i === 0 ? `${commandMark(block2)} ${line}` : `  ${line}`);
   }
   const open = `\u25CF ${name}(`;
   const room = cols - width(open) - 1;
   const cut = PATH_LIKE.test(keyArg) ? truncatePath(keyArg, room) : truncate(keyArg, room);
   const text = room > 1 ? `${open}${cut})` : truncate(`${open}${keyArg})`, cols);
-  return [`${commandMark(block)}${text.slice(1)}`];
+  return [`${commandMark(block2)}${text.slice(1)}`];
 }
 function argumentLines(args) {
   if (!args.trim()) return [];
@@ -2277,21 +2388,21 @@ function argumentLines(args) {
     return [`${key}: ${first}`, ...rest];
   });
 }
-function resultLines(block, room, detailAll) {
-  if (block.status === "pending") return [style.grey("Running\u2026")];
+function resultLines(block2, room, detailAll) {
+  if (block2.status === "pending") return [style.grey("Running\u2026")];
   const fit2 = (line) => detailAll ? wrap(line, room) : [truncate(line, room)];
-  const outcome = unsettledOutcome(block);
+  const outcome = unsettledOutcome(block2);
   if (outcome) {
-    const [reason, ...rest] = (0, import_core11.outputLines)(block.output).map(sanitize);
+    const [reason, ...rest] = (0, import_core13.outputLines)(block2.output).map(sanitize);
     const status = fit2(reason ? `${outcome.label}: ${reason}` : outcome.label).map(outcome.paint);
     return detailAll ? [...status, ...rest.flatMap(fit2).map(style.grey)] : status;
   }
   if (detailAll) {
-    const lines2 = (0, import_core11.outputLines)(block.output).map(sanitize);
+    const lines2 = (0, import_core13.outputLines)(block2.output).map(sanitize);
     const note = lines2.length > PREVIEW_LINES ? ["\u2026 (ctrl+o to collapse)"] : [];
     return lines2.length > 0 ? [...lines2.flatMap(fit2), ...note].map(style.grey) : [style.grey("(no output)")];
   }
-  const { lines, hiddenLineCount } = (0, import_core11.outputPreview)(block.output, PREVIEW_LINES);
+  const { lines, hiddenLineCount } = (0, import_core13.outputPreview)(block2.output, PREVIEW_LINES);
   if (lines.length === 0) return [style.grey("(no output)")];
   const more = hiddenLineCount > 0 ? [`\u2026 +${countOf(hiddenLineCount, "line")} (ctrl+o to expand)`] : [];
   return [...lines.map(sanitize), ...more].map((line) => style.grey(truncate(line, room)));
@@ -2304,8 +2415,8 @@ var DIFF_PAINT = {
   gap: style.grey
 };
 var DIFF_SIGN = { added: "+", removed: "-", context: " ", gap: "" };
-function diffLines(block, diff, room, detailAll) {
-  const rows = (0, import_core11.diffRows)(block.output);
+function diffLines(block2, diff, room, detailAll) {
+  const rows = (0, import_core13.diffRows)(block2.output);
   const gutter = Math.max(0, ...rows.map((row) => String(row.line ?? "").length));
   const draw = (row) => {
     const text = row.kind === "gap" ? `${" ".repeat(gutter)} \u22EE` : `${String(row.line ?? "").padStart(gutter)} ${DIFF_SIGN[row.kind]} ${sanitize(row.text)}`;
@@ -2314,14 +2425,14 @@ function diffLines(block, diff, room, detailAll) {
   const shown = detailAll ? rows : rows.slice(0, DIFF_PREVIEW_ROWS);
   const hidden = rows.length - shown.length;
   const more = hidden > 0 ? [style.grey(`\u2026 +${countOf(hidden, "line")} (ctrl+o to expand)`)] : [];
-  return [(0, import_core11.diffSummary)(diff), ...shown.flatMap(draw), ...more];
+  return [(0, import_core13.diffSummary)(diff), ...shown.flatMap(draw), ...more];
 }
-function toolLines(block, cols, detailAll) {
+function toolLines(block2, cols, detailAll) {
   const room = Math.max(1, cols - OUTPUT_INDENT.length);
-  const diff = block.diff && block.status === "ok" ? block.diff : null;
-  const args = detailAll && !diff ? argumentLines(block.args).flatMap((line) => wrap(line, room)).map((line) => OUTPUT_INDENT + style.grey(line)) : [];
-  const result = diff ? diffLines(block, diff, room, detailAll) : resultLines(block, room, detailAll);
-  return [...commandHeader(block, cols, detailAll), ...args, ...underHeader(result)];
+  const diff = block2.diff && block2.status === "ok" ? block2.diff : null;
+  const args = detailAll && !diff ? argumentLines(block2.args).flatMap((line) => wrap(line, room)).map((line) => OUTPUT_INDENT + style.grey(line)) : [];
+  const result = diff ? diffLines(block2, diff, room, detailAll) : resultLines(block2, room, detailAll);
+  return [...commandHeader(block2, cols, detailAll), ...args, ...underHeader(result)];
 }
 var SUBAGENT_PAINT = {
   running: style.yellow,
@@ -2330,24 +2441,24 @@ var SUBAGENT_PAINT = {
   stopped: style.grey
 };
 var CHILD_INDENT = "    ";
-function subagentHeader(block, cols) {
-  const brief = firstLine(block.brief);
-  const steps = block.children.filter((c) => c.type === "tool").length;
-  const status = block.status === "running" && steps > 0 ? `running \xB7 ${countOf(steps, "step")}` : block.status;
+function subagentHeader(block2, cols) {
+  const brief = firstLine(block2.brief);
+  const steps = block2.children.filter((c) => c.type === "tool").length;
+  const status = block2.status === "running" && steps > 0 ? `running \xB7 ${countOf(steps, "step")}` : block2.status;
   const head = brief ? " Agent: " : " Agent";
   const briefRoom = cols - width(`\u25C6${head}  ${status}`);
   if (briefRoom < 4) return truncate(`\u25C6${head}${brief}  ${status}`, cols);
-  const named = `${style.brand("\u25C6")}${head}${truncate(brief, briefRoom)}  ${SUBAGENT_PAINT[block.status](status)}`;
-  const digest = firstLine(block.digest);
+  const named = `${style.brand("\u25C6")}${head}${truncate(brief, briefRoom)}  ${SUBAGENT_PAINT[block2.status](status)}`;
+  const digest = firstLine(block2.digest);
   const digestRoom = cols - width(named) - width(" \xB7 ");
   return digest && digestRoom >= 4 ? `${named}${style.grey(` \xB7 ${truncate(digest, digestRoom)}`)}` : named;
 }
-function subagentLines(block, cols, detailAll) {
-  const header = subagentHeader(block, cols);
+function subagentLines(block2, cols, detailAll) {
+  const header = subagentHeader(block2, cols);
   if (!detailAll) return [header];
   const childCols = Math.max(1, cols - CHILD_INDENT.length);
-  const children = block.children.flatMap((child) => blockLines(child, childCols, true).map((line) => CHILD_INDENT + line));
-  const digest = sanitize(block.digest).trim();
+  const children = block2.children.flatMap((child) => blockLines(child, childCols, true).map((line) => CHILD_INDENT + line));
+  const digest = sanitize(block2.digest).trim();
   const handedBack = digest ? underHeader(wrap(digest, Math.max(1, cols - OUTPUT_INDENT.length)).map(style.grey)) : [];
   return [header, ...children, ...handedBack];
 }
@@ -2372,24 +2483,39 @@ var DECIDED_BY = {
   budget: "web-read budget",
   unsupported: "not usable on this runner version"
 };
-function approvalLine(block, cols) {
-  const policy = block.decidedBy && block.decidedBy !== "asked" ? DECIDED_BY[block.decidedBy] : void 0;
-  const [mark, status, paint] = block.status === "pending" ? ["?", "Waiting for you", style.yellow] : block.status === "granted" ? ["\u2713", policy ? `Auto-approved (${policy})` : block.forTask ? "Approved for this task" : "Approved", style.green] : block.status === "withdrawn" ? ["\xB7", "Withdrawn", style.grey] : ["\u2298", policy ? `Auto-denied (${policy})` : "Denied", style.yellow];
-  const note = block.note ? ` \u2014 \u201C${firstLine(block.note)}\u201D` : "";
-  const line = `${mark} ${status} \xB7 ${APPROVAL_KIND[block.kind]}: ${firstLine(block.subject)}${note}`;
+function approvalLine(block2, cols) {
+  const policy = block2.decidedBy && block2.decidedBy !== "asked" ? DECIDED_BY[block2.decidedBy] : void 0;
+  const [mark, status, paint] = block2.status === "pending" ? ["?", "Waiting for you", style.yellow] : block2.status === "granted" ? ["\u2713", policy ? `Auto-approved (${policy})` : block2.forTask ? "Approved for this task" : "Approved", style.green] : block2.status === "withdrawn" ? ["\xB7", "Withdrawn", style.grey] : ["\u2298", policy ? `Auto-denied (${policy})` : "Denied", style.yellow];
+  const note = block2.note ? ` \u2014 \u201C${firstLine(block2.note)}\u201D` : "";
+  const line = `${mark} ${status} \xB7 ${APPROVAL_KIND[block2.kind]}: ${firstLine(block2.subject)}${note}`;
   return `${paint(mark)}${truncate(line, cols).slice(mark.length)}`;
 }
-function approvalKeysLine(block, cols) {
-  const keys = ["ctrl-y allow", ...block.allowForTask ? ["ctrl-t allow for task"] : [], "ctrl-g deny (composer text is the note)"];
+function approvalKeysLine(block2, cols) {
+  const keys = ["ctrl-y allow", ...block2.allowForTask ? ["ctrl-t allow for task"] : [], "ctrl-g deny (composer text is the note)"];
   return style.grey(truncate(`  ${keys.join(" \xB7 ")}`, cols));
 }
 function checkpointCardLines(order, question, cols, approvalFirst) {
   const room = Math.max(1, cols - 2);
-  const keys = approvalFirst ? "answer the tool request above first (ctrl-y / ctrl-g), then ctrl-y approves \xB7 ctrl-g rejects (composer text is the reason)" : "ctrl-y approve \xB7 ctrl-g reject (composer text is the reason)";
+  const first = approvalFirst ? wrap("answer the tool request above first (ctrl-y / ctrl-g), then:", room) : [];
   return [
     truncate(`${style.accent("\u25C6")} ${style.bold(`Task ${order} asks`)}`, cols),
     ...wrap(sanitize(question).trim(), room).map((line) => `  ${line}`),
-    ...wrap(keys, room).map((line) => style.grey(`  ${line}`))
+    ...first.map((line) => style.grey(`  ${line}`)),
+    ...CHECKPOINT_CHOICES.flatMap(([key, text]) => choiceLines(key, text, room))
+  ];
+}
+var CHECKPOINT_CHOICES = [
+  ["enter", "reply: the task goes on with what you typed"],
+  ["ctrl-y", "approve as is"],
+  ["ctrl-g", "reject (with nothing typed, a plain no)"]
+];
+var CHOICE_KEY_WIDTH = 6;
+function choiceLines(key, text, room) {
+  const hang = CHOICE_KEY_WIDTH + 2;
+  const [head = "", ...rest] = wrap(text, Math.max(1, room - hang));
+  return [
+    `  ${style.accent(style.bold(pad(key, CHOICE_KEY_WIDTH)))}  ${style.grey(head)}`,
+    ...rest.map((line) => `  ${" ".repeat(hang)}${style.grey(line)}`)
   ];
 }
 var COMMAND_PAINT = {
@@ -2398,22 +2524,22 @@ var COMMAND_PAINT = {
   failed: style.red,
   stopped: style.grey
 };
-function runnerCommandLines(block, cols, detailAll) {
-  const typed = sanitize(`/${block.name}${block.args ? ` ${block.args}` : ""}`);
-  const status = `  ${block.status}`;
-  const head = `${style.accent("\u276F")} ${truncate(typed, Math.max(1, cols - 2 - width(status)))}${COMMAND_PAINT[block.status](status)}`;
+function runnerCommandLines(block2, cols, detailAll) {
+  const typed = sanitize(`/${block2.name}${block2.args ? ` ${block2.args}` : ""}`);
+  const status = `  ${block2.status}`;
+  const head = `${style.accent("\u276F")} ${truncate(typed, Math.max(1, cols - 2 - width(status)))}${COMMAND_PAINT[block2.status](status)}`;
   const room = Math.max(1, cols - OUTPUT_INDENT.length);
-  const printed = (0, import_core11.outputLines)(block.output).map(sanitize);
+  const printed = (0, import_core13.outputLines)(block2.output).map(sanitize);
   const shown = detailAll ? printed.flatMap((line) => wrap(line, room)) : printed.slice(0, PREVIEW_LINES).map((line) => truncate(line, room));
   return [head, ...underHeader(shown.map(style.grey))];
 }
-function compactionLine(block, cols) {
-  const sizes = block.preTokens !== void 0 && block.postTokens !== void 0 ? ` \xB7 ${compactCount(block.preTokens)} \u2192 ${compactCount(block.postTokens)} tokens` : "";
-  const text = block.trigger === "auto" && !sizes ? "\u2261 Context compacted by the runner on its own" : `\u2261 Context compacted${sizes}`;
+function compactionLine(block2, cols) {
+  const sizes = block2.preTokens !== void 0 && block2.postTokens !== void 0 ? ` \xB7 ${compactCount(block2.preTokens)} \u2192 ${compactCount(block2.postTokens)} tokens` : "";
+  const text = block2.trigger === "auto" && !sizes ? "\u2261 Context compacted by the runner on its own" : `\u2261 Context compacted${sizes}`;
   return style.grey(truncate(text, cols));
 }
-function runnerLoadedLines(block, cols, detailAll) {
-  const of = (kind) => block.commands.filter((c) => c.kind === kind).map((c) => `/${sanitize(c.name)}`);
+function runnerLoadedLines(block2, cols, detailAll) {
+  const of = (kind) => block2.commands.filter((c) => c.kind === kind).map((c) => `/${sanitize(c.name)}`);
   const skills = of("skill");
   const commands = of("command");
   const builtins = of("builtin");
@@ -2421,66 +2547,66 @@ function runnerLoadedLines(block, cols, detailAll) {
     countOf(skills.length, "skill"),
     countOf(commands.length, "command"),
     countOf(builtins.length, "built-in command"),
-    countOf(block.mcpServers.length, "MCP server")
+    countOf(block2.mcpServers.length, "MCP server")
   ];
   const head = truncate(`\u25CF Runner loaded ${counts.join(", ")}`, cols);
   const lines = [`${style.green("\u25CF")}${style.grey(head.slice(1))}`];
   if (!detailAll) return lines;
   const room = Math.max(1, cols - OUTPUT_INDENT.length);
-  const list = (label, names) => names.length > 0 ? wrap(`${label}: ${names.join(" ")}`, room) : [];
-  const servers = block.mcpServers.map((m) => `${sanitize(m.name)}${m.status ? ` (${sanitize(m.status)})` : ""}`);
+  const list2 = (label, names) => names.length > 0 ? wrap(`${label}: ${names.join(" ")}`, room) : [];
+  const servers = block2.mcpServers.map((m) => `${sanitize(m.name)}${m.status ? ` (${sanitize(m.status)})` : ""}`);
   return [
     ...lines,
-    ...[...list("skills", skills), ...list("commands", commands), ...list("built-in", builtins), ...servers.length > 0 ? wrap(`MCP servers: ${servers.join(", ")}`, room) : []].map((line) => OUTPUT_INDENT + style.grey(line))
+    ...[...list2("skills", skills), ...list2("commands", commands), ...list2("built-in", builtins), ...servers.length > 0 ? wrap(`MCP servers: ${servers.join(", ")}`, room) : []].map((line) => OUTPUT_INDENT + style.grey(line))
   ];
 }
-function planLine(block, cols) {
-  const count = block.taskCount === void 0 ? "" : ` (${countOf(block.taskCount, "task")})`;
-  const text = block.status === "building" ? "Building plan\u2026" : `Plan ${block.status}${count}`;
+function planLine(block2, cols) {
+  const count = block2.taskCount === void 0 ? "" : ` (${countOf(block2.taskCount, "task")})`;
+  const text = block2.status === "building" ? "Building plan\u2026" : `Plan ${block2.status}${count}`;
   return `${style.brand("\u25C7")}${truncate(`\u25C7 ${text}`, cols).slice(1)}`;
 }
-function blockLines(block, cols, detailAll) {
-  switch (block.type) {
+function blockLines(block2, cols, detailAll) {
+  switch (block2.type) {
     case "message":
-      return messageLines(block, cols);
+      return messageLines(block2, cols);
     case "thinking":
-      return thinkingLines(block, cols, detailAll);
+      return thinkingLines(block2, cols, detailAll);
     case "tool":
-      return toolLines(block, cols, detailAll);
+      return toolLines(block2, cols, detailAll);
     case "subagent":
-      return subagentLines(block, cols, detailAll);
+      return subagentLines(block2, cols, detailAll);
     case "approval":
-      return [approvalLine(block, cols)];
+      return [approvalLine(block2, cols)];
     case "plan":
-      return [planLine(block, cols)];
+      return [planLine(block2, cols)];
     case "skill_load":
-      return [skillLoadLine(block, cols)];
+      return [skillLoadLine(block2, cols)];
     case "command":
-      return runnerCommandLines(block, cols, detailAll);
+      return runnerCommandLines(block2, cols, detailAll);
     case "compaction":
-      return [compactionLine(block, cols)];
+      return [compactionLine(block2, cols)];
     case "runner_loaded":
-      return runnerLoadedLines(block, cols, detailAll);
+      return runnerLoadedLines(block2, cols, detailAll);
     // Pinned under the pane rather than drawn in it — see `tokenLine`.
     case "usage":
       return [];
   }
 }
 var drawnBlocks = /* @__PURE__ */ new WeakMap();
-function drawn(block, cols, detailAll) {
-  const cached = drawnBlocks.get(block);
+function drawn(block2, cols, detailAll) {
+  const cached = drawnBlocks.get(block2);
   if (cached && cached.cols === cols && cached.detailAll === detailAll) return cached.lines;
-  const lines = blockLines(block, cols, detailAll);
-  drawnBlocks.set(block, { cols, detailAll, lines });
+  const lines = blockLines(block2, cols, detailAll);
+  drawnBlocks.set(block2, { cols, detailAll, lines });
   return lines;
 }
-function conversationLines(blocks, cols, detailAll, answering) {
+function conversationLines(blocks2, cols, detailAll, answering) {
   const lines = [];
-  for (const [i, block] of blocks.entries()) {
-    if (block.type === "usage") continue;
-    lines.push(...drawn(block, cols, detailAll));
-    if (block === answering) lines.push(approvalKeysLine(block, cols));
-    if (blocks[i + 1]?.type !== "skill_load") lines.push("");
+  for (const [i, block2] of blocks2.entries()) {
+    if (block2.type === "usage") continue;
+    lines.push(...drawn(block2, cols, detailAll));
+    if (block2 === answering) lines.push(approvalKeysLine(block2, cols));
+    if (blocks2[i + 1]?.type !== "skill_load") lines.push("");
   }
   return lines;
 }
@@ -2494,8 +2620,8 @@ function formatCost(currency, amount) {
   const value = `${whole}.${frac.padEnd(2, "0")}`;
   return currency.toLowerCase() === "usd" ? `$${value}` : `${value} ${currency.toUpperCase()}`;
 }
-function tokenLine(blocks, cols) {
-  const usage = blocks[blocks.length - 1];
+function tokenLine(blocks2, cols) {
+  const usage = blocks2[blocks2.length - 1];
   if (usage?.type !== "usage") return null;
   const parts = usageMeasures(usage.totals, false);
   if (usage.model && !usage.contextFill) parts.push("ctx unknown");
@@ -2521,7 +2647,7 @@ function taskUsageText(usage) {
 
 // src/commands/status.ts
 var import_fs4 = require("fs");
-var import_core12 = require("@ordewell/core");
+var import_core14 = require("@ordewell/core");
 async function handleStatus(subArgs, injectedApi) {
   const sessionId = flag(subArgs, "--session-id");
   const workspace = flag(subArgs, "--workspace") || process.cwd();
@@ -2576,8 +2702,8 @@ function emitJson(payload, outputPath) {
 }
 function printOneSession(sessionId, meta, plan) {
   const allTasks = allTasksOf(plan);
-  const everyTask = (0, import_core12.flattenTasks)(allTasks);
-  const blocked = (0, import_core12.blockingFailures)(everyTask.map((t) => ({ ...t, subtasks: [], dependencies: t.dependencies ?? [] })));
+  const everyTask = (0, import_core14.flattenTasks)(allTasks);
+  const blocked = (0, import_core14.blockingFailures)(everyTask.map((t) => ({ ...t, subtasks: [], dependencies: t.dependencies ?? [] })));
   const count = (status) => everyTask.filter((t) => t.status === status || status === "blocked" && blocked.has(t.id)).length;
   console.log(`Session:  ${sessionId}`);
   console.log(`Goal:     ${meta.goal}`);
@@ -2585,25 +2711,25 @@ function printOneSession(sessionId, meta, plan) {
   console.log(`Phase:    ${plan?.phase || "unknown"}  |  Created: ${meta.createdAt}`);
   console.log(`Tasks:    ${everyTask.length} total  |  ${count("completed")} done  |  ${count("failed")} failed  |  ${count("in_progress")} running  |  ${count("blocked")} blocked  |  ${count("skipped")} skipped
 `);
-  const usage = (0, import_core12.planUsage)(allTasks);
+  const usage = (0, import_core14.planUsage)(allTasks);
   if (usage.attempts) console.log(`Tasks total: ${taskUsageText(usage)}`);
   for (const t of allTasks) {
     const icon = iconFor(blocked.has(t.id) ? "blocked" : t.status);
     const model = t.assignedModel ? ` (${t.assignedModel.modelLabel})` : "";
     const shortId = (t.id ?? "").slice(-8);
-    console.log(`  ${(0, import_core12.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
-    const row = (0, import_core12.taskRowView)({ ...t, dependencies: t.dependencies ?? [] }, { tasks: allTasks });
-    if (row.blockedBy) console.log(`      ${(0, import_core12.blockedByLabel)(row.blockedBy)}`);
-    if (row.status === "skipped") console.log(`      ${(0, import_core12.skippedLabel)(row.skipReason)}`);
+    console.log(`  ${(0, import_core14.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
+    const row = (0, import_core14.taskRowView)({ ...t, dependencies: t.dependencies ?? [] }, { tasks: allTasks });
+    if (row.blockedBy) console.log(`      ${(0, import_core14.blockedByLabel)(row.blockedBy)}`);
+    if (row.status === "skipped") console.log(`      ${(0, import_core14.skippedLabel)(row.skipReason)}`);
     if (row.usage) console.log(`      ${taskUsageText(row.usage)}`);
     for (const sub of t.subtasks || []) {
       const subIcon = iconFor(blocked.has(sub.id) ? "blocked" : sub.status);
       const subModel = sub.assignedModel ? ` (${sub.assignedModel.modelLabel})` : "";
       const subShortId = (sub.id ?? "").slice(-8);
-      console.log(`    ${(0, import_core12.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
-      const subRow = (0, import_core12.taskRowView)({ ...sub, dependencies: sub.dependencies ?? [] }, { parent: t, tasks: allTasks });
-      if (subRow.blockedBy) console.log(`        ${(0, import_core12.blockedByLabel)(subRow.blockedBy)}`);
-      if (subRow.status === "skipped") console.log(`        ${(0, import_core12.skippedLabel)(subRow.skipReason)}`);
+      console.log(`    ${(0, import_core14.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
+      const subRow = (0, import_core14.taskRowView)({ ...sub, dependencies: sub.dependencies ?? [] }, { parent: t, tasks: allTasks });
+      if (subRow.blockedBy) console.log(`        ${(0, import_core14.blockedByLabel)(subRow.blockedBy)}`);
+      if (subRow.status === "skipped") console.log(`        ${(0, import_core14.skippedLabel)(subRow.skipReason)}`);
       if (subRow.usage) console.log(`        ${taskUsageText(subRow.usage)}`);
     }
   }
@@ -2656,10 +2782,10 @@ async function handleWeb(subArgs) {
 }
 
 // src/commands/models.ts
-var import_core14 = require("@ordewell/core");
+var import_core16 = require("@ordewell/core");
 
 // src/commands/model.ts
-var import_core13 = require("@ordewell/core");
+var import_core15 = require("@ordewell/core");
 var USAGE = "Usage: ordewell model [show | set <model-id>]";
 async function handleModel(subArgs, injectedApi) {
   const [action, modelId] = positionals(subArgs);
@@ -2674,7 +2800,7 @@ async function handleModel(subArgs, injectedApi) {
   if (!modelId) fail(USAGE);
   const settings = await api.getSettings();
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
-  const runner = (0, import_core13.runnerForProvider)(provider);
+  const runner = (0, import_core15.runnerForProvider)(provider);
   if (runner) {
     const known = (await fetchCatalog(api)).models.filter((m) => m.runners?.includes(runner));
     if (known.length > 0 && !known.some((m) => m.id === modelId)) {
@@ -2697,7 +2823,7 @@ async function showModels(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   const current = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
-  const runner = (0, import_core13.runnerForProvider)(provider);
+  const runner = (0, import_core15.runnerForProvider)(provider);
   const options = runner ? catalog.models.filter((m) => m.runners?.includes(runner)) : catalog.orchestratorModels;
   console.log(`
 Planner model: ${current || "(backend default)"}`);
@@ -2731,8 +2857,8 @@ async function handleModels(subArgs) {
     const rest = subArgs.filter((_, i) => i !== setIdx && i !== setIdx + 1);
     return handleModel(["set", subArgs[setIdx + 1], ...rest]);
   }
-  const config = new import_core14.EnvConfig();
-  const providers = (0, import_core14.configuredProviders)(config);
+  const config = new import_core16.EnvConfig();
+  const providers = (0, import_core16.configuredProviders)(config);
   if (providers.length === 0) {
     console.error("No providers configured. Set an API key for a provider, e.g.:");
     console.error("  OPENROUTER_API_KEY=...   (OpenRouter)");
@@ -2741,19 +2867,19 @@ async function handleModels(subArgs) {
     console.error("  OPENAI_COMPATIBLE_BASE_URL=...  (self-hosted / OpenAI-compatible)");
     process.exit(1);
   }
-  const { apiKeys, baseUrls } = (0, import_core14.collectProviderCredentials)(config);
+  const { apiKeys, baseUrls } = (0, import_core16.collectProviderCredentials)(config);
   let models;
   let errors;
   try {
-    const result = await (0, import_core14.fetchAllProviderModels)({ apiKeys, baseUrls });
-    models = (0, import_core14.toOrchestratorOptions)(result.models, import_core14.ORCHESTRATOR_SHORTCUTS);
+    const result = await (0, import_core16.fetchAllProviderModels)({ apiKeys, baseUrls });
+    models = (0, import_core16.toOrchestratorOptions)(result.models, import_core16.ORCHESTRATOR_SHORTCUTS);
     errors = result.errors;
   } catch (err) {
     console.error(`Failed to fetch models: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
     return;
   }
-  const providerLabel = (p) => (0, import_core14.getProviderMeta)(p)?.label ?? p;
+  const providerLabel = (p) => (0, import_core16.getProviderMeta)(p)?.label ?? p;
   console.log(
     `
 Available models (${models.length}) across ${providers.length} configured provider(s):`
@@ -2793,7 +2919,7 @@ ${providerLabel(provider)}`);
 
 // src/commands/setup.ts
 var import_fs6 = require("fs");
-var import_core15 = require("@ordewell/core");
+var import_core17 = require("@ordewell/core");
 function handleSetup(subArgs) {
   const modelIdx = subArgs.indexOf("--model");
   const chosenModel = modelIdx !== -1 ? subArgs[modelIdx + 1] : null;
@@ -2838,7 +2964,7 @@ function handleSetup(subArgs) {
 
 # Or plan with a coding agent you already have installed \u2014 no API key needed,
 # it uses that agent's own subscription. Set the model to one of its own.
-# AI_PROVIDER=claude-code|codex|opencode
+# AI_PROVIDER=${runnerIdChoice()}
 # ORCHESTRATOR_MODEL=haiku
 # ORDEWELL_PLANNER_EFFORT=low
 
@@ -2865,13 +2991,13 @@ function handleSetup(subArgs) {
 # STEPFUN_API_KEY=...
 # SILICONFLOW_API_KEY=...
 `;
-  (0, import_core15.writePrivateFile)(envFile, content);
+  (0, import_core17.writePrivateFile)(envFile, content);
   console.log(`Wrote: ${envFile}`);
   console.log("Review and edit the file, then run: ordewell tui");
 }
 
 // src/commands/skills.ts
-var import_core16 = require("@ordewell/core");
+var import_core18 = require("@ordewell/core");
 var import_path5 = require("path");
 function invocation(skill) {
   if (skill.userInvocable && skill.modelInvocable) return "both";
@@ -2884,22 +3010,22 @@ function handleSkills(subArgs) {
     fail("Usage: ordewell skills [--workspace /path] [--json]");
   }
   const workspace = (0, import_path5.resolve)(flag(subArgs, "--workspace") || process.cwd());
-  const catalog = (0, import_core16.createSkillsService)(workspace, new import_core16.EnvConfig().workspaceRepos).readCatalog();
+  const catalog = (0, import_core18.createSkillsService)(workspace, new import_core18.EnvConfig().workspaceRepos).readCatalog();
   const skills = catalog.skills.map((skill) => ({
     name: skill.name,
     scope: skill.source,
     appliesTo: skill.appliesTo,
     invocation: invocation(skill),
-    path: (0, import_core16.abbreviateHome)(skill.path)
+    path: (0, import_core18.abbreviateHome)(skill.path)
   }));
   const shadowed = catalog.shadowed.map(({ skill, shadowedBy }) => ({
     name: skill.name,
-    path: (0, import_core16.abbreviateHome)(skill.path),
-    shadowedBy: { scope: shadowedBy.source, path: (0, import_core16.abbreviateHome)(shadowedBy.path) }
+    path: (0, import_core18.abbreviateHome)(skill.path),
+    shadowedBy: { scope: shadowedBy.source, path: (0, import_core18.abbreviateHome)(shadowedBy.path) }
   }));
   const invalid = catalog.invalid.map((skill) => ({
     name: skill.name,
-    path: (0, import_core16.abbreviateHome)(skill.path),
+    path: (0, import_core18.abbreviateHome)(skill.path),
     reason: skill.reason
   }));
   if (hasFlag(subArgs, "--json")) {
@@ -3014,7 +3140,7 @@ async function handleShow(args, api) {
 }
 
 // src/commands/task-control.ts
-var import_core17 = require("@ordewell/core");
+var import_core19 = require("@ordewell/core");
 var PAST_TENSE = {
   run: "Task started.",
   "force-start": "Task force-started.",
@@ -3057,7 +3183,7 @@ async function confirmPastGate(subArgs, api, sessionId, taskId, confirm2) {
   if (hasFlag(subArgs, "--yes")) return;
   const unmerged = await api.getMergeGate(sessionId, taskId).catch(() => []);
   if (unmerged.length === 0) return;
-  const question = `${(0, import_core17.pastGateConfirmation)(unmerged.map((d) => (0, import_core17.titledTaskRef)(d)))} Start it anyway?`;
+  const question = `${(0, import_core19.pastGateConfirmation)(unmerged.map((d) => (0, import_core19.titledTaskRef)(d)))} Start it anyway?`;
   if (!await confirm2(question)) fail("Not started \u2014 nothing was changed. Pass --yes to start it without a prompt.");
 }
 function makeHandler(action, command = action) {
@@ -3370,24 +3496,24 @@ async function handleRewind(subArgs, injectedApi) {
 }
 
 // src/tui/transcript.ts
-var import_core18 = require("@ordewell/core");
+var import_core20 = require("@ordewell/core");
 function show(state, { view: conversation, gate: turnGate }) {
   const gated = turnGate === state.turnGate ? state : { ...state, turnGate };
   if (conversation === state.conversation) return gated;
   return { ...gated, conversation };
 }
 function fold(state, input) {
-  return show(state, { view: (0, import_core18.reduceConversation)(state.conversation, input), gate: state.turnGate });
+  return show(state, { view: (0, import_core20.reduceConversation)(state.conversation, input), gate: state.turnGate });
 }
 function say(state, role, text) {
   const said = fold(state, { type: "local_entry", role, text });
   return said.conversation.nextId > state.conversation.nextId ? { ...said, scroll: 0 } : said;
 }
 function hear(state, message) {
-  return show(state, (0, import_core18.followTurn)(state.conversation, state.turnGate, message));
+  return show(state, (0, import_core20.followTurn)(state.conversation, state.turnGate, message));
 }
 function cutTurn(state) {
-  return show(state, (0, import_core18.stopTurn)(state.conversation, state.turnGate));
+  return show(state, (0, import_core20.stopTurn)(state.conversation, state.turnGate));
 }
 function wiped(view) {
   return { ...view, blocks: view.blocks.filter((b) => b.type === "usage") };
@@ -3636,7 +3762,7 @@ async function handleHandoff(subArgs, injectedApi, confirm2 = askYesNo) {
 }
 
 // src/commands/planner.ts
-var import_core19 = require("@ordewell/core");
+var import_core21 = require("@ordewell/core");
 
 // src/plannerModelSwitch.ts
 function plannerSwitchRecall(settings) {
@@ -3646,7 +3772,6 @@ function plannerSwitchRecall(settings) {
 }
 
 // src/commands/planner.ts
-var isAiProvider = (id) => Object.hasOwn(import_core19.ALL_PROVIDERS, id);
 async function handlePlanner(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
   const [wanted] = positionals(subArgs);
@@ -3655,19 +3780,19 @@ async function handlePlanner(subArgs, injectedApi) {
     return;
   }
   const provider = wanted.toLowerCase();
-  if (!isAiProvider(provider)) {
+  const meta = (0, import_core21.getProviderMeta)(provider);
+  if (!meta) {
     fail(`Unknown planner: ${provider}`, "Run `ordewell planner` with no arguments to see the list.");
   }
   const settings = await persistEnv(api, { AI_PROVIDER: provider });
   const recall2 = plannerSwitchRecall(settings);
   writeEnv({ ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
-  const meta = import_core19.ALL_PROVIDERS[provider];
   const catalog = await fetchCatalog(api);
   console.log(
-    (0, import_core19.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
+    (0, import_core21.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
   );
   console.log(plannerModelLine(recall2));
-  if (!(0, import_core19.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
+  if ((0, import_core21.isApiProvider)(provider) && !catalog.providers.includes(provider)) {
     console.log(`  No ${meta.apiKeyEnvVar} configured yet \u2014 set one with \`ordewell key set ${provider} <key>\`.`);
   }
 }
@@ -3685,15 +3810,15 @@ async function showPlanners(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
   const current = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   console.log("\nCoding agents (no API key \u2014 they use their own subscription)");
-  for (const id of import_core19.CLI_PROVIDERS) {
-    const runner = (0, import_core19.runnerForProvider)(id);
+  for (const id of import_core21.CLI_PROVIDERS) {
+    const runner = (0, import_core21.runnerForProvider)(id);
     const discovered = runner ? catalog.models.some((m) => m.runners?.includes(runner)) : false;
-    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core19.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
+    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${(0, import_core21.getProviderMeta)(id)?.label ?? id}${discovered ? "" : "  (not detected)"}`);
   }
   console.log("\nAPI providers");
-  for (const id of import_core19.PROVIDER_PRIORITY) {
+  for (const id of import_core21.PROVIDER_PRIORITY) {
     const configured = catalog.providers.includes(id);
-    const meta = import_core19.ALL_PROVIDERS[id];
+    const meta = (0, import_core21.getProviderMeta)(id);
     console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${meta.label}${configured ? "" : `  (no ${meta.apiKeyEnvVar})`}`);
   }
   console.log(`
@@ -3710,11 +3835,11 @@ async function handlePlannerEffort(subArgs, injectedApi) {
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   const modelId = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
   const currentEffort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
-  const runner = isAiProvider(provider) ? (0, import_core19.runnerForProvider)(provider) : null;
+  const runner = (0, import_core21.runnerForProvider)(provider);
   if (!runner) {
     fail(
       "Thinking effort applies to a coding-agent planner.",
-      "Switch with: ordewell planner claude-code|codex|opencode"
+      `Switch with: ordewell planner ${runnerIdChoice()}`
     );
   }
   const model = catalog.models.find((m) => m.id === modelId && m.runners?.includes(runner));
@@ -3750,7 +3875,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
 }
 
 // src/commands/parallel.ts
-var import_core20 = require("@ordewell/core");
+var import_core22 = require("@ordewell/core");
 var USAGE5 = "Usage: ordewell parallel [<number of tasks, 1 or more>]";
 async function handleParallel(subArgs, injectedApi) {
   const [wanted] = positionals(subArgs);
@@ -3760,14 +3885,14 @@ async function handleParallel(subArgs, injectedApi) {
     console.log(`Up to ${String(settings.maxParallel ?? "?")} AI tasks run at once. Change with: ordewell parallel <n>`);
     return;
   }
-  const limit = (0, import_core20.parseMaxParallel)(wanted);
+  const limit = (0, import_core22.parseMaxParallel)(wanted);
   if (limit === null) fail(`"${wanted}" is not a number of tasks (1 or more).`, USAGE5);
   await persistEnv(api, { ORDEWELL_MAX_PARALLEL: String(limit) });
   console.log(`Up to ${limit} AI task${limit === 1 ? "" : "s"} now run at once.`);
 }
 
 // src/commands/runSettings.ts
-var import_core21 = require("@ordewell/core");
+var import_core23 = require("@ordewell/core");
 var SUPERVISOR_USAGE = "Usage: ordewell supervisor [off|watch|act] \xB7 ordewell supervisor retries <n> \xB7 ordewell supervisor reads <n>";
 var AUTOMERGE_USAGE = "Usage: ordewell automerge [on|off]";
 var AUTORUN_USAGE = "Usage: ordewell autorun [on|off]";
@@ -3778,28 +3903,28 @@ async function handleSupervisor(subArgs, injectedApi) {
   const [arg, value] = positionals(subArgs);
   let changes = null;
   if (arg === "off" || arg === "watch" || arg === "act") changes = { supervisorLevel: arg };
-  else if (arg === "retries") changes = maybe((0, import_core21.parseCount)(value, 0), (n) => ({ supervisorRetryLimit: n }));
-  else if (arg === "reads") changes = maybe((0, import_core21.parseCount)(value, 1), (n) => ({ wakeUpReadBudget: n }));
+  else if (arg === "retries") changes = maybe((0, import_core23.parseCount)(value, 0), (n) => ({ supervisorRetryLimit: n }));
+  else if (arg === "reads") changes = maybe((0, import_core23.parseCount)(value, 1), (n) => ({ wakeUpReadBudget: n }));
   if (arg !== void 0 && changes === null) fail(SUPERVISOR_USAGE);
   const api = await connect(subArgs, injectedApi);
   if (!changes) {
-    console.log((0, import_core21.supervisorSummary)((await api.getSettings()).run));
+    console.log((0, import_core23.supervisorSummary)((await api.getSettings()).run));
     console.log(`  ${SUPERVISOR_USAGE}`);
     return;
   }
   await save(api, changes);
-  if (changes.supervisorLevel) console.log(`Supervisor: ${import_core21.SUPERVISOR_LEVEL_LABEL[changes.supervisorLevel]}, from each session's next run.`);
-  if (changes.supervisorLevel === "act") console.log(import_core21.ACT_RISK);
+  if (changes.supervisorLevel) console.log(`Supervisor: ${import_core23.SUPERVISOR_LEVEL_LABEL[changes.supervisorLevel]}, from each session's next run.`);
+  if (changes.supervisorLevel === "act") console.log(import_core23.ACT_RISK);
   if (changes.supervisorRetryLimit !== void 0) console.log(`Supervisor retry limit: ${changes.supervisorRetryLimit} per task.`);
   if (changes.wakeUpReadBudget !== void 0) console.log(`Wake-up read budget: ${changes.wakeUpReadBudget} reads.`);
 }
 async function handleAutomerge(subArgs, injectedApi) {
   const [arg] = positionals(subArgs);
-  const enabled = arg === void 0 ? null : (0, import_core21.parseSwitch)(arg);
+  const enabled = arg === void 0 ? null : (0, import_core23.parseSwitch)(arg);
   if (arg !== void 0 && enabled === null) fail(AUTOMERGE_USAGE);
   const api = await connect(subArgs, injectedApi);
   if (enabled === null) {
-    console.log((0, import_core21.automergeSummary)((await api.getSettings()).run));
+    console.log((0, import_core23.automergeSummary)((await api.getSettings()).run));
     console.log(`  ${AUTOMERGE_USAGE}`);
     return;
   }
@@ -3808,24 +3933,24 @@ async function handleAutomerge(subArgs, injectedApi) {
 }
 async function handleAutorun(subArgs, injectedApi) {
   const [arg] = positionals(subArgs);
-  const enabled = arg === void 0 ? null : (0, import_core21.parseSwitch)(arg);
+  const enabled = arg === void 0 ? null : (0, import_core23.parseSwitch)(arg);
   if (arg !== void 0 && enabled === null) fail(AUTORUN_USAGE);
   const api = await connect(subArgs, injectedApi);
   if (enabled === null) {
-    console.log((0, import_core21.autorunSummary)((await api.getSettings()).run));
+    console.log((0, import_core23.autorunSummary)((await api.getSettings()).run));
     console.log(`  ${AUTORUN_USAGE}`);
     return;
   }
   await save(api, { autorun: enabled });
   console.log(`Autorun: ${enabled ? "on \u2014 each plan the planner submits starts at once" : "off \u2014 plans wait for your review"}.`);
-  if (enabled) console.log(import_core21.AUTORUN_RISK);
+  if (enabled) console.log(import_core23.AUTORUN_RISK);
 }
 function maybe(n, wrap2) {
   return n === null ? null : wrap2(n);
 }
 
 // src/commands/key.ts
-var import_core22 = require("@ordewell/core");
+var import_core24 = require("@ordewell/core");
 var USAGE6 = "Usage: ordewell key [list | set <provider> <key>]";
 async function handleKey(subArgs, injectedApi) {
   const [action, provider, ...keyParts] = positionals(subArgs);
@@ -3836,8 +3961,8 @@ async function handleKey(subArgs, injectedApi) {
   if (action !== "set") {
     const catalog = await fetchCatalog(api);
     console.log("\nAPI provider keys\n");
-    for (const id2 of import_core22.PROVIDER_PRIORITY) {
-      const meta2 = import_core22.ALL_PROVIDERS[id2];
+    for (const id2 of import_core24.PROVIDER_PRIORITY) {
+      const meta2 = (0, import_core24.getProviderMeta)(id2);
       const configured = catalog.providers.includes(id2);
       console.log(`  ${configured ? "\u2713" : " "} ${id2.padEnd(14)} ${meta2.apiKeyEnvVar.padEnd(28)} ${meta2.label}`);
     }
@@ -3847,10 +3972,10 @@ async function handleKey(subArgs, injectedApi) {
   }
   if (!provider) fail(USAGE6);
   const id = provider.toLowerCase();
-  const meta = import_core22.ALL_PROVIDERS[id];
-  if (!meta) {
+  if (!(0, import_core24.isApiProvider)(id)) {
     fail(`Unknown provider: ${provider}`, "Run `ordewell key` to see the list.");
   }
+  const meta = (0, import_core24.getProviderMeta)(id);
   const key = keyParts.join(" ").trim();
   if (!key) fail(`Usage: ordewell key set ${id} <key>`);
   await persistEnv(api, { [meta.apiKeyEnvVar]: key });
@@ -3858,7 +3983,7 @@ async function handleKey(subArgs, injectedApi) {
 }
 
 // src/commands/runners.ts
-var import_core23 = require("@ordewell/core");
+var import_core25 = require("@ordewell/core");
 var USAGE7 = "Usage: ordewell runners [<runner-id> on|off]";
 async function handleRunners(subArgs, injectedApi) {
   const [runner, toggle] = positionals(subArgs);
@@ -3869,7 +3994,7 @@ async function handleRunners(subArgs, injectedApi) {
     for (const r of state2.runners) {
       console.log(`  ${r.enabled ? "\u2713" : " "} ${r.id.padEnd(14)} ${r.name}${r.enabled ? "" : "  (disabled)"}`);
     }
-    const notice = (0, import_core23.codexSandboxNotice)((await fetchCatalog(api).catch(() => null))?.modesByRunner);
+    const notice = (0, import_core25.codexSandboxNotice)((await fetchCatalog(api).catch(() => null))?.modesByRunner);
     if (notice) console.log(`
   ${notice.line}
   ${notice.docs}`);
@@ -3890,17 +4015,17 @@ async function handleRunners(subArgs, injectedApi) {
 var AUTO_USAGE = "Usage: ordewell auto [full|guarded]";
 function handleAuto(subArgs) {
   const [arg] = positionals(subArgs);
-  const settings = new import_core23.SettingsService();
+  const settings = new import_core25.SettingsService();
   const current = settings.autonomousMode();
   if (!arg) {
-    console.log(`Autonomy level: ${(0, import_core23.autonomyLevelLabel)(current)}`);
+    console.log(`Autonomy level: ${(0, import_core25.autonomyLevelLabel)(current)}`);
     console.log(`  ${AUTO_USAGE}`);
     return;
   }
-  const enabled = (0, import_core23.parseAutonomyLevel)(arg);
+  const enabled = (0, import_core25.parseAutonomyLevel)(arg);
   if (enabled === null) fail(AUTO_USAGE);
   settings.setAutonomousMode(enabled);
-  console.log(settings.autonomousModeOverridden() ? `${(0, import_core23.autonomyLevelLabel)(enabled)} is saved, but ORDEWELL_AUTONOMOUS_MODE in the environment decides the level until it is unset.` : `Autonomy level: ${(0, import_core23.autonomyLevelLabel)(enabled)} for new plans.`);
+  console.log(settings.autonomousModeOverridden() ? `${(0, import_core25.autonomyLevelLabel)(enabled)} is saved, but ORDEWELL_AUTONOMOUS_MODE in the environment decides the level until it is unset.` : `Autonomy level: ${(0, import_core25.autonomyLevelLabel)(enabled)} for new plans.`);
 }
 async function handleRefresh(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
@@ -3930,7 +4055,7 @@ async function handleApprove(subArgs, injectedApi) {
 }
 
 // src/commands/task-assign.ts
-var import_core25 = require("@ordewell/core");
+var import_core27 = require("@ordewell/core");
 var import_plan_utils = require("@ordewell/core/plan-utils");
 
 // src/tui/taskAssignment.ts
@@ -3970,7 +4095,7 @@ function modesForTask(modesByRunner, task) {
 }
 
 // src/tui/state.ts
-var import_core24 = require("@ordewell/core");
+var import_core26 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -4128,7 +4253,7 @@ function queuedTarget(tv) {
   for (let i = queued.length - 1; i >= 0; i--) if (!queued[i].forced) return i;
   return -1;
 }
-var anyTaskRunning = (state) => state.tasks.some(import_core24.isTaskRunning);
+var anyTaskRunning = (state) => state.tasks.some(import_core26.isTaskRunning);
 var plannerInFlight = (state) => state.planner !== "idle";
 var planPaneOpen = (state) => state.focus === "plan" && !state.overlay && (!!state.taskEditor || !!state.expandedTaskId);
 function planRows(state) {
@@ -4148,8 +4273,8 @@ function selectedPlanRow(state) {
 }
 function runnerCommands(tv) {
   for (let i = tv.view.blocks.length - 1; i >= 0; i--) {
-    const block = tv.view.blocks[i];
-    if (block.type === "runner_loaded") return block.commands;
+    const block2 = tv.view.blocks[i];
+    if (block2.type === "runner_loaded") return block2.commands;
   }
   return [];
 }
@@ -4174,10 +4299,10 @@ function findTask(tasks, id) {
   return void 0;
 }
 function refFor(state, task) {
-  return (0, import_core24.taskRefOf)(state.tasks, task.id) ?? (0, import_core24.taskRef)(task);
+  return (0, import_core26.taskRefOf)(state.tasks, task.id) ?? (0, import_core26.taskRef)(task);
 }
 function titledRefFor(state, task) {
-  return (0, import_core24.titledTaskRefOf)(state.tasks, task.id) ?? (0, import_core24.titledTaskRef)(task);
+  return (0, import_core26.titledTaskRefOf)(state.tasks, task.id) ?? (0, import_core26.titledTaskRef)(task);
 }
 function asRunTasks(tasks) {
   return tasks.map((task) => ({ ...task, subtasks: asRunTasks(task.subtasks ?? []) }));
@@ -4185,7 +4310,7 @@ function asRunTasks(tasks) {
 function seedRun(overrides) {
   if (overrides.run) return overrides.run;
   return {
-    ...import_core24.EMPTY_RUN,
+    ...import_core26.EMPTY_RUN,
     tasks: asRunTasks(overrides.tasks ?? []),
     handoff: overrides.handoff ?? null,
     runMerge: overrides.runMerge ? { waitingAtGate: overrides.runMerge.waitingAtGate, paused: overrides.runMerge.paused, repos: overrides.runMerge.handoff.repos, landed: overrides.runMerge.handoff.landed } : null
@@ -4194,9 +4319,9 @@ function seedRun(overrides) {
 function initialState(overrides = {}) {
   return {
     editor: emptyEditor(),
-    conversation: import_core24.EMPTY_CONVERSATION,
+    conversation: import_core26.EMPTY_CONVERSATION,
     taskView: null,
-    turnGate: import_core24.NO_TURN,
+    turnGate: import_core26.NO_TURN,
     detailAll: false,
     status: "idle",
     planner: "idle",
@@ -4222,11 +4347,11 @@ function initialState(overrides = {}) {
     plannerProvider: "",
     plannerEffort: "",
     plannerModels: {},
-    maxParallel: import_core24.DEFAULT_MAX_PARALLEL,
+    maxParallel: import_core26.DEFAULT_MAX_PARALLEL,
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
-    runSettings: { ...import_core24.RUN_SETTINGS_DEFAULTS },
+    runSettings: { ...import_core26.RUN_SETTINGS_DEFAULTS },
     runAutoMerge: null,
     runSupervisor: null,
     mouseCapture: true,
@@ -4236,7 +4361,7 @@ function initialState(overrides = {}) {
     runMerge: null,
     overlay: null,
     pendingApprovals: [],
-    queuedPrompts: import_core24.EMPTY_HOLD,
+    queuedPrompts: import_core26.EMPTY_HOLD,
     stopArmed: false,
     stopArmToken: 0,
     stopRequested: false,
@@ -4370,7 +4495,7 @@ Mode \xB7 ${namedOf(tasks, task)}${task.assignedRunner ? ` (${task.assignedRunne
       for (const m of modes) {
         console.log(`  ${m.id === task.taskMode ? "*" : " "} ${m.id.padEnd(14)} ${m.label}${m.unavailable ? " \u2014 unavailable on this host" : m.description ? ` \u2014 ${m.description}` : ""}`);
       }
-      const notice = (0, import_core25.codexSandboxNotice)(catalog.modesByRunner);
+      const notice = (0, import_core27.codexSandboxNotice)(catalog.modesByRunner);
       if (notice) console.log(`
   ${notice.line}
   ${notice.docs}`);
@@ -4419,7 +4544,7 @@ var SKILLS_USAGE = "Usage: ordewell task-skills <task-id-or-order> [<name> [<nam
 async function handleTaskSkills(subArgs, injectedApi) {
   await withTask(subArgs, SKILLS_USAGE, injectedApi, async (api, sessionId, task, tasks, value) => {
     if (task.type !== "ai") fail("Manual tasks do not run an executor, so they take no skills.");
-    const catalog = (0, import_core25.createSkillsService)(flag(subArgs, "--workspace") || process.cwd(), new import_core25.EnvConfig().workspaceRepos).listSkills().filter((s) => s.appliesTo === "task");
+    const catalog = (0, import_core27.createSkillsService)(flag(subArgs, "--workspace") || process.cwd(), new import_core27.EnvConfig().workspaceRepos).listSkills().filter((s) => s.appliesTo === "task");
     if (!value) {
       console.log(`
 Skills \xB7 ${namedOf(tasks, task)}
@@ -4464,10 +4589,10 @@ ${namedOf(tasks, task)} is ${task.ops ? "an ops task: it runs in your checkout o
 }
 
 // src/tui/index.ts
-var import_core45 = require("@ordewell/core");
+var import_core48 = require("@ordewell/core");
 
 // src/tui/slash.ts
-var import_core26 = require("@ordewell/core");
+var import_core28 = require("@ordewell/core");
 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.
@@ -4485,6 +4610,7 @@ var SLASH_COMMANDS = [
   { 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: "continue", usage: "/continue <id> <message>", description: "Continue a finished task in its saved runner session, with your message", category: "tasks" },
+  { name: "open", usage: "/open <id>", description: "Open a task's view: its log, and the keys that answer its checkpoint or tool request", category: "tasks" },
   { name: "checkpoint", usage: "/checkpoint <id> approve|reject [reason]", description: "Answer the checkpoint a task waits at: approve lets it go on, reject tells it why not", 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" },
@@ -4499,7 +4625,7 @@ var SLASH_COMMANDS = [
   { 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: "runners", usage: "/runners [<id> on|off]", description: `Enable or disable runners (${runnerIdList()})`, category: "models" },
   { name: "auto", usage: "/auto [full|guarded]", description: "Autonomy level for new plans: Full or Guarded", category: "models" },
   { name: "supervisor", usage: "/supervisor [off|watch|act] \xB7 retries <n> \xB7 reads <n>", description: "Whether the planner watches or acts on your runs, now and from then on", category: "models" },
   { name: "automerge", usage: "/automerge [on|off]", description: "Merge into your branch by itself at merge gates and at the end of a run", category: "models" },
@@ -4585,7 +4711,7 @@ function parseRunnerCommand(text) {
   return match ? { name: match[1], args: (match[2] ?? "").trim() } : null;
 }
 function runnerCommandFor(commands, name) {
-  return (0, import_core26.findRunnerCommand)(commands, name) ?? (0, import_core26.findRunnerCommand)(commands, name.toLowerCase());
+  return (0, import_core28.findRunnerCommand)(commands, name) ?? (0, import_core28.findRunnerCommand)(commands, name.toLowerCase());
 }
 function composerCompletions(token, runner) {
   if (runner) return token.start === 0 ? runner.filter((c) => c.name.toLowerCase().startsWith(token.name)).map((c) => c.name) : [];
@@ -4632,10 +4758,10 @@ function chatEditorRoomFor(state, active) {
 }
 
 // src/tui/layout.ts
-var import_core29 = require("@ordewell/core");
+var import_core31 = require("@ordewell/core");
 
 // src/tui/reducers/pickers.ts
-var import_core27 = require("@ordewell/core");
+var import_core29 = require("@ordewell/core");
 var import_plan_utils2 = require("@ordewell/core/plan-utils");
 var DEFAULT_EFFORT = "__runner_default__";
 function picker(title, items, action, extra = {}) {
@@ -4654,11 +4780,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_core27.ALL_PROVIDERS[p]?.label ?? p);
+  const names = failed.map((p) => (0, import_core29.getProviderMeta)(p)?.label ?? p);
   return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")} \u2014 showing working providers only.`;
 }
 function plannerModelItems(state, provider, selectedId) {
-  const runner = (0, import_core27.runnerForProvider)(provider);
+  const runner = (0, import_core29.runnerForProvider)(provider);
   if (!runner) {
     return state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m), selected: m.id === selectedId }));
   }
@@ -4674,11 +4800,11 @@ function plannerModelItems(state, provider, selectedId) {
   return items.length > 0 ? items : [{ id: "", label: `No ${runner} models discovered yet`, detail: "run /refresh", disabled: true }];
 }
 function plannerHarnessModel(state, provider, modelId) {
-  const runner = (0, import_core27.runnerForProvider)(provider);
+  const runner = (0, import_core29.runnerForProvider)(provider);
   return runner ? state.models.find((m) => m.id === modelId && m.runners?.includes(runner)) : void 0;
 }
 function plannerEffortItems(state, provider, modelId, selectedEffort) {
-  if (!(0, import_core27.runnerForProvider)(provider)) {
+  if (!(0, import_core29.runnerForProvider)(provider)) {
     return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
   }
   const model = plannerHarnessModel(state, provider, modelId);
@@ -4796,11 +4922,11 @@ function pickerItemsFor(state, action) {
 function plannerItems(state) {
   const installed = new Set(state.runners.map((r) => r.id));
   const usability = {};
-  for (const id of import_core27.CLI_PROVIDERS) {
-    const runner = (0, import_core27.runnerForProvider)(id);
+  for (const id of import_core29.CLI_PROVIDERS) {
+    const runner = (0, import_core29.runnerForProvider)(id);
     usability[runner] = installed.has(runner) ? { usable: true } : { usable: false, reason: "CLI not installed or not on PATH" };
   }
-  const entries = (0, import_core27.plannerBackendEntries)(usability, state.configuredProviders);
+  const entries = (0, import_core29.plannerBackendEntries)(usability, state.configuredProviders);
   const items = entries.map((entry) => ({
     id: entry.id,
     label: entry.label,
@@ -4825,12 +4951,17 @@ function cliVersion() {
 }
 
 // src/tui/planKeys.ts
-var import_core28 = require("@ordewell/core");
+var import_core30 = require("@ordewell/core");
 var PLAN_KEYS = {
   move: { keys: "up / down", meaning: "move between tasks", group: "Navigation" },
   scroll: { keys: "pgup / pgdn", meaning: "scroll the plan", group: "Navigation" },
   expand: { keys: "\u2192", meaning: "reveal a task's subtasks, then edit its prompt", group: "Navigation", hint: "\u2192 expand" },
-  log: { keys: "enter", meaning: "open the task's log and message its runner", group: "Navigation", hint: "enter log" },
+  log: {
+    keys: "enter",
+    meaning: "open the task's log and message its runner \u2014 or, at a checkpoint, answer it",
+    group: "Navigation",
+    hint: (task) => task?.status === "awaiting_user" && task.awaitingReason === "checkpoint" ? "enter answer" : "enter log"
+  },
   back: { keys: "esc", meaning: "collapse the task, or leave a task's log for the plan", group: "Navigation" },
   runner: { keys: "R", meaning: "pick the task's runner", group: "Assign" },
   model: { keys: "o", meaning: "pick the task's model", group: "Assign", hint: "o model" },
@@ -4847,7 +4978,7 @@ var PLAN_KEYS = {
     meaning: "cancel the task's runner, or keep a task paused on a usage limit from resuming on its own",
     group: "Run",
     // `c` cancels the resume while the task has one; it has no runner to cancel then.
-    hint: (task) => task && (0, import_core28.resumeLabel)(task) ? "c don't resume" : "c cancel"
+    hint: (task) => task && (0, import_core30.resumeLabel)(task) ? "c don't resume" : "c cancel"
   },
   resume: { keys: "r", meaning: "resume a task paused on a usage limit now, once the limit has reset", group: "Run", hint: "r resume now" },
   resolve: { keys: "x", meaning: "resolve a merge conflict", group: "Run", hint: "x resolve conflict" },
@@ -4857,7 +4988,7 @@ var PLAN_KEYS = {
     meaning: "mark the task done, or take it back",
     group: "Status",
     // `m` toggles, so the hint names the direction it will go for this task.
-    hint: (task) => task && (0, import_core28.markAction)(task) === "uncomplete" ? "m undone" : "m done"
+    hint: (task) => task && (0, import_core30.markAction)(task) === "uncomplete" ? "m undone" : "m done"
   },
   skip: { keys: "s", meaning: "skip the task: none of its work lands, and what depends on it goes ahead", group: "Status", hint: "s skip" },
   remove: { keys: "d", meaning: "remove the task", group: "Status" },
@@ -4884,7 +5015,7 @@ function hintOf(id, task) {
 }
 function taskKeyIds(task, runActive) {
   if (!task) return ["add"];
-  const row = (0, import_core28.taskRowView)(task);
+  const row = (0, import_core30.taskRowView)(task);
   if (row.conflict) return ["resolve", "log"];
   if (row.actions.includes("resume-now") || row.resumes) {
     return [...row.actions.includes("resume-now") ? ["resume"] : [], ...row.resumes ? ["cancel"] : [], "skip", "log"];
@@ -4912,7 +5043,7 @@ function planFooterHints(task, runActive) {
 }
 
 // src/tui/layout.ts
-var import_core30 = require("@ordewell/core");
+var import_core32 = require("@ordewell/core");
 var CHROME_ROWS = 1;
 function chatInputWrap(state) {
   const active = state.focus === "chat" && !state.overlay;
@@ -4931,15 +5062,17 @@ function footerHints(state) {
   const taskSends = !!tv && tv.view.working && !!state.editor.text.trim() && !continuesTask(findTask(state.tasks, tv.taskId));
   const sendNowHint = planning || taskSends ? "ctrl-s send now" : null;
   const stopRunnerHint = runnerStoppable(state) ? "ctrl-x stop runner" : null;
+  const checkpointHints = tv && waitingCheckpoint(findTask(state.tasks, tv.taskId)) && !waitingApproval(tv) ? ["enter reply", "ctrl-y approve", "ctrl-g reject"] : [];
   if (state.focus === "plan") {
     if (state.taskEditor) {
       return ["type to edit prompt", "pgup/pgdn scroll", "alt-enter newline", "enter save", "esc cancel"];
     }
     return [...escHint ? [escHint] : [], ...planFooterHints(selected, state.status === "executing")];
   }
-  const detailHint = (0, import_core30.hasHiddenDetail)(state.taskView ? state.taskView.view.blocks : state.conversation.blocks) ? [state.detailAll ? "ctrl-o collapse all" : "ctrl-o expand all"] : [];
+  const detailHint = (0, import_core32.hasHiddenDetail)(state.taskView ? state.taskView.view.blocks : state.conversation.blocks) ? [state.detailAll ? "ctrl-o collapse all" : "ctrl-o expand all"] : [];
   return [
     "/help",
+    ...checkpointHints,
     ...stopRunnerHint ? [stopRunnerHint] : [],
     "tab plan",
     ...detailHint,
@@ -4995,12 +5128,12 @@ function queuedTaskBubble(message, target, sends, cols) {
 }
 function taskActivity(task, working) {
   if (task?.status === "completed" || task?.status === "failed") return task.status;
-  const approvals = (0, import_core30.approvalLabel)(task?.awaitingApproval);
+  const approvals = (0, import_core32.approvalLabel)(task?.awaitingApproval);
   if (approvals) return inRow(approvals);
   if (working) return "working";
   if (task?.status === "awaiting_user") {
-    const resumes = (0, import_core30.resumeLabel)(task);
-    return [inRow((0, import_core30.awaitingLabel)(task) ?? "Waiting for your input"), resumes ? inRow(resumes) : ""].filter(Boolean).join(" \xB7 ");
+    const resumes = (0, import_core32.resumeLabel)(task);
+    return [inRow((0, import_core32.awaitingLabel)(task) ?? "Waiting for your input"), resumes ? inRow(resumes) : ""].filter(Boolean).join(" \xB7 ");
   }
   return task?.status ?? "";
 }
@@ -5013,7 +5146,7 @@ function taskHeaderLines(state, tv, cols) {
     taskActivity(task, tv.view.working)
   ].filter(Boolean);
   const approval = waitingApproval(tv);
-  const hint = approval ? ["ctrl-y allow", ...approval.allowForTask ? ["ctrl-t allow for task"] : [], "ctrl-g deny (composer text is the note)"] : waitingCheckpoint(task) ? ["ctrl-y approve", "ctrl-g reject (composer text is the reason)", "ctrl-x stop runner"] : task && (0, import_core30.resumeLabel)(task) ? ["ctrl-x don't resume"] : [...runnerStoppable(state) ? ["ctrl-x stop runner"] : [], "ctrl-r remove queued", "ctrl-s send now"];
+  const hint = approval ? ["ctrl-y allow", ...approval.allowForTask ? ["ctrl-t allow for task"] : [], "ctrl-g deny (composer text is the note)"] : waitingCheckpoint(task) ? ["enter reply", "ctrl-y approve", "ctrl-g reject", "ctrl-x stop runner"] : task && (0, import_core32.resumeLabel)(task) ? ["ctrl-x don't resume"] : [...runnerStoppable(state) ? ["ctrl-x stop runner"] : [], "ctrl-r remove queued", "ctrl-s send now"];
   if (approval && waitingCheckpoint(task)) hint.push("then the checkpoint");
   const index = tv.attempts.indexOf(tv.attempt);
   if (tv.attempts.length > 1) hint.push(`alt\u2190/\u2192 attempt ${index >= 0 ? index + 1 : 1}/${tv.attempts.length}`);
@@ -5043,9 +5176,9 @@ function chatActivity(state) {
   const own = findTask(state.tasks, tv.taskId);
   const task = state.tasks.find((t) => t.subtasks?.some((s) => s.id === tv.taskId)) ?? own;
   if (!task) return null;
-  if ((0, import_core24.isTaskRunning)(task) || own && (0, import_core24.isTaskRunning)(own)) return { label: "Working\u2026", busy: true };
+  if ((0, import_core26.isTaskRunning)(task) || own && (0, import_core26.isTaskRunning)(own)) return { label: "Working\u2026", busy: true };
   const at = task.status === "awaiting_user" && task.awaitingReason === "usage-limit" && task.resumeAt ? new Date(task.resumeAt) : null;
-  if (at && !Number.isNaN(at.getTime())) return { label: `paused \xB7 resumes ${(0, import_core30.resumeTime)(at)}`, busy: false };
+  if (at && !Number.isNaN(at.getTime())) return { label: `paused \xB7 resumes ${(0, import_core32.resumeTime)(at)}`, busy: false };
   return null;
 }
 function runHints(state) {
@@ -5074,41 +5207,41 @@ function bodyRows(state) {
   return Math.max(0, state.rows - CHROME_ROWS - composerRows(state) - footer);
 }
 var chatBodyMemo = null;
-function chatBodyLines(blocks, cols, detailAll, answering) {
+function chatBodyLines(blocks2, cols, detailAll, answering) {
   const memo = chatBodyMemo;
-  if (memo && memo.blocks === blocks && memo.cols === cols && memo.detailAll === detailAll) return memo.lines;
-  const lines = conversationLines(blocks, cols, detailAll, answering);
-  chatBodyMemo = { blocks, cols, detailAll, lines };
+  if (memo && memo.blocks === blocks2 && memo.cols === cols && memo.detailAll === detailAll) return memo.lines;
+  const lines = conversationLines(blocks2, cols, detailAll, answering);
+  chatBodyMemo = { blocks: blocks2, cols, detailAll, lines };
   return lines;
 }
 function chatLayout(state, rows, cols) {
   const tv = state.taskView;
-  const blocks = tv ? tv.view.blocks : state.conversation.blocks;
+  const blocks2 = tv ? tv.view.blocks : state.conversation.blocks;
   const welcome = !tv && state.tasks.length === 0;
   const checkpoint = tv ? waitingCheckpoint(findTask(state.tasks, tv.taskId)) : void 0;
   const card = tv && checkpoint ? checkpointCardLines(findTask(state.tasks, tv.taskId)?.order ?? 0, checkpoint, cols, waitingApproval(tv) !== void 0) : [];
-  const answering = chatBodyLines(blocks, cols, state.detailAll, tv ? waitingApproval(tv) : void 0);
+  const answering = chatBodyLines(blocks2, cols, state.detailAll, tv ? waitingApproval(tv) : void 0);
   const body = card.length > 0 ? [...answering, ...card] : answering;
   const transcript = !welcome ? body : body.length === 0 ? welcomeLines(state, rows, cols) : [...welcomeLines(state, rows, cols), "", ...body];
   const bubbles = tv ? taskQueuedRows(state, cols) : queuedPromptRows(state, cols);
   const content = [...transcript, ...bubbles.length > 0 ? ["", ...bubbles] : []];
   const taskHeader = tv ? taskHeaderLines(state, tv, cols) : [];
-  const usage = rows <= 1 ? [] : tv ? taskUsageFooter(state, tv, blocks, cols) : tokenRow(blocks, cols);
+  const usage = rows <= 1 ? [] : tv ? taskUsageFooter(state, tv, blocks2, cols) : tokenRow(blocks2, cols);
   const footer = usage.slice(0, Math.max(1, rows - taskHeader.length - 1));
   const space = Math.max(0, rows - taskHeader.length - footer.length);
   return { lines: content, header: taskHeader, footer, anchor: content.length > space ? "bottom" : "top", maxScroll: Math.max(0, content.length - space) };
 }
-var tokenRow = (blocks, cols) => {
-  const line = tokenLine(blocks, cols);
+var tokenRow = (blocks2, cols) => {
+  const line = tokenLine(blocks2, cols);
   return line ? [line] : [];
 };
-function taskUsageFooter(state, tv, blocks, cols) {
+function taskUsageFooter(state, tv, blocks2, cols) {
   const task = findTask(state.tasks, tv.taskId);
   const reported = task?.attemptUsage ?? [];
   const onScreen = tv.attempt > 0 ? reported.find((a) => a.attempt === tv.attempt) : reported.at(-1);
-  if (!task || !onScreen) return tokenRow(blocks, cols);
-  const usage = (0, import_core30.taskRowView)({ ...task, attemptUsage: [onScreen] }).usage;
-  if (!usage) return tokenRow(blocks, cols);
+  if (!task || !onScreen) return tokenRow(blocks2, cols);
+  const usage = (0, import_core32.taskRowView)({ ...task, attemptUsage: [onScreen] }).usage;
+  if (!usage) return tokenRow(blocks2, cols);
   const models = usage.byModel ?? [];
   return [
     style.grey(truncate(taskUsageText(usage), cols)),
@@ -5120,17 +5253,17 @@ function chatScrollMax(state) {
 }
 function plannerSetup(state) {
   const provider = state.plannerProvider;
-  const registration = import_core30.ALL_PROVIDERS[provider];
+  const registration = (0, import_core32.getProviderMeta)(provider);
   if (!registration) return { label: "not set", ready: false };
-  const runner = (0, import_core30.runnerForProvider)(provider);
-  const ready = runner ? state.runners.some((r) => r.id === runner) : state.configuredProviders.includes(provider);
+  const runner = (0, import_core32.runnerForProvider)(provider);
+  const ready = runner ? state.runners.some((r) => r.id === runner) : (0, import_core32.isApiProvider)(provider) && state.configuredProviders.includes(provider);
   return { label: registration.label, ready };
 }
 var SETUP_KEY_COLS = 10;
 var SETUP_VALUE_COLS = 32;
 function runSettingsValue(state) {
   const { supervisorLevel, mergeAtGatesAutomatically, autorun } = state.runSettings;
-  const level = `supervisor ${import_core29.SUPERVISOR_LEVEL_LABEL[supervisorLevel]}`;
+  const level = `supervisor ${import_core31.SUPERVISOR_LEVEL_LABEL[supervisorLevel]}`;
   return [
     supervisorLevel === "act" ? style.yellow(level) : level,
     `auto-merge ${mergeAtGatesAutomatically ? "on" : "off"}`,
@@ -5231,7 +5364,7 @@ function welcomeLines(state, rows, cols) {
   ];
   const notice = canPlan ? [] : [
     ...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."),
+      style.yellow(`Ordewell needs one coding agent installed (${runnerNamesOr()}) \u2014 or an API key from a provider such as OpenRouter, added with /key.`),
       Math.max(1, cols - 1)
     ),
     ""
@@ -5265,7 +5398,7 @@ var STATUS_ICON = {
 var inRow = (label) => label.charAt(0).toLowerCase() + label.slice(1);
 function planLayout(state, rows, cols) {
   const done = state.tasks.filter((t) => t.status === "completed").length;
-  const totalUsage = (0, import_core30.planUsage)(state.tasks);
+  const totalUsage = (0, import_core32.planUsage)(state.tasks);
   const unmerged = state.runMerge?.handoff.landed.length ?? 0;
   const count = `${done}/${state.tasks.length}`;
   const hints = runHints(state);
@@ -5343,7 +5476,7 @@ function planScrollExtent(state) {
 }
 function taskLines(state, planRow, index, cols) {
   const { task, parent } = planRow;
-  const row = (0, import_core30.taskRowView)(task, { parent, tasks: state.tasks, modes: modesForTask(state.modesByRunner, task) });
+  const row = (0, import_core32.taskRowView)(task, { parent, tasks: state.tasks, modes: modesForTask(state.modesByRunner, task) });
   const selected = state.focus === "plan" && index === state.selectedTask;
   const expanded = state.expandedTaskId === task.id;
   const rawIcon = row.status === "running" ? SPINNER[state.spinnerFrame % SPINNER.length] : STATUS_ICON[row.status];
@@ -5394,10 +5527,10 @@ function taskLines(state, planRow, index, cols) {
     lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for Merge all \u2014 ${row.mergeGate.join(", ")} not merged into your branch yet`, cols)));
   }
   if (row.blockedBy) {
-    lines.push(style.red(truncate(`${bodyPad}\u2298 ${inRow((0, import_core30.blockedByLabel)(row.blockedBy))} \u2014 runs once ${row.blockedBy.length === 1 ? "it is retried and passes" : "they are retried and pass"}`, cols)));
+    lines.push(style.red(truncate(`${bodyPad}\u2298 ${inRow((0, import_core32.blockedByLabel)(row.blockedBy))} \u2014 runs once ${row.blockedBy.length === 1 ? "it is retried and passes" : "they are retried and pass"}`, cols)));
   }
   if (row.status === "skipped") {
-    lines.push(style.grey(truncate(`${bodyPad}\xBB ${inRow((0, import_core30.skippedLabel)(row.skipReason))} \u2014 nothing of it landed; m done lands its kept work`, cols)));
+    lines.push(style.grey(truncate(`${bodyPad}\xBB ${inRow((0, import_core32.skippedLabel)(row.skipReason))} \u2014 nothing of it landed; m done lands its kept work`, cols)));
   }
   const resumable = row.actions.includes("resume-now");
   if (row.resumes) {
@@ -5515,7 +5648,7 @@ function commandSheetBody(cols) {
     style.grey("  ctrl-n/ctrl-p pick a pending message (the newest until you do) \xB7 ctrl-r removes a queued one"),
     style.grey("  ctrl-x stops the runner's running turn, and it then waits for your next message \u2014 on a task paused on a usage limit, it keeps it from resuming"),
     style.grey("  ctrl-y allows a tool request (its keys sit under it) \xB7 ctrl-t allows it for the task \xB7 ctrl-g denies it, with the composer text as the note"),
-    style.grey("  at a checkpoint, ctrl-y approves and ctrl-g rejects, with the composer text as the reason \xB7 /checkpoint <id> approve|reject [reason] from anywhere"),
+    style.grey("  at a checkpoint, enter replies with what you typed, ctrl-y approves, ctrl-g rejects (the text is its reason) \xB7 /checkpoint <id> approve|reject [reason] from anywhere"),
     style.grey("  alt\u2190/\u2192 changes attempt \xB7 esc returns")
   );
   return body;
@@ -5532,8 +5665,8 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
-var import_core31 = require("@ordewell/core");
-var import_core32 = require("@ordewell/core");
+var import_core33 = require("@ordewell/core");
+var import_core34 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
@@ -5632,8 +5765,8 @@ function runSettingsBadge(state) {
   const { supervisorLevel, mergeAtGatesAutomatically, autorun } = state.runSettings;
   const paint = (text, warn) => warn ? style.yellow(text) : style.grey(text);
   const run = state.status === "executing" ? state.runSupervisor : null;
-  const actual = run?.unsupervised ? "unsupervised" : run && run.level !== supervisorLevel ? import_core32.SUPERVISOR_LEVEL_LABEL[run.level] : null;
-  const level = `supervisor ${import_core32.SUPERVISOR_LEVEL_LABEL[supervisorLevel]}${actual ? ` \u2192 ${actual}` : ""}`;
+  const actual = run?.unsupervised ? "unsupervised" : run && run.level !== supervisorLevel ? import_core34.SUPERVISOR_LEVEL_LABEL[run.level] : null;
+  const level = `supervisor ${import_core34.SUPERVISOR_LEVEL_LABEL[supervisorLevel]}${actual ? ` \u2192 ${actual}` : ""}`;
   return [
     paint(level, supervisorLevel === "act"),
     ...mergeAtGatesAutomatically ? [style.grey("auto-merge")] : [],
@@ -5830,8 +5963,8 @@ function renderHandoff(state, overlay, rows, cols) {
     return frame(`Diff \u2014 ${handoffBranch(handoff)}`, [...shown, "", style.grey(`${more}enter or esc goes back`)], rows, cols);
   }
   const landed = handoff.landed.length === 0 ? [style.grey("Nothing landed on it.")] : handoff.landed.map((task) => {
-    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core31.capConflictFiles)(task.repairedFiles)})`) : "";
-    return `  ${style.green("\u2713")} ${(0, import_core31.titledTaskRefOf)(state.tasks, task.taskId) ?? (0, import_core31.titledTaskRef)(task)}${repaired}`;
+    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core33.capConflictFiles)(task.repairedFiles)})`) : "";
+    return `  ${style.green("\u2713")} ${(0, import_core33.titledTaskRefOf)(state.tasks, task.taskId) ?? (0, import_core33.titledTaskRef)(task)}${repaired}`;
   });
   const actions = handoffActions(handoff).map((action, index) => {
     const active = index === overlay.index;
@@ -5879,8 +6012,8 @@ function renderPicker(picker2, rows, cols) {
     ...picker2.filterable ? [["type", "to filter"]] : []
   ]);
   const room = Math.max(1, rows - head.length - 3);
-  const list = items.length === 0 ? [style.grey(picker2.filter ? "Nothing matches that filter." : "Nothing to show yet\u2026")] : pickerRows({ items, index: picker2.index, numbered: !picker2.filterable, chosen: picker2.multi ? picker2.chosen : void 0 }, room, inner);
-  return frame(picker2.title, [...head, ...list, "", footer], rows, cols);
+  const list2 = items.length === 0 ? [style.grey(picker2.filter ? "Nothing matches that filter." : "Nothing to show yet\u2026")] : pickerRows({ items, index: picker2.index, numbered: !picker2.filterable, chosen: picker2.multi ? picker2.chosen : void 0 }, room, inner);
+  return frame(picker2.title, [...head, ...list2, "", footer], rows, cols);
 }
 function renderStepper(stepper, rows, cols) {
   const { definition, trail } = stepper;
@@ -5911,13 +6044,13 @@ function renderStepper(stepper, rows, cols) {
     cancel
   ]);
   const room = Math.max(1, rows - head.length - 3);
-  const list = items.length === 0 ? [style.grey(stepper.filter ? "Nothing matches that filter." : "Nothing to show yet\u2026")] : pickerRows({ items, index: stepper.index, numbered: !active.filterable }, room, inner);
-  return frame(definition.title, [...head, ...list, "", footer], rows, cols);
+  const list2 = items.length === 0 ? [style.grey(stepper.filter ? "Nothing matches that filter." : "Nothing to show yet\u2026")] : pickerRows({ items, index: stepper.index, numbered: !active.filterable }, room, inner);
+  return frame(definition.title, [...head, ...list2, "", footer], rows, cols);
 }
 var DETAIL_GAP = 2;
-function pickerRows(list, room, inner) {
-  const { items, numbered, chosen } = list;
-  const index = Math.max(0, Math.min(list.index, items.length - 1));
+function pickerRows(list2, room, inner) {
+  const { items, numbered, chosen } = list2;
+  const index = Math.max(0, Math.min(list2.index, items.length - 1));
   const digits = String(items.length).length;
   const prefixWidth = 2 + (numbered ? digits + 2 : 0) + (chosen ? 4 : 0);
   const rowWidth = Math.max(1, inner - prefixWidth);
@@ -5926,7 +6059,7 @@ function pickerRows(list, room, inner) {
   const labelWidth = items.some((item) => item.detail) ? Math.min(widest, Math.max(8, rowWidth - DETAIL_GAP - Math.max(16, Math.floor(rowWidth / 3)))) : Math.min(widest, rowWidth);
   const detailWidth = Math.max(1, rowWidth - labelWidth - DETAIL_GAP);
   const detailIndent = " ".repeat(prefixWidth + labelWidth + DETAIL_GAP);
-  const block = (item, i) => {
+  const block2 = (item, i) => {
     const active = i === index;
     const current = isCurrent(item);
     const number = numbered ? `${String(i + 1).padStart(digits)}. ` : "";
@@ -5943,29 +6076,29 @@ function pickerRows(list, room, inner) {
     ];
     return active ? lines.map((line) => style.highlight(pad(line, inner))) : lines;
   };
-  const blocks = items.map(block);
-  if (blocks.reduce((n, b) => n + b.length, 0) <= room) return blocks.flat();
+  const blocks2 = items.map(block2);
+  if (blocks2.reduce((n, b) => n + b.length, 0) <= room) return blocks2.flat();
   const fit2 = Math.max(1, room - 2);
   let lo = index;
   let hi = index;
-  let used = blocks[index].length;
+  let used = blocks2[index].length;
   for (let grew = true; grew; ) {
     grew = false;
-    if (hi + 1 < blocks.length && used + blocks[hi + 1].length <= fit2) {
+    if (hi + 1 < blocks2.length && used + blocks2[hi + 1].length <= fit2) {
       hi += 1;
-      used += blocks[hi].length;
+      used += blocks2[hi].length;
       grew = true;
     }
-    if (lo > 0 && used + blocks[lo - 1].length <= fit2) {
+    if (lo > 0 && used + blocks2[lo - 1].length <= fit2) {
       lo -= 1;
-      used += blocks[lo].length;
+      used += blocks2[lo].length;
       grew = true;
     }
   }
   return [
     ...lo > 0 ? [style.grey(`  \u2191 \u2026 +${lo} more`)] : [],
-    ...blocks.slice(lo, hi + 1).flat().slice(0, fit2),
-    ...hi < blocks.length - 1 ? [style.grey(`  \u2193 \u2026 +${blocks.length - 1 - hi} more`)] : []
+    ...blocks2.slice(lo, hi + 1).flat().slice(0, fit2),
+    ...hi < blocks2.length - 1 ? [style.grey(`  \u2193 \u2026 +${blocks2.length - 1 - hi} more`)] : []
   ];
 }
 function keyHints(hints) {
@@ -6005,7 +6138,10 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core43 = require("@ordewell/core");
+var import_core46 = require("@ordewell/core");
+
+// src/tui/reducers/overlays.ts
+var import_core45 = require("@ordewell/core");
 
 // src/tui/reducers/shared.ts
 function step(state, effects = []) {
@@ -6064,10 +6200,10 @@ function handleApprovalKey(state, overlay, key) {
 }
 
 // src/tui/reducers/commands.ts
-var import_core42 = require("@ordewell/core");
+var import_core44 = require("@ordewell/core");
 
 // src/tui/reducers/plannerStepper.ts
-var import_core33 = require("@ordewell/core");
+var import_core35 = require("@ordewell/core");
 var offered = (items) => new Set(items.filter((i) => !i.disabled).map((i) => i.id));
 function preferredModel(state, provider) {
   const listed = offered(plannerModelItems(state, provider, ""));
@@ -6115,7 +6251,7 @@ var plannerStepper = {
     const model = plannerModelItems(state, provider, "").find((m) => m.id === modelId);
     const level = plannerEffortItems(state, provider, modelId, "").find((e) => e.id === effort);
     const parts = [
-      import_core33.ALL_PROVIDERS[provider]?.label ?? provider,
+      (0, import_core35.getProviderMeta)(provider)?.label ?? provider,
       model?.label ?? modelId,
       ...effort ? [effortLabel(level?.label ?? effort)] : []
     ];
@@ -6130,10 +6266,10 @@ var plannerStepper = {
 };
 
 // src/tui/reducers/stepper.ts
-var import_core34 = require("@ordewell/core");
+var import_core36 = require("@ordewell/core");
 function openStepper(state, definition) {
   const { choices, lists } = settle(state, definition, {});
-  const first = lists.findIndex((list) => list !== null);
+  const first = lists.findIndex((list2) => list2 !== null);
   if (first === -1) return definition.save(state, choices);
   return step({ ...state, overlay: { kind: "stepper", stepper: show2(state, definition, choices, first) } });
 }
@@ -6153,11 +6289,11 @@ function handleStepperKey(state, stepper, key) {
   const reopen = (next) => step({ ...state, overlay: { kind: "stepper", stepper: next } });
   const { definition, current, entry, choices } = stepper;
   const def = definition.steps[current];
-  const typed = def.number && entry ? (0, import_core34.parseCount)(entry.text, def.number.min) : null;
+  const typed = def.number && entry ? (0, import_core36.parseCount)(entry.text, def.number.min) : null;
   const { lists } = settle(state, definition, choices);
   const items = matchingItems(stepper.items, stepper.filter);
   const before = lastIndexBefore(lists, current);
-  const after = lists.findIndex((list, i) => i > current && list !== null);
+  const after = lists.findIndex((list2, i) => i > current && list2 !== null);
   if (key.name === "escape") return step({ ...state, overlay: null });
   if (key.name === "tab" || key.name === "right") return after === -1 ? reopen(stepper) : reopen(show2(state, definition, choices, after));
   if (key.name === "shift-tab" || key.name === "left") return before === -1 ? reopen(stepper) : reopen(show2(state, definition, choices, before));
@@ -6203,14 +6339,14 @@ function choose(state, stepper, value) {
   const saved = definition.save(open, choices);
   if (saved.state.overlay !== open.overlay) return saved;
   const { lists } = settle(saved.state, definition, choices);
-  const next = !definition.advanceOnEnter ? current : lists.findIndex((list, i) => i > current && list !== null);
+  const next = !definition.advanceOnEnter ? current : lists.findIndex((list2, i) => i > current && list2 !== null);
   if (next === -1 || lists[next] === null) return { ...saved, state: { ...saved.state, overlay: null } };
   return { ...saved, state: { ...saved.state, overlay: { kind: "stepper", stepper: show2(saved.state, definition, choices, next) } } };
 }
 function reopenStepper(state, stepper) {
   const { definition, current } = stepper;
   const { lists } = settle(state, definition, {});
-  const at = lists[current] !== null ? current : lists.findIndex((list) => list !== null);
+  const at = lists[current] !== null ? current : lists.findIndex((list2) => list2 !== null);
   if (at === -1) return { ...state, overlay: null };
   return { ...state, overlay: { kind: "stepper", stepper: show2(state, definition, {}, at) } };
 }
@@ -6219,7 +6355,7 @@ function settle(state, definition, wanted) {
   const lists = definition.steps.map((def) => {
     if (def.skip?.(state, { ...choices })) return null;
     if (def.number) {
-      choices[def.id] = String((0, import_core34.parseCount)(wanted[def.id], def.number.min) ?? def.number.current(state, { ...choices }));
+      choices[def.id] = String((0, import_core36.parseCount)(wanted[def.id], def.number.min) ?? def.number.current(state, { ...choices }));
       return [];
     }
     const items = def.items(state, { ...choices });
@@ -6233,10 +6369,10 @@ function settle(state, definition, wanted) {
 function show2(state, definition, wanted, current) {
   const { choices, lists } = settle(state, definition, wanted);
   const items = lists[current] ?? [];
-  const trail = lists.flatMap((list, i) => {
-    if (list === null) return [];
+  const trail = lists.flatMap((list2, i) => {
+    if (list2 === null) return [];
     const def2 = definition.steps[i];
-    const value = i >= current ? void 0 : def2.number ? choices[def2.id] : list.find((item) => item.id === choices[def2.id])?.label;
+    const value = i >= current ? void 0 : def2.number ? choices[def2.id] : list2.find((item) => item.id === choices[def2.id])?.label;
     return [{ label: def2.label, active: i === current, ...value !== void 0 ? { value } : {} }];
   });
   const def = definition.steps[current];
@@ -6258,7 +6394,7 @@ function lastIndexBefore(lists, index) {
 }
 
 // src/tui/reducers/planPane.ts
-var import_core37 = require("@ordewell/core");
+var import_core39 = require("@ordewell/core");
 
 // src/tui/reducers/pointer.ts
 var WHEEL_NOTCH = 3;
@@ -6336,13 +6472,13 @@ function handleMouseSelect(state, key) {
 }
 
 // src/tui/reducers/taskView.ts
-var import_core35 = require("@ordewell/core");
+var import_core37 = require("@ordewell/core");
 function openTaskView(state, sessionId, taskId) {
   const task = findTask(state.tasks, taskId);
   if (!task) return step(say(state, "system", `No task ${taskId} in this plan.`));
   const taskView = {
     taskId,
-    view: import_core35.EMPTY_TASK_LOG,
+    view: import_core37.EMPTY_TASK_LOG,
     attempts: [],
     attempt: 0,
     pending: [],
@@ -6372,13 +6508,13 @@ function applyLive(tv, attempt, events) {
     }
     next = {
       ...next,
-      view: import_core35.EMPTY_TASK_LOG,
+      view: import_core37.EMPTY_TASK_LOG,
       attempt,
       attempts: next.attempts.includes(attempt) ? next.attempts : [...next.attempts, attempt]
     };
   }
   if (attempt < next.attempt) return next;
-  return clampQueueIndex({ ...next, view: events.reduce(import_core35.reduceTaskLog, next.view) });
+  return clampQueueIndex({ ...next, view: events.reduce(import_core37.reduceTaskLog, next.view) });
 }
 function taskLogAbandoned(state) {
   const tv = state.taskView;
@@ -6398,14 +6534,15 @@ function taskLogArrived(state, action) {
 function announceApprovals(state, action) {
   if (state.taskView?.taskId === action.taskId) return state;
   const task = findTask(state.tasks, action.taskId);
-  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" && !event.decided ? say(s, "system", `Task ${task?.order ?? "?"} waits for approval: ${(0, import_core35.runnerToolSubject)(event.tool, event.args)} \u2014 enter on it, then ctrl-y to allow or ctrl-g to deny`) : s, state);
+  const way = task ? `tab to the plan, select task ${task.order} and press enter (or /open ${task.order})` : "tab to the plan, select it and press enter";
+  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" && !event.decided ? say(s, "system", `Task ${task?.order ?? "?"} waits for approval: ${(0, import_core37.runnerToolSubject)(event.tool, event.args)} \u2014 ${way}, then ctrl-y allows or ctrl-g denies`) : s, state);
   return spoken !== state ? { ...spoken, scroll: state.scroll } : spoken;
 }
 function announceCheckpoint(state, action) {
   const task = findTask(state.tasks, action.taskId) ?? state.tasks.find((t) => t.title === action.title);
   const label = task ? `Task ${task.order}` : action.title;
-  const where = "enter on it to answer";
-  const spoken = say(state, "system", `${label} asks: ${(0, import_core35.truncateCheckpointSummary)(action.summary)} \u2014 ${where}`);
+  const where = task ? `tab to the plan, select task ${task.order} and press enter (or /open ${task.order}) to answer` : "tab to the plan, select it and press enter to answer";
+  const spoken = say(state, "system", `${label} asks: ${(0, import_core37.truncateCheckpointSummary)(action.summary)} \u2014 ${where}`);
   return { ...spoken, scroll: state.scroll };
 }
 function taskLogLoaded(state, action) {
@@ -6413,7 +6550,7 @@ function taskLogLoaded(state, action) {
   if (!tv || tv.taskId !== action.taskId) return state;
   const loaded = action.attempt >= 1 ? {
     ...tv,
-    view: (0, import_core35.replayTaskLog)(action.events),
+    view: (0, import_core37.replayTaskLog)(action.events),
     attempts: action.attempts ?? tv.attempts,
     attempt: action.attempt
   } : { ...tv, attempts: action.attempts ?? tv.attempts };
@@ -6487,7 +6624,7 @@ function handleTaskViewKey(state, key) {
   if (key.name === "ctrl-s") return sendNow(state, tv, state.sessionId);
   if (key.name === "ctrl-x") {
     const task = findTask(state.tasks, tv.taskId);
-    if (task && (0, import_core35.resumeLabel)(task)) return step(state, [{ type: "taskAction", sessionId: state.sessionId, taskId: tv.taskId, action: "cancel-resume" }]);
+    if (task && (0, import_core37.resumeLabel)(task)) return step(state, [{ type: "taskAction", sessionId: state.sessionId, taskId: tv.taskId, action: "cancel-resume" }]);
     return step(state, [{ type: "interruptTask", sessionId: state.sessionId, taskId: tv.taskId }]);
   }
   if (key.name === "ctrl-y") return answerWaiting(state, tv, state.sessionId, "allow");
@@ -6505,7 +6642,7 @@ function handleTaskViewKey(state, key) {
 }
 
 // src/tui/reducers/taskEdits.ts
-var import_core36 = require("@ordewell/core");
+var import_core38 = require("@ordewell/core");
 var import_plan_utils3 = require("@ordewell/core/plan-utils");
 function openTaskRunnerPicker(state, task) {
   if (task.type !== "ai") return fail3(state, "Manual tasks do not run on an executor, so they have no runner.");
@@ -6616,7 +6753,7 @@ function openTaskModePicker(state, task) {
       overlay: {
         kind: "picker",
         picker: picker(`Mode \xB7 ${refFor(state, task)}`, pickerItemsFor(state, action), action, {
-          hint: [`Modes declared by ${task.assignedRunner}.`, (0, import_core36.codexSandboxNotice)(state.modesByRunner)?.line].filter(Boolean).join(" ")
+          hint: [`Modes declared by ${task.assignedRunner}.`, (0, import_core38.codexSandboxNotice)(state.modesByRunner)?.line].filter(Boolean).join(" ")
         })
       }
     }
@@ -6844,11 +6981,11 @@ function handlePlanKey(state, key) {
   if (!state.sessionId || key.name !== "char") return step(state);
   if (key.char === "E") return step(state, [{ type: "execute", sessionId: state.sessionId }]);
   if (key.char === "S") return step(state, [{ type: "stopExecution", sessionId: state.sessionId }]);
-  const shortcut = key.char === "c" && (0, import_core37.resumeLabel)(task) ? "cancel-resume" : PLAN_SHORTCUTS[key.char ?? ""];
+  const shortcut = key.char === "c" && (0, import_core39.resumeLabel)(task) ? "cancel-resume" : PLAN_SHORTCUTS[key.char ?? ""];
   if (key.char === "r") {
-    return (0, import_core37.taskRowActions)(task).includes("resume-now") ? step(state, [taskActionEffect(state, state.sessionId, task.id, "resume-now")]) : step(state);
+    return (0, import_core39.taskRowActions)(task).includes("resume-now") ? step(state, [taskActionEffect(state, state.sessionId, task.id, "resume-now")]) : step(state);
   }
-  const action = key.char === "m" ? (0, import_core37.markAction)(task) : shortcut;
+  const action = key.char === "m" ? (0, import_core39.markAction)(task) : shortcut;
   if (action === "force-start" && task.mergeGate?.length) return confirmForceStartPastGate(state, task);
   if (action) {
     return step(state, [taskActionEffect(state, state.sessionId, task.id, action)]);
@@ -6888,9 +7025,9 @@ function commitTaskEdit(state, task, editor) {
 }
 
 // src/tui/reducers/turnQueue.ts
-var import_core38 = require("@ordewell/core");
+var import_core40 = require("@ordewell/core");
 function drainQueue(state, settled) {
-  const next = (0, import_core38.drainNext)(state.queuedPrompts);
+  const next = (0, import_core40.drainNext)(state.queuedPrompts);
   const ended = disarmStop({ ...settled, stopRequested: false, forceSendPending: null });
   if (!next) return step(ended);
   const spoken = say(ended, "user", next.text);
@@ -6905,7 +7042,7 @@ function restoreForced(state) {
   if (!forced) return state;
   const cleared = { ...state, forceSendPending: null };
   if (forced.queueIndex === void 0) {
-    const text = (0, import_core38.aheadOfDraft)(forced.text, state.editor.text);
+    const text = (0, import_core40.aheadOfDraft)(forced.text, state.editor.text);
     return { ...cleared, editor: { ...state.editor, text, cursor: text.length } };
   }
   const queued = [...state.queuedPrompts];
@@ -6921,14 +7058,14 @@ function stopPlanning(state, sessionId) {
   return step(queueToEditor(cutTurn({ ...dismissed, stopArmed: false, stopRequested: true, forceSendPending: null })), [{ type: "cancelPlanning", sessionId }]);
 }
 function queueToEditor(state) {
-  const all = (0, import_core38.unsendAll)(state.queuedPrompts);
+  const all = (0, import_core40.unsendAll)(state.queuedPrompts);
   if (!all) return state;
   return { ...state, queuedPrompts: all.rest, editor: { ...state.editor, text: all.text, cursor: all.text.length } };
 }
 function unsendLatest(state) {
-  const latest = (0, import_core38.unsendLatest)(state.queuedPrompts);
+  const latest = (0, import_core40.unsendLatest)(state.queuedPrompts);
   if (!latest) return step(state);
-  const text = (0, import_core38.aheadOfDraft)(latest.text, state.editor.text);
+  const text = (0, import_core40.aheadOfDraft)(latest.text, state.editor.text);
   return step({
     ...state,
     queuedPrompts: latest.rest,
@@ -6944,7 +7081,7 @@ function forceSendPlanner(state) {
       { type: "forceSendPlannerMessage", sessionId: state.sessionId, message: text }
     ]);
   }
-  const latest = (0, import_core38.unsendLatest)(state.queuedPrompts);
+  const latest = (0, import_core40.unsendLatest)(state.queuedPrompts);
   if (!latest) return step(say(state, "system", "Nothing to send now: type a message, or queue one with enter."));
   const forced = { text: latest.text, queueIndex: latest.rest.length };
   return step({ ...state, queuedPrompts: latest.rest, stopRequested: false, forceSendPending: forced }, [
@@ -6960,7 +7097,7 @@ function plannerEscape(state) {
 }
 
 // src/tui/reducers/incoming.ts
-var import_core39 = require("@ordewell/core");
+var import_core41 = require("@ordewell/core");
 var planText = (value, fallback = "") => sanitize(String(value ?? fallback));
 var planLabel = (value, fallback = "") => planText(value, fallback).replace(/\n+/g, " ");
 var asRecord = (value) => typeof value === "object" && value !== null ? value : {};
@@ -6999,7 +7136,7 @@ function runTaskToView(t) {
       ...Array.isArray(model.availableVariants) ? { availableVariants: model.availableVariants.map((variant) => planLabel(variant)) } : {}
     } : void 0,
     isolation: t.isolation,
-    awaitingReason: t.status === "awaiting_user" && (0, import_core39.isAwaitingReason)(t.awaitingReason) ? t.awaitingReason : void 0,
+    awaitingReason: t.status === "awaiting_user" && (0, import_core41.isAwaitingReason)(t.awaitingReason) ? t.awaitingReason : void 0,
     ...t.status === "awaiting_user" && t.awaitingReason === "usage-limit" && typeof t.resumeAt === "string" ? { resumeAt: t.resumeAt } : {},
     ...t.status === "skipped" && typeof t.skipReason === "string" ? { skipReason: sanitize(t.skipReason) } : {},
     checkpoint: typeof t.checkpoint === "string" ? sanitize(t.checkpoint) : void 0,
@@ -7018,7 +7155,7 @@ function supervisorOfRun(runSettings) {
   const unsupervised = typeof runSettings.unsupervised === "string" ? runSettings.unsupervised : void 0;
   return {
     runSupervisor: {
-      level: (0, import_core39.isSupervisorLevel)(runSettings.supervisorLevel) ? runSettings.supervisorLevel : "off",
+      level: (0, import_core41.isSupervisorLevel)(runSettings.supervisorLevel) ? runSettings.supervisorLevel : "off",
       ...unsupervised ? { unsupervised } : {}
     }
   };
@@ -7035,7 +7172,7 @@ function withRun(state, run) {
   };
 }
 function foldRun(state, input) {
-  const run = (0, import_core39.reduceRun)(state.run, input);
+  const run = (0, import_core41.reduceRun)(state.run, input);
   return run === state.run ? state : withRun(state, run);
 }
 function mapRunTasks(tasks, map) {
@@ -7083,21 +7220,21 @@ function followSession(state, message) {
 }
 
 // src/tui/reducers/runSettings.ts
-var import_core40 = require("@ordewell/core");
+var import_core42 = require("@ordewell/core");
 function runSettingsEffect(state, changes) {
   return { type: "setRunSettings", changes, ...state.sessionId ? { sessionId: state.sessionId } : {} };
 }
 function supervisorCommand(state, args) {
   const [arg, value] = args;
   if (arg === void 0) {
-    return step(say(state, "system", `${(0, import_core40.supervisorSummary)(state.runSettings)} \u2014 /supervisor off|watch|act, /supervisor retries <n>, /supervisor reads <n>.`));
+    return step(say(state, "system", `${(0, import_core42.supervisorSummary)(state.runSettings)} \u2014 /supervisor off|watch|act, /supervisor retries <n>, /supervisor reads <n>.`));
   }
   if (arg === "retries") {
-    const n = (0, import_core40.parseCount)(value, 0);
+    const n = (0, import_core42.parseCount)(value, 0);
     return n === null ? fail3(state, "Usage: /supervisor retries <whole number, 0 or more>") : step(state, [runSettingsEffect(state, { supervisorRetryLimit: n })]);
   }
   if (arg === "reads") {
-    const n = (0, import_core40.parseCount)(value, 1);
+    const n = (0, import_core42.parseCount)(value, 1);
     return n === null ? fail3(state, "Usage: /supervisor reads <whole number, 1 or more>") : step(state, [runSettingsEffect(state, { wakeUpReadBudget: n })]);
   }
   if (arg === "act") return confirmSupervisorAct(state);
@@ -7106,17 +7243,17 @@ function supervisorCommand(state, args) {
 }
 function automergeCommand(state, arg) {
   if (arg === void 0) {
-    return step(say(state, "system", `${(0, import_core40.automergeSummary)(state.runSettings)} \u2014 /automerge on|off.`));
+    return step(say(state, "system", `${(0, import_core42.automergeSummary)(state.runSettings)} \u2014 /automerge on|off.`));
   }
-  const enabled = (0, import_core40.parseSwitch)(arg);
+  const enabled = (0, import_core42.parseSwitch)(arg);
   if (enabled === null) return fail3(state, "Usage: /automerge [on|off]");
   return step(state, [runSettingsEffect(state, { mergeAtGatesAutomatically: enabled })]);
 }
 function autorunCommand(state, arg) {
   if (arg === void 0) {
-    return step(say(state, "system", `${(0, import_core40.autorunSummary)(state.runSettings)} \u2014 /autorun on starts each plan the planner submits, without review.`));
+    return step(say(state, "system", `${(0, import_core42.autorunSummary)(state.runSettings)} \u2014 /autorun on starts each plan the planner submits, without review.`));
   }
-  const enabled = (0, import_core40.parseSwitch)(arg);
+  const enabled = (0, import_core42.parseSwitch)(arg);
   if (enabled === null) return fail3(state, "Usage: /autorun [on|off]");
   if (enabled) return confirmAutorun(state);
   return step(state, [runSettingsEffect(state, { autorun: false })]);
@@ -7128,7 +7265,7 @@ function confirmSupervisorAct(state) {
       kind: "confirm",
       title: "Let the supervisor act?",
       message: "At Act the supervisor runs, stops and retries tasks, answers their requests (never allowing), edits the plan and merges, without asking you.",
-      note: `${import_core40.ACT_RISK}
+      note: `${import_core42.ACT_RISK}
 It applies to this session's run now, and to every later run.`,
       action: { kind: "supervisor-act" }
     }
@@ -7141,14 +7278,14 @@ function confirmAutorun(state) {
       kind: "confirm",
       title: "Start plans without review?",
       message: "With autorun on, each plan the planner submits starts at once, as if you had pressed Execute. The planner still asks when something is unclear.",
-      note: import_core40.AUTORUN_RISK,
+      note: import_core42.AUTORUN_RISK,
       action: { kind: "autorun-on" }
     }
   });
 }
 
 // src/tui/reducers/settings.ts
-var import_core41 = require("@ordewell/core");
+var import_core43 = require("@ordewell/core");
 var SUPERVISOR_DETAIL = {
   off: "The planner speaks only when you write",
   watch: "The planner follows your runs and suggests what to do",
@@ -7173,7 +7310,7 @@ var SETTINGS = {
         {
           id: "guarded",
           label: "Guarded",
-          detail: [`New plans run tasks in each runner's safer mode`, (0, import_core41.codexSandboxNotice)(state.modesByRunner)?.line].filter(Boolean).join(" \xB7 "),
+          detail: [`New plans run tasks in each runner's safer mode`, (0, import_core43.codexSandboxNotice)(state.modesByRunner)?.line].filter(Boolean).join(" \xB7 "),
           selected: !state.autonomous
         }
       ]
@@ -7183,7 +7320,7 @@ var SETTINGS = {
       label: "Supervisor",
       items: (state) => ["off", "watch", "act"].map((level) => ({
         id: level,
-        label: import_core41.SUPERVISOR_LEVEL_LABEL[level],
+        label: import_core43.SUPERVISOR_LEVEL_LABEL[level],
         detail: SUPERVISOR_DETAIL[level],
         selected: state.runSettings.supervisorLevel === level
       }))
@@ -7237,12 +7374,12 @@ function saveChoices(state, choices) {
   const autonomous = choices.autonomy === "full";
   if (autonomous !== state.autonomous) {
     save2.autonomous = autonomous;
-    changed.push(`Autonomy ${(0, import_core41.autonomyLevelLabel)(autonomous)}`);
+    changed.push(`Autonomy ${(0, import_core43.autonomyLevelLabel)(autonomous)}`);
   }
   const level = choices.supervisor;
   if (level !== state.runSettings.supervisorLevel) {
     run.supervisorLevel = level;
-    changed.push(`Supervisor ${import_core41.SUPERVISOR_LEVEL_LABEL[level]}`);
+    changed.push(`Supervisor ${import_core43.SUPERVISOR_LEVEL_LABEL[level]}`);
   }
   if (choices.retries !== void 0 && Number(choices.retries) !== state.runSettings.supervisorRetryLimit) {
     run.supervisorRetryLimit = Number(choices.retries);
@@ -7269,7 +7406,7 @@ function saveChoices(state, choices) {
   }
   if (changed.length === 0) return step(state);
   const effect = { ...save2, message: `Settings: ${changed.join(" \xB7 ")}` };
-  const risks = [...run.supervisorLevel === "act" ? [import_core41.ACT_RISK] : [], ...run.autorun ? [import_core41.AUTORUN_RISK] : []];
+  const risks = [...run.supervisorLevel === "act" ? [import_core43.ACT_RISK] : [], ...run.autorun ? [import_core43.AUTORUN_RISK] : []];
   if (risks.length === 0) return saveSettings(state, effect);
   return step({
     ...state,
@@ -7298,7 +7435,6 @@ function saveSettings(state, effect) {
 }
 
 // src/tui/reducers/commands.ts
-var KNOWN_PROVIDERS = Object.keys(import_core42.ALL_PROVIDERS);
 var unknownCommand = (state, name) => fail3(state, `Unknown command: /${name} \u2014 type /help to see what's available.`);
 function runCommand(state, { name, args }) {
   if (!findCommand(name)) return unknownCommand(state, name);
@@ -7385,6 +7521,8 @@ function runCommand(state, { name, args }) {
         if (!text) return fail3(state, "Usage: /continue <id> <message>");
         return continueTaskStep(state, sessionId, taskId, text);
       });
+    case "open":
+      return taskCommand(state, args[0], (sessionId, taskId) => openTaskView(state, sessionId, taskId));
     case "checkpoint":
       return taskCommand(state, args[0], (sessionId, taskId) => {
         const answer = args[1]?.toLowerCase();
@@ -7459,8 +7597,8 @@ function newSession(state) {
     goal: "",
     taskView: null,
     planApproved: false,
-    conversation: import_core42.EMPTY_CONVERSATION,
-    turnGate: import_core42.NO_TURN,
+    conversation: import_core44.EMPTY_CONVERSATION,
+    turnGate: import_core44.NO_TURN,
     selectedTask: 0,
     expandedTaskId: null,
     taskEditor: null,
@@ -7471,15 +7609,15 @@ function newSession(state) {
     // Prompts belong to the session that raised them; the old planner is gone
     // and its pending requests deny on their own timeout.
     pendingApprovals: [],
-    queuedPrompts: import_core42.EMPTY_HOLD,
+    queuedPrompts: import_core44.EMPTY_HOLD,
     stopArmed: false,
     forceSendPending: null,
     overlay: state.overlay?.kind === "approval" ? null : state.overlay
-  }, import_core42.EMPTY_RUN), closeEffects);
+  }, import_core44.EMPTY_RUN), closeEffects);
 }
 function setModel(state, args) {
   if (args[0] === "set" && args[1]) {
-    const runner = (0, import_core42.runnerForProvider)(state.plannerProvider);
+    const runner = (0, import_core44.runnerForProvider)(state.plannerProvider);
     const known = runner ? modelsForRunner(state.models, runner) : [];
     if (runner && known.length > 0 && !known.some((m) => m.id === args[1])) {
       return fail3(state, `${args[1]} was not discovered for ${runner}.`);
@@ -7502,7 +7640,7 @@ function setModel(state, args) {
 function setPlanner(state, args) {
   if (args[0]) {
     const id = args[0].toLowerCase();
-    if (!KNOWN_PROVIDERS.includes(id)) {
+    if (!(0, import_core44.isPlannerBackend)(id)) {
       return fail3(state, `Unknown planner: ${id}. Run /planner with no arguments to see the list.`);
     }
     return step(state, [{ type: "setPlanner", provider: id }]);
@@ -7534,7 +7672,7 @@ function setPlannerEffort(state, args) {
 function setKey(state, args) {
   if (args[0] === "set" && args[1]) {
     const provider = args[1].toLowerCase();
-    if (!KNOWN_PROVIDERS.includes(provider)) {
+    if (!(0, import_core44.isApiProvider)(provider)) {
       return fail3(state, `Unknown provider: ${provider}. Run /key with no arguments to see the list.`);
     }
     if (!args[2]) {
@@ -7545,16 +7683,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core42.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core44.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core42.ALL_PROVIDERS[id].label,
-    detail: import_core42.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: (0, import_core44.getProviderMeta)(id).label,
+    detail: (0, import_core44.getProviderMeta)(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_core42.ALL_PROVIDERS[provider];
+  const meta = (0, import_core44.getProviderMeta)(provider);
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -7631,13 +7769,13 @@ function runners(state, args) {
 }
 function setMaxParallel(state, arg) {
   if (!arg) return step(say(state, "system", `Up to ${state.maxParallel} AI task${state.maxParallel === 1 ? "" : "s"} run at once \u2014 /parallel <n> changes it.`));
-  const limit = (0, import_core42.parseMaxParallel)(arg);
+  const limit = (0, import_core44.parseMaxParallel)(arg);
   if (limit === null) return fail3(state, "Usage: /parallel [<number of tasks, 1 or more>]");
   return step({ ...state, maxParallel: limit }, [{ type: "setMaxParallel", limit }]);
 }
 function setAutonomous(state, arg) {
-  if (arg === void 0) return step(say(state, "system", `Autonomy level: ${(0, import_core42.autonomyLevelLabel)(state.autonomous)} \u2014 /auto full or /auto guarded changes it for new plans.`));
-  const enabled = (0, import_core42.parseAutonomyLevel)(arg);
+  if (arg === void 0) return step(say(state, "system", `Autonomy level: ${(0, import_core44.autonomyLevelLabel)(state.autonomous)} \u2014 /auto full or /auto guarded changes it for new plans.`));
+  const enabled = (0, import_core44.parseAutonomyLevel)(arg);
   if (enabled === null) return fail3(state, "Usage: /auto [full|guarded]");
   return step({ ...state, autonomous: enabled }, [{ type: "setAutonomous", enabled }]);
 }
@@ -7846,7 +7984,7 @@ function choose2(state, picker2, item) {
     case "delete-session":
       return step(closed, [{ type: "deleteSession", sessionId: item.id }]);
     case "set-key":
-      return step({ ...state, overlay: keyPrompt(item.id) });
+      return (0, import_core45.isApiProvider)(item.id) ? step({ ...state, overlay: keyPrompt(item.id) }) : step(closed);
     case "choose-allowlist-runner": {
       const action = { kind: "set-allowlist", runner: item.id };
       const items = pickerItemsFor(state, action);
@@ -7922,7 +8060,7 @@ function reduceAction(state, action) {
     // (`task-1`), so nothing of the last one's — a merge gate, a checkpoint, its
     // tasks — may carry over into this.
     case "sessionStarted":
-      return step(withRun({ ...state, sessionId: action.sessionId, goal: action.goal, taskView: null }, import_core43.EMPTY_RUN));
+      return step(withRun({ ...state, sessionId: action.sessionId, goal: action.goal, taskView: null }, import_core46.EMPTY_RUN));
     // The daemon registers a session only once planning succeeds; when it does
     // not, holding on to the id would send every next message to a session the
     // server never had.
@@ -7933,18 +8071,18 @@ function reduceAction(state, action) {
         goal: "",
         taskView: null,
         pendingApprovals: [],
-        queuedPrompts: import_core43.EMPTY_HOLD,
+        queuedPrompts: import_core46.EMPTY_HOLD,
         stopArmed: false,
         forceSendPending: null,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
-      }, import_core43.EMPTY_RUN));
+      }, import_core46.EMPTY_RUN));
     // Deleting the session on screen stops it in the daemon; a view left on it
     // would answer every next message with a session-not-found.
     case "sessionDeleted":
       return action.sessionId === state.sessionId ? newSession(state) : step(state);
     case "chatRestored":
       if (stale(state, action.sessionId)) return step(state);
-      return step({ ...state, conversation: (0, import_core43.fromTranscript)(action.history, action.researchLog, action.plannerUsage, action.pendingTurns), scroll: 0 });
+      return step({ ...state, conversation: (0, import_core46.fromTranscript)(action.history, action.researchLog, action.plannerUsage, action.pendingTurns), scroll: 0 });
     case "planUpdated": {
       if (stale(state, action.sessionId)) return step(state);
       const settled = { ...showPlan(state, action.plan), planner: "idle" };
@@ -7984,15 +8122,15 @@ function reduceAction(state, action) {
     case "taskStarted": {
       if (stale(state, action.sessionId)) return step(state);
       const existing = findTask(state.tasks, action.taskId);
-      if (existing && (0, import_core24.isTaskRunning)(existing)) return step(state);
+      if (existing && (0, import_core26.isTaskRunning)(existing)) return step(state);
       const folded = foldRun(state, {
         type: "task_started",
         taskId: action.taskId,
         order: action.order ?? 0,
         title: action.title,
-        runner: action.runner ?? "claude-code"
+        runner: action.runner ?? import_core46.DEFAULT_RUNNERS[0]
       });
-      const spoken = say(folded, "system", (0, import_core43.taskStartedNotice)(action.title, action.runner));
+      const spoken = say(folded, "system", (0, import_core46.taskStartedNotice)(action.title, action.runner));
       return step({ ...spoken, status: "executing" });
     }
     case "taskCheckpoint":
@@ -8038,7 +8176,7 @@ function reduceAction(state, action) {
         completed: state.tasks.filter((t) => t.status === "completed").length,
         total: state.tasks.length,
         failed: state.tasks.filter((t) => t.status === "failed").length,
-        blocked: (0, import_core43.blockingFailures)(state.tasks).size,
+        blocked: (0, import_core46.blockingFailures)(state.tasks).size,
         skipped: state.tasks.filter((t) => t.status === "skipped").length
       };
       const failures = `${failed > 0 ? ` \xB7 ${failed} failed` : ""}${blocked ? ` \xB7 ${blocked} blocked` : ""}${skipped ? ` \xB7 ${skipped} skipped` : ""}`;
@@ -8102,11 +8240,11 @@ function reduceAction(state, action) {
         planner: "idle",
         planApproved: false,
         pendingApprovals: [],
-        queuedPrompts: import_core43.EMPTY_HOLD,
+        queuedPrompts: import_core46.EMPTY_HOLD,
         stopArmed: false,
         forceSendPending: null,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
-      }, import_core43.EMPTY_RUN));
+      }, import_core46.EMPTY_RUN));
     // The rewound message comes back as a draft to edit and resend, so it lands
     // as if just typed: history is not being browsed, and nothing is parked.
     case "inputPrefilled":
@@ -8178,7 +8316,7 @@ function showPlan(state, plan) {
   });
 }
 function runStatus(state, tasks) {
-  if (tasks.some(import_core24.isTaskRunning)) return "executing";
+  if (tasks.some(import_core26.isTaskRunning)) return "executing";
   if (tasks.some((t) => t.status === "awaiting_user") || state.runMerge?.paused) return "executing";
   return "idle";
 }
@@ -8257,6 +8395,12 @@ function submit(state) {
       return step({ ...cleared, taskView: { ...state.taskView, notice } });
     }
     if (state.taskView.notice) cleared.taskView = { ...state.taskView, notice: void 0 };
+    if (!command && waitingCheckpoint(task)) {
+      if (waitingApproval(state.taskView)) {
+        return step(say(state, "system", "A tool request is waiting ahead of the checkpoint \u2014 answer it first (ctrl-y to allow, ctrl-g to deny), then enter replies to the checkpoint."));
+      }
+      return answerCheckpoint(cleared, state.sessionId, taskId, "reject", text);
+    }
     if (continuesTask(task)) return continueTaskStep(cleared, state.sessionId, taskId, text);
     if (command && offered2.length > 0) return step(cleared, [{ type: "invokeTaskCommand", sessionId: state.sessionId, taskId, ...command }]);
     return step(cleared, [{ type: "sendTaskMessage", sessionId: state.sessionId, taskId, text }]);
@@ -8264,7 +8408,7 @@ function submit(state) {
   const builtIn = builtInCommand(text);
   if (builtIn) return runCommand(cleared, builtIn);
   if (plannerInFlight(state)) {
-    return step({ ...cleared, queuedPrompts: (0, import_core43.holdPrompt)(state.queuedPrompts, text) });
+    return step({ ...cleared, queuedPrompts: (0, import_core46.holdPrompt)(state.queuedPrompts, text) });
   }
   const spoken = say(cleared, "user", text);
   const effect = state.sessionId ? { type: "sendMessage", sessionId: state.sessionId, message: text } : { type: "startConversation", goal: text };
@@ -8339,7 +8483,7 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process3 = require("child_process");
-var import_core44 = require("@ordewell/core");
+var import_core47 = require("@ordewell/core");
 
 // src/tui/inbound.ts
 var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
@@ -8748,13 +8892,13 @@ async function perform(effect, deps) {
         await refreshPlan(deps, sessionId);
         return;
       }
-      const request = action === "cancel" || action === "retry" || action === "force-start" ? () => api.taskControl(sessionId, taskId, action) : action === "resume-now" ? () => api.resumeNow(sessionId, taskId) : action === "skip" ? () => api.skipTask(sessionId, taskId) : (0, import_core44.markRequestFor)(action) === "uncomplete" ? () => api.markTaskIncomplete(sessionId, taskId) : () => api.markTaskComplete(sessionId, taskId);
+      const request = action === "cancel" || action === "retry" || action === "force-start" ? () => api.taskControl(sessionId, taskId, action) : action === "resume-now" ? () => api.resumeNow(sessionId, taskId) : action === "skip" ? () => api.skipTask(sessionId, taskId) : (0, import_core47.markRequestFor)(action) === "uncomplete" ? () => api.markTaskIncomplete(sessionId, taskId) : () => api.markTaskComplete(sessionId, taskId);
       await (effect.watch ? withExecutionStream(deps, sessionId, request) : request());
       await refreshPlan(deps, sessionId);
       return;
     }
     case "addTask": {
-      const fields = (0, import_core44.newTaskFields)(effect.title);
+      const fields = (0, import_core47.newTaskFields)(effect.title);
       if (!fields) return;
       await api.addTask(effect.sessionId, { ...fields });
       await refreshPlan(deps, effect.sessionId);
@@ -8862,7 +9006,7 @@ async function perform(effect, deps) {
       return;
     }
     case "setPlanner": {
-      const meta = import_core44.ALL_PROVIDERS[effect.provider];
+      const meta = (0, import_core47.getProviderMeta)(effect.provider);
       if (!meta) throw new Error(`Unknown planner: ${effect.provider}`);
       const env = { AI_PROVIDER: effect.provider };
       const settings = await api.updateSettings({ env });
@@ -8874,7 +9018,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core44.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
+        message: `${(0, import_core47.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
       });
       await loadModels(deps);
       return;
@@ -8902,7 +9046,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Planner effort set to ${effect.effort || "the runner default"}.` });
       return;
     case "setApiKey": {
-      const meta = import_core44.ALL_PROVIDERS[effect.provider];
+      const meta = (0, import_core47.isApiProvider)(effect.provider) ? (0, import_core47.getProviderMeta)(effect.provider) : void 0;
       if (!meta) throw new Error(`Unknown provider: ${effect.provider}`);
       await api.updateSettings({ env: { [meta.apiKeyEnvVar]: effect.key } });
       deps.setEnvVar(meta.apiKeyEnvVar, effect.key);
@@ -8950,7 +9094,7 @@ async function perform(effect, deps) {
     }
     case "setAutonomous": {
       const { overridden } = deps.saveAutonomy(effect.enabled);
-      const level = (0, import_core44.autonomyLevelLabel)(effect.enabled);
+      const level = (0, import_core47.autonomyLevelLabel)(effect.enabled);
       dispatch({ type: "notice", message: overridden ? `${level} is saved, but ORDEWELL_AUTONOMOUS_MODE in the environment decides the level until it is unset.` : `Autonomy level: ${level} for new plans.` });
       return;
     }
@@ -9114,7 +9258,7 @@ async function saveMaxParallel(deps, limit) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core44.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core47.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -9219,7 +9363,7 @@ function lastAssistantMessage(plan) {
   const history = plan?.conversationHistory ?? [];
   for (let i = history.length - 1; i >= 0; i--) {
     const entry = history[i];
-    if ((0, import_core44.isUserMessage)(entry)) return null;
+    if ((0, import_core47.isUserMessage)(entry)) return null;
     if (entry.role === "assistant" && entry.kind === void 0) {
       const { content, timestamp } = entry;
       return { content, ...timestamp ? { timestamp } : {} };
@@ -9241,14 +9385,14 @@ async function loadModels(deps) {
 }
 async function loadSessions(deps) {
   const sessions = await deps.api.getSessions(deps.workspace);
-  const list = sessions.map((s) => ({
+  const list2 = sessions.map((s) => ({
     id: String(s.id),
     goal: String(s.goal ?? ""),
     taskCount: Number(s.taskCount ?? 0),
     status: String(s.status ?? ""),
     createdAt: String(s.createdAt ?? "")
   }));
-  deps.dispatch({ type: "sessionsLoaded", sessions: list });
+  deps.dispatch({ type: "sessionsLoaded", sessions: list2 });
 }
 async function loadRunners(deps) {
   const state = await deps.api.getRunners();
@@ -9574,7 +9718,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core45.assertWorkspaceExists)(workspace);
+    (0, import_core48.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -9583,7 +9727,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  const discoveredSkills = (0, import_core45.createSkillsService)(workspace, new import_core45.EnvConfig().workspaceRepos).listSkills();
+  const discoveredSkills = (0, import_core48.createSkillsService)(workspace, new import_core48.EnvConfig().workspaceRepos).listSkills();
   registerSkillCommands(discoveredSkills);
   const taskSkills = discoveredSkills.filter((s) => s.appliesTo === "task").map((s) => ({ name: s.name, description: s.description }));
   const explicitPort = flag(subArgs, "--port") || process.env.ORDEWELL_PORT;
@@ -9595,20 +9739,20 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
   const mouseCapture = process.env.ORDEWELL_TUI_MOUSE !== "false" && process.env.ORDEWELL_TUI_MOUSE !== "0";
   const app = createApp({
     // The level the daemon plans with: the saved one, unless the environment overrides it (ADR-0030).
-    initial: { workspace, autonomous: new import_core45.SettingsService().autonomousMode(), mouseCapture, taskSkills },
+    initial: { workspace, autonomous: new import_core48.SettingsService().autonomousMode(), mouseCapture, taskSkills },
     draw: (frame2) => terminal?.draw(frame2),
     perform: (effect) => runEffect(effect, {
       api,
       workspace,
       port,
       dispatch: (action) => app.dispatch(action),
-      newSessionId: () => (0, import_core45.mintSessionId)(),
+      newSessionId: () => (0, import_core48.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
       },
       saveAutonomy: (enabled) => {
-        const settings = new import_core45.SettingsService();
+        const settings = new import_core48.SettingsService();
         settings.setAutonomousMode(enabled);
         return { overridden: settings.autonomousModeOverridden() };
       },
@@ -9722,7 +9866,7 @@ var COMMANDS = {
 // src/main.ts
 var TUI_FLAGS = /* @__PURE__ */ new Set(["--workspace", "--port"]);
 async function main() {
-  (0, import_core46.migrateOldConfigDir)();
+  (0, import_core49.migrateOldConfigDir)();
   moveAutonomyToSettings();
   loadEnvFile();
   const argv = process.argv.slice(2);