@ordewell/cli 0.10.2 → 0.10.4

package/dist/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/main.ts
-var import_core49 = require("@ordewell/core");
+var import_core52 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -127,7 +127,7 @@ function runnerNamesOr() {
 // src/help.ts
 function printHelp() {
   console.log(`
-Ordewell \u2014 task orchestration for coding agents
+Ordewell: task orchestration for coding agents
 
 Run "ordewell" with no arguments for the TUI. Every command below has a TUI
 slash command of the same name, where each one opens a picker instead of taking
@@ -135,7 +135,7 @@ an id.
 
 Planning:
   ordewell                        Full-screen terminal UI (everything the VS Code extension does)
-  ordewell tui                    The same thing, named \u2014 for scripts and aliases
+  ordewell tui                    Explicit TUI command for scripts and aliases
   ordewell plan --goal "text"     Plan a goal conversationally
   ordewell run                    Execute the last generated plan (streams status)
   ordewell approve                Sign off a plan paused for review, and continue it
@@ -170,7 +170,7 @@ Per-task assignment (omit the value to list the options):
   ordewell task-ops <id> [on|off]      Make a task an ops task (runs in your checkout once its dependencies are merged) or a change task
 
 Planner, models and runners:
-  ordewell planner [<provider>]   Choose who plans \u2014 an API provider or a coding agent (no API key)
+  ordewell planner [<provider>]   Choose who plans: an API provider or a coding agent (no API key)
   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
@@ -249,17 +249,20 @@ Global options:
   --session-id <id>   Session to act on (default: last planned session)
 
 Quick Start:
-  Set OPENROUTER_API_KEY or GEMINI_API_KEY in your environment,
-  then run: ordewell plan --goal "Your task description"
+  Run "ordewell", then use /planner to choose a coding agent,
+  or /key to choose an API provider and add its key.
+
+  To plan from the command line after setup:
+    ordewell plan --goal "Your task description"
 
   No API key? Plan with a coding agent you already pay for:
     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
-                             ${runnerIdList()} \u2014 plan with that CLI,
+  OPENROUTER_API_KEY         OpenRouter API key
+  GEMINI_API_KEY             Google Gemini API key
+  AI_PROVIDER                Provider ID (auto-detected from keys); list with "ordewell planner"
+                             ${runnerIdList()}: 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
@@ -433,7 +436,7 @@ function isConnectionRefused(err) {
   return message.includes("ECONNREFUSED");
 }
 function describeConnectionRefused(port) {
-  return `No Ordewell server is listening on port ${port}. It may have been stopped, or it may have crashed \u2014 check ${(0, import_path2.join)(CONFIG_DIR, "server.log")}. Start one with \`ordewell web --daemon\`.`;
+  return `No Ordewell server is listening on port ${port}. It may have been stopped, or it may have crashed: check ${(0, import_path2.join)(CONFIG_DIR, "server.log")}. Start one with \`ordewell web --daemon\`.`;
 }
 function findFreePort() {
   return new Promise((resolvePromise, reject) => {
@@ -464,14 +467,16 @@ var import_ws = __toESM(require("ws"));
 var import_core4 = require("@ordewell/core");
 var DEFAULT_HTTP_TIMEOUT_MS = 15 * 60 * 1e3;
 var DaemonError = class extends Error {
-  constructor(message, status, code) {
+  constructor(message, status, code, plannerNotReady) {
     super(message);
     this.status = status;
     this.code = code;
+    this.plannerNotReady = plannerNotReady;
     this.name = "DaemonError";
   }
   status;
   code;
+  plannerNotReady;
 };
 var WorkspaceInitNeededError = class extends DaemonError {
   constructor(message, workspace) {
@@ -483,9 +488,9 @@ var WorkspaceInitNeededError = class extends DaemonError {
 };
 var SESSION_PATH = /^\/api\/(?:plans|sessions)\/([^/?]+)/;
 function daemonError(status, data, fallback) {
-  const { error, code, workspace } = typeof data === "object" && data !== null ? data : {};
+  const { error, code, workspace, plannerNotReady } = typeof data === "object" && data !== null ? data : {};
   if (code === "workspace_not_a_project") return new WorkspaceInitNeededError(error || "Not a project directory", workspace ?? "");
-  return new DaemonError(error || fallback, status, code);
+  return new DaemonError(error || fallback, status, code, plannerNotReady);
 }
 var ApiClient = class _ApiClient {
   /** Where a CLI invocation's sessions live, when a client is built without one: `--workspace`, else the cwd. */
@@ -628,7 +633,7 @@ var ApiClient = class _ApiClient {
   markTaskComplete(sessionId, taskId) {
     return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/complete`, "Mark complete failed");
   }
-  /** Skip: end the task without landing its work, so what depends on it goes ahead; never a mark complete. */
+  /** Skip: end the task without landing its work, so what depends on it goes ahead once the work it waited on is done; never a mark complete. */
   skipTask(sessionId, taskId, reason) {
     return this.call("POST", `/api/plans/${sessionId}/tasks/${taskId}/skip`, "Skip failed", reason ? { reason } : {});
   }
@@ -728,7 +733,7 @@ var ApiClient = class _ApiClient {
   compactConversation(sessionId) {
     return this.call("POST", `/api/plans/${sessionId}/conversation/compact`, "Compaction failed");
   }
-  /** The dependencies a task waits on at its merge gate (ADR-0020); empty when nothing gates it. */
+  /** The ancestors a task waits on at its merge gate (ADR-0020); empty when nothing gates it. */
   async getMergeGate(sessionId, taskId) {
     const res = await this.call("GET", `/api/plans/${sessionId}/tasks/${taskId}/merge-gate`, "Could not read the merge gate");
     return res.mergeGate ?? [];
@@ -979,7 +984,7 @@ var ApiClient = class _ApiClient {
 };
 
 // src/commands/plan.ts
-var import_readline = require("readline");
+var import_readline2 = require("readline");
 
 // src/utils/args.ts
 function flag(args, name) {
@@ -1140,7 +1145,7 @@ ${describeApproval(event)}
     deps.write("  Approved automatically (--yes).\n");
   } else if (!interactive) {
     granted = false;
-    deps.write("  Denied: no interactive terminal. Re-run with --yes, or pre-approve via ORDEWELL_APPROVAL_ALLOW.\n");
+    deps.write(event.kind === "task_start" ? "  Not started: there is no terminal here to ask you. Start it yourself with `ordewell run`, or Execute plan in the TUI or VS Code.\n" : "  Denied: no interactive terminal. Re-run with --yes, or pre-approve via ORDEWELL_APPROVAL_ALLOW.\n");
   } else {
     const answer = (await deps.ask("  Allow? [y/N] ")).trim().toLowerCase();
     granted = answer === "y" || answer === "yes";
@@ -1148,7 +1153,7 @@ ${describeApproval(event)}
   try {
     await deps.respond(sessionId, id, granted);
   } catch {
-    deps.write("  (could not deliver the answer \u2014 the planner will treat it as denied)\n");
+    deps.write("  (could not deliver the answer: the planner will treat it as denied)\n");
   }
 }
 
@@ -1215,7 +1220,118 @@ function createStepLog(options = {}) {
 }
 
 // src/commands/plan.ts
+var import_core9 = require("@ordewell/core");
+
+// src/commands/shared.ts
+var import_readline = require("readline");
+
+// src/catalog.ts
+function normalizeCatalog(result) {
+  const runnersByModel = /* @__PURE__ */ new Map();
+  for (const [runner, entries] of Object.entries(result.modelsByRunner ?? {})) {
+    for (const entry of entries ?? []) {
+      const id = String(entry.modelId);
+      runnersByModel.set(id, [.../* @__PURE__ */ new Set([...runnersByModel.get(id) ?? [], runner])]);
+    }
+  }
+  const models = (result.models ?? []).map((m) => {
+    const id = String(m.modelId);
+    return {
+      id,
+      label: String(m.modelLabel ?? id),
+      provider: String(m.runnerProviderLabel ?? m.runnerProvider ?? ""),
+      variants: Array.isArray(m.variants) ? m.variants.map((v) => ({ id: String(v.id), label: String(v.label ?? v.id) })) : [],
+      runners: runnersByModel.get(id) ?? []
+    };
+  });
+  const orchestratorModels = (result.orchestratorModels ?? []).map((m) => ({
+    id: String(m.id),
+    label: String(m.label ?? m.id),
+    provider: String(m.provider ?? ""),
+    pricing: m.pricing ? `$${m.pricing}/MTok` : void 0
+  }));
+  return {
+    models,
+    orchestratorModels,
+    providers: result.providers ?? [],
+    providerErrors: result.providerErrors ?? {},
+    modesByRunner: Object.fromEntries(
+      Object.entries(result.modesByRunner ?? {}).map(([runner, modes]) => [
+        runner,
+        (modes ?? []).map((m) => ({
+          id: String(m.id),
+          label: String(m.label ?? m.id),
+          description: m.description ? String(m.description) : void 0,
+          autonomous: m.autonomous ? true : void 0,
+          unavailable: m.unavailable ? String(m.unavailable) : void 0
+        }))
+      ])
+    )
+  };
+}
+
+// src/commands/shared.ts
 var import_core8 = require("@ordewell/core");
+async function connect(subArgs, injected) {
+  return injected ?? new ApiClient(await ensureDaemon(resolvePort(subArgs)));
+}
+async function fetchCatalog(api) {
+  return normalizeCatalog(await api.getModels());
+}
+function fail(...lines) {
+  for (const line of lines) console.error(line);
+  process.exit(1);
+}
+function headlessPlannerRefusal(err) {
+  return err instanceof DaemonError && err.plannerNotReady ? (0, import_core8.describePlannerNotReady)(err.plannerNotReady, import_core8.HEADLESS_CLI_COMMANDS) : null;
+}
+async function askYesNo(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await new Promise((resolve4) => rl.question(`${question} [y/N] `, resolve4));
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+function writeEnv(env) {
+  const envFile = findEnvFile();
+  for (const [key, value] of Object.entries(env)) {
+    writeEnvVar(envFile, key, value);
+    process.env[key] = value;
+  }
+}
+async function persistEnv(api, env) {
+  const settings = await api.updateSettings({ env });
+  writeEnv(env);
+  return settings;
+}
+function toTaskView(task) {
+  return {
+    id: task.id,
+    order: task.order,
+    title: task.title,
+    description: task.description,
+    prompt: task.prompt ?? void 0,
+    type: task.type === "user" ? "user" : "ai",
+    status: task.status ?? "pending",
+    dependencies: task.dependencies ?? [],
+    assignedRunner: task.assignedRunner || void 0,
+    taskMode: task.taskMode || void 0,
+    assignedModel: task.assignedModel ?? void 0,
+    subtasks: [...task.subtasks ?? []].sort((a, b) => a.order - b.order).map(toTaskView),
+    ...task.ops ? { ops: true } : {},
+    ...task.skills?.length ? { skills: [...task.skills] } : {},
+    ...task.addedBy ? { addedBy: task.addedBy } : {}
+  };
+}
+function taskViews(plan) {
+  const tasks = allTasksOf(plan);
+  return [...tasks].sort((a, b) => a.order - b.order).map(toTaskView);
+}
+
+// src/commands/plan.ts
 function planTasks(plan) {
   return plan ? allTasksOf(plan) : [];
 }
@@ -1237,8 +1353,16 @@ function commitNotes(plan) {
   const marker2 = history.map((e) => e.kind).lastIndexOf("plan_generated");
   return marker2 < 0 ? [] : history.slice(marker2 + 1).filter((e) => e.kind === "system").map((e) => e.content);
 }
+async function nextStep(api, plan) {
+  const approved = "approved" in plan && plan.approved === true;
+  const moving = planTasks(plan).some((t) => t.status !== void 0 && t.status !== "pending" && t.status !== "approved");
+  if (!approved && !moving) return `Run 'ordewell run' to execute, 'ordewell status' to inspect, or 'ordewell tui' for the full UI.`;
+  const follow2 = `Follow it with 'ordewell status', or 'ordewell tui' for the full UI.`;
+  const autorun = await api.getSettings().then((settings) => settings.run?.autorun === true, () => false);
+  return autorun ? `Autorun started the plan. ${follow2}` : `The plan is running. ${follow2}`;
+}
 function stdinReader(input = process.stdin) {
-  const rl = (0, import_readline.createInterface)({ input, output: process.stderr });
+  const rl = (0, import_readline2.createInterface)({ input, output: process.stderr });
   const buffered = [];
   let waiting = null;
   let ended = false;
@@ -1293,35 +1417,36 @@ function printPlan(plan, sessionId, runners2, models) {
     return rp ? ` (${task.assignedModel.modelLabel} \xB7 ${label})` : ` (${task.assignedModel.modelLabel})`;
   };
   console.log(`
-Plan: ${tasks.length} task${tasks.length === 1 ? "" : "s"} (${aiCount} AI, ${manCount} Manual) \u2014 ${runnersOf(plan, runners2).join(", ")}`);
+Plan: ${tasks.length} task${tasks.length === 1 ? "" : "s"} (${aiCount} AI, ${manCount} Manual): ${runnersOf(plan, runners2).join(", ")}`);
   console.log(`Session: ${sessionId}
 `);
   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_core8.taskOrderLabel)(t).padStart(2)}. ${typeIcon} ${t.title}${modelSuffix(t)}${deps}`);
+    console.log(`  ${(0, import_core9.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_core8.taskOrderLabel)(sub, t)}. ${subTypeIcon} ${sub.title}${modelSuffix(sub)}${subDeps}`);
+      console.log(`    ${(0, import_core9.taskOrderLabel)(sub, t)}. ${subTypeIcon} ${sub.title}${modelSuffix(sub)}${subDeps}`);
     }
   }
   if (manCount > 0) {
-    console.log("\n  [MAN] = manual step \u2014 run `ordewell tui` to work through it");
+    console.log("\n  [MAN] = manual step: run `ordewell tui` to work through it");
   }
   if (tasks.some((t) => t.ops)) {
-    console.log("  [OPS] = ops task \u2014 runs in your checkout once the work it depends on is merged (`ordewell handoff merge`)");
+    console.log("  [OPS] = ops task: runs in your checkout once the work it depends on is merged (`ordewell handoff merge`)");
   }
 }
-var PLANNER_ENV = ["AI_PROVIDER", "ORCHESTRATOR_MODEL", "ORDEWELL_PLANNER_EFFORT"];
+var INHERITED_PLANNER_ENV = ["ORCHESTRATOR_MODEL", "ORDEWELL_PLANNER_EFFORT"];
 async function forwardPlannerEnv(api) {
+  const provider = process.env.AI_PROVIDER;
+  if (provider) await api.updateSettings({ env: { AI_PROVIDER: provider } });
   const env = {};
-  for (const key of PLANNER_ENV) {
+  for (const key of INHERITED_PLANNER_ENV) {
     const value = process.env[key];
     if (value) env[key] = value;
   }
-  if (Object.keys(env).length === 0) return;
-  await api.updateSettings({ env });
+  if (Object.keys(env).length > 0) await api.updateSettings({ env, inherited: true });
 }
 async function handlePlan(subArgs, deps = {}) {
   const injectedApi = deps.api;
@@ -1340,20 +1465,27 @@ async function handlePlan(subArgs, deps = {}) {
   await forwardPlannerEnv(api);
   const state = await api.getRunners();
   const enabledIds = state.runners.filter((r) => r.enabled).map((r) => r.id);
+  const enableHint = (id) => `Enable it with: ordewell runners ${id} on`;
   let runners2;
   if (runnerFlags.length === 0) {
+    if (enabledIds.length === 0) {
+      const installed = state.runners.map((r) => r.id);
+      fail(
+        "No runner is enabled.",
+        installed.length > 0 ? `Installed: ${installed.join(", ")}. ${enableHint(installed[0])}` : "No supported coding agent is installed or on PATH."
+      );
+    }
     runners2 = enabledIds;
   } else {
     for (const r of runnerFlags) {
-      if (!enabledIds.includes(r)) {
-        console.error(`Unknown runner: "${r}". Enabled runners: ${enabledIds.join(", ")}`);
-        process.exit(1);
-      }
+      if (enabledIds.includes(r)) continue;
+      if (state.runners.some((known) => known.id === r)) fail(`${r} is installed but not enabled. ${enableHint(r)}`);
+      fail(`Unknown runner: "${r}". Enabled runners: ${enabledIds.join(", ")}`);
     }
     runners2 = runnerFlags;
   }
   console.error(`Generating plan for: "${goal}"...`);
-  const sessionId = (0, import_core8.mintSessionId)();
+  const sessionId = (0, import_core9.mintSessionId)();
   const isTty = !!process.stderr.isTTY;
   let lastLineLength = 0;
   const stepLog = createStepLog({ verbose });
@@ -1447,19 +1579,24 @@ ${lastPlannerMessage(plan)}
 ${note}`);
     saveLastSession(sessionId, goal, runnersOf(plan, runners2), workspace);
     console.log(`
-  Run 'ordewell run' to execute, 'ordewell status' to inspect, or 'ordewell tui' for the full UI.`);
+  ${await nextStep(api, plan)}`);
   } catch (err) {
     reader?.close();
     closeStream();
     if (isTty && lastLineLength > 0) process.stderr.write("\r\x1B[2K");
     process.stderr.write("\n");
-    console.error(`Plan generation failed: ${err instanceof Error ? err.message : String(err)}`);
+    const refusal = headlessPlannerRefusal(err);
+    if (refusal) {
+      console.error(refusal);
+    } else {
+      console.error(`Plan generation failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     process.exit(1);
   }
 }
 
 // src/isolation.ts
-var import_core9 = require("@ordewell/core");
+var import_core10 = require("@ordewell/core");
 var STATE_OF = {
   active: "active",
   merged: "integrated",
@@ -1543,7 +1680,7 @@ function repairedLanded(handoff) {
 function repairedNotice(handoff) {
   const repaired = repairedLanded(handoff);
   if (repaired.length === 0) return "";
-  const named = repaired.map((t) => `${t.title} (${(0, import_core9.capConflictFiles)(t.repairedFiles)})`);
+  const named = repaired.map((t) => `${t.title} (${(0, import_core10.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"}.`;
 }
@@ -1556,16 +1693,16 @@ function repoResultLines(handoff) {
 function mergeOutcome(result, branch, group, repaired = []) {
   const ok = result.outcome === "merged";
   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.` };
+    return { ok, message: `Merging ${branch} conflicted, so it was aborted: your tree is as it was. Merge it with git and resolve the conflict there.` };
   }
-  const { message } = (0, import_core9.describeMergeResult)(result, branch, group, repaired);
+  const { message } = (0, import_core10.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_core10 = require("@ordewell/core");
+var import_core11 = require("@ordewell/core");
 function iconFor(status) {
-  switch ((0, import_core10.taskStatusKind)({ status })) {
+  switch ((0, import_core11.taskStatusKind)({ status })) {
     case "done":
       return "\x1B[32m\u2713\x1B[0m";
     case "running":
@@ -1585,114 +1722,8 @@ function iconFor(status) {
 }
 
 // src/commands/run.ts
-var import_core11 = require("@ordewell/core");
-
-// src/commands/shared.ts
-var import_readline2 = require("readline");
-
-// src/catalog.ts
-function normalizeCatalog(result) {
-  const runnersByModel = /* @__PURE__ */ new Map();
-  for (const [runner, entries] of Object.entries(result.modelsByRunner ?? {})) {
-    for (const entry of entries ?? []) {
-      const id = String(entry.modelId);
-      runnersByModel.set(id, [.../* @__PURE__ */ new Set([...runnersByModel.get(id) ?? [], runner])]);
-    }
-  }
-  const models = (result.models ?? []).map((m) => {
-    const id = String(m.modelId);
-    return {
-      id,
-      label: String(m.modelLabel ?? id),
-      provider: String(m.runnerProviderLabel ?? m.runnerProvider ?? ""),
-      variants: Array.isArray(m.variants) ? m.variants.map((v) => ({ id: String(v.id), label: String(v.label ?? v.id) })) : [],
-      runners: runnersByModel.get(id) ?? []
-    };
-  });
-  const orchestratorModels = (result.orchestratorModels ?? []).map((m) => ({
-    id: String(m.id),
-    label: String(m.label ?? m.id),
-    provider: String(m.provider ?? ""),
-    pricing: m.pricing ? `$${m.pricing}/MTok` : void 0
-  }));
-  return {
-    models,
-    orchestratorModels,
-    providers: result.providers ?? [],
-    providerErrors: result.providerErrors ?? {},
-    modesByRunner: Object.fromEntries(
-      Object.entries(result.modesByRunner ?? {}).map(([runner, modes]) => [
-        runner,
-        (modes ?? []).map((m) => ({
-          id: String(m.id),
-          label: String(m.label ?? m.id),
-          description: m.description ? String(m.description) : void 0,
-          autonomous: m.autonomous ? true : void 0,
-          unavailable: m.unavailable ? String(m.unavailable) : void 0
-        }))
-      ])
-    )
-  };
-}
-
-// src/commands/shared.ts
-async function connect(subArgs, injected) {
-  return injected ?? new ApiClient(await ensureDaemon(resolvePort(subArgs)));
-}
-async function fetchCatalog(api) {
-  return normalizeCatalog(await api.getModels());
-}
-function fail(...lines) {
-  for (const line of lines) console.error(line);
-  process.exit(1);
-}
-async function askYesNo(question) {
-  if (!process.stdin.isTTY) return false;
-  const rl = (0, import_readline2.createInterface)({ input: process.stdin, output: process.stderr });
-  try {
-    const answer = await new Promise((resolve4) => rl.question(`${question} [y/N] `, resolve4));
-    return /^y(es)?$/i.test(answer.trim());
-  } finally {
-    rl.close();
-  }
-}
-function writeEnv(env) {
-  const envFile = findEnvFile();
-  for (const [key, value] of Object.entries(env)) {
-    writeEnvVar(envFile, key, value);
-    process.env[key] = value;
-  }
-}
-async function persistEnv(api, env) {
-  const settings = await api.updateSettings({ env });
-  writeEnv(env);
-  return settings;
-}
-function toTaskView(task) {
-  return {
-    id: task.id,
-    order: task.order,
-    title: task.title,
-    description: task.description,
-    prompt: task.prompt ?? void 0,
-    type: task.type === "user" ? "user" : "ai",
-    status: task.status ?? "pending",
-    dependencies: task.dependencies ?? [],
-    assignedRunner: task.assignedRunner || void 0,
-    taskMode: task.taskMode || void 0,
-    assignedModel: task.assignedModel ?? void 0,
-    subtasks: [...task.subtasks ?? []].sort((a, b) => a.order - b.order).map(toTaskView),
-    ...task.ops ? { ops: true } : {},
-    ...task.skills?.length ? { skills: [...task.skills] } : {},
-    ...task.addedBy ? { addedBy: task.addedBy } : {}
-  };
-}
-function taskViews(plan) {
-  const tasks = allTasksOf(plan);
-  return [...tasks].sort((a, b) => a.order - b.order).map(toTaskView);
-}
-
-// src/commands/run.ts
+var import_core12 = require("@ordewell/core");
+var inLine = (label) => label.charAt(0).toLowerCase() + label.slice(1);
 function resolveSessionId(subArgs) {
   const explicit = flag(subArgs, "--session-id");
   if (explicit) return explicit;
@@ -1718,8 +1749,9 @@ async function followExecution(api, sessionId, start, onBlocked) {
     const lines = [];
     for (const t of entries) {
       const icon = iconFor(t.status);
-      const verdict = t.verdict ? ` \u2014 ${t.verdict.outcome.toUpperCase()}: ${t.verdict.reason.slice(0, 60)}` : "";
-      lines.push(`  ${icon} #${t.id.slice(-4)} ${t.status}${verdict}`);
+      const verdict = t.verdict ? `: ${t.verdict.outcome.toUpperCase()}: ${t.verdict.reason.slice(0, 60)}` : "";
+      const waits = t.waitsForApproval ? `: ${inLine(import_core12.WAITS_FOR_APPROVAL_LABEL)}: \`ordewell run-task <id>\` starts it` : "";
+      lines.push(`  ${icon} #${t.id.slice(-4)} ${t.status}${verdict}${waits}`);
     }
     const output = lines.join("\n");
     if (output !== lastPrinted && output.trim()) {
@@ -1744,21 +1776,21 @@ async function followExecution(api, sessionId, start, onBlocked) {
   });
   const stream = api.streamExecution(sessionId, (event) => {
     if (event.type === "task_started") {
-      process.stderr.write(`\xB7 ${(0, import_core11.taskStartedNotice)(event.title, event.runner)}
+      process.stderr.write(`\xB7 ${(0, import_core12.taskStartedNotice)(event.title, event.runner)}
 `);
     }
     if (event.type === "checkpoint") {
-      process.stderr.write(`\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core11.truncateCheckpointSummary)(event.summary)} \u2014 \`ordewell checkpoint <id> approve|reject [reason]\` answers it
+      process.stderr.write(`\xB7 Checkpoint: ${event.taskTitle}: ${(0, import_core12.truncateCheckpointSummary)(event.summary)}: \`ordewell checkpoint <id> approve|reject [reason]\` answers it
 `);
     }
     if (event.type === "status_update" && event.tasks) {
       printStatus(event.tasks);
       const paused = event.runMerge?.paused === true;
-      if (paused && !pausedAtGate) process.stderr.write("\xB7 Paused for Merge all \u2014 `ordewell handoff merge` merges what has landed, and the waiting tasks start.\n");
+      if (paused && !pausedAtGate) process.stderr.write("\xB7 Paused for Merge all: `ordewell handoff merge` merges what has landed, and the waiting tasks start.\n");
       pausedAtGate = paused;
     }
     if (event.type === "review_needed") {
-      console.log("\nPlan needs your sign-off \u2014 run `ordewell approve` to continue.");
+      console.log("\nPlan needs your sign-off: run `ordewell approve` to continue.");
     }
     if (event.type === "execution_complete") {
       const s = event;
@@ -1782,7 +1814,7 @@ Done. ${summary.completed || 0} completed, ${summary.failed || 0} failed, ${summ
       const n = event.landed.length;
       const where = isRepoGroup(event) ? ` in ${event.repos.map((r) => r.path).join(", ")}` : "";
       console.log(`
-Run finished on ${handoffBranch(event)}${where} \u2014 ${n} task${n === 1 ? "" : "s"} landed.`);
+Run finished on ${handoffBranch(event)}${where}: ${n} task${n === 1 ? "" : "s"} landed.`);
       if (isRepoGroup(event)) for (const line of repoResultLines(event)) console.log(`  ${line}`);
       if (event.deferredTo === "supervisor") console.log("  The supervisor may merge it.");
       console.log("  `ordewell handoff review|merge|discard|cleanup` to land it.");
@@ -1800,7 +1832,7 @@ Run finished on ${handoffBranch(event)}${where} \u2014 ${n} task${n === 1 ? "" :
   await start();
   const outcome = await Promise.race([stream, blockedSeen]).catch(streamFailed);
   if (outcome === "lost") {
-    console.error("Lost the connection to the daemon \u2014 the run is no longer being followed, but the daemon may still be running it. `ordewell status` shows where it stands.");
+    console.error("Lost the connection to the daemon: the run is no longer being followed, but the daemon may still be running it. `ordewell status` shows where it stands.");
     process.exit(1);
   }
   if (blocked === null) return;
@@ -1829,7 +1861,7 @@ async function handleRun(subArgs, injectedApi) {
 }
 
 // src/tui/blocks.ts
-var import_core13 = require("@ordewell/core");
+var import_core14 = require("@ordewell/core");
 
 // src/tui/ansi.ts
 var import_string_width = __toESM(require("string-width"));
@@ -2008,6 +2040,7 @@ var style = {
   dim: colour("2"),
   italic: colour("3"),
   underline: colour("4"),
+  strike: colour("9"),
   inverse: colour("7"),
   red: colour("31"),
   green: colour("32"),
@@ -2044,9 +2077,9 @@ var style = {
 };
 
 // src/tui/markdown.ts
-var import_core12 = require("@ordewell/core");
+var import_core13 = require("@ordewell/core");
 function renderMarkdown(source, cols) {
-  return blocks((0, import_core12.markdownTokens)(source), { room: Math.max(1, cols), base: [] });
+  return blocks((0, import_core13.markdownTokens)(source), { room: Math.max(1, cols), base: [] });
 }
 function closeOf(tokens, open) {
   const { level } = tokens[open];
@@ -2297,7 +2330,7 @@ function onBand(rows, cols) {
   return style.enabled ? band.map((row) => style.band(pad(row, cols))) : band;
 }
 function skillPaintedLines(text, skills, room) {
-  const tokens = (0, import_core13.loadedSkillTokens)(text, skills);
+  const tokens = (0, import_core14.loadedSkillTokens)(text, skills);
   return wrapLines(text, room).map(({ line, start }) => {
     let painted = "";
     let at = 0;
@@ -2393,16 +2426,16 @@ function resultLines(block2, room, detailAll) {
   const fit2 = (line) => detailAll ? wrap(line, room) : [truncate(line, room)];
   const outcome = unsettledOutcome(block2);
   if (outcome) {
-    const [reason, ...rest] = (0, import_core13.outputLines)(block2.output).map(sanitize);
+    const [reason, ...rest] = (0, import_core14.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_core13.outputLines)(block2.output).map(sanitize);
+    const lines2 = (0, import_core14.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_core13.outputPreview)(block2.output, PREVIEW_LINES);
+  const { lines, hiddenLineCount } = (0, import_core14.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)));
@@ -2416,7 +2449,7 @@ var DIFF_PAINT = {
 };
 var DIFF_SIGN = { added: "+", removed: "-", context: " ", gap: "" };
 function diffLines(block2, diff, room, detailAll) {
-  const rows = (0, import_core13.diffRows)(block2.output);
+  const rows = (0, import_core14.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)}`;
@@ -2425,7 +2458,7 @@ function diffLines(block2, 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_core13.diffSummary)(diff), ...shown.flatMap(draw), ...more];
+  return [(0, import_core14.diffSummary)(diff), ...shown.flatMap(draw), ...more];
 }
 function toolLines(block2, cols, detailAll) {
   const room = Math.max(1, cols - OUTPUT_INDENT.length);
@@ -2486,7 +2519,7 @@ var DECIDED_BY = {
 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 note = block2.note ? `: \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)}`;
 }
@@ -2529,7 +2562,7 @@ function runnerCommandLines(block2, cols, detailAll) {
   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_core13.outputLines)(block2.output).map(sanitize);
+  const printed = (0, import_core14.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))];
 }
@@ -2647,7 +2680,7 @@ function taskUsageText(usage) {
 
 // src/commands/status.ts
 var import_fs4 = require("fs");
-var import_core14 = require("@ordewell/core");
+var import_core15 = require("@ordewell/core");
 async function handleStatus(subArgs, injectedApi) {
   const sessionId = flag(subArgs, "--session-id");
   const workspace = flag(subArgs, "--workspace") || process.cwd();
@@ -2702,8 +2735,8 @@ function emitJson(payload, outputPath) {
 }
 function printOneSession(sessionId, meta, plan) {
   const allTasks = allTasksOf(plan);
-  const everyTask = (0, import_core14.flattenTasks)(allTasks);
-  const blocked = (0, import_core14.blockingFailures)(everyTask.map((t) => ({ ...t, subtasks: [], dependencies: t.dependencies ?? [] })));
+  const everyTask = (0, import_core15.flattenTasks)(allTasks);
+  const blocked = (0, import_core15.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}`);
@@ -2711,29 +2744,39 @@ 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_core14.planUsage)(allTasks);
+  const usage = (0, import_core15.planUsage)(allTasks);
   if (usage.attempts) console.log(`Tasks total: ${taskUsageText(usage)}`);
+  const record = servedApprovalRecord(plan);
+  const approval = (row, ref) => row.waitsForApproval ? `${row.waitsForApproval}: \`ordewell run-task ${ref}\` starts it, or \`ordewell run\` runs the plan` : null;
   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_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)}`);
+    console.log(`  ${(0, import_core15.taskOrderLabel)(t).padStart(2)}. ${icon} [${shortId}] ${t.title}${model}`);
+    const row = (0, import_core15.taskRowView)({ ...t, dependencies: t.dependencies ?? [], waitsForApproval: (0, import_core15.waitsForApproval)(t, record) }, { tasks: allTasks });
+    const waiting = approval(row, (0, import_core15.taskOrderLabel)(t));
+    if (waiting) console.log(`      ${waiting}`);
+    if (row.blockedBy) console.log(`      ${(0, import_core15.blockedByLabel)(row.blockedBy)}`);
+    if (row.status === "skipped") console.log(`      ${(0, import_core15.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_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)}`);
+      console.log(`    ${(0, import_core15.taskOrderLabel)(sub, t)}. ${subIcon} [${subShortId}] ${sub.title}${subModel}`);
+      const subRow = (0, import_core15.taskRowView)({ ...sub, dependencies: sub.dependencies ?? [], waitsForApproval: (0, import_core15.waitsForApproval)(sub, record) }, { parent: t, tasks: allTasks });
+      const subWaiting = approval(subRow, (0, import_core15.taskOrderLabel)(sub, t));
+      if (subWaiting) console.log(`        ${subWaiting}`);
+      if (subRow.blockedBy) console.log(`        ${(0, import_core15.blockedByLabel)(subRow.blockedBy)}`);
+      if (subRow.status === "skipped") console.log(`        ${(0, import_core15.skippedLabel)(subRow.skipReason)}`);
       if (subRow.usage) console.log(`        ${taskUsageText(subRow.usage)}`);
     }
   }
 }
+function servedApprovalRecord(plan) {
+  const approvedTasks = Array.isArray(plan?.approvedTasks) ? plan.approvedTasks.filter((id) => typeof id === "string") : void 0;
+  return { approved: plan?.approved === true, ...approvedTasks ? { approvedTasks } : {} };
+}
 
 // src/commands/stop.ts
 async function handleStop(subArgs) {
@@ -2782,10 +2825,32 @@ async function handleWeb(subArgs) {
 }
 
 // src/commands/models.ts
+var import_core18 = require("@ordewell/core");
+
+// src/commands/model.ts
+var import_core17 = require("@ordewell/core");
+
+// src/plannerModelSwitch.ts
 var import_core16 = require("@ordewell/core");
+function plannerSwitchRecall(settings) {
+  if (settings.switchRecall) return settings.switchRecall;
+  const model = settings.orchestratorModel;
+  return model ? { model, effort: settings.plannerThinkingEffort, source: "remembered" } : { model: "", effort: "", source: "none" };
+}
+function vendorModelRefusal(provider, model, pickPlanner) {
+  const meta = (0, import_core16.getProviderMeta)(provider);
+  if (!(0, import_core16.runnerForProvider)(provider) || !meta || !(0, import_core16.isVendorModelFor)(meta.id, model)) return null;
+  return `${model} is a vendor's model, which ${meta.label} cannot run. To plan with that vendor, switch planner with ${pickPlanner}.`;
+}
+function uninstalledPlannerRefusal(provider, installed, pickPlanner) {
+  const runner = (0, import_core16.runnerForProvider)(provider);
+  if (!runner || installed.includes(runner)) return null;
+  const agents = import_core16.CLI_PROVIDERS.filter((id) => installed.includes((0, import_core16.runnerForProvider)(id) ?? ""));
+  const label = (0, import_core16.getProviderMeta)(provider)?.label ?? provider;
+  return agents.length > 0 ? `${label} is not installed or not on PATH. Installed coding agents: ${agents.join(", ")}. Switch with ${pickPlanner}.` : `${label} is not installed or not on PATH, and no other coding agent is. Install one, or plan with an API provider through ${pickPlanner}.`;
+}
 
 // src/commands/model.ts
-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);
@@ -2800,7 +2865,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_core15.runnerForProvider)(provider);
+  const runner = (0, import_core17.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)) {
@@ -2809,6 +2874,8 @@ async function handleModel(subArgs, injectedApi) {
         `Run \`ordewell model\` to see what ${runner} offers.`
       );
     }
+    const refusal = known.length === 0 ? vendorModelRefusal(provider, modelId, import_core17.HEADLESS_CLI_COMMANDS.pickPlanner) : null;
+    if (refusal) fail(refusal);
   }
   const settled = await api.updateSettings({ orchestratorModel: modelId });
   const effort = typeof settled.plannerThinkingEffort === "string" ? settled.plannerThinkingEffort : "";
@@ -2823,14 +2890,14 @@ 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_core15.runnerForProvider)(provider);
+  const runner = (0, import_core17.runnerForProvider)(provider);
   const options = runner ? catalog.models.filter((m) => m.runners?.includes(runner)) : catalog.orchestratorModels;
   console.log(`
 Planner model: ${current || "(backend default)"}`);
-  console.log(`Planner backend: ${provider || "(default)"}${runner ? ` \u2014 showing ${runner} models only` : ""}
+  console.log(`Planner backend: ${provider || "(default)"}${runner ? `: showing ${runner} models only` : ""}
 `);
   if (options.length === 0) {
-    console.log(runner ? `  No ${runner} models discovered yet \u2014 try \`ordewell refresh\`.` : "  No models discovered. Configure a provider key with `ordewell key set <provider> <key>`.");
+    console.log(runner ? `  No ${runner} models discovered yet: try \`ordewell refresh\`.` : "  No models discovered. Configure a provider key with `ordewell key set <provider> <key>`.");
   }
   for (const m of options) {
     const detail = [
@@ -2839,7 +2906,7 @@ Planner model: ${current || "(backend default)"}`);
       m.variants?.length ? `${m.variants.length} effort level${m.variants.length === 1 ? "" : "s"}` : void 0
     ].filter(Boolean).join(" \xB7 ");
     console.log(`  ${m.id === current ? "*" : " "} ${m.id}`);
-    if (detail) console.log(`      ${m.label} \u2014 ${detail}`);
+    if (detail) console.log(`      ${m.label}: ${detail}`);
   }
   const failed = Object.entries(catalog.providerErrors);
   for (const [id, message] of failed) {
@@ -2857,8 +2924,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_core16.EnvConfig();
-  const providers = (0, import_core16.configuredProviders)(config);
+  const config = new import_core18.EnvConfig();
+  const providers = (0, import_core18.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)");
@@ -2867,19 +2934,19 @@ async function handleModels(subArgs) {
     console.error("  OPENAI_COMPATIBLE_BASE_URL=...  (self-hosted / OpenAI-compatible)");
     process.exit(1);
   }
-  const { apiKeys, baseUrls } = (0, import_core16.collectProviderCredentials)(config);
+  const { apiKeys, baseUrls } = (0, import_core18.collectProviderCredentials)(config);
   let models;
   let errors;
   try {
-    const result = await (0, import_core16.fetchAllProviderModels)({ apiKeys, baseUrls });
-    models = (0, import_core16.toOrchestratorOptions)(result.models, import_core16.ORCHESTRATOR_SHORTCUTS);
+    const result = await (0, import_core18.fetchAllProviderModels)({ apiKeys, baseUrls });
+    models = (0, import_core18.toOrchestratorOptions)(result.models, import_core18.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_core16.getProviderMeta)(p)?.label ?? p;
+  const providerLabel = (p) => (0, import_core18.getProviderMeta)(p)?.label ?? p;
   console.log(
     `
 Available models (${models.length}) across ${providers.length} configured provider(s):`
@@ -2919,7 +2986,7 @@ ${providerLabel(provider)}`);
 
 // src/commands/setup.ts
 var import_fs6 = require("fs");
-var import_core17 = require("@ordewell/core");
+var import_core19 = require("@ordewell/core");
 function handleSetup(subArgs) {
   const modelIdx = subArgs.indexOf("--model");
   const chosenModel = modelIdx !== -1 ? subArgs[modelIdx + 1] : null;
@@ -2962,7 +3029,7 @@ function handleSetup(subArgs) {
 # OPENAI_COMPATIBLE_BASE_URL=http://localhost:11434/v1
 # OPENAI_COMPATIBLE_API_KEY=your-key-here
 
-# Or plan with a coding agent you already have installed \u2014 no API key needed,
+# Or plan with a coding agent you already have installed: no API key needed,
 # it uses that agent's own subscription. Set the model to one of its own.
 # AI_PROVIDER=${runnerIdChoice()}
 # ORCHESTRATOR_MODEL=haiku
@@ -2991,13 +3058,13 @@ function handleSetup(subArgs) {
 # STEPFUN_API_KEY=...
 # SILICONFLOW_API_KEY=...
 `;
-  (0, import_core17.writePrivateFile)(envFile, content);
+  (0, import_core19.writePrivateFile)(envFile, content);
   console.log(`Wrote: ${envFile}`);
   console.log("Review and edit the file, then run: ordewell tui");
 }
 
 // src/commands/skills.ts
-var import_core18 = require("@ordewell/core");
+var import_core20 = require("@ordewell/core");
 var import_path5 = require("path");
 function invocation(skill) {
   if (skill.userInvocable && skill.modelInvocable) return "both";
@@ -3010,22 +3077,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_core18.createSkillsService)(workspace, new import_core18.EnvConfig().workspaceRepos).readCatalog();
+  const catalog = (0, import_core20.createSkillsService)(workspace, new import_core20.EnvConfig().workspaceRepos).readCatalog();
   const skills = catalog.skills.map((skill) => ({
     name: skill.name,
     scope: skill.source,
     appliesTo: skill.appliesTo,
     invocation: invocation(skill),
-    path: (0, import_core18.abbreviateHome)(skill.path)
+    path: (0, import_core20.abbreviateHome)(skill.path)
   }));
   const shadowed = catalog.shadowed.map(({ skill, shadowedBy }) => ({
     name: skill.name,
-    path: (0, import_core18.abbreviateHome)(skill.path),
-    shadowedBy: { scope: shadowedBy.source, path: (0, import_core18.abbreviateHome)(shadowedBy.path) }
+    path: (0, import_core20.abbreviateHome)(skill.path),
+    shadowedBy: { scope: shadowedBy.source, path: (0, import_core20.abbreviateHome)(shadowedBy.path) }
   }));
   const invalid = catalog.invalid.map((skill) => ({
     name: skill.name,
-    path: (0, import_core18.abbreviateHome)(skill.path),
+    path: (0, import_core20.abbreviateHome)(skill.path),
     reason: skill.reason
   }));
   if (hasFlag(subArgs, "--json")) {
@@ -3140,7 +3207,7 @@ async function handleShow(args, api) {
 }
 
 // src/commands/task-control.ts
-var import_core19 = require("@ordewell/core");
+var import_core21 = require("@ordewell/core");
 var PAST_TENSE = {
   run: "Task started.",
   "force-start": "Task force-started.",
@@ -3183,8 +3250,8 @@ 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_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.");
+  const question = `${(0, import_core21.pastGateConfirmation)(unmerged.map((d) => (0, import_core21.titledTaskRef)(d)))} Start it anyway?`;
+  if (!await confirm2(question)) fail("Not started: nothing was changed. Pass --yes to start it without a prompt.");
 }
 function makeHandler(action, command = action) {
   const yes = PASSES_GATE.has(action) ? " [--yes]" : "";
@@ -3232,7 +3299,7 @@ async function handleCheckpoint(subArgs, injectedApi) {
     process.exit(1);
   }
   if (answer === "approve" && reason) {
-    console.error(`Approving takes no note \u2014 reject with a reason to tell the task something.
+    console.error(`Approving takes no note: reject with a reason to tell the task something.
 ${usage}`);
     process.exit(1);
   }
@@ -3293,7 +3360,7 @@ async function handleSkip(subArgs, api) {
     async (client, sessionId, taskId) => {
       try {
         await client.skipTask(sessionId, taskId, flag(subArgs, "--reason"));
-        console.log("Task skipped: none of its work lands, and the tasks that depend on it go ahead without it.");
+        console.log("Task skipped: none of its work lands, and the tasks that depend on it go ahead without it once the work it waited on is done.");
       } catch (err) {
         console.error(`Failed to skip task: ${err.message}`);
         process.exit(1);
@@ -3401,7 +3468,7 @@ async function handleSessions(subArgs, injectedApi) {
     }
     const { meta } = session;
     saveLastSession(meta.id, meta.goal, meta.runners || [], workspace);
-    console.log(`Loaded session ${meta.id} ("${meta.goal}") \u2014 ${meta.taskCount} tasks, status ${meta.status}.`);
+    console.log(`Loaded session ${meta.id} ("${meta.goal}"): ${meta.taskCount} tasks, status ${meta.status}.`);
     console.log("  `ordewell status` for detail, `ordewell run` to execute.");
     return;
   }
@@ -3425,7 +3492,7 @@ async function handleSessions(subArgs, injectedApi) {
 }
 
 // src/commands/conversation.ts
-var REWIND_USAGE = "Usage: ordewell rewind [<n>] [--session-id <id>] [--workspace /path] \u2014 with no <n>, lists the messages you can rewind to.";
+var REWIND_USAGE = "Usage: ordewell rewind [<n>] [--session-id <id>] [--workspace /path]: with no <n>, lists the messages you can rewind to.";
 async function adopted(subArgs, injectedApi) {
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   const sessionId = resolveSessionId(subArgs);
@@ -3447,7 +3514,7 @@ async function handleFork(subArgs, injectedApi) {
     fail(`Failed to fork: ${err.message}`);
   }
   saveLastSession(fork.sessionId, fork.goal, fork.plan.runners ?? [], workspace);
-  console.log(`Forked ${sessionId} into ${fork.sessionId} \u2014 the fork is now the current session.`);
+  console.log(`Forked ${sessionId} into ${fork.sessionId}: the fork is now the current session.`);
   console.log(`  \`ordewell sessions load ${sessionId}\` to go back to the original.`);
 }
 async function handleCompact(subArgs, injectedApi) {
@@ -3456,7 +3523,7 @@ async function handleCompact(subArgs, injectedApi) {
   try {
     result = await api.compactConversation(sessionId);
   } catch (err) {
-    fail(`Failed to condense: ${err.message}`);
+    fail(`Failed to condense: ${headlessPlannerRefusal(err) ?? err.message}`);
   }
   console.log(`Condensed ${sessionId}. The last two exchanges were kept as they were; the tasks are unchanged.
 `);
@@ -3474,7 +3541,7 @@ async function handleRewind(subArgs, injectedApi) {
       fail(`Failed to list messages: ${err.message}`);
     }
     if (targets.length === 0) {
-      console.log("Nothing to rewind to yet \u2014 the only message so far is the goal.");
+      console.log("Nothing to rewind to yet: the only message so far is the goal.");
       return;
     }
     console.log("Your messages, most recent first:\n");
@@ -3489,31 +3556,31 @@ async function handleRewind(subArgs, injectedApi) {
     fail(`Failed to rewind: ${err.message}`);
   }
   saveLastSession(fork.sessionId, fork.goal, fork.plan.runners ?? [], workspace);
-  console.log(`Forked ${sessionId} into ${fork.sessionId} from just before message ${arg} \u2014 the fork is now the current session.`);
+  console.log(`Forked ${sessionId} into ${fork.sessionId} from just before message ${arg}. The fork is now the current session.`);
   console.log(`  \`ordewell sessions load ${sessionId}\` to go back to the original.`);
   console.log("\nThe message you rewound to, to resend or edit:\n");
   console.log(fork.rewoundMessage);
 }
 
 // src/tui/transcript.ts
-var import_core20 = require("@ordewell/core");
+var import_core22 = 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_core20.reduceConversation)(state.conversation, input), gate: state.turnGate });
+  return show(state, { view: (0, import_core22.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_core20.followTurn)(state.conversation, state.turnGate, message));
+  return show(state, (0, import_core22.followTurn)(state.conversation, state.turnGate, message));
 }
 function cutTurn(state) {
-  return show(state, (0, import_core20.stopTurn)(state.conversation, state.turnGate));
+  return show(state, (0, import_core22.stopTurn)(state.conversation, state.turnGate));
 }
 function wiped(view) {
   return { ...view, blocks: view.blocks.filter((b) => b.type === "usage") };
@@ -3522,16 +3589,16 @@ function wiped(view) {
 // src/tui/handoff.ts
 var HANDOFF_ACTIONS = [
   { id: "review", label: "Review diff", hint: "the branch against the commit it forked from" },
-  { id: "merge", label: "Merge", hint: "into the branch you have checked out \u2014 asks first" },
-  { id: "discard", label: "Discard", hint: "the run, its worktrees and this branch \u2014 asks first" },
+  { id: "merge", label: "Merge", hint: "into the branch you have checked out (asks first)" },
+  { id: "discard", label: "Discard", hint: "the run, its worktrees and this branch (asks first)" },
   { id: "cleanup", label: "Clean up", hint: "remove worktrees and task branches, keep this branch" }
 ];
 function handoffActions(handoff) {
   if (!isRepoGroup(handoff)) return HANDOFF_ACTIONS;
   return [
     { id: "review", label: "Review diff", hint: "each repository's branch against the commit it forked from" },
-    { id: "merge", label: "Merge all", hint: "every repository's branch into what you have checked out there \u2014 asks first" },
-    { id: "discard", label: "Discard", hint: "the run, its worktrees and every repository's branch \u2014 asks first" },
+    { id: "merge", label: "Merge all", hint: "every repository's branch into what you have checked out there (asks first)" },
+    { id: "discard", label: "Discard", hint: "the run, its worktrees and every repository's branch (asks first)" },
     { id: "cleanup", label: "Clean up", hint: "remove worktrees and task branches everywhere, keep the integration branches" }
   ];
 }
@@ -3544,7 +3611,7 @@ function currentHandoff(state) {
 }
 var midRun = (state) => state.status === "executing";
 function handoffCommand(state, arg) {
-  if (!state.sessionId || !currentHandoff(state)) return fail2(state, "No isolated run to hand off \u2014 a plan that ran in worktrees leaves one here.");
+  if (!state.sessionId || !currentHandoff(state)) return fail2(state, "No isolated run to hand off: a plan that ran in worktrees leaves one here.");
   if (arg === void 0) return { state: { ...state, overlay: { kind: "handoff", index: 0, diff: null } }, effects: [] };
   const action = HANDOFF_ACTIONS.find((a) => a.id === arg.toLowerCase());
   if (!action) return fail2(state, `Usage: ${HANDOFF_USAGE}`);
@@ -3557,13 +3624,13 @@ function handoffArrived(state, handoff) {
   const tasks = `${landed} task${landed === 1 ? "" : "s"} landed`;
   const received = { ...state, handoff };
   if (handoff.deferredTo === "supervisor") {
-    return say(received, "system", `Run finished on ${branch}${where} \u2014 ${tasks}. The supervisor may merge it; /handoff to review it yourself.`);
+    return say(received, "system", `Run finished on ${branch}${where}: ${tasks}. The supervisor may merge it; /handoff to review it yourself.`);
   }
   const returned = state.handoff?.deferredTo === "supervisor" && handoffBranch(state.handoff) === branch;
   const told = say(
     received,
     "system",
-    returned ? `The supervisor left ${branch}${where} to you \u2014 ${tasks}. /handoff to review and land it.` : `Run finished on ${branch}${where} \u2014 ${tasks}. /handoff to review and land it.`
+    returned ? `The supervisor left ${branch}${where} to you: ${tasks}. /handoff to review and land it.` : `Run finished on ${branch}${where}: ${tasks}. /handoff to review and land it.`
   );
   return state.overlay ? told : { ...told, overlay: { kind: "handoff", index: 0, diff: null } };
 }
@@ -3601,12 +3668,12 @@ function runHandoffAction(state, id) {
           overlay: isRepoGroup(handoff) ? {
             kind: "confirm",
             title: "Merge all into your branches?",
-            message: `Merge ${handoffBranch(handoff)} into whatever each of ${reposWithWork(handoff).join(", ")} has checked out. It checks every repository first and merges none unless every repository can take it; on git older than 2.38 it goes repository by repository and stops at the first that fails. A merge that conflicts is aborted, and your trees stay as they were. Once every repository has merged, the run's worktrees and branches are removed \u2014 unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
+            message: `Merge ${handoffBranch(handoff)} into whatever each of ${reposWithWork(handoff).join(", ")} has checked out. It checks every repository first and merges none unless every repository can take it; on git older than 2.38 it goes repository by repository and stops at the first that fails. A merge that conflicts is aborted, and your trees stay as they were. Once every repository has merged, the run's worktrees and branches are removed unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
             action: { kind: "merge-run" }
           } : {
             kind: "confirm",
             title: "Merge into your branch?",
-            message: `Merge ${handoffBranch(handoff)} into whatever you have checked out. If it conflicts the merge is aborted and your tree stays as it was. Once it has merged, the run's worktrees and branches are removed \u2014 unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
+            message: `Merge ${handoffBranch(handoff)} into whatever you have checked out. If it conflicts the merge is aborted and your tree stays as it was. Once it has merged, the run's worktrees and branches are removed unless a task still has work in its worktree that has not landed: then the run stays, and so does that work.${repairedNotice(handoff)}`,
             action: { kind: "merge-run" }
           }
         },
@@ -3619,7 +3686,7 @@ function runHandoffAction(state, id) {
           overlay: {
             kind: "confirm",
             title: "Discard this run?",
-            message: `Removes the run's worktrees and task branches and deletes ${handoffBranch(handoff)}${isRepoGroup(handoff) ? ` in ${reposOf2(handoff)}` : ""}. Tasks keep their status \u2014 mark one not done if you did not keep its work.`,
+            message: `Removes the run's worktrees and task branches and deletes ${handoffBranch(handoff)}${isRepoGroup(handoff) ? ` in ${reposOf2(handoff)}` : ""}. Tasks keep their status: mark one not done if you did not keep its work.`,
             action: { kind: "discard-run" }
           }
         },
@@ -3714,7 +3781,7 @@ async function handleHandoff(subArgs, injectedApi, confirm2 = askYesNo) {
   if (action === void 0) {
     console.log(`${USAGE4}
 `);
-    for (const a of HANDOFF_ACTIONS) console.log(`  ${a.id.padEnd(8)} ${a.label} \u2014 ${a.hint}`);
+    for (const a of HANDOFF_ACTIONS) console.log(`  ${a.id.padEnd(8)} ${a.label}: ${a.hint}`);
     return;
   }
   if (!HANDOFF_ACTIONS.some((a) => a.id === action)) fail(`Unknown handoff action "${action}".`, USAGE4);
@@ -3727,7 +3794,7 @@ async function handleHandoff(subArgs, injectedApi, confirm2 = askYesNo) {
   const asked = hasFlag(subArgs, "--yes");
   const confirmed = async (question) => {
     if (asked || await confirm2(question)) return;
-    fail("Not confirmed \u2014 nothing was changed. Pass --yes to confirm without a prompt.");
+    fail("Not confirmed: nothing was changed. Pass --yes to confirm without a prompt.");
   };
   const attempt = async (work) => {
     try {
@@ -3762,16 +3829,7 @@ async function handleHandoff(subArgs, injectedApi, confirm2 = askYesNo) {
 }
 
 // src/commands/planner.ts
-var import_core21 = require("@ordewell/core");
-
-// src/plannerModelSwitch.ts
-function plannerSwitchRecall(settings) {
-  if (settings.switchRecall) return settings.switchRecall;
-  const model = settings.orchestratorModel;
-  return model ? { model, effort: settings.plannerThinkingEffort, source: "remembered" } : { model: "", effort: "", source: "none" };
-}
-
-// src/commands/planner.ts
+var import_core23 = require("@ordewell/core");
 async function handlePlanner(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
   const [wanted] = positionals(subArgs);
@@ -3780,20 +3838,25 @@ async function handlePlanner(subArgs, injectedApi) {
     return;
   }
   const provider = wanted.toLowerCase();
-  const meta = (0, import_core21.getProviderMeta)(provider);
+  const meta = (0, import_core23.getProviderMeta)(provider);
   if (!meta) {
     fail(`Unknown planner: ${provider}`, "Run `ordewell planner` with no arguments to see the list.");
   }
+  if ((0, import_core23.isCliProvider)(provider)) {
+    const installed = (await api.getRunners()).runners.map((r) => r.id);
+    const refusal = uninstalledPlannerRefusal(provider, installed, import_core23.HEADLESS_CLI_COMMANDS.pickPlanner);
+    if (refusal) fail(refusal);
+  }
   const settings = await persistEnv(api, { AI_PROVIDER: provider });
   const recall2 = plannerSwitchRecall(settings);
   writeEnv({ ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
   const catalog = await fetchCatalog(api);
   console.log(
-    (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}.`
+    (0, import_core23.isCliProvider)(provider) ? `Planning with ${meta.label}: no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
   );
   console.log(plannerModelLine(recall2));
-  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>\`.`);
+  if ((0, import_core23.isApiProvider)(provider) && !catalog.providers.includes(provider)) {
+    console.log(`  No ${meta.apiKeyEnvVar} configured yet: set one with \`ordewell key set ${provider} <key>\`.`);
   }
 }
 function plannerModelLine(recall2) {
@@ -3801,7 +3864,7 @@ function plannerModelLine(recall2) {
     case "remembered":
       return `  Restored its planner model: ${recall2.model}.`;
     case "catalog-default":
-      return `  Using ${recall2.model}, its default model \u2014 pick another with \`ordewell model set <id>\`.`;
+      return `  Using ${recall2.model}, its default model: pick another with \`ordewell model set <id>\`.`;
     case "none":
       return "  Pick a model with `ordewell model set <id>`, or leave it on the default.";
   }
@@ -3809,16 +3872,16 @@ function plannerModelLine(recall2) {
 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_core21.CLI_PROVIDERS) {
-    const runner = (0, import_core21.runnerForProvider)(id);
+  console.log("\nCoding agents (no API key; they use their own subscription)");
+  for (const id of import_core23.CLI_PROVIDERS) {
+    const runner = (0, import_core23.runnerForProvider)(id);
     const discovered = runner ? catalog.models.some((m) => m.runners?.includes(runner)) : false;
-    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${(0, import_core21.getProviderMeta)(id)?.label ?? id}${discovered ? "" : "  (not detected)"}`);
+    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${(0, import_core23.getProviderMeta)(id)?.label ?? id}${discovered ? "" : "  (not detected)"}`);
   }
   console.log("\nAPI providers");
-  for (const id of import_core21.PROVIDER_PRIORITY) {
+  for (const id of import_core23.PROVIDER_PRIORITY) {
     const configured = catalog.providers.includes(id);
-    const meta = (0, import_core21.getProviderMeta)(id);
+    const meta = (0, import_core23.getProviderMeta)(id);
     console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${meta.label}${configured ? "" : `  (no ${meta.apiKeyEnvVar})`}`);
   }
   console.log(`
@@ -3835,7 +3898,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
   const provider = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   const modelId = typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : "";
   const currentEffort = typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : "";
-  const runner = (0, import_core21.runnerForProvider)(provider);
+  const runner = (0, import_core23.runnerForProvider)(provider);
   if (!runner) {
     fail(
       "Thinking effort applies to a coding-agent planner.",
@@ -3847,7 +3910,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
   if (!wanted || wanted === "show") {
     console.log(`Planner effort: ${currentEffort || "runner default"}`);
     if (!model) {
-      console.log(`  No planner model selected for ${runner} \u2014 pick one with \`ordewell model set <id>\`.`);
+      console.log(`  No planner model selected for ${runner}: pick one with \`ordewell model set <id>\`.`);
     } else if (variants.length === 0) {
       console.log(`  ${model.label} exposes no effort levels; it always runs at the agent's default.`);
     } else {
@@ -3875,7 +3938,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
 }
 
 // src/commands/parallel.ts
-var import_core22 = require("@ordewell/core");
+var import_core24 = require("@ordewell/core");
 var USAGE5 = "Usage: ordewell parallel [<number of tasks, 1 or more>]";
 async function handleParallel(subArgs, injectedApi) {
   const [wanted] = positionals(subArgs);
@@ -3885,14 +3948,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_core22.parseMaxParallel)(wanted);
+  const limit = (0, import_core24.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_core23 = require("@ordewell/core");
+var import_core25 = 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]";
@@ -3903,28 +3966,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_core23.parseCount)(value, 0), (n) => ({ supervisorRetryLimit: n }));
-  else if (arg === "reads") changes = maybe((0, import_core23.parseCount)(value, 1), (n) => ({ wakeUpReadBudget: n }));
+  else if (arg === "retries") changes = maybe((0, import_core25.parseCount)(value, 0), (n) => ({ supervisorRetryLimit: n }));
+  else if (arg === "reads") changes = maybe((0, import_core25.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_core23.supervisorSummary)((await api.getSettings()).run));
+    console.log((0, import_core25.supervisorSummary)((await api.getSettings()).run));
     console.log(`  ${SUPERVISOR_USAGE}`);
     return;
   }
   await save(api, changes);
-  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.supervisorLevel) console.log(`Supervisor: ${import_core25.SUPERVISOR_LEVEL_LABEL[changes.supervisorLevel]}, from each session's next run.`);
+  if (changes.supervisorLevel === "act") console.log(import_core25.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_core23.parseSwitch)(arg);
+  const enabled = arg === void 0 ? null : (0, import_core25.parseSwitch)(arg);
   if (arg !== void 0 && enabled === null) fail(AUTOMERGE_USAGE);
   const api = await connect(subArgs, injectedApi);
   if (enabled === null) {
-    console.log((0, import_core23.automergeSummary)((await api.getSettings()).run));
+    console.log((0, import_core25.automergeSummary)((await api.getSettings()).run));
     console.log(`  ${AUTOMERGE_USAGE}`);
     return;
   }
@@ -3933,24 +3996,24 @@ async function handleAutomerge(subArgs, injectedApi) {
 }
 async function handleAutorun(subArgs, injectedApi) {
   const [arg] = positionals(subArgs);
-  const enabled = arg === void 0 ? null : (0, import_core23.parseSwitch)(arg);
+  const enabled = arg === void 0 ? null : (0, import_core25.parseSwitch)(arg);
   if (arg !== void 0 && enabled === null) fail(AUTORUN_USAGE);
   const api = await connect(subArgs, injectedApi);
   if (enabled === null) {
-    console.log((0, import_core23.autorunSummary)((await api.getSettings()).run));
+    console.log((0, import_core25.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_core23.AUTORUN_RISK);
+  console.log(`Autorun: ${enabled ? "on: each plan the planner submits starts at once" : "off: plans wait for your review"}.`);
+  if (enabled) console.log(import_core25.AUTORUN_RISK);
 }
 function maybe(n, wrap2) {
   return n === null ? null : wrap2(n);
 }
 
 // src/commands/key.ts
-var import_core24 = require("@ordewell/core");
+var import_core26 = require("@ordewell/core");
 var USAGE6 = "Usage: ordewell key [list | set <provider> <key>]";
 async function handleKey(subArgs, injectedApi) {
   const [action, provider, ...keyParts] = positionals(subArgs);
@@ -3961,8 +4024,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_core24.PROVIDER_PRIORITY) {
-      const meta2 = (0, import_core24.getProviderMeta)(id2);
+    for (const id2 of import_core26.PROVIDER_PRIORITY) {
+      const meta2 = (0, import_core26.getProviderMeta)(id2);
       const configured = catalog.providers.includes(id2);
       console.log(`  ${configured ? "\u2713" : " "} ${id2.padEnd(14)} ${meta2.apiKeyEnvVar.padEnd(28)} ${meta2.label}`);
     }
@@ -3972,10 +4035,10 @@ async function handleKey(subArgs, injectedApi) {
   }
   if (!provider) fail(USAGE6);
   const id = provider.toLowerCase();
-  if (!(0, import_core24.isApiProvider)(id)) {
+  if (!(0, import_core26.isApiProvider)(id)) {
     fail(`Unknown provider: ${provider}`, "Run `ordewell key` to see the list.");
   }
-  const meta = (0, import_core24.getProviderMeta)(id);
+  const meta = (0, import_core26.getProviderMeta)(id);
   const key = keyParts.join(" ").trim();
   if (!key) fail(`Usage: ordewell key set ${id} <key>`);
   await persistEnv(api, { [meta.apiKeyEnvVar]: key });
@@ -3983,7 +4046,7 @@ async function handleKey(subArgs, injectedApi) {
 }
 
 // src/commands/runners.ts
-var import_core25 = require("@ordewell/core");
+var import_core27 = require("@ordewell/core");
 var USAGE7 = "Usage: ordewell runners [<runner-id> on|off]";
 async function handleRunners(subArgs, injectedApi) {
   const [runner, toggle] = positionals(subArgs);
@@ -3994,7 +4057,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_core25.codexSandboxNotice)((await fetchCatalog(api).catch(() => null))?.modesByRunner);
+    const notice = (0, import_core27.codexSandboxNotice)((await fetchCatalog(api).catch(() => null))?.modesByRunner);
     if (notice) console.log(`
   ${notice.line}
   ${notice.docs}`);
@@ -4015,17 +4078,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_core25.SettingsService();
+  const settings = new import_core27.SettingsService();
   const current = settings.autonomousMode();
   if (!arg) {
-    console.log(`Autonomy level: ${(0, import_core25.autonomyLevelLabel)(current)}`);
+    console.log(`Autonomy level: ${(0, import_core27.autonomyLevelLabel)(current)}`);
     console.log(`  ${AUTO_USAGE}`);
     return;
   }
-  const enabled = (0, import_core25.parseAutonomyLevel)(arg);
+  const enabled = (0, import_core27.parseAutonomyLevel)(arg);
   if (enabled === null) fail(AUTO_USAGE);
   settings.setAutonomousMode(enabled);
-  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.`);
+  console.log(settings.autonomousModeOverridden() ? `${(0, import_core27.autonomyLevelLabel)(enabled)} is saved, but ORDEWELL_AUTONOMOUS_MODE in the environment decides the level until it is unset.` : `Autonomy level: ${(0, import_core27.autonomyLevelLabel)(enabled)} for new plans.`);
 }
 async function handleRefresh(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
@@ -4050,12 +4113,12 @@ async function handleApprove(subArgs, injectedApi) {
       console.error(`Failed to approve: ${err.message}`);
       process.exit(1);
     }
-    console.error("Plan approved \u2014 continuing execution.");
+    console.error("Plan approved: continuing execution.");
   });
 }
 
 // src/commands/task-assign.ts
-var import_core27 = require("@ordewell/core");
+var import_core29 = require("@ordewell/core");
 var import_plan_utils = require("@ordewell/core/plan-utils");
 
 // src/tui/taskAssignment.ts
@@ -4095,7 +4158,7 @@ function modesForTask(modesByRunner, task) {
 }
 
 // src/tui/state.ts
-var import_core26 = require("@ordewell/core");
+var import_core28 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -4253,7 +4316,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_core26.isTaskRunning);
+var anyTaskRunning = (state) => state.tasks.some(import_core28.isTaskRunning);
 var plannerInFlight = (state) => state.planner !== "idle";
 var planPaneOpen = (state) => state.focus === "plan" && !state.overlay && (!!state.taskEditor || !!state.expandedTaskId);
 function planRows(state) {
@@ -4299,10 +4362,10 @@ function findTask(tasks, id) {
   return void 0;
 }
 function refFor(state, task) {
-  return (0, import_core26.taskRefOf)(state.tasks, task.id) ?? (0, import_core26.taskRef)(task);
+  return (0, import_core28.taskRefOf)(state.tasks, task.id) ?? (0, import_core28.taskRef)(task);
 }
 function titledRefFor(state, task) {
-  return (0, import_core26.titledTaskRefOf)(state.tasks, task.id) ?? (0, import_core26.titledTaskRef)(task);
+  return (0, import_core28.titledTaskRefOf)(state.tasks, task.id) ?? (0, import_core28.titledTaskRef)(task);
 }
 function asRunTasks(tasks) {
   return tasks.map((task) => ({ ...task, subtasks: asRunTasks(task.subtasks ?? []) }));
@@ -4310,7 +4373,7 @@ function asRunTasks(tasks) {
 function seedRun(overrides) {
   if (overrides.run) return overrides.run;
   return {
-    ...import_core26.EMPTY_RUN,
+    ...import_core28.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
@@ -4319,9 +4382,9 @@ function seedRun(overrides) {
 function initialState(overrides = {}) {
   return {
     editor: emptyEditor(),
-    conversation: import_core26.EMPTY_CONVERSATION,
+    conversation: import_core28.EMPTY_CONVERSATION,
     taskView: null,
-    turnGate: import_core26.NO_TURN,
+    turnGate: import_core28.NO_TURN,
     detailAll: false,
     status: "idle",
     planner: "idle",
@@ -4347,11 +4410,15 @@ function initialState(overrides = {}) {
     plannerProvider: "",
     plannerEffort: "",
     plannerModels: {},
-    maxParallel: import_core26.DEFAULT_MAX_PARALLEL,
+    maxParallel: import_core28.DEFAULT_MAX_PARALLEL,
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
-    runSettings: { ...import_core26.RUN_SETTINGS_DEFAULTS },
+    runSettings: { ...import_core28.RUN_SETTINGS_DEFAULTS },
+    runSettingsKnown: false,
+    plannerKnown: false,
+    runnersKnown: false,
+    providersKnown: false,
     runAutoMerge: null,
     runSupervisor: null,
     mouseCapture: true,
@@ -4361,7 +4428,7 @@ function initialState(overrides = {}) {
     runMerge: null,
     overlay: null,
     pendingApprovals: [],
-    queuedPrompts: import_core26.EMPTY_HOLD,
+    queuedPrompts: import_core28.EMPTY_HOLD,
     stopArmed: false,
     stopArmToken: 0,
     stopRequested: false,
@@ -4411,7 +4478,7 @@ Runner \xB7 ${namedOf(tasks, task)}
       fail(`Unknown runner: ${runner}`, `This daemon knows: ${state.runners.map((r) => r.id).join(", ")}`);
     }
     await api.updateTask(sessionId, task.id, { assignedRunner: runner });
-    console.log(`Task ${refOf(tasks, task)} runner set to ${runner} \u2014 its model, effort and mode were re-picked for it.`);
+    console.log(`Task ${refOf(tasks, task)} runner set to ${runner}: its model, effort and mode were re-picked for it.`);
   });
 }
 var MODEL_USAGE = "Usage: ordewell task-model <task-id-or-order> [<model-id>] [--session-id <id>]";
@@ -4423,11 +4490,11 @@ async function handleTaskModel(subArgs, injectedApi) {
       console.log(`
 Model \xB7 ${namedOf(tasks, task)}${task.assignedRunner ? ` (${task.assignedRunner})` : ""}
 `);
-      if (options.length === 0) console.log("  No models discovered for this runner \u2014 try `ordewell refresh`.");
+      if (options.length === 0) console.log("  No models discovered for this runner: try `ordewell refresh`.");
       for (const m of options) {
         const detail = [m.provider, m.variants?.length ? `${m.variants.length} effort levels` : "runner default effort"].filter(Boolean).join(" \xB7 ");
         console.log(`  ${m.id === task.assignedModel?.modelId ? "*" : " "} ${m.id}`);
-        console.log(`      ${m.label} \u2014 ${detail}`);
+        console.log(`      ${m.label}: ${detail}`);
       }
       console.log(`
   ${MODEL_USAGE}`);
@@ -4493,9 +4560,9 @@ Mode \xB7 ${namedOf(tasks, task)}${task.assignedRunner ? ` (${task.assignedRunne
         console.log("  This task has no runner, or its runner declares no modes.");
       }
       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}` : ""}`);
+        console.log(`  ${m.id === task.taskMode ? "*" : " "} ${m.id.padEnd(14)} ${m.label}${m.unavailable ? ": unavailable on this host" : m.description ? `: ${m.description}` : ""}`);
       }
-      const notice = (0, import_core27.codexSandboxNotice)(catalog.modesByRunner);
+      const notice = (0, import_core29.codexSandboxNotice)(catalog.modesByRunner);
       if (notice) console.log(`
   ${notice.line}
   ${notice.docs}`);
@@ -4544,7 +4611,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_core27.createSkillsService)(flag(subArgs, "--workspace") || process.cwd(), new import_core27.EnvConfig().workspaceRepos).listSkills().filter((s) => s.appliesTo === "task");
+    const catalog = (0, import_core29.createSkillsService)(flag(subArgs, "--workspace") || process.cwd(), new import_core29.EnvConfig().workspaceRepos).listSkills().filter((s) => s.appliesTo === "task");
     if (!value) {
       console.log(`
 Skills \xB7 ${namedOf(tasks, task)}
@@ -4581,7 +4648,7 @@ ${namedOf(tasks, task)} is ${task.ops ? "an ops task: it runs in your checkout o
     }
     const to = value.toLowerCase();
     if (to !== "on" && to !== "off") fail(OPS_USAGE);
-    if (task.type !== "ai") fail("Only an AI task can be an ops task \u2014 a manual task already runs outside any worktree.");
+    if (task.type !== "ai") fail("Only an AI task can be an ops task: a manual task already runs outside any worktree.");
     if (!tasks.some((t) => t.id === task.id)) fail("A subtask runs with its parent; make the parent an ops task instead.");
     await api.updateTask(sessionId, task.id, { ops: to === "on" });
     console.log(to === "on" ? `Task ${refOf(tasks, task)} is an ops task: it runs in your checkout once the work it depends on is merged.` : `Task ${refOf(tasks, task)} is a change task: it runs in its own worktree.`);
@@ -4589,10 +4656,10 @@ ${namedOf(tasks, task)} is ${task.ops ? "an ops task: it runs in your checkout o
 }
 
 // src/tui/index.ts
-var import_core48 = require("@ordewell/core");
+var import_core51 = require("@ordewell/core");
 
 // src/tui/slash.ts
-var import_core28 = require("@ordewell/core");
+var import_core30 = 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.
@@ -4618,9 +4685,9 @@ var SLASH_COMMANDS = [
   { name: "task-mode", usage: "/task-mode <id> [mode]", description: "Choose or set a task's runner mode", category: "tasks" },
   { name: "task-deps", usage: "/task-deps <id>", description: "Edit which earlier tasks a task waits for", category: "tasks" },
   { name: "task-skills", usage: "/task-skills <id> [a,b|none]", description: "Choose or set the skills attached to a task; none clears them", category: "tasks" },
-  { name: "task-ops", usage: "/task-ops <id> [on|off]", description: "Make a task an ops task \u2014 run in your checkout once its dependencies are merged \u2014 or a change task", category: "tasks" },
+  { name: "task-ops", usage: "/task-ops <id> [on|off]", description: "Choose between an ops task (runs in your checkout once its dependencies are merged) and a change task", category: "tasks" },
   // Models & providers
-  { name: "planner", usage: "/planner [<provider>]", description: "Pick the planner \u2014 harness, model and effort in one go", category: "models" },
+  { name: "planner", usage: "/planner [<provider>]", description: "Pick the planner: harness, model and effort in one go", category: "models" },
   { name: "model", usage: "/model [set <id>]", description: "Show or set the planner model", category: "models" },
   { name: "planner-effort", usage: "/planner-effort [<level>]", description: "Thinking effort for a coding-agent planner", category: "models" },
   { name: "key", usage: "/key [set <provider> <key>]", description: "Configure API provider keys", category: "models" },
@@ -4711,7 +4778,7 @@ function parseRunnerCommand(text) {
   return match ? { name: match[1], args: (match[2] ?? "").trim() } : null;
 }
 function runnerCommandFor(commands, name) {
-  return (0, import_core28.findRunnerCommand)(commands, name) ?? (0, import_core28.findRunnerCommand)(commands, name.toLowerCase());
+  return (0, import_core30.findRunnerCommand)(commands, name) ?? (0, import_core30.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) : [];
@@ -4758,10 +4825,10 @@ function chatEditorRoomFor(state, active) {
 }
 
 // src/tui/layout.ts
-var import_core31 = require("@ordewell/core");
+var import_core33 = require("@ordewell/core");
 
 // src/tui/reducers/pickers.ts
-var import_core29 = require("@ordewell/core");
+var import_core31 = require("@ordewell/core");
 var import_plan_utils2 = require("@ordewell/core/plan-utils");
 var DEFAULT_EFFORT = "__runner_default__";
 function picker(title, items, action, extra = {}) {
@@ -4780,11 +4847,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) => (0, import_core29.getProviderMeta)(p)?.label ?? p);
-  return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")} \u2014 showing working providers only.`;
+  const names = failed.map((p) => (0, import_core31.getProviderMeta)(p)?.label ?? p);
+  return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")}. Showing working providers only.`;
 }
 function plannerModelItems(state, provider, selectedId) {
-  const runner = (0, import_core29.runnerForProvider)(provider);
+  const runner = (0, import_core31.runnerForProvider)(provider);
   if (!runner) {
     return state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m), selected: m.id === selectedId }));
   }
@@ -4800,11 +4867,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_core29.runnerForProvider)(provider);
+  const runner = (0, import_core31.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_core29.runnerForProvider)(provider)) {
+  if (!(0, import_core31.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);
@@ -4922,19 +4989,21 @@ function pickerItemsFor(state, action) {
 function plannerItems(state) {
   const installed = new Set(state.runners.map((r) => r.id));
   const usability = {};
-  for (const id of import_core29.CLI_PROVIDERS) {
-    const runner = (0, import_core29.runnerForProvider)(id);
+  for (const id of import_core31.CLI_PROVIDERS) {
+    const runner = (0, import_core31.runnerForProvider)(id);
     usability[runner] = installed.has(runner) ? { usable: true } : { usable: false, reason: "CLI not installed or not on PATH" };
   }
-  const entries = (0, import_core29.plannerBackendEntries)(usability, state.configuredProviders);
-  const items = entries.map((entry) => ({
+  const offered2 = (0, import_core31.plannerBackendEntries)(usability, state.configuredProviders).filter((entry) => entry.usable);
+  if (offered2.length === 0) {
+    return [{ id: "", label: "No planner available", detail: "install a coding agent or add a key with /key", disabled: true }];
+  }
+  const items = offered2.map((entry) => ({
     id: entry.id,
     label: entry.label,
     detail: entry.reason,
-    selected: state.plannerProvider === entry.id,
-    disabled: !entry.usable
+    selected: state.plannerProvider === entry.id
   }));
-  return entries.some((entry) => entry.kind === "vendor") ? items : [...items, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
+  return offered2.some((entry) => entry.kind === "vendor") ? items : [...items, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
 }
 
 // src/version.ts
@@ -4951,14 +5020,14 @@ function cliVersion() {
 }
 
 // src/tui/planKeys.ts
-var import_core30 = require("@ordewell/core");
+var import_core32 = 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 \u2014 or, at a checkpoint, answer it",
+    meaning: "open the task's log and message its runner or, at a checkpoint, answer it",
     group: "Navigation",
     hint: (task) => task?.status === "awaiting_user" && task.awaitingReason === "checkpoint" ? "enter answer" : "enter log"
   },
@@ -4978,7 +5047,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_core30.resumeLabel)(task) ? "c don't resume" : "c cancel"
+    hint: (task) => task && (0, import_core32.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" },
@@ -4988,7 +5057,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_core30.markAction)(task) === "uncomplete" ? "m undone" : "m done"
+    hint: (task) => task && (0, import_core32.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" },
@@ -5015,7 +5084,7 @@ function hintOf(id, task) {
 }
 function taskKeyIds(task, runActive) {
   if (!task) return ["add"];
-  const row = (0, import_core30.taskRowView)(task);
+  const row = (0, import_core32.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"];
@@ -5043,7 +5112,7 @@ function planFooterHints(task, runActive) {
 }
 
 // src/tui/layout.ts
-var import_core32 = require("@ordewell/core");
+var import_core34 = require("@ordewell/core");
 var CHROME_ROWS = 1;
 function chatInputWrap(state) {
   const active = state.focus === "chat" && !state.overlay;
@@ -5069,7 +5138,7 @@ function footerHints(state) {
     }
     return [...escHint ? [escHint] : [], ...planFooterHints(selected, state.status === "executing")];
   }
-  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"] : [];
+  const detailHint = (0, import_core34.hasHiddenDetail)(state.taskView ? state.taskView.view.blocks : state.conversation.blocks) ? [state.detailAll ? "ctrl-o collapse all" : "ctrl-o expand all"] : [];
   return [
     "/help",
     ...checkpointHints,
@@ -5128,12 +5197,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_core32.approvalLabel)(task?.awaitingApproval);
+  const approvals = (0, import_core34.approvalLabel)(task?.awaitingApproval);
   if (approvals) return inRow(approvals);
   if (working) return "working";
   if (task?.status === "awaiting_user") {
-    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 ");
+    const resumes = (0, import_core34.resumeLabel)(task);
+    return [inRow((0, import_core34.awaitingLabel)(task) ?? "Waiting for your input"), resumes ? inRow(resumes) : ""].filter(Boolean).join(" \xB7 ");
   }
   return task?.status ?? "";
 }
@@ -5146,7 +5215,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) ? ["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"];
+  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_core34.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}`);
@@ -5176,15 +5245,15 @@ 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_core26.isTaskRunning)(task) || own && (0, import_core26.isTaskRunning)(own)) return { label: "Working\u2026", busy: true };
+  if ((0, import_core28.isTaskRunning)(task) || own && (0, import_core28.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_core32.resumeTime)(at)}`, busy: false };
+  if (at && !Number.isNaN(at.getTime())) return { label: `paused \xB7 resumes ${(0, import_core34.resumeTime)(at)}`, busy: false };
   return null;
 }
 function runHints(state) {
   const waiting = state.tasks.filter((t) => t.status === "awaiting_user").length;
   if (waiting > 0) return [waiting === 1 ? "1 task waits for you" : `${waiting} tasks wait for you`, `${waiting} waiting`];
-  return state.runMerge?.paused ? ["paused for Merge all \u2014 /handoff merge", "paused \xB7 /handoff merge", "merge paused"] : [];
+  return state.runMerge?.paused ? ["paused for Merge all: /handoff merge", "paused \xB7 /handoff merge", "merge paused"] : [];
 }
 var runHint = (state) => runHints(state)[0] ?? "";
 function packHints(hints, cols) {
@@ -5240,7 +5309,7 @@ function taskUsageFooter(state, tv, blocks2, cols) {
   const reported = task?.attemptUsage ?? [];
   const onScreen = tv.attempt > 0 ? reported.find((a) => a.attempt === tv.attempt) : reported.at(-1);
   if (!task || !onScreen) return tokenRow(blocks2, cols);
-  const usage = (0, import_core32.taskRowView)({ ...task, attemptUsage: [onScreen] }).usage;
+  const usage = (0, import_core34.taskRowView)({ ...task, attemptUsage: [onScreen] }).usage;
   if (!usage) return tokenRow(blocks2, cols);
   const models = usage.byModel ?? [];
   return [
@@ -5253,17 +5322,17 @@ function chatScrollMax(state) {
 }
 function plannerSetup(state) {
   const provider = state.plannerProvider;
-  const registration = (0, import_core32.getProviderMeta)(provider);
+  const registration = (0, import_core34.getProviderMeta)(provider);
   if (!registration) return { label: "not set", ready: false };
-  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);
+  const runner = (0, import_core34.runnerForProvider)(provider);
+  const ready = runner ? state.runners.some((r) => r.id === runner) : (0, import_core34.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_core31.SUPERVISOR_LEVEL_LABEL[supervisorLevel]}`;
+  const level = `supervisor ${import_core33.SUPERVISOR_LEVEL_LABEL[supervisorLevel]}`;
   return [
     supervisorLevel === "act" ? style.yellow(level) : level,
     `auto-merge ${mergeAtGatesAutomatically ? "on" : "off"}`,
@@ -5343,18 +5412,22 @@ var twoLines = ({ orde, well }) => [...orde, ...well.map((row) => style.brand(ro
 function welcomeLogo(restRows, rows, cols) {
   return [bannerLines(), oneLine2(BANNER_WORDMARK), twoLines(BANNER_WORDMARK)].find((lines) => lines.every((line) => width(line) <= cols - 1) && lines.length + restRows <= rows) ?? [];
 }
+var DETECTING = "Detecting coding agents\u2026";
 function welcomeLines(state, rows, cols) {
   const planner = plannerSetup(state);
   const enabledRunners = state.runners.filter((r) => r.enabled).map((r) => r.name);
   const canPlan = planner.ready || state.runners.length > 0 || state.configuredProviders.length > 0;
-  const plannerValue = planner.ready ? [planner.label, state.orchestratorModel || style.yellow("no model"), plannerEffortLabel(state)].filter(Boolean).join(style.grey(" \xB7 ")) : style.yellow(planner.label === "not set" ? "not set" : `${planner.label} (unavailable)`);
+  const detecting = !state.plannerKnown || !state.runnersKnown;
+  const plannerValue = detecting ? style.grey(DETECTING) : planner.ready ? [planner.label, state.orchestratorModel || style.yellow("no model"), plannerEffortLabel(state)].filter(Boolean).join(style.grey(" \xB7 ")) : style.yellow(planner.label === "not set" ? "not set" : `${planner.label} (unavailable)`);
   const prompt = wrap(style.bold("Describe a goal to start planning."), Math.max(1, cols - 1));
+  const approvalText = !state.runSettingsKnown ? "" : state.runSettings.autorun ? style.yellow("Autorun is on. A plan starts as soon as the planner submits it. Change it in /settings.") : style.grey("Nothing runs until you approve the plan.");
+  const approval = approvalText ? wrap(approvalText, Math.max(1, cols - 1)) : [];
   const setup = [
     style.bold("Setup"),
     setupRow("Planner", plannerValue, "/planner", cols),
     setupRow(
       "Runners",
-      enabledRunners.length > 0 ? enabledRunners.join(", ") : style.yellow("none enabled"),
+      detecting ? style.grey(DETECTING) : enabledRunners.length > 0 ? enabledRunners.join(", ") : style.yellow("none enabled"),
       "/runners",
       cols
     ),
@@ -5362,15 +5435,15 @@ function welcomeLines(state, rows, cols) {
     setupRow("Run", runSettingsValue(state), "/settings", cols),
     ""
   ];
-  const notice = canPlan ? [] : [
+  const notice = canPlan || detecting || !state.providersKnown ? [] : [
     ...wrap(
-      style.yellow(`Ordewell needs one coding agent installed (${runnerNamesOr()}) \u2014 or an API key from a provider such as OpenRouter, added with /key.`),
+      style.yellow(`Install a coding agent (${runnerNamesOr()}) and pick it with /planner. No API key needed. Or add an API key with /key and choose your provider.`),
       Math.max(1, cols - 1)
     ),
     ""
   ];
   const tail = [...notice, style.grey("/help   all commands"), workspaceLine(state.workspace, cols)];
-  const rest = ["", ...prompt, "", ...setup, ...tail];
+  const rest = ["", ...prompt, ...approval, "", ...setup, ...tail];
   const logo = welcomeLogo(rest.length, rows, cols);
   return logo.length > 0 ? [...logo, ...rest] : rest.slice(1);
 }
@@ -5398,7 +5471,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_core32.planUsage)(state.tasks);
+  const totalUsage = (0, import_core34.planUsage)(state.tasks);
   const unmerged = state.runMerge?.handoff.landed.length ?? 0;
   const count = `${done}/${state.tasks.length}`;
   const hints = runHints(state);
@@ -5408,7 +5481,7 @@ function planLayout(state, rows, cols) {
     totalUsage.attempts ? style.grey(truncate(`Tasks total: ${taskUsageText(totalUsage)}`, cols)) : ""
   ];
   if (unmerged > 0) {
-    const landed = style.dim(truncate(`${unmerged} landed task${unmerged === 1 ? "" : "s"} not merged \u2014 /handoff merge`, cols));
+    const landed = style.dim(truncate(`${unmerged} landed task${unmerged === 1 ? "" : "s"} not merged: /handoff merge`, cols));
     if (totalUsage.attempts) lines.push(landed);
     else lines[1] = landed;
   }
@@ -5425,10 +5498,21 @@ function planLayout(state, rows, cols) {
     lines.push(...renderedTask.lines);
     rowSpans.push({ start: taskStart, end: lines.length - 1 });
   });
+  lines.push(...heldEditLines(state, cols));
   const selected = rowSpans[state.selectedTask] ?? { start: firstRowLine, end: firstRowLine };
   const anchor = editorLine === void 0 ? selected : { start: editorLine, end: editorLine };
   return { lines, rowSpans, anchor, rows, maxScroll: Math.max(0, lines.length - rows) };
 }
+var heldMark = (mark) => mark === "added" ? style.green("+") : mark === "changed" ? style.yellow("~") : style.red("-");
+function heldEditLines(state, cols) {
+  const rows = (state.run.heldEdit?.tasks ?? []).flatMap(({ label, mark, task }) => {
+    if (!mark) return [];
+    const title = mark === "removed" ? style.strike(task.title) : task.title;
+    return [truncate(`  ${heldMark(mark)} ${style.grey(label.padStart(2))}  ${title}`, cols)];
+  });
+  if (rows.length === 0) return [];
+  return ["", style.dim(truncate("Proposed: lands when this reply ends", cols)), ...rows];
+}
 var clampOffset = (layout, offset) => Math.max(0, Math.min(layout.maxScroll, offset));
 function revealOffset(layout, offset, span) {
   const at = clampOffset(layout, offset);
@@ -5476,7 +5560,7 @@ function planScrollExtent(state) {
 }
 function taskLines(state, planRow, index, cols) {
   const { task, parent } = planRow;
-  const row = (0, import_core32.taskRowView)(task, { parent, tasks: state.tasks, modes: modesForTask(state.modesByRunner, task) });
+  const row = (0, import_core34.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];
@@ -5504,10 +5588,9 @@ function taskLines(state, planRow, index, cols) {
   const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}${row.autonomous ? style.yellow(" \u26A1") : ""}` : "";
   const runner = task.assignedRunner ?? "";
   const bodyPad = parent ? "      " : "    ";
-  const activity = row.approvals ? `${inRow(row.approvals)} \u2014 enter opens it` : row.awaiting ? inRow(row.awaiting) : "";
+  const activity = row.approvals ? `${inRow(row.approvals)}: enter opens it` : row.awaiting ? inRow(row.awaiting) : "";
   const skills = (task.skills ?? []).join(" \xB7 ");
-  const origin = task.addedBy === "supervisor" ? "added by supervisor" : "";
-  const meta = [activity, origin, runner, model];
+  const meta = [activity, runner, model];
   const variant = task.type === "ai" ? sanitize(task.assignedModel?.thinkingEffort ?? "") : "";
   const withVariant = variant ? [...meta, variant] : meta;
   const metaLine = variant && width(`${continuation}${withVariant.filter(Boolean).join(" \xB7 ")}`) <= cols ? withVariant : meta;
@@ -5516,7 +5599,7 @@ function taskLines(state, planRow, index, cols) {
   if (row.conflict) {
     const where = row.conflict.repo ? ` in ${row.conflict.repo}` : "";
     const files = row.conflict.files ? ` (${row.conflict.files})` : "";
-    lines.push(style.red(truncate(`${bodyPad}\u26A0 merge conflict${where}${files} \u2014 its work is kept on its own branch`, cols)));
+    lines.push(style.red(truncate(`${bodyPad}\u26A0 merge conflict${where}${files}: its work is kept on its own branch`, cols)));
   }
   if (row.repairing) {
     const files = row.repairing.files ? ` in ${row.repairing.files}` : "";
@@ -5524,22 +5607,25 @@ function taskLines(state, planRow, index, cols) {
     lines.push(style.yellow(truncate(`${bodyPad}\u21BB repairing conflict${files}${attempt}`, cols)));
   }
   if (row.mergeGate) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for Merge all \u2014 ${row.mergeGate.join(", ")} not merged into your branch yet`, cols)));
+    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for Merge all: ${row.mergeGate.join(", ")} not merged into your branch yet`, cols)));
+  }
+  if (row.waitsForApproval) {
+    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 ${inRow(row.waitsForApproval)}: added after you approved the plan; f starts it, or /run runs the plan`, cols)));
   }
   if (row.blockedBy) {
-    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)));
+    lines.push(style.red(truncate(`${bodyPad}\u2298 ${inRow((0, import_core34.blockedByLabel)(row.blockedBy))}: 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_core32.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_core34.skippedLabel)(row.skipReason))}: nothing of it landed; m done lands its kept work`, cols)));
   }
   const resumable = row.actions.includes("resume-now");
   if (row.resumes) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 ${inRow(row.resumes)}, once the usage limit resets \u2014 ${resumable ? "r resume now \xB7 " : ""}c don't resume`, cols)));
+    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 ${inRow(row.resumes)}, once the usage limit resets: ${resumable ? "r resume now \xB7 " : ""}c don't resume`, cols)));
   } else if (resumable) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for the usage limit to reset \u2014 r resume now`, cols)));
+    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for the usage limit to reset: r resume now`, cols)));
   }
   if (row.opsChangedFiles) {
-    lines.push(style.yellow(truncate(`${bodyPad}\u26A0 an ops task changed tracked files \u2014 check them, then m done or /retry`, cols)));
+    lines.push(style.yellow(truncate(`${bodyPad}\u26A0 an ops task changed tracked files: check them, then m done or /retry`, cols)));
   }
   if (row.repaired?.landed) {
     lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${row.repaired.files}`, cols)));
@@ -5639,14 +5725,14 @@ function commandSheetBody(cols) {
   body.push(
     style.grey("tab switches panes \xB7 pgup/pgdn scroll \xB7 ctrl-o toggles full detail \xB7 esc takes back a queued prompt, otherwise esc twice stops \xB7 ctrl-l clears \xB7 ctrl-c quits"),
     style.grey("alt-enter inserts a newline \xB7 ? lists the plan pane's keys, once tab has put you there"),
-    style.grey("  in the planner chat, ctrl-s sends now: stops the running planner turn and sends the composer text next \u2014 or, with it empty, the newest queued prompt")
+    style.grey("  in the planner chat, ctrl-s sends now: stops the running planner turn and sends the composer text next: or, with it empty, the newest queued prompt")
   );
   body.push(
     "",
     style.bold("In a task view (enter on a task)"),
-    style.grey("  ctrl-s sends now: interrupts the running step, then delivers the composer text \u2014 or, with it empty, the highlighted pending message"),
+    style.grey("  ctrl-s sends now: interrupts the running step, then delivers the composer text or, with it empty, the highlighted pending message"),
     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-x stops the runner's running turn, and it then waits for your next message: 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, 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")
@@ -5665,8 +5751,8 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
-var import_core33 = require("@ordewell/core");
-var import_core34 = require("@ordewell/core");
+var import_core35 = require("@ordewell/core");
+var import_core36 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
@@ -5765,8 +5851,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_core34.SUPERVISOR_LEVEL_LABEL[run.level] : null;
-  const level = `supervisor ${import_core34.SUPERVISOR_LEVEL_LABEL[supervisorLevel]}${actual ? ` \u2192 ${actual}` : ""}`;
+  const actual = run?.unsupervised ? "unsupervised" : run && run.level !== supervisorLevel ? import_core36.SUPERVISOR_LEVEL_LABEL[run.level] : null;
+  const level = `supervisor ${import_core36.SUPERVISOR_LEVEL_LABEL[supervisorLevel]}${actual ? ` \u2192 ${actual}` : ""}`;
   return [
     paint(level, supervisorLevel === "act"),
     ...mergeAtGatesAutomatically ? [style.grey("auto-merge")] : [],
@@ -5960,16 +6046,16 @@ function renderHandoff(state, overlay, rows, cols) {
     const { lines, scroll } = overlay.diff;
     const shown = lines.slice(scroll, scroll + room).map((line) => paintDiffLine(truncate(line, Math.max(1, cols - 2))));
     const more = scroll + room < lines.length ? "\u2191\u2193 pgup/pgdn scroll \xB7 " : "";
-    return frame(`Diff \u2014 ${handoffBranch(handoff)}`, [...shown, "", style.grey(`${more}enter or esc goes back`)], rows, cols);
+    return frame(`Diff: ${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_core33.capConflictFiles)(task.repairedFiles)})`) : "";
-    return `  ${style.green("\u2713")} ${(0, import_core33.titledTaskRefOf)(state.tasks, task.taskId) ?? (0, import_core33.titledTaskRef)(task)}${repaired}`;
+    const repaired = task.repairedFiles?.length ? style.yellow(`: repaired (${(0, import_core35.capConflictFiles)(task.repairedFiles)})`) : "";
+    return `  ${style.green("\u2713")} ${(0, import_core35.titledTaskRefOf)(state.tasks, task.taskId) ?? (0, import_core35.titledTaskRef)(task)}${repaired}`;
   });
   const actions = handoffActions(handoff).map((action, index) => {
     const active = index === overlay.index;
     const caret = active ? style.brand("\u276F") : " ";
-    return `${caret} ${active ? style.bold(action.label) : action.label}${style.grey(` \u2014 ${action.hint}`)}`;
+    return `${caret} ${active ? style.bold(action.label) : action.label}${style.grey(`: ${action.hint}`)}`;
   });
   const perRepo = isRepoGroup(handoff) ? ["Per repository:", ...handoff.repos.map((repo, i) => `  ${repo.landed.length > 0 ? style.green("\u2713") : style.grey("\xB7")} ${repoResultLines(handoff)[i]}`), ""] : [];
   return frame(
@@ -6138,10 +6224,13 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core46 = require("@ordewell/core");
+var import_core49 = require("@ordewell/core");
 
 // src/tui/reducers/overlays.ts
-var import_core45 = require("@ordewell/core");
+var import_core48 = require("@ordewell/core");
+
+// src/tui/reducers/approvals.ts
+var import_core37 = require("@ordewell/core");
 
 // src/tui/reducers/shared.ts
 function step(state, effects = []) {
@@ -6157,7 +6246,7 @@ function clampSelection(index, rows) {
 }
 function withSession(state, run) {
   if (!state.sessionId) {
-    return fail3(state, "No active plan \u2014 describe a goal first, or load a session with /sessions.");
+    return fail3(state, "No active plan: describe a goal first, or load a session with /sessions.");
   }
   return run(state.sessionId);
 }
@@ -6186,6 +6275,13 @@ function dropApproval(state, approvalId) {
   if (open?.id !== approvalId) return { ...state, pendingApprovals: pending };
   return showNextApproval({ ...state, pendingApprovals: pending, overlay: null });
 }
+function syncApprovals(state, waiting) {
+  const ids = new Set(waiting.map((request) => request.id));
+  const open = state.overlay?.kind === "approval" ? [state.overlay.request] : [];
+  const answered = [...open, ...state.pendingApprovals].filter((request) => !ids.has(request.id));
+  const dropped = answered.reduce((current, request) => dropApproval(current, request.id), { ...state, conversation: (0, import_core37.reconcileApprovals)(state.conversation, waiting) });
+  return waiting.reduce((current, { id, kind, subject, scope, detail }) => kind === "runner_tool" ? current : enqueueApproval(current, { id, kind, subject, scope, ...detail ? { detail } : {} }), dropped);
+}
 function showNextApproval(state) {
   const [next, ...rest] = state.pendingApprovals;
   if (!next) return { ...state, overlay: null };
@@ -6200,10 +6296,10 @@ function handleApprovalKey(state, overlay, key) {
 }
 
 // src/tui/reducers/commands.ts
-var import_core44 = require("@ordewell/core");
+var import_core47 = require("@ordewell/core");
 
 // src/tui/reducers/plannerStepper.ts
-var import_core35 = require("@ordewell/core");
+var import_core38 = 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, ""));
@@ -6222,7 +6318,7 @@ var effortLabel = (label) => /\beffort$/i.test(label) ? label : `${label} effort
 var plannerStepper = {
   title: "Planner",
   advanceOnEnter: true,
-  hint: "Who researches your goal and writes the plan. Coding agents use their own subscription \u2014 no API key.",
+  hint: "Who researches your goal and writes the plan. Coding agents use their own subscription. No API key.",
   steps: [
     {
       id: "harness",
@@ -6251,7 +6347,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 = [
-      (0, import_core35.getProviderMeta)(provider)?.label ?? provider,
+      (0, import_core38.getProviderMeta)(provider)?.label ?? provider,
       model?.label ?? modelId,
       ...effort ? [effortLabel(level?.label ?? effort)] : []
     ];
@@ -6266,7 +6362,7 @@ var plannerStepper = {
 };
 
 // src/tui/reducers/stepper.ts
-var import_core36 = require("@ordewell/core");
+var import_core39 = require("@ordewell/core");
 function openStepper(state, definition) {
   const { choices, lists } = settle(state, definition, {});
   const first = lists.findIndex((list2) => list2 !== null);
@@ -6289,7 +6385,7 @@ 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_core36.parseCount)(entry.text, def.number.min) : null;
+  const typed = def.number && entry ? (0, import_core39.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);
@@ -6326,7 +6422,7 @@ function handleStepperKey(state, stepper, key) {
 function confirm(state, stepper, item) {
   if (!item) return step(state);
   if (item.disabled) {
-    return step(say(state, "error", item.detail ? `${item.label} \u2014 ${item.detail}` : `${item.label} is not available.`));
+    return step(say(state, "error", item.detail ? `${item.label}: ${item.detail}` : `${item.label} is not available.`));
   }
   return choose(state, stepper, item.id);
 }
@@ -6355,7 +6451,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_core36.parseCount)(wanted[def.id], def.number.min) ?? def.number.current(state, { ...choices }));
+      choices[def.id] = String((0, import_core39.parseCount)(wanted[def.id], def.number.min) ?? def.number.current(state, { ...choices }));
       return [];
     }
     const items = def.items(state, { ...choices });
@@ -6394,7 +6490,7 @@ function lastIndexBefore(lists, index) {
 }
 
 // src/tui/reducers/planPane.ts
-var import_core39 = require("@ordewell/core");
+var import_core42 = require("@ordewell/core");
 
 // src/tui/reducers/pointer.ts
 var WHEEL_NOTCH = 3;
@@ -6472,13 +6568,13 @@ function handleMouseSelect(state, key) {
 }
 
 // src/tui/reducers/taskView.ts
-var import_core37 = require("@ordewell/core");
+var import_core40 = 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_core37.EMPTY_TASK_LOG,
+    view: import_core40.EMPTY_TASK_LOG,
     attempts: [],
     attempt: 0,
     pending: [],
@@ -6508,13 +6604,13 @@ function applyLive(tv, attempt, events) {
     }
     next = {
       ...next,
-      view: import_core37.EMPTY_TASK_LOG,
+      view: import_core40.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_core37.reduceTaskLog, next.view) });
+  return clampQueueIndex({ ...next, view: events.reduce(import_core40.reduceTaskLog, next.view) });
 }
 function taskLogAbandoned(state) {
   const tv = state.taskView;
@@ -6535,14 +6631,14 @@ function announceApprovals(state, action) {
   if (state.taskView?.taskId === action.taskId) return state;
   const task = findTask(state.tasks, action.taskId);
   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);
+  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" && !event.decided ? say(s, "system", `Task ${task?.order ?? "?"} waits for approval: ${(0, import_core40.runnerToolSubject)(event.tool, event.args)}: ${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 = 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}`);
+  const spoken = say(state, "system", `${label} asks: ${(0, import_core40.truncateCheckpointSummary)(action.summary)}: ${where}`);
   return { ...spoken, scroll: state.scroll };
 }
 function taskLogLoaded(state, action) {
@@ -6550,7 +6646,7 @@ function taskLogLoaded(state, action) {
   if (!tv || tv.taskId !== action.taskId) return state;
   const loaded = action.attempt >= 1 ? {
     ...tv,
-    view: (0, import_core37.replayTaskLog)(action.events),
+    view: (0, import_core40.replayTaskLog)(action.events),
     attempts: action.attempts ?? tv.attempts,
     attempt: action.attempt
   } : { ...tv, attempts: action.attempts ?? tv.attempts };
@@ -6565,7 +6661,7 @@ function answerApproval(state, tv, sessionId, decision) {
   const approval = waitingApproval(tv);
   if (!approval?.approvalId) return step(say(state, "system", "Nothing is waiting for approval."));
   if (decision === "allowForTask" && !approval.allowForTask) {
-    return step(say(state, "system", "The runner offered no grant for the rest of this task \u2014 ctrl-y allows this call."));
+    return step(say(state, "system", "The runner offered no grant for the rest of this task: ctrl-y allows this call."));
   }
   const note = decision === "deny" ? state.editor.text.trim() : "";
   const answer = decision === "deny" ? { decision, ...note ? { note } : {} } : { decision };
@@ -6589,7 +6685,7 @@ function sendNow(state, tv, sessionId) {
   if (text) {
     const task = findTask(state.tasks, tv.taskId);
     if (continuesTask(task)) {
-      return step(say(state, "system", resumesTask(task) ? "The task is paused on a usage limit, so there is no turn to interrupt \u2014 enter resumes it." : "The task has finished, so there is no turn to interrupt \u2014 enter continues it."));
+      return step(say(state, "system", resumesTask(task) ? "The task is paused on a usage limit, so there is no turn to interrupt: enter resumes it." : "The task has finished, so there is no turn to interrupt: enter continues it."));
     }
     return step({ ...state, editor: commit(state.editor) }, [{ type: "forceSendTaskMessage", sessionId, taskId: tv.taskId, text }]);
   }
@@ -6624,7 +6720,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_core37.resumeLabel)(task)) return step(state, [{ type: "taskAction", sessionId: state.sessionId, taskId: tv.taskId, action: "cancel-resume" }]);
+    if (task && (0, import_core40.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");
@@ -6642,7 +6738,7 @@ function handleTaskViewKey(state, key) {
 }
 
 // src/tui/reducers/taskEdits.ts
-var import_core38 = require("@ordewell/core");
+var import_core41 = 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.");
@@ -6672,7 +6768,7 @@ function confirmRemoveTask(state, task) {
 }
 function toggleTaskOps(state, task, subtask, to = !task.ops) {
   if (!state.sessionId) return fail3(state, "No active plan.");
-  if (task.type !== "ai") return fail3(state, "Only an AI task can be an ops task \u2014 a manual task already runs outside any worktree.");
+  if (task.type !== "ai") return fail3(state, "Only an AI task can be an ops task: a manual task already runs outside any worktree.");
   if (subtask) return fail3(state, "A subtask runs with its parent; make the parent an ops task instead.");
   if (!!task.ops === to) return fail3(state, `${refFor(state, task)} is already ${to ? "an ops" : "a change"} task.`);
   return step(state, [{
@@ -6753,7 +6849,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_core38.codexSandboxNotice)(state.modesByRunner)?.line].filter(Boolean).join(" ")
+          hint: [`Modes declared by ${task.assignedRunner}.`, (0, import_core41.codexSandboxNotice)(state.modesByRunner)?.line].filter(Boolean).join(" ")
         })
       }
     }
@@ -6905,7 +7001,7 @@ function taskOpsCommand(state, args) {
 }
 function addTask(state, title) {
   if (!state.sessionId) {
-    return fail3(state, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
+    return fail3(state, "No active plan to add a task to: describe a goal first, then /add-task <title>.");
   }
   if (!title) {
     return step({
@@ -6981,11 +7077,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_core39.resumeLabel)(task) ? "cancel-resume" : PLAN_SHORTCUTS[key.char ?? ""];
+  const shortcut = key.char === "c" && (0, import_core42.resumeLabel)(task) ? "cancel-resume" : PLAN_SHORTCUTS[key.char ?? ""];
   if (key.char === "r") {
-    return (0, import_core39.taskRowActions)(task).includes("resume-now") ? step(state, [taskActionEffect(state, state.sessionId, task.id, "resume-now")]) : step(state);
+    return (0, import_core42.taskRowActions)(task).includes("resume-now") ? step(state, [taskActionEffect(state, state.sessionId, task.id, "resume-now")]) : step(state);
   }
-  const action = key.char === "m" ? (0, import_core39.markAction)(task) : shortcut;
+  const action = key.char === "m" ? (0, import_core42.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)]);
@@ -7025,9 +7121,9 @@ function commitTaskEdit(state, task, editor) {
 }
 
 // src/tui/reducers/turnQueue.ts
-var import_core40 = require("@ordewell/core");
+var import_core43 = require("@ordewell/core");
 function drainQueue(state, settled) {
-  const next = (0, import_core40.drainNext)(state.queuedPrompts);
+  const next = (0, import_core43.drainNext)(state.queuedPrompts);
   const ended = disarmStop({ ...settled, stopRequested: false, forceSendPending: null });
   if (!next) return step(ended);
   const spoken = say(ended, "user", next.text);
@@ -7042,7 +7138,7 @@ function restoreForced(state) {
   if (!forced) return state;
   const cleared = { ...state, forceSendPending: null };
   if (forced.queueIndex === void 0) {
-    const text = (0, import_core40.aheadOfDraft)(forced.text, state.editor.text);
+    const text = (0, import_core43.aheadOfDraft)(forced.text, state.editor.text);
     return { ...cleared, editor: { ...state.editor, text, cursor: text.length } };
   }
   const queued = [...state.queuedPrompts];
@@ -7058,14 +7154,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_core40.unsendAll)(state.queuedPrompts);
+  const all = (0, import_core43.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_core40.unsendLatest)(state.queuedPrompts);
+  const latest = (0, import_core43.unsendLatest)(state.queuedPrompts);
   if (!latest) return step(state);
-  const text = (0, import_core40.aheadOfDraft)(latest.text, state.editor.text);
+  const text = (0, import_core43.aheadOfDraft)(latest.text, state.editor.text);
   return step({
     ...state,
     queuedPrompts: latest.rest,
@@ -7081,7 +7177,7 @@ function forceSendPlanner(state) {
       { type: "forceSendPlannerMessage", sessionId: state.sessionId, message: text }
     ]);
   }
-  const latest = (0, import_core40.unsendLatest)(state.queuedPrompts);
+  const latest = (0, import_core43.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 }, [
@@ -7097,7 +7193,7 @@ function plannerEscape(state) {
 }
 
 // src/tui/reducers/incoming.ts
-var import_core41 = require("@ordewell/core");
+var import_core44 = 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 : {};
@@ -7136,12 +7232,13 @@ 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_core41.isAwaitingReason)(t.awaitingReason) ? t.awaitingReason : void 0,
+    awaitingReason: t.status === "awaiting_user" && (0, import_core44.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,
     continuable: t.continuable === true,
     awaitingApproval: t.awaitingApproval,
+    ...t.waitsForApproval === true ? { waitsForApproval: true } : {},
     ...t.ops === true ? { ops: true } : {},
     ...Array.isArray(t.skills) && t.skills.length > 0 ? { skills: t.skills.map((name) => planLabel(name)) } : {},
     ...t.addedBy ? { addedBy: t.addedBy } : {},
@@ -7155,7 +7252,7 @@ function supervisorOfRun(runSettings) {
   const unsupervised = typeof runSettings.unsupervised === "string" ? runSettings.unsupervised : void 0;
   return {
     runSupervisor: {
-      level: (0, import_core41.isSupervisorLevel)(runSettings.supervisorLevel) ? runSettings.supervisorLevel : "off",
+      level: (0, import_core44.isSupervisorLevel)(runSettings.supervisorLevel) ? runSettings.supervisorLevel : "off",
       ...unsupervised ? { unsupervised } : {}
     }
   };
@@ -7172,7 +7269,7 @@ function withRun(state, run) {
   };
 }
 function foldRun(state, input) {
-  const run = (0, import_core41.reduceRun)(state.run, input);
+  const run = (0, import_core44.reduceRun)(state.run, input);
   return run === state.run ? state : withRun(state, run);
 }
 function mapRunTasks(tasks, map) {
@@ -7202,11 +7299,13 @@ function applySettings(state, settings) {
     ...state,
     orchestratorModel: typeof settings.orchestratorModel === "string" ? settings.orchestratorModel : state.orchestratorModel,
     plannerProvider: typeof settings.aiProvider === "string" ? settings.aiProvider : state.plannerProvider,
+    plannerKnown: state.plannerKnown || typeof settings.aiProvider === "string",
     plannerEffort: typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : state.plannerEffort,
     plannerModels: settings.plannerModels && typeof settings.plannerModels === "object" ? settings.plannerModels : state.plannerModels,
     maxParallel: typeof settings.maxParallel === "number" ? settings.maxParallel : state.maxParallel,
     allowlist: settings.modelAllowlist && typeof settings.modelAllowlist === "object" ? settings.modelAllowlist : state.allowlist,
-    runSettings: settings.run ?? state.runSettings
+    runSettings: settings.run ?? state.runSettings,
+    runSettingsKnown: state.runSettingsKnown || settings.run !== void 0
   };
 }
 function followSession(state, message) {
@@ -7220,21 +7319,21 @@ function followSession(state, message) {
 }
 
 // src/tui/reducers/runSettings.ts
-var import_core42 = require("@ordewell/core");
+var import_core45 = 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_core42.supervisorSummary)(state.runSettings)} \u2014 /supervisor off|watch|act, /supervisor retries <n>, /supervisor reads <n>.`));
+    return step(say(state, "system", `${(0, import_core45.supervisorSummary)(state.runSettings)}: /supervisor off|watch|act, /supervisor retries <n>, /supervisor reads <n>.`));
   }
   if (arg === "retries") {
-    const n = (0, import_core42.parseCount)(value, 0);
+    const n = (0, import_core45.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_core42.parseCount)(value, 1);
+    const n = (0, import_core45.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);
@@ -7243,17 +7342,17 @@ function supervisorCommand(state, args) {
 }
 function automergeCommand(state, arg) {
   if (arg === void 0) {
-    return step(say(state, "system", `${(0, import_core42.automergeSummary)(state.runSettings)} \u2014 /automerge on|off.`));
+    return step(say(state, "system", `${(0, import_core45.automergeSummary)(state.runSettings)}: /automerge on|off.`));
   }
-  const enabled = (0, import_core42.parseSwitch)(arg);
+  const enabled = (0, import_core45.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_core42.autorunSummary)(state.runSettings)} \u2014 /autorun on starts each plan the planner submits, without review.`));
+    return step(say(state, "system", `${(0, import_core45.autorunSummary)(state.runSettings)}: /autorun on starts each plan the planner submits, without review.`));
   }
-  const enabled = (0, import_core42.parseSwitch)(arg);
+  const enabled = (0, import_core45.parseSwitch)(arg);
   if (enabled === null) return fail3(state, "Usage: /autorun [on|off]");
   if (enabled) return confirmAutorun(state);
   return step(state, [runSettingsEffect(state, { autorun: false })]);
@@ -7265,7 +7364,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_core42.ACT_RISK}
+      note: `${import_core45.ACT_RISK}
 It applies to this session's run now, and to every later run.`,
       action: { kind: "supervisor-act" }
     }
@@ -7278,14 +7377,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_core42.AUTORUN_RISK,
+      note: import_core45.AUTORUN_RISK,
       action: { kind: "autorun-on" }
     }
   });
 }
 
 // src/tui/reducers/settings.ts
-var import_core43 = require("@ordewell/core");
+var import_core46 = 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",
@@ -7310,7 +7409,7 @@ var SETTINGS = {
         {
           id: "guarded",
           label: "Guarded",
-          detail: [`New plans run tasks in each runner's safer mode`, (0, import_core43.codexSandboxNotice)(state.modesByRunner)?.line].filter(Boolean).join(" \xB7 "),
+          detail: [`New plans run tasks in each runner's safer mode`, (0, import_core46.codexSandboxNotice)(state.modesByRunner)?.line].filter(Boolean).join(" \xB7 "),
           selected: !state.autonomous
         }
       ]
@@ -7320,7 +7419,7 @@ var SETTINGS = {
       label: "Supervisor",
       items: (state) => ["off", "watch", "act"].map((level) => ({
         id: level,
-        label: import_core43.SUPERVISOR_LEVEL_LABEL[level],
+        label: import_core46.SUPERVISOR_LEVEL_LABEL[level],
         detail: SUPERVISOR_DETAIL[level],
         selected: state.runSettings.supervisorLevel === level
       }))
@@ -7374,12 +7473,12 @@ function saveChoices(state, choices) {
   const autonomous = choices.autonomy === "full";
   if (autonomous !== state.autonomous) {
     save2.autonomous = autonomous;
-    changed.push(`Autonomy ${(0, import_core43.autonomyLevelLabel)(autonomous)}`);
+    changed.push(`Autonomy ${(0, import_core46.autonomyLevelLabel)(autonomous)}`);
   }
   const level = choices.supervisor;
   if (level !== state.runSettings.supervisorLevel) {
     run.supervisorLevel = level;
-    changed.push(`Supervisor ${import_core43.SUPERVISOR_LEVEL_LABEL[level]}`);
+    changed.push(`Supervisor ${import_core46.SUPERVISOR_LEVEL_LABEL[level]}`);
   }
   if (choices.retries !== void 0 && Number(choices.retries) !== state.runSettings.supervisorRetryLimit) {
     run.supervisorRetryLimit = Number(choices.retries);
@@ -7406,7 +7505,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_core43.ACT_RISK] : [], ...run.autorun ? [import_core43.AUTORUN_RISK] : []];
+  const risks = [...run.supervisorLevel === "act" ? [import_core46.ACT_RISK] : [], ...run.autorun ? [import_core46.AUTORUN_RISK] : []];
   if (risks.length === 0) return saveSettings(state, effect);
   return step({
     ...state,
@@ -7435,7 +7534,7 @@ function saveSettings(state, effect) {
 }
 
 // src/tui/reducers/commands.ts
-var unknownCommand = (state, name) => fail3(state, `Unknown command: /${name} \u2014 type /help to see what's available.`);
+var unknownCommand = (state, name) => fail3(state, `Unknown command: /${name}. Type /help to see what's available.`);
 function runCommand(state, { name, args }) {
   if (!findCommand(name)) return unknownCommand(state, name);
   switch (name) {
@@ -7504,7 +7603,7 @@ function runCommand(state, { name, args }) {
     case "save":
       return withSession(state, (sessionId) => step(state, [{ type: "saveSession", sessionId }]));
     case "load":
-      return args[0] ? step(state, [{ type: "loadSession", sessionId: args[0] }]) : fail3(state, "Usage: /load <session-id> \u2014 or run /sessions to pick one.");
+      return args[0] ? step(state, [{ type: "loadSession", sessionId: args[0] }]) : fail3(state, "Usage: /load <session-id>: or run /sessions to pick one.");
     case "delete":
       return args[0] ? step(state, [{ type: "deleteSession", sessionId: args[0] }]) : fail3(state, "Usage: /delete <session-id>");
     case "add-task":
@@ -7528,7 +7627,7 @@ function runCommand(state, { name, args }) {
         const answer = args[1]?.toLowerCase();
         const reason = args.slice(2).join(" ").trim();
         if (answer !== "approve" && answer !== "reject") return fail3(state, "Usage: /checkpoint <id> approve|reject [reason]");
-        if (answer === "approve" && reason) return fail3(state, "Approving takes no note \u2014 reject with a reason to tell the task something.");
+        if (answer === "approve" && reason) return fail3(state, "Approving takes no note: reject with a reason to tell the task something.");
         return answerCheckpoint(state, sessionId, taskId, answer, reason);
       });
     case "task-runner":
@@ -7566,7 +7665,7 @@ function runCommand(state, { name, args }) {
 function withIdlePlanner(state, run) {
   return withSession(
     state,
-    (sessionId) => plannerInFlight(state) ? fail3(state, "The planner is still answering \u2014 wait for its reply, or /stop it first.") : run(sessionId)
+    (sessionId) => plannerInFlight(state) ? fail3(state, "The planner is still answering: wait for its reply, or /stop it first.") : run(sessionId)
   );
 }
 function resolveToggle(arg, current) {
@@ -7597,8 +7696,8 @@ function newSession(state) {
     goal: "",
     taskView: null,
     planApproved: false,
-    conversation: import_core44.EMPTY_CONVERSATION,
-    turnGate: import_core44.NO_TURN,
+    conversation: import_core47.EMPTY_CONVERSATION,
+    turnGate: import_core47.NO_TURN,
     selectedTask: 0,
     expandedTaskId: null,
     taskEditor: null,
@@ -7609,19 +7708,21 @@ 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_core44.EMPTY_HOLD,
+    queuedPrompts: import_core47.EMPTY_HOLD,
     stopArmed: false,
     forceSendPending: null,
     overlay: state.overlay?.kind === "approval" ? null : state.overlay
-  }, import_core44.EMPTY_RUN), closeEffects);
+  }, import_core47.EMPTY_RUN), closeEffects);
 }
 function setModel(state, args) {
   if (args[0] === "set" && args[1]) {
-    const runner = (0, import_core44.runnerForProvider)(state.plannerProvider);
+    const runner = (0, import_core47.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}.`);
     }
+    const refusal = known.length === 0 ? vendorModelRefusal(state.plannerProvider, args[1], import_core47.TERMINAL_UI_COMMANDS.pickPlanner) : null;
+    if (refusal) return fail3(state, refusal);
     return step(state, [{ type: "setModel", modelId: args[1] }]);
   }
   if (args.length > 0 && args[0] !== "set") return fail3(state, "Usage: /model [set <model-id>]");
@@ -7640,7 +7741,7 @@ function setModel(state, args) {
 function setPlanner(state, args) {
   if (args[0]) {
     const id = args[0].toLowerCase();
-    if (!(0, import_core44.isPlannerBackend)(id)) {
+    if (!(0, import_core47.isPlannerBackend)(id)) {
       return fail3(state, `Unknown planner: ${id}. Run /planner with no arguments to see the list.`);
     }
     return step(state, [{ type: "setPlanner", provider: id }]);
@@ -7672,7 +7773,7 @@ function setPlannerEffort(state, args) {
 function setKey(state, args) {
   if (args[0] === "set" && args[1]) {
     const provider = args[1].toLowerCase();
-    if (!(0, import_core44.isApiProvider)(provider)) {
+    if (!(0, import_core47.isApiProvider)(provider)) {
       return fail3(state, `Unknown provider: ${provider}. Run /key with no arguments to see the list.`);
     }
     if (!args[2]) {
@@ -7683,16 +7784,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core44.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core47.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: (0, import_core44.getProviderMeta)(id).label,
-    detail: (0, import_core44.getProviderMeta)(id).apiKeyEnvVar,
+    label: (0, import_core47.getProviderMeta)(id).label,
+    detail: (0, import_core47.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 = (0, import_core44.getProviderMeta)(provider);
+  const meta = (0, import_core47.getProviderMeta)(provider);
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -7768,14 +7869,14 @@ 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_core44.parseMaxParallel)(arg);
+  if (!arg) return step(say(state, "system", `Up to ${state.maxParallel} AI task${state.maxParallel === 1 ? "" : "s"} run at once: /parallel <n> changes it.`));
+  const limit = (0, import_core47.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_core44.autonomyLevelLabel)(state.autonomous)} \u2014 /auto full or /auto guarded changes it for new plans.`));
-  const enabled = (0, import_core44.parseAutonomyLevel)(arg);
+  if (arg === void 0) return step(say(state, "system", `Autonomy level: ${(0, import_core47.autonomyLevelLabel)(state.autonomous)}. /auto full or /auto guarded changes it for new plans.`));
+  const enabled = (0, import_core47.parseAutonomyLevel)(arg);
   if (enabled === null) return fail3(state, "Usage: /auto [full|guarded]");
   return step({ ...state, autonomous: enabled }, [{ type: "setAutonomous", enabled }]);
 }
@@ -7788,7 +7889,7 @@ function setMouseCapture(state, arg) {
     // move it.
     { ...state, mouseCapture: enabled, selection: null },
     "system",
-    enabled ? "Mouse capture on \u2014 the wheel scrolls, and dragging selects within one pane and copies on release." : "Mouse capture off \u2014 the terminal's own drag-select is back, across both panes; scroll with pgup/pgdn."
+    enabled ? "Mouse capture on: the wheel scrolls, and dragging selects within one pane and copies on release." : "Mouse capture off: the terminal's own drag-select is back, across both panes; scroll with pgup/pgdn."
   );
   return step(noted, [{ type: "setMouseCapture", enabled }]);
 }
@@ -7800,7 +7901,7 @@ function rewind(state, arg) {
         [{ type: "loadRewindTargets", sessionId }]
       );
     }
-    if (!/^\d+$/.test(arg)) return fail3(state, "Usage: /rewind [<message>] \u2014 or /rewind alone to pick one.");
+    if (!/^\d+$/.test(arg)) return fail3(state, "Usage: /rewind [<message>]: or /rewind alone to pick one.");
     return step(state, [{ type: "loadRewindTargets", sessionId, pick: Number(arg) }]);
   });
 }
@@ -7811,7 +7912,7 @@ var REWIND_OPTIONS = [
 function pickRewindTarget(state, index) {
   return withIdlePlanner({ ...state, overlay: null }, () => {
     const target = state.rewindTargets?.find((t) => t.index === index);
-    if (!target) return fail3({ ...state, overlay: null }, `No message ${index} to rewind to \u2014 /rewind alone lists them.`);
+    if (!target) return fail3({ ...state, overlay: null }, `No message ${index} to rewind to: /rewind alone lists them.`);
     return step({
       ...state,
       overlay: {
@@ -7903,7 +8004,7 @@ function handlePromptKey(state, overlay, key) {
     if (overlay.action.kind === "api-key") {
       return step(closed, [{ type: "setApiKey", provider: overlay.action.provider, key: value2 }]);
     }
-    if (!state.sessionId) return fail3(closed, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
+    if (!state.sessionId) return fail3(closed, "No active plan to add a task to: describe a goal first, then /add-task <title>.");
     return step(closed, [{ type: "addTask", sessionId: state.sessionId, title: value2 }]);
   }
   const value = editText(overlay.value, key);
@@ -7948,7 +8049,7 @@ function choose2(state, picker2, item) {
     return step(closed, [{
       type: "setRunners",
       changes,
-      message: names.length > 0 ? `Runners enabled: ${names.join(", ")}.` : "No runners enabled \u2014 the planner has nothing to assign work to."
+      message: names.length > 0 ? `Runners enabled: ${names.join(", ")}.` : "No runners enabled: the planner has nothing to assign work to."
     }]);
   }
   if (picker2.action.kind === "set-task-deps") {
@@ -7970,7 +8071,7 @@ function choose2(state, picker2, item) {
   }
   if (!item) return step(state);
   if (item.disabled) {
-    return step(say(state, "error", item.detail ? `${item.label} \u2014 ${item.detail}` : `${item.label} is not available.`));
+    return step(say(state, "error", item.detail ? `${item.label}: ${item.detail}` : `${item.label} is not available.`));
   }
   switch (picker2.action.kind) {
     case "set-model":
@@ -7984,7 +8085,7 @@ function choose2(state, picker2, item) {
     case "delete-session":
       return step(closed, [{ type: "deleteSession", sessionId: item.id }]);
     case "set-key":
-      return (0, import_core45.isApiProvider)(item.id) ? step({ ...state, overlay: keyPrompt(item.id) }) : step(closed);
+      return (0, import_core48.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);
@@ -8060,7 +8161,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_core46.EMPTY_RUN));
+      return step(withRun({ ...state, sessionId: action.sessionId, goal: action.goal, taskView: null }, import_core49.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.
@@ -8071,18 +8172,18 @@ function reduceAction(state, action) {
         goal: "",
         taskView: null,
         pendingApprovals: [],
-        queuedPrompts: import_core46.EMPTY_HOLD,
+        queuedPrompts: import_core49.EMPTY_HOLD,
         stopArmed: false,
         forceSendPending: null,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
-      }, import_core46.EMPTY_RUN));
+      }, import_core49.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_core46.fromTranscript)(action.history, action.researchLog, action.plannerUsage, action.pendingTurns), scroll: 0 });
+      return step({ ...state, conversation: (0, import_core49.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" };
@@ -8103,10 +8204,14 @@ function reduceAction(state, action) {
     // its status line with it, as a status update would have set it.
     case "runSnapshot": {
       if (stale(state, action.sessionId)) return step(state);
-      const next = withRun(state, action.view);
+      const run = withRun(state, action.view);
+      const next = action.approvals ? syncApprovals(run, action.approvals) : run;
       const status = runStatus(next, next.tasks);
       return step({ ...next, status });
     }
+    case "heldEdit":
+      if (stale(state, action.sessionId)) return step(state);
+      return step(foldRun(state, { type: "plan_edit_held", held: action.held }));
     case "taskLog":
       if (stale(state, action.sessionId)) return step(state);
       return step(announceApprovals(taskLogArrived(state, action), action));
@@ -8122,15 +8227,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_core26.isTaskRunning)(existing)) return step(state);
+      if (existing && (0, import_core28.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 ?? import_core46.DEFAULT_RUNNERS[0]
+        runner: action.runner ?? import_core49.DEFAULT_RUNNERS[0]
       });
-      const spoken = say(folded, "system", (0, import_core46.taskStartedNotice)(action.title, action.runner));
+      const spoken = say(folded, "system", (0, import_core49.taskStartedNotice)(action.title, action.runner));
       return step({ ...spoken, status: "executing" });
     }
     case "taskCheckpoint":
@@ -8176,13 +8281,13 @@ 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_core46.blockingFailures)(state.tasks).size,
+        blocked: (0, import_core49.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` : ""}`;
       const verb = action.stopped ? "stopped" : "finished";
       return step({
-        ...say(state, "system", `Execution ${verb} \u2014 ${completed}/${total} tasks complete${failures}.`),
+        ...say(state, "system", `Execution ${verb}: ${completed}/${total} tasks complete${failures}.`),
         status: "idle"
       });
     }
@@ -8201,7 +8306,7 @@ function reduceAction(state, action) {
     case "executionLost": {
       if (stale(state, action.sessionId)) return step(state);
       return step({
-        ...say(state, "error", "Lost the connection to the daemon \u2014 this view is no longer following the run, but the daemon may still be running it. /load this session again to see where it stands."),
+        ...say(state, "error", "Lost the connection to the daemon: this view is no longer following the run, but the daemon may still be running it. /load this session again to see where it stands."),
         status: "idle"
       });
     }
@@ -8215,6 +8320,7 @@ function reduceAction(state, action) {
             models: action.models,
             orchestratorModels: action.orchestratorModels ?? state.orchestratorModels,
             configuredProviders: action.providers ?? state.configuredProviders,
+            providersKnown: state.providersKnown || action.providers !== void 0,
             providerErrors: action.providerErrors ?? state.providerErrors,
             modesByRunner: action.modesByRunner ?? state.modesByRunner
           },
@@ -8240,11 +8346,11 @@ function reduceAction(state, action) {
         planner: "idle",
         planApproved: false,
         pendingApprovals: [],
-        queuedPrompts: import_core46.EMPTY_HOLD,
+        queuedPrompts: import_core49.EMPTY_HOLD,
         stopArmed: false,
         forceSendPending: null,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
-      }, import_core46.EMPTY_RUN));
+      }, import_core49.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":
@@ -8258,6 +8364,7 @@ function reduceAction(state, action) {
       return step(refreshStepper(refillPicker({
         ...state,
         runners: action.runners,
+        runnersKnown: true,
         orchestratorModel: action.orchestratorModel ?? state.orchestratorModel
       }, ["set-task-runner"])));
     case "failed": {
@@ -8316,7 +8423,7 @@ function showPlan(state, plan) {
   });
 }
 function runStatus(state, tasks) {
-  if (tasks.some(import_core26.isTaskRunning)) return "executing";
+  if (tasks.some(import_core28.isTaskRunning)) return "executing";
   if (tasks.some((t) => t.status === "awaiting_user") || state.runMerge?.paused) return "executing";
   return "idle";
 }
@@ -8391,13 +8498,13 @@ function submit(state) {
     const command = parseRunnerCommand(text);
     const offered2 = runnerCommands(state.taskView);
     if (command && offered2.length > 0 && !runnerCommandFor(offered2, command.name)) {
-      const notice = `/${command.name} is not a command ${task?.assignedRunner ?? "the runner"} offers this task \u2014 type / to see them.`;
+      const notice = `/${command.name} is not a command ${task?.assignedRunner ?? "the runner"} offers this task: type / to see them.`;
       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 step(say(state, "system", "A tool request is waiting ahead of the checkpoint: 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);
     }
@@ -8408,7 +8515,7 @@ function submit(state) {
   const builtIn = builtInCommand(text);
   if (builtIn) return runCommand(cleared, builtIn);
   if (plannerInFlight(state)) {
-    return step({ ...cleared, queuedPrompts: (0, import_core46.holdPrompt)(state.queuedPrompts, text) });
+    return step({ ...cleared, queuedPrompts: (0, import_core49.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 };
@@ -8483,7 +8590,7 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process3 = require("child_process");
-var import_core47 = require("@ordewell/core");
+var import_core50 = require("@ordewell/core");
 
 // src/tui/inbound.ts
 var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
@@ -8534,6 +8641,52 @@ function identity(event) {
 function replyKey(content, timestamp) {
   return timestamp ? `planner_message:${timestamp}:${content}` : `planner_message:content:${content}`;
 }
+function stampOf(frame2) {
+  return frame2.stream !== void 0 && frame2.seq !== void 0 ? { stream: frame2.stream, seq: frame2.seq } : null;
+}
+var COVERED = /* @__PURE__ */ new Set(["plan_edit_held", "status_update", "task_updated", "approval_request", "approval_settled"]);
+var Delivered = class {
+  constructor(window) {
+    this.window = window;
+  }
+  window;
+  stream = null;
+  highest = 0;
+  snapshot = 0;
+  seen = /* @__PURE__ */ new Set();
+  first({ stream, seq }) {
+    this.follow(stream);
+    if (seq <= this.highest - this.window || this.seen.has(seq)) return false;
+    this.seen.add(seq);
+    if (seq > this.highest) {
+      this.highest = seq;
+      for (const old of this.seen) if (old <= seq - this.window) this.seen.delete(old);
+    }
+    return true;
+  }
+  covered({ seq }) {
+    return seq <= this.snapshot;
+  }
+  /** Whether a snapshot is as new as everything delivered, and so adopted; an older one would undo what came after it. */
+  adopt({ stream, seq }) {
+    this.follow(stream);
+    if (seq < this.highest) return false;
+    this.snapshot = seq;
+    this.highest = seq;
+    return true;
+  }
+  // A new stream is a restarted daemon: its numbers start over and mean nothing against the last one's.
+  follow(stream) {
+    if (stream === this.stream) return;
+    this.stream = stream;
+    this.highest = 0;
+    this.snapshot = 0;
+    this.seen.clear();
+  }
+};
+function isClear(event) {
+  return event.type === "plan_edit_held" && event.held === null || event.type === "approval_settled";
+}
 var Copies = class {
   constructor(cap) {
     this.cap = cap;
@@ -8604,6 +8757,7 @@ function inboundFor(api, dispatch, sessionId) {
   return inbound;
 }
 function createInbound(dispatch, sessionId) {
+  const delivered = new Delivered(256);
   const copies = new Copies(64);
   const shown = new WindowSet(64);
   const pending = new WindowSet(16);
@@ -8612,6 +8766,7 @@ function createInbound(dispatch, sessionId) {
   let timer = null;
   let holdingSnapshot = false;
   let heldSnapshot = null;
+  let heldAfter = [];
   const flush = () => {
     if (timer !== null) {
       clearTimeout(timer);
@@ -8636,8 +8791,17 @@ function createInbound(dispatch, sessionId) {
     shown.add(message.content);
     dispatch({ type: "sessionMessage", message, sessionId });
   };
+  const fresh = (id, event) => {
+    const stamp = stampOf(event);
+    if (stamp) return delivered.first(stamp) && !(COVERED.has(event.type) && delivered.covered(stamp));
+    return isClear(event) || copies.first(id, identity(event));
+  };
   const acceptReply = (id, event) => {
     const key = replyKey(event.content, event.timestamp);
+    if (stampOf(event)) {
+      if (fresh(id, event) && !pending.take(key)) showReply(event);
+      return;
+    }
     if (pending.take(key)) {
       copies.credit(id, key);
       return;
@@ -8645,12 +8809,15 @@ function createInbound(dispatch, sessionId) {
     if (!copies.first(id, key)) return;
     showReply(event);
   };
+  const deliverSnapshot = ({ view, approvals }) => {
+    dispatch({ type: "runSnapshot", view, ...approvals ? { approvals } : {}, sessionId });
+  };
   const deliverConversation = (id, event) => {
     if (event.type === "planner_message") {
       acceptReply(id, event);
       return;
     }
-    if (!copies.first(id, identity(event))) return;
+    if (!fresh(id, event)) return;
     if (event.type === "plan_generated") {
       dispatch({ type: "sessionMessage", message: event, sessionId });
       dispatch({ type: "planBroadcast", plan: event.plan, sessionId });
@@ -8661,12 +8828,18 @@ function createInbound(dispatch, sessionId) {
   const receive = (kind, id, event) => {
     if (event.type === "run_snapshot") {
       flush();
-      if (holdingSnapshot) heldSnapshot = event.view;
-      else dispatch({ type: "runSnapshot", view: event.view, sessionId });
+      const stamp = stampOf(event);
+      if (stamp && !delivered.adopt(stamp)) return;
+      if (holdingSnapshot) heldSnapshot = event;
+      else deliverSnapshot(event);
+      return;
+    }
+    if (holdingSnapshot) {
+      heldAfter.push(() => receive(kind, id, event));
       return;
     }
     if (isStreamed(event)) {
-      if (kind === "planning") hold(event);
+      if (kind === "planning" && (!stampOf(event) || fresh(id, event))) hold(event);
       return;
     }
     flush();
@@ -8674,7 +8847,7 @@ function createInbound(dispatch, sessionId) {
       deliverConversation(id, event);
       return;
     }
-    if (!copies.first(id, identity(event))) return;
+    if (!fresh(id, event)) return;
     dispatchLifecycle(dispatch, event, sessionId);
   };
   let subscription = 0;
@@ -8701,12 +8874,17 @@ function createInbound(dispatch, sessionId) {
     holdSnapshot: () => {
       holdingSnapshot = true;
       heldSnapshot = null;
+      heldAfter = [];
     },
     releaseSnapshot: (deliver) => {
       holdingSnapshot = false;
-      const view = heldSnapshot;
+      const snapshot = heldSnapshot;
+      const after = heldAfter;
       heldSnapshot = null;
-      if (deliver && view) dispatch({ type: "runSnapshot", view, sessionId });
+      heldAfter = [];
+      if (!deliver) return;
+      if (snapshot) deliverSnapshot(snapshot);
+      for (const next of after) next();
     }
   };
 }
@@ -8730,7 +8908,7 @@ function dispatchLifecycle(dispatch, event, sessionId) {
       dispatch({ type: "taskCheckpoint", taskId: String(event.taskId), title: String(event.taskTitle), summary: event.summary, sessionId });
       return;
     case "review_needed":
-      dispatch({ type: "notice", message: "Plan needs your sign-off \u2014 /approve to continue." });
+      dispatch({ type: "notice", message: "Plan needs your sign-off: /approve to continue." });
       return;
     case "review_approved":
       dispatch({ type: "notice", message: "Plan approved." });
@@ -8750,6 +8928,10 @@ function dispatchLifecycle(dispatch, event, sessionId) {
     case "notice":
       dispatch({ type: "notice", message: event.message, level: event.level });
       return;
+    // The pane draws it apart from the plan's rows; the reducer folds it into the run view.
+    case "plan_edit_held":
+      dispatch({ type: "heldEdit", held: event.held, sessionId });
+      return;
     case "isolation_handoff":
       dispatch({ type: "isolationHandoff", handoff: { repos: event.repos, landed: event.landed, ...event.deferredTo ? { deferredTo: event.deferredTo } : {} }, sessionId });
       return;
@@ -8814,7 +8996,7 @@ function isPlannerTurn(effect) {
 }
 function explain(err) {
   if (err instanceof DaemonError && err.code === "session_not_found") {
-    return "This server is no longer holding that session \u2014 it was deleted, or the server restarted. Reload it with /sessions if it is still listed.";
+    return "This server is no longer holding that session: it was deleted, or the server restarted. Reload it with /sessions if it is still listed.";
   }
   return err instanceof Error ? err.message : String(err);
 }
@@ -8830,7 +9012,7 @@ function plannerModelNotice(recall2) {
     case "remembered":
       return `Restored ${recall2.model}.`;
     case "catalog-default":
-      return `Using its default model, ${recall2.model} \u2014 pick another with /model.`;
+      return `Using its default model, ${recall2.model}. Pick another with /model.`;
     case "none":
       return "Pick a model with /model.";
   }
@@ -8892,13 +9074,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_core47.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_core50.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_core47.newTaskFields)(effect.title);
+      const fields = (0, import_core50.newTaskFields)(effect.title);
       if (!fields) return;
       await api.addTask(effect.sessionId, { ...fields });
       await refreshPlan(deps, effect.sessionId);
@@ -8923,7 +9105,7 @@ async function perform(effect, deps) {
       try {
         await api.respondToApproval(effect.sessionId, effect.approvalId, effect.granted);
       } catch {
-        dispatch({ type: "failed", message: "Could not deliver the approval answer \u2014 the planner will treat it as denied." });
+        dispatch({ type: "failed", message: "Could not deliver the approval answer: the planner will treat it as denied." });
       }
       return;
     }
@@ -8932,7 +9114,7 @@ async function perform(effect, deps) {
       try {
         await api.respondToApproval(effect.sessionId, effect.approvalId, effect.answer);
       } catch {
-        dispatch({ type: "failed", message: "Could not deliver the answer \u2014 the task is still waiting for approval." });
+        dispatch({ type: "failed", message: "Could not deliver the answer: the task is still waiting for approval." });
       }
       return;
     }
@@ -9006,8 +9188,13 @@ async function perform(effect, deps) {
       return;
     }
     case "setPlanner": {
-      const meta = (0, import_core47.getProviderMeta)(effect.provider);
+      const meta = (0, import_core50.getProviderMeta)(effect.provider);
       if (!meta) throw new Error(`Unknown planner: ${effect.provider}`);
+      if ((0, import_core50.isCliProvider)(effect.provider)) {
+        const installed = ((await api.getRunners()).runners ?? []).map((r) => r.id);
+        const refusal = uninstalledPlannerRefusal(effect.provider, installed, import_core50.TERMINAL_UI_COMMANDS.pickPlanner);
+        if (refusal) throw new Error(refusal);
+      }
       const env = { AI_PROVIDER: effect.provider };
       const settings = await api.updateSettings({ env });
       const recall2 = plannerSwitchRecall(settings);
@@ -9018,7 +9205,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core47.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
+        message: `${(0, import_core50.isCliProvider)(effect.provider) ? `Planning with ${meta.label}: no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
       });
       await loadModels(deps);
       return;
@@ -9046,7 +9233,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Planner effort set to ${effect.effort || "the runner default"}.` });
       return;
     case "setApiKey": {
-      const meta = (0, import_core47.isApiProvider)(effect.provider) ? (0, import_core47.getProviderMeta)(effect.provider) : void 0;
+      const meta = (0, import_core50.isApiProvider)(effect.provider) ? (0, import_core50.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);
@@ -9089,12 +9276,12 @@ async function perform(effect, deps) {
       }
       if (effect.maxParallel !== void 0) await saveMaxParallel(deps, effect.maxParallel);
       const overridden = effect.autonomous !== void 0 && deps.saveAutonomy(effect.autonomous).overridden;
-      dispatch({ type: "notice", message: overridden ? `${effect.message} \u2014 ORDEWELL_AUTONOMOUS_MODE in the environment decides the autonomy level until it is unset.` : effect.message });
+      dispatch({ type: "notice", message: overridden ? `${effect.message}: ORDEWELL_AUTONOMOUS_MODE in the environment decides the autonomy level until it is unset.` : effect.message });
       return;
     }
     case "setAutonomous": {
       const { overridden } = deps.saveAutonomy(effect.enabled);
-      const level = (0, import_core47.autonomyLevelLabel)(effect.enabled);
+      const level = (0, import_core50.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;
     }
@@ -9132,8 +9319,8 @@ async function perform(effect, deps) {
       }
       const { plan, goal } = adopted2;
       dispatch({ type: "sessionStarted", sessionId: effect.sessionId, goal });
-      inbound.releaseSnapshot(true);
       dispatch(restoredChat(plan, effect.sessionId));
+      inbound.releaseSnapshot(true);
       dispatch({ type: "planUpdated", plan, sessionId: effect.sessionId });
       dispatch({ type: "notice", message: `Loaded "${goal || effect.sessionId}".` });
       return;
@@ -9146,7 +9333,7 @@ async function perform(effect, deps) {
       dispatch({ type: "sessionForked", sessionId: fork.sessionId, goal: fork.goal });
       dispatch(restoredChat(fork.plan, fork.sessionId));
       dispatch({ type: "planUpdated", plan: fork.plan, sessionId: fork.sessionId });
-      dispatch({ type: "notice", message: `Forked ${effect.sessionId} into ${fork.sessionId} \u2014 you are in the fork now. /sessions to go back.` });
+      dispatch({ type: "notice", message: `Forked ${effect.sessionId} into ${fork.sessionId}: you are in the fork now. /sessions to go back.` });
       return;
     }
     case "loadRewindTargets":
@@ -9167,7 +9354,7 @@ async function perform(effect, deps) {
       dispatch(restoredChat(fork.plan, fork.sessionId));
       dispatch({ type: "planUpdated", plan: fork.plan, sessionId: fork.sessionId });
       dispatch({ type: "inputPrefilled", text: fork.rewoundMessage, sessionId: fork.sessionId });
-      dispatch({ type: "notice", message: `Forked ${effect.sessionId} into ${fork.sessionId} from before that message \u2014 the original is kept (/sessions to go back). The message is ready to edit and resend.` });
+      dispatch({ type: "notice", message: `Forked ${effect.sessionId} into ${fork.sessionId} from before that message: the original is kept (/sessions to go back). The message is ready to edit and resend.` });
       return;
     }
     // The redrawn transcript opens with the summary entry, which is what the
@@ -9258,7 +9445,7 @@ async function saveMaxParallel(deps, limit) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core47.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core50.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -9270,7 +9457,7 @@ function copySelection(deps, text) {
   deps.writeTerminal(osc52(text));
   deps.dispatch({
     type: "notice",
-    message: `Copied ${lines} ${lines === 1 ? "line" : "lines"} through the terminal \u2014 no clipboard tool here (pbcopy, xclip, xsel or wl-copy), so it only lands if your terminal supports OSC 52.`
+    message: `Copied ${lines} ${lines === 1 ? "line" : "lines"} through the terminal: no clipboard tool here (pbcopy, xclip, xsel or wl-copy), so it only lands if your terminal supports OSC 52.`
   });
 }
 async function withExecutionStream(deps, sessionId, request) {
@@ -9363,7 +9550,7 @@ function lastAssistantMessage(plan) {
   const history = plan?.conversationHistory ?? [];
   for (let i = history.length - 1; i >= 0; i--) {
     const entry = history[i];
-    if ((0, import_core47.isUserMessage)(entry)) return null;
+    if ((0, import_core50.isUserMessage)(entry)) return null;
     if (entry.role === "assistant" && entry.kind === void 0) {
       const { content, timestamp } = entry;
       return { content, ...timestamp ? { timestamp } : {} };
@@ -9718,7 +9905,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core48.assertWorkspaceExists)(workspace);
+    (0, import_core51.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -9727,7 +9914,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  const discoveredSkills = (0, import_core48.createSkillsService)(workspace, new import_core48.EnvConfig().workspaceRepos).listSkills();
+  const discoveredSkills = (0, import_core51.createSkillsService)(workspace, new import_core51.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;
@@ -9737,24 +9924,37 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
   const api = new ApiClient(port, workspace);
   let terminal;
   const mouseCapture = process.env.ORDEWELL_TUI_MOUSE !== "false" && process.env.ORDEWELL_TUI_MOUSE !== "0";
+  const settings = new import_core51.SettingsService();
   const app = createApp({
     // The level the daemon plans with: the saved one, unless the environment overrides it (ADR-0030).
-    initial: { workspace, autonomous: new import_core48.SettingsService().autonomousMode(), mouseCapture, taskSkills },
+    // The run settings are seeded from the same file because the first frame is
+    // drawn before the daemon answers, and the welcome's autorun line is only
+    // truthful once they are known. That holds only for a daemon this process
+    // spawned, which inherits its settings path; an attached one may read a
+    // different file (ORDEWELL_SETTINGS_PATH), and nothing it reports names that
+    // file, so the welcome stays silent until its own settings arrive.
+    initial: {
+      workspace,
+      autonomous: settings.autonomousMode(),
+      ...ownedAtLaunch ? { runSettings: settings.getRunSettings(), runSettingsKnown: true } : {},
+      mouseCapture,
+      taskSkills
+    },
     draw: (frame2) => terminal?.draw(frame2),
     perform: (effect) => runEffect(effect, {
       api,
       workspace,
       port,
       dispatch: (action) => app.dispatch(action),
-      newSessionId: () => (0, import_core48.mintSessionId)(),
+      newSessionId: () => (0, import_core51.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
       },
       saveAutonomy: (enabled) => {
-        const settings = new import_core48.SettingsService();
-        settings.setAutonomousMode(enabled);
-        return { overridden: settings.autonomousModeOverridden() };
+        const settings2 = new import_core51.SettingsService();
+        settings2.setAutonomousMode(enabled);
+        return { overridden: settings2.autonomousModeOverridden() };
       },
       setMouseCapture: (enabled) => terminal?.setMouse(enabled),
       // The alt screen is up with the cursor hidden, so an OSC 52 write shows
@@ -9866,7 +10066,7 @@ var COMMANDS = {
 // src/main.ts
 var TUI_FLAGS = /* @__PURE__ */ new Set(["--workspace", "--port"]);
 async function main() {
-  (0, import_core49.migrateOldConfigDir)();
+  (0, import_core52.migrateOldConfigDir)();
   moveAutonomyToSettings();
   loadEnvFile();
   const argv = process.argv.slice(2);