@ordewell/cli 0.5.5 → 0.6.0

package/dist/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/main.ts
-var import_core30 = require("@ordewell/core");
+var import_core34 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -33,42 +33,56 @@ var import_core = require("@ordewell/core");
 function findEnvFile() {
   return (0, import_path.join)((0, import_core.globalDataDir)(), ".env");
 }
+function unquote(value) {
+  const quote = value[0];
+  return value.length >= 2 && (quote === '"' || quote === "'") && value.endsWith(quote) ? value.slice(1, -1) : value;
+}
 function loadEnvFile() {
   const filePath = findEnvFile();
   if (!(0, import_fs.existsSync)(filePath)) return;
   const content = (0, import_fs.readFileSync)(filePath, "utf8");
   for (const line of content.split("\n")) {
-    const trimmed = line.trim();
+    const trimmed = line.trim().replace(/^export\s+/, "");
     if (!trimmed || trimmed.startsWith("#")) continue;
     const eq = trimmed.indexOf("=");
     if (eq === -1) continue;
     const key = trimmed.slice(0, eq).trim();
-    const value = trimmed.slice(eq + 1).trim();
+    const value = unquote(trimmed.slice(eq + 1).trim());
     if (key && process.env[key] === void 0) {
       process.env[key] = value;
     }
   }
 }
+var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertValidEnvKey(key) {
+  if (!ENV_KEY_PATTERN.test(key)) {
+    throw new Error(`"${key}" is not a valid environment variable name.`);
+  }
+}
 function writeEnvVar(filePath, key, value) {
-  try {
-    const { dir } = (0, import_path.parse)(filePath);
-    if (!(0, import_fs.existsSync)(dir)) (0, import_fs.mkdirSync)(dir, { recursive: true });
-    let content = "";
-    if ((0, import_fs.existsSync)(filePath)) {
-      content = (0, import_fs.readFileSync)(filePath, "utf8");
-      const regex = new RegExp(`^${key}=.*$`, "m");
-      if (regex.test(content)) {
-        content = content.replace(regex, `${key}=${value}`);
-      } else {
-        content += `
-${key}=${value}
+  assertValidEnvKey(key);
+  if (/[\r\n]/.test(value)) {
+    throw new Error(`Refusing to write ${key}: the value contains a newline.`);
+  }
+  let content = "";
+  if ((0, import_fs.existsSync)(filePath)) {
+    content = (0, import_fs.readFileSync)(filePath, "utf8");
+    const lines = content.split("\n");
+    const index = lines.findIndex((line) => line.startsWith(`${key}=`));
+    if (index === -1) {
+      if (content.length > 0 && !content.endsWith("\n")) content += "\n";
+      content += `${key}=${value}
 `;
-      }
     } else {
-      content = `${key}=${value}
-`;
+      lines[index] = `${key}=${value}`;
+      content = lines.join("\n");
     }
-    (0, import_fs.writeFileSync)(filePath, content);
+  } else {
+    content = `${key}=${value}
+`;
+  }
+  try {
+    (0, import_core.writePrivateFile)(filePath, content);
   } catch (err) {
     console.error(`Could not write to ${filePath}: ${err.message}`);
   }
@@ -106,6 +120,7 @@ Tasks (<id> is an order number or a task ID):
   ordewell force-start <id>       Start a task now, ignoring dependencies
   ordewell run-task <id>          Run only one task
   ordewell retry <id>             Re-run a failed task
+  ordewell continue <id> <msg>    Continue a finished task in its saved runner session
   ordewell cancel <id>            Kill a running task
   ordewell terminal <id>          Open a real terminal attached to a task's runner
 
@@ -123,7 +138,8 @@ Planner, models and runners:
   ordewell key [set <p> <key>]    Show which providers have a key, or store one
   ordewell runners [<id> on|off]  Enable or disable runners (claude-code, opencode, codex)
   ordewell allowlist set|clear|show       Limit which models a runner may use
-  ordewell auto [on|off]          Autonomous permission mode for new sessions
+  ordewell auto [full|auto]       Autonomy level for new sessions: Full auto or Auto
+  ordewell transport [terminal|structured]   Structured (default) or terminal task transport, from the next run
   ordewell parallel [<n>]         How many AI tasks run at once (default 3; applies to a live run)
   ordewell refresh                Re-discover runners and model catalogs
   ordewell models                 List every provider's catalog (works without a server)
@@ -196,7 +212,7 @@ Environment:
   ORDEWELL_PLANNER_EFFORT    Thinking effort for a coding-agent planner
   ORCHESTRATOR_MODEL         Default: deepseek/deepseek-v4-flash
   OPENROUTER_BASE_URL        Default: https://openrouter.ai/api/v1
-  ORDEWELL_AUTONOMOUS_MODE   Approval posture for new sessions (see "ordewell auto")
+  ORDEWELL_AUTONOMOUS_MODE   true: Full auto, false: Auto, for new sessions (see "ordewell auto")
   ORDEWELL_PORT              Daemon port CLI commands target (default: 3742)
   ORDEWELL_DIRENV            false: agents skip the project's direnv .envrc
   ORDEWELL_RESEARCH_ENABLED  true (default) or false
@@ -583,6 +599,40 @@ var ApiClient = class _ApiClient {
     }
     return res.data;
   }
+  /** A user message to a structured task: delivered now if it waits for input, else queued behind its turn. */
+  async sendTaskMessage(sessionId, taskId, text) {
+    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/messages`, { text });
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Send message failed");
+    }
+    return res.data;
+  }
+  /** Continue a finished structured task in its saved session, with `text` as its next turn. */
+  async continueTask(sessionId, taskId, text) {
+    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/continue`, { text });
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Continue failed");
+    }
+    return res.data;
+  }
+  /** `removed` is false once the message was already delivered. */
+  async removeQueuedTaskMessage(sessionId, taskId, messageId) {
+    const res = await this.httpRequest(
+      "DELETE",
+      `/api/plans/${sessionId}/tasks/${taskId}/messages/${encodeURIComponent(messageId)}`
+    );
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Remove message failed");
+    }
+    return res.data;
+  }
+  async interruptTask(sessionId, taskId) {
+    const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks/${taskId}/interrupt`);
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Interrupt failed");
+    }
+    return res.data;
+  }
   async addTask(sessionId, task) {
     const res = await this.httpRequest("POST", `/api/plans/${sessionId}/tasks`, task);
     if (res.status !== 200) {
@@ -742,6 +792,20 @@ var ApiClient = class _ApiClient {
     }
     return res.data;
   }
+  /** The attempts of a structured task that have a saved log, oldest first. */
+  async getTaskLogAttempts(sessionId, taskId, workspace) {
+    const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
+    const res = await this.httpRequest("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log${qs}`);
+    if (res.status !== 200) throw new Error(res.data?.error || "Could not read the task log");
+    return res.data.attempts;
+  }
+  /** One attempt's saved log, for `replayTaskLog`. */
+  async getTaskLog(sessionId, taskId, attempt, workspace) {
+    const qs = workspace ? `?workspace=${encodeURIComponent(workspace)}` : "";
+    const res = await this.httpRequest("GET", `/api/sessions/${sessionId}/tasks/${encodeURIComponent(taskId)}/log/${attempt}${qs}`);
+    if (res.status !== 200) throw new Error(res.data?.error || "Could not read the task log");
+    return res.data.events;
+  }
   /**
    * The one place a session socket is built, so the token travels on both
    * stream paths. It rides as a subprotocol rather than a query parameter, so
@@ -808,12 +872,16 @@ var ApiClient = class _ApiClient {
       });
     });
   }
-  /** Answer a planner approval prompt. Requests arrive over the session socket. */
-  async respondToApproval(sessionId, approvalId, granted) {
+  /**
+   * Answer an approval prompt: the planner's with a yes/no, a task runner's
+   * with the whole decision (ADR-0018, A1). The planner's requests arrive over
+   * the session socket; a runner's, in its task log.
+   */
+  async respondToApproval(sessionId, approvalId, answer) {
     const { status, data } = await this.httpRequest(
       "POST",
       `/api/approvals/${encodeURIComponent(sessionId)}/${encodeURIComponent(approvalId)}`,
-      { granted }
+      typeof answer === "boolean" ? { granted: answer } : answer
     );
     if (status !== 200) throw new Error(`Failed to answer approval ${approvalId} (HTTP ${status})`);
     return data;
@@ -1931,6 +1999,7 @@ ${providerLabel(provider)}`);
 
 // src/commands/setup.ts
 var import_fs6 = require("fs");
+var import_core13 = require("@ordewell/core");
 function handleSetup(subArgs) {
   const modelIdx = subArgs.indexOf("--model");
   const chosenModel = modelIdx !== -1 ? subArgs[modelIdx + 1] : null;
@@ -2002,15 +2071,15 @@ function handleSetup(subArgs) {
 # STEPFUN_API_KEY=...
 # SILICONFLOW_API_KEY=...
 `;
-  (0, import_fs6.writeFileSync)(envFile, content);
+  (0, import_core13.writePrivateFile)(envFile, content);
   console.log(`Wrote: ${envFile}`);
   console.log("Review and edit the file, then run: ordewell tui");
 }
 
 // src/commands/plugins.ts
-var import_core13 = require("@ordewell/core");
+var import_core14 = require("@ordewell/core");
 function handlePlugins(subArgs) {
-  const registry = new import_core13.RunnerRegistry();
+  const registry = new import_core14.RunnerRegistry();
   registry.loadUserPlugins();
   const sub = subArgs[0];
   if (sub === "list" || !sub) {
@@ -2046,7 +2115,7 @@ ${plugins.length} plugin(s):
       process.exit(1);
     }
     try {
-      const resolved = (0, import_core13.classifyPluginSource)(source);
+      const resolved = (0, import_core14.classifyPluginSource)(source);
       const manifest = resolved.kind === "git" ? registry.installFromGit(resolved.url) : registry.installFromPath(resolved.path);
       console.log(`Installed plugin: ${manifest.name} v${manifest.version}`);
     } catch (err) {
@@ -2207,6 +2276,22 @@ async function handleVerify(subArgs, api) {
   }
 }
 
+// src/commands/transport.ts
+var describe = (transport) => `Runner transport: ${transport === "terminal" ? "terminal" : "structured"} \u2014 applies from the next run`;
+async function handleTransport(subArgs, api) {
+  const action = subArgs[0];
+  const port = api ? void 0 : await ensureDaemon(resolvePort(subArgs));
+  const client = api || new ApiClient(port);
+  if (action === "terminal" || action === "structured") {
+    const result = await client.sendCommand("transport", { action });
+    console.log(describe(result.settings?.runnerTransport));
+  } else {
+    const settings = await client.getSettings();
+    console.log(describe(settings.runnerTransport));
+    console.log("Usage: ordewell transport [terminal|structured]");
+  }
+}
+
 // src/commands/task-control.ts
 var PAST_TENSE = {
   run: "Task started.",
@@ -2263,6 +2348,23 @@ function makeHandler(action, command = action) {
     );
   };
 }
+async function handleContinue(subArgs, injectedApi) {
+  const usage = "Usage: ordewell continue <task-id-or-order> <message> [--session-id <id>] [--workspace /path]";
+  const message = positionals(subArgs).slice(1).join(" ").trim();
+  if (!message) {
+    console.error(usage);
+    process.exit(1);
+  }
+  await withResolvedTask(subArgs, usage, injectedApi, async (api, sessionId, taskId) => {
+    try {
+      await api.continueTask(sessionId, taskId, message);
+      console.log("Task continued.");
+    } catch (err) {
+      console.error(`Failed to continue task: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
 var handleRunTask = makeHandler("run", "run-task");
 var handleForceStart = makeHandler("force-start");
 var handleRetry = makeHandler("retry");
@@ -2515,24 +2617,24 @@ async function handleRewind(subArgs, injectedApi) {
 var import_readline2 = require("readline");
 
 // src/tui/transcript.ts
-var import_core14 = require("@ordewell/core");
+var import_core15 = require("@ordewell/core");
 function show(state, { view: conversation, gate: turnGate }) {
   const gated = turnGate === state.turnGate ? state : { ...state, turnGate };
   if (conversation === state.conversation) return gated;
-  const scroll = conversation.nextId > state.conversation.nextId ? 0 : state.scroll;
-  return { ...gated, conversation, scroll };
+  return { ...gated, conversation };
 }
 function fold(state, input) {
-  return show(state, { view: (0, import_core14.reduceConversation)(state.conversation, input), gate: state.turnGate });
+  return show(state, { view: (0, import_core15.reduceConversation)(state.conversation, input), gate: state.turnGate });
 }
 function say(state, role, text) {
-  return fold(state, { type: "local_entry", 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_core14.followTurn)(state.conversation, state.turnGate, message));
+  return show(state, (0, import_core15.followTurn)(state.conversation, state.turnGate, message));
 }
 function cutTurn(state) {
-  return show(state, (0, import_core14.stopTurn)(state.conversation, state.turnGate));
+  return show(state, (0, import_core15.stopTurn)(state.conversation, state.turnGate));
 }
 function wiped(view) {
   return { ...view, blocks: view.blocks.filter((b) => b.type === "usage") };
@@ -2677,7 +2779,13 @@ var style = {
   blue: colour("34"),
   magenta: colour("35"),
   cyan: colour("36"),
-  grey: colour("90")
+  grey: colour("90"),
+  /**
+   * The task view's accent: a bright blue, separate from the planner chat's
+   * cyan and magenta. Bright rather than the plain 34, which reads as black on
+   * a dark background.
+   */
+  accent: colour("94")
 };
 
 // src/tui/handoff.ts
@@ -2927,7 +3035,7 @@ async function handleHandoff(subArgs, injectedApi, confirm = askYesNo) {
 }
 
 // src/commands/planner.ts
-var import_core15 = require("@ordewell/core");
+var import_core16 = require("@ordewell/core");
 
 // src/plannerModelSwitch.ts
 function describePlannerSwitch(settings, provider) {
@@ -2946,7 +3054,7 @@ function rememberedModelFor(settings, provider) {
 }
 
 // src/commands/planner.ts
-var KNOWN_PROVIDERS = Object.keys(import_core15.ALL_PROVIDERS);
+var KNOWN_PROVIDERS = Object.keys(import_core16.ALL_PROVIDERS);
 async function handlePlanner(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
   const [wanted] = positionals(subArgs);
@@ -2961,13 +3069,13 @@ async function handlePlanner(subArgs, injectedApi) {
   const settings = await persistEnv(api, { AI_PROVIDER: provider });
   const recall2 = describePlannerSwitch(settings, provider);
   writeEnv({ ORCHESTRATOR_MODEL: recall2.model, ORDEWELL_PLANNER_EFFORT: recall2.effort });
-  const meta = import_core15.ALL_PROVIDERS[provider];
+  const meta = import_core16.ALL_PROVIDERS[provider];
   const catalog = await fetchCatalog(api);
   console.log(
-    (0, import_core15.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
+    (0, import_core16.isCliProvider)(provider) ? `Planning with ${meta.label} \u2014 no API key needed, it uses that agent's own subscription.` : `Planner set to ${meta.label}.`
   );
   console.log(plannerModelLine(recall2));
-  if (!(0, import_core15.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
+  if (!(0, import_core16.isCliProvider)(provider) && !catalog.providers.includes(provider)) {
     console.log(`  No ${meta.apiKeyEnvVar} configured yet \u2014 set one with \`ordewell key set ${provider} <key>\`.`);
   }
 }
@@ -2985,15 +3093,15 @@ async function showPlanners(api) {
   const [settings, catalog] = await Promise.all([api.getSettings(), fetchCatalog(api)]);
   const current = typeof settings.aiProvider === "string" ? settings.aiProvider : "";
   console.log("\nCoding agents (no API key \u2014 they use their own subscription)");
-  for (const id of import_core15.CLI_PROVIDERS) {
-    const runner = (0, import_core15.runnerForProvider)(id);
+  for (const id of import_core16.CLI_PROVIDERS) {
+    const runner = (0, import_core16.runnerForProvider)(id);
     const discovered = runner ? catalog.models.some((m) => m.runners?.includes(runner)) : false;
-    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core15.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
+    console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${import_core16.ALL_PROVIDERS[id].label}${discovered ? "" : "  (not detected)"}`);
   }
   console.log("\nAPI providers");
-  for (const id of import_core15.PROVIDER_PRIORITY) {
+  for (const id of import_core16.PROVIDER_PRIORITY) {
     const configured = catalog.providers.includes(id);
-    const meta = import_core15.ALL_PROVIDERS[id];
+    const meta = import_core16.ALL_PROVIDERS[id];
     console.log(`  ${marker(id === current)} ${id.padEnd(14)} ${meta.label}${configured ? "" : `  (no ${meta.apiKeyEnvVar})`}`);
   }
   console.log(`
@@ -3010,7 +3118,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_core15.runnerForProvider)(provider);
+  const runner = (0, import_core16.runnerForProvider)(provider);
   if (!runner) {
     fail(
       "Thinking effort applies to a coding-agent planner.",
@@ -3050,7 +3158,7 @@ async function handlePlannerEffort(subArgs, injectedApi) {
 }
 
 // src/commands/parallel.ts
-var import_core16 = require("@ordewell/core");
+var import_core17 = require("@ordewell/core");
 var USAGE5 = "Usage: ordewell parallel [<number of tasks, 1 or more>]";
 async function handleParallel(subArgs, injectedApi) {
   const [wanted] = positionals(subArgs);
@@ -3060,14 +3168,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_core16.parseMaxParallel)(wanted);
+  const limit = (0, import_core17.parseMaxParallel)(wanted);
   if (limit === null) fail(`"${wanted}" is not a number of tasks (1 or more).`, USAGE5);
   await persistEnv(api, { ORDEWELL_MAX_PARALLEL: String(limit) });
   console.log(`Up to ${limit} AI task${limit === 1 ? "" : "s"} now run at once.`);
 }
 
 // src/commands/key.ts
-var import_core17 = require("@ordewell/core");
+var import_core18 = require("@ordewell/core");
 var USAGE6 = "Usage: ordewell key [list | set <provider> <key>]";
 async function handleKey(subArgs, injectedApi) {
   const [action, provider, ...keyParts] = positionals(subArgs);
@@ -3078,8 +3186,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_core17.PROVIDER_PRIORITY) {
-      const meta2 = import_core17.ALL_PROVIDERS[id2];
+    for (const id2 of import_core18.PROVIDER_PRIORITY) {
+      const meta2 = import_core18.ALL_PROVIDERS[id2];
       const configured = catalog.providers.includes(id2);
       console.log(`  ${configured ? "\u2713" : " "} ${id2.padEnd(14)} ${meta2.apiKeyEnvVar.padEnd(28)} ${meta2.label}`);
     }
@@ -3089,7 +3197,7 @@ async function handleKey(subArgs, injectedApi) {
   }
   if (!provider) fail(USAGE6);
   const id = provider.toLowerCase();
-  const meta = import_core17.ALL_PROVIDERS[id];
+  const meta = import_core18.ALL_PROVIDERS[id];
   if (!meta) {
     fail(`Unknown provider: ${provider}`, "Run `ordewell key` to see the list.");
   }
@@ -3100,6 +3208,7 @@ async function handleKey(subArgs, injectedApi) {
 }
 
 // src/commands/runners.ts
+var import_core19 = require("@ordewell/core");
 var USAGE7 = "Usage: ordewell runners [<runner-id> on|off]";
 async function handleRunners(subArgs, injectedApi) {
   const [runner, toggle] = positionals(subArgs);
@@ -3124,21 +3233,21 @@ async function handleRunners(subArgs, injectedApi) {
   await api.setRunnerEnabled(runner, enabled);
   console.log(`${runner} ${enabled ? "enabled" : "disabled"}.`);
 }
-var AUTO_USAGE = "Usage: ordewell auto [on|off]";
+var AUTO_USAGE = "Usage: ordewell auto [full|auto]";
 function handleAuto(subArgs) {
   const [arg] = positionals(subArgs);
   const currentRaw = process.env.ORDEWELL_AUTONOMOUS_MODE;
   const current = currentRaw !== "false" && currentRaw !== "0";
   if (!arg) {
-    console.log(`Autonomous mode: ${current ? "ON" : "OFF"}`);
+    console.log(`Autonomy level: ${(0, import_core19.autonomyLevelLabel)(current)}`);
     console.log(`  ${AUTO_USAGE}`);
     return;
   }
-  const enabled = arg === "on" ? true : arg === "off" ? false : null;
+  const enabled = (0, import_core19.parseAutonomyLevel)(arg);
   if (enabled === null) fail(AUTO_USAGE);
   writeEnvVar(findEnvFile(), "ORDEWELL_AUTONOMOUS_MODE", String(enabled));
   process.env.ORDEWELL_AUTONOMOUS_MODE = String(enabled);
-  console.log(`Autonomous mode ${enabled ? "on" : "off"} for new sessions.`);
+  console.log(`Autonomy level: ${(0, import_core19.autonomyLevelLabel)(enabled)} for new sessions.`);
 }
 async function handleRefresh(subArgs, injectedApi) {
   const api = await connect(subArgs, injectedApi);
@@ -3170,7 +3279,7 @@ async function handleApprove(subArgs, injectedApi) {
 // src/tui/terminalLauncher.ts
 var import_child_process3 = require("child_process");
 var import_util = require("util");
-var import_core18 = require("@ordewell/core");
+var import_core20 = require("@ordewell/core");
 var execFileAsync = (0, import_util.promisify)(import_child_process3.execFile);
 var defaultExecFile = async (command, args) => {
   const { stdout, stderr } = await execFileAsync(command, args);
@@ -3190,16 +3299,16 @@ var defaultWhich = (bin) => {
 async function openTaskTerminal(port, planSessionId, taskId, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const env = deps.env ?? process.env;
-  const hasTmuxImpl = deps.hasTmuxImpl ?? import_core18.hasTmux;
+  const hasTmuxImpl = deps.hasTmuxImpl ?? import_core20.hasTmux;
   const execFileImpl = deps.execFileImpl ?? defaultExecFile;
   const spawnImpl = deps.spawnImpl ?? defaultSpawn;
   const which = deps.which ?? defaultWhich;
   if (!hasTmuxImpl()) {
-    return { ok: false, message: "tmux is not installed \u2014 install it to get a real terminal per task." };
+    return { ok: false, message: "No terminal window for this task: tmux is not installed. Install tmux to get one for terminal-transport tasks; a structured task has its log view instead." };
   }
-  const session = (0, import_core18.tmuxSessionName)(port);
-  const socket = (0, import_core18.tmuxSocketName)(port);
-  const base = (0, import_core18.tmuxWindowName)(taskId, planSessionId);
+  const session = (0, import_core20.tmuxSessionName)(port);
+  const socket = (0, import_core20.tmuxSocketName)(port);
+  const base = (0, import_core20.tmuxWindowName)(taskId, planSessionId);
   let windows;
   try {
     const { stdout } = await execFileImpl("tmux", ["-L", socket, "list-windows", "-t", session, "-F", "#{window_name}"]);
@@ -3209,7 +3318,7 @@ async function openTaskTerminal(port, planSessionId, taskId, deps = {}) {
   }
   const window = latestAttempt(windows, base);
   if (!window) {
-    return { ok: false, message: "This task hasn't opened a terminal yet \u2014 it may still be pending." };
+    return { ok: false, message: "This task has no live terminal and no saved log \u2014 it may still be pending." };
   }
   const manualHint = `tmux -L ${socket} attach -t ${session}:${window}`;
   const viewer = `${session}-view-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
@@ -3493,7 +3602,7 @@ Dependencies \xB7 #${task.order} ${task.title}
 }
 
 // src/tui/index.ts
-var import_core29 = require("@ordewell/core");
+var import_core33 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -3641,7 +3750,8 @@ var SLASH_COMMANDS = [
   { name: "retry", usage: "/retry <id>", description: "Re-run a failed task", category: "tasks" },
   { name: "cancel", usage: "/cancel <id>", description: "Kill a running task", category: "tasks" },
   { name: "force-start", usage: "/force-start <id>", description: "Start a task now, ignoring dependencies", category: "tasks" },
-  { name: "terminal", usage: "/terminal <id>", description: "Open a real terminal attached to a task's runner", category: "tasks" },
+  { name: "continue", usage: "/continue <id> <message>", description: "Continue a finished task in its saved runner session, with your message", category: "tasks" },
+  { name: "terminal", usage: "/terminal <id>", description: "Open a task: its OS terminal, or a structured task's live log", category: "tasks" },
   { name: "task-runner", usage: "/task-runner <id> [runner]", description: "Choose or set a task's executor (re-picks its model and mode)", category: "tasks" },
   { name: "task-model", usage: "/task-model <id> [model]", description: "Choose or set a task's executor model", category: "tasks" },
   { name: "task-effort", usage: "/task-effort <id> [level]", description: "Choose or set a task's thinking effort", category: "tasks" },
@@ -3654,7 +3764,8 @@ var SLASH_COMMANDS = [
   { name: "key", usage: "/key [set <provider> <key>]", description: "Configure API provider keys", category: "models" },
   { name: "allowlist", usage: "/allowlist [set <runner> <ids> | clear <runner>]", description: "Limit which models a runner may use", category: "models" },
   { name: "runners", usage: "/runners [<id> on|off]", description: "Enable or disable runners (claude-code, opencode, codex)", category: "models" },
-  { name: "auto", usage: "/auto [on|off]", description: "Autonomous permission mode for new plans", category: "models" },
+  { name: "auto", usage: "/auto [full|auto]", description: "Autonomy level for new plans: Full auto or Auto", category: "models" },
+  { name: "transport", usage: "/transport [terminal|structured]", description: "Drive tasks through each runner's protocol (structured) or a terminal, from the next run", category: "models" },
   { name: "parallel", usage: "/parallel [<n>]", description: "How many AI tasks run at once (applies to a live run)", category: "models" },
   { name: "refresh", usage: "/refresh", description: "Re-discover runners and model catalogs", category: "models" },
   // Skills
@@ -3739,7 +3850,7 @@ function tokenCompletions(token) {
 }
 
 // src/tui/blocks.ts
-var import_core19 = require("@ordewell/core");
+var import_core21 = require("@ordewell/core");
 
 // src/tui/markdown.ts
 function renderMarkdown(source, cols) {
@@ -3872,13 +3983,14 @@ function tailOf(text, max) {
 var ROLE_PREFIX = {
   user: (t) => `${style.cyan("\u276F")} ${t}`,
   planner: (t) => `${style.magenta("\u25C6")} ${t}`,
+  agent: (t) => `${style.magenta("\u25C6")} ${t}`,
   system: (t) => style.grey(`\xB7 ${t}`),
   error: (t) => `${style.red("\u2717")} ${style.red(t)}`
 };
 function messageLines(block, cols) {
   const text = sanitize(block.text);
   const room = Math.max(1, cols - 2);
-  const wrapped = block.role === "planner" ? renderMarkdown(text, room) : wrap(text, room);
+  const wrapped = block.role === "planner" || block.role === "agent" ? renderMarkdown(text, room) : wrap(text, room);
   return wrapped.map((line, i) => i === 0 ? ROLE_PREFIX[block.role](line) : `  ${line}`);
 }
 function thinkingLines(block, cols, detailAll) {
@@ -3946,16 +4058,16 @@ function resultLines(block, room, detailAll) {
   const fit2 = (line) => detailAll ? wrap(line, room) : [truncate(line, room)];
   const outcome = unsettledOutcome(block);
   if (outcome) {
-    const [reason, ...rest] = (0, import_core19.outputLines)(block.output).map(sanitize);
+    const [reason, ...rest] = (0, import_core21.outputLines)(block.output).map(sanitize);
     const status = fit2(reason ? `${outcome.label}: ${reason}` : outcome.label).map(outcome.paint);
     return detailAll ? [...status, ...rest.flatMap(fit2).map(style.grey)] : status;
   }
   if (detailAll) {
-    const lines2 = (0, import_core19.outputLines)(block.output).map(sanitize);
+    const lines2 = (0, import_core21.outputLines)(block.output).map(sanitize);
     const note = lines2.length > PREVIEW_LINES ? ["\u2026 (ctrl+o to collapse)"] : [];
     return lines2.length > 0 ? [...lines2.flatMap(fit2), ...note].map(style.grey) : [style.grey("(no output)")];
   }
-  const { lines, hiddenLineCount } = (0, import_core19.outputPreview)(block.output, PREVIEW_LINES);
+  const { lines, hiddenLineCount } = (0, import_core21.outputPreview)(block.output, PREVIEW_LINES);
   if (lines.length === 0) return [style.grey("(no output)")];
   const more = hiddenLineCount > 0 ? [`\u2026 +${countOf(hiddenLineCount, "line")} (ctrl+o to expand)`] : [];
   return [...lines.map(sanitize), ...more].map((line) => style.grey(truncate(line, room)));
@@ -3996,7 +4108,8 @@ function subagentLines(block, cols, detailAll) {
 var APPROVAL_KIND = {
   shell_command: "Run a command",
   url_fetch: "Fetch a URL",
-  external_path: "Read outside the workspace"
+  external_path: "Read outside the workspace",
+  runner_tool: "Use a tool"
 };
 var DECIDED_BY = {
   "pre-approved": "pre-approved",
@@ -4006,8 +4119,9 @@ var DECIDED_BY = {
 };
 function approvalLine(block, cols) {
   const policy = block.decidedBy && block.decidedBy !== "asked" ? DECIDED_BY[block.decidedBy] : void 0;
-  const [mark, status, paint] = block.status === "pending" ? ["?", "Waiting for you", style.yellow] : block.status === "granted" ? ["\u2713", policy ? `Auto-approved (${policy})` : "Approved", style.green] : ["\u2298", policy ? `Auto-denied (${policy})` : "Denied", style.yellow];
-  const line = `${mark} ${status} \xB7 ${APPROVAL_KIND[block.kind]}: ${firstLine(block.subject)}`;
+  const [mark, status, paint] = block.status === "pending" ? ["?", "Waiting for you", style.yellow] : block.status === "granted" ? ["\u2713", policy ? `Auto-approved (${policy})` : block.forTask ? "Approved for this task" : "Approved", style.green] : block.status === "withdrawn" ? ["\xB7", "Withdrawn", style.grey] : ["\u2298", policy ? `Auto-denied (${policy})` : "Denied", style.yellow];
+  const note = block.note ? ` \u2014 \u201C${firstLine(block.note)}\u201D` : "";
+  const line = `${mark} ${status} \xB7 ${APPROVAL_KIND[block.kind]}: ${firstLine(block.subject)}${note}`;
   return `${paint(mark)}${truncate(line, cols).slice(mark.length)}`;
 }
 function planLine(block, cols) {
@@ -4073,38 +4187,8 @@ function tokenLine(blocks, cols) {
   return parts.length > 0 ? style.grey(truncate(parts.join(" \xB7 "), cols)) : null;
 }
 
-// src/tui/geometry.ts
-var PLAN_MIN_COLS = 32;
-var PLAN_MAX_COLS = 64;
-var PANE_INDENT = 4;
-var CHAT_PROMPT_COLS = 2;
-function planPaneWidth(state) {
-  if (state.tasks.length === 0) return 0;
-  const wanted = Math.min(PLAN_MAX_COLS, Math.floor(state.cols * 0.46));
-  return wanted >= PLAN_MIN_COLS && state.cols - wanted > PLAN_MIN_COLS ? wanted : 0;
-}
-function chatPaneWidth(state) {
-  const plan = planPaneWidth(state);
-  return plan === 0 ? state.cols : state.cols - plan - 1;
-}
-function paneColumns(state, pane) {
-  const plan = planPaneWidth(state);
-  if (plan === 0) return { first: 1, last: state.cols };
-  const chat = chatPaneWidth(state);
-  return pane === "chat" ? { first: 1, last: chat } : { first: chat + 2, last: state.cols };
-}
-function paneTextRoom(paneCols) {
-  return Math.max(1, paneCols - PANE_INDENT);
-}
-function taskEditorRoom(state) {
-  return paneTextRoom(planPaneWidth(state));
-}
-function chatEditorRoom(cols, active) {
-  return Math.max(1, cols - CHAT_PROMPT_COLS - (active ? 1 : 0));
-}
-
 // src/tui/state.ts
-var import_core20 = require("@ordewell/core");
+var import_core22 = require("@ordewell/core");
 var SKILL_IDS = ["tdd", "verify"];
 function noSkills() {
   return { tdd: false, verify: false };
@@ -4134,6 +4218,12 @@ function planRows(state) {
 function selectedPlanRow(state) {
   return planRows(state)[state.selectedTask] ?? null;
 }
+function waitingApproval(tv) {
+  return tv.view.blocks.find((b) => b.type === "approval" && b.status === "pending" && b.approvalId !== void 0);
+}
+function continuesTask(task) {
+  return task?.continuable === true && (task.status === "completed" || task.status === "failed");
+}
 function findTask(tasks, id) {
   for (const task of tasks) {
     if (task.id === id) return task;
@@ -4145,8 +4235,9 @@ function findTask(tasks, id) {
 function initialState(overrides = {}) {
   return {
     editor: emptyEditor(),
-    conversation: import_core20.EMPTY_CONVERSATION,
-    turnGate: import_core20.NO_TURN,
+    conversation: import_core22.EMPTY_CONVERSATION,
+    taskView: null,
+    turnGate: import_core22.NO_TURN,
     detailAll: false,
     status: "idle",
     busyLabel: "",
@@ -4171,17 +4262,18 @@ function initialState(overrides = {}) {
     orchestratorModel: "",
     plannerProvider: "",
     plannerEffort: "",
-    maxParallel: import_core20.DEFAULT_MAX_PARALLEL,
+    maxParallel: import_core22.DEFAULT_MAX_PARALLEL,
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
+    runnerTransport: "structured",
     mouseCapture: true,
     selection: null,
     workspace: process.cwd(),
     handoff: null,
     overlay: null,
     pendingApprovals: [],
-    queuedPrompts: import_core20.EMPTY_HOLD,
+    queuedPrompts: import_core22.EMPTY_HOLD,
     stopArmed: false,
     stopArmToken: 0,
     stopRequested: false,
@@ -4194,19 +4286,53 @@ function initialState(overrides = {}) {
   };
 }
 
+// src/tui/geometry.ts
+var PLAN_MIN_COLS = 32;
+var PLAN_MAX_COLS = 64;
+var PANE_INDENT = 4;
+function planPaneWidth(state) {
+  if (state.tasks.length === 0) return 0;
+  const wanted = Math.min(PLAN_MAX_COLS, Math.floor(state.cols * 0.46));
+  return wanted >= PLAN_MIN_COLS && state.cols - wanted > PLAN_MIN_COLS ? wanted : 0;
+}
+function chatPaneWidth(state) {
+  const plan = planPaneWidth(state);
+  return plan === 0 ? state.cols : state.cols - plan - 1;
+}
+function paneColumns(state, pane) {
+  const plan = planPaneWidth(state);
+  if (plan === 0) return { first: 1, last: state.cols };
+  const chat = chatPaneWidth(state);
+  return pane === "chat" ? { first: 1, last: chat } : { first: chat + 2, last: state.cols };
+}
+function paneTextRoom(paneCols) {
+  return Math.max(1, paneCols - PANE_INDENT);
+}
+function taskEditorRoom(state) {
+  return paneTextRoom(planPaneWidth(state));
+}
+function chatPromptLabel(state) {
+  if (!state.taskView) return "\u276F";
+  const task = findTask(state.tasks, state.taskView.taskId);
+  return `\u2192 ${continuesTask(task) ? "Continue task" : "Task"} ${task?.order ?? "?"}`;
+}
+function chatEditorRoomFor(state, active) {
+  return Math.max(1, state.cols - width(chatPromptLabel(state)) - 1 - (active ? 1 : 0));
+}
+
 // src/tui/layout.ts
-var import_core21 = require("@ordewell/core");
+var import_core23 = require("@ordewell/core");
 var CHROME_ROWS = 4;
 function chatInputWrap(state) {
   const active = state.focus === "chat" && !state.overlay;
   if (!active) return null;
-  return wrapLines(state.editor.text, chatEditorRoom(state.cols, true));
+  return wrapLines(state.editor.text, chatEditorRoomFor(state, true));
 }
 function footerHints(state) {
   const selected = selectedPlanRow(state)?.task;
   const markHint = selected?.status === "completed" ? "m undone" : "m done";
   const resolveHint = selected?.isolation?.state === "conflict" ? ["x resolve conflict"] : [];
-  const planning = plannerInFlight(state);
+  const planning = plannerInFlight(state) && !state.taskView;
   const escHint = !planning ? null : state.queuedPrompts.length > 0 ? "esc unsend" : "esc \xD72 stop planning";
   if (state.focus === "plan") {
     if (state.taskEditor) {
@@ -4234,7 +4360,7 @@ function footerHints(state) {
       "tab chat"
     ];
   }
-  const detailHint = (0, import_core21.hasHiddenDetail)(state.conversation.blocks) ? [state.detailAll ? "ctrl-o collapse all" : "ctrl-o expand all"] : [];
+  const detailHint = (0, import_core23.hasHiddenDetail)(state.taskView ? state.taskView.view.blocks : state.conversation.blocks) ? [state.detailAll ? "ctrl-o collapse all" : "ctrl-o expand all"] : [];
   return [
     "/help",
     "tab plan",
@@ -4252,6 +4378,43 @@ function queuedBubble(text, cols) {
   const room = Math.max(1, cols - width("\u25C7  \xB7 queued \xB7 esc to unsend"));
   return wrap(text, room).map((line, i) => i === 0 ? truncate(`${style.grey(`\u25C7 ${line}`)} \xB7 queued \xB7 esc to unsend`, cols) : truncate(style.grey(`  ${line}`), cols));
 }
+function taskQueuedRows(state, cols) {
+  const tv = state.taskView;
+  if (!tv) return [];
+  return tv.view.queued.flatMap((message, i) => queuedTaskBubble(message.text, i === tv.queuedIndex, cols));
+}
+function queuedTaskBubble(text, selected, cols) {
+  const marker2 = selected ? style.accent("\u276F") : style.grey("\u25C7");
+  const tag = selected ? " \xB7 queued \xB7 ctrl-r removes" : " \xB7 queued";
+  const room = Math.max(1, cols - width(`\u276F \u25C7  ${tag}`));
+  return wrap(text, room).map((line, i) => i === 0 ? truncate(`${marker2} ${selected ? style.bold(line) : line}${style.grey(tag)}`, cols) : truncate(`  ${line}`, cols));
+}
+function taskActivity(task, working) {
+  if (task?.awaitingApproval) return approvalLabel(task.awaitingApproval);
+  if (working) return "working";
+  if (task?.status === "awaiting_user") {
+    return task.awaitingReason ? AWAITING_LABEL[task.awaitingReason] : "waiting for your input";
+  }
+  return task?.status ?? "";
+}
+function taskHeaderLines(state, tv, cols) {
+  const task = findTask(state.tasks, tv.taskId);
+  const parts = [
+    `\u2192 Task ${task?.order ?? "?"}`,
+    task?.title ?? "(task removed)",
+    task?.assignedRunner ?? "",
+    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)"] : ["ctrl-r remove queued", "ctrl-x interrupt"];
+  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}`);
+  hint.push("esc back");
+  return [
+    style.accent(truncate(parts.join(" \xB7 "), cols)),
+    style.grey(truncate(hint.join(" \xB7 "), cols))
+  ];
+}
 function stopHint(state) {
   return plannerInFlight(state) && state.stopArmed ? "Press Esc again to stop" : "";
 }
@@ -4284,24 +4447,27 @@ function chatBodyLines(blocks, cols, detailAll) {
   return lines;
 }
 function chatLayout(state, rows, cols) {
-  const welcome = state.tasks.length === 0;
-  const body = chatBodyLines(state.conversation.blocks, cols, state.detailAll);
+  const tv = state.taskView;
+  const blocks = tv ? tv.view.blocks : state.conversation.blocks;
+  const welcome = !tv && state.tasks.length === 0;
+  const body = chatBodyLines(blocks, cols, state.detailAll);
   const transcript = !welcome ? body : body.length === 0 ? welcomeLines(state, cols) : [...welcomeLines(state, cols), "", ...body];
-  const bubbles = queuedPromptRows(state, cols);
+  const bubbles = tv ? taskQueuedRows(state, cols) : queuedPromptRows(state, cols);
   const lines = [...transcript, ...bubbles.length > 0 ? ["", ...bubbles] : []];
-  const usage = rows > 1 ? tokenLine(state.conversation.blocks, cols) : null;
+  const header = tv ? taskHeaderLines(state, tv, cols) : [];
+  const usage = rows > 1 ? tokenLine(blocks, cols) : null;
   const footer = usage ? [usage] : [];
-  const room = rows - footer.length;
-  return { lines, footer, anchor: lines.length > room ? "bottom" : "top", maxScroll: Math.max(0, lines.length - room) };
+  const room = Math.max(0, rows - header.length - footer.length);
+  return { lines, header, footer, anchor: lines.length > room ? "bottom" : "top", maxScroll: Math.max(0, lines.length - room) };
 }
 function chatScrollMax(state) {
   return chatLayout(state, bodyRows(state), chatPaneWidth(state)).maxScroll;
 }
 function plannerSetup(state) {
   const provider = state.plannerProvider;
-  const registration = import_core21.ALL_PROVIDERS[provider];
+  const registration = import_core23.ALL_PROVIDERS[provider];
   if (!registration) return { label: "not set", ready: false };
-  const runner = (0, import_core21.runnerForProvider)(provider);
+  const runner = (0, import_core23.runnerForProvider)(provider);
   const ready = runner ? state.runners.some((r) => r.id === runner) : state.configuredProviders.includes(provider);
   return { label: registration.label, ready };
 }
@@ -4408,6 +4574,14 @@ var STATUS_ICON = {
   approved: "\xB7",
   pending: "\xB7"
 };
+var AWAITING_LABEL = {
+  input: "waiting for your input",
+  checkpoint: "checkpoint",
+  conflict: "merge conflict"
+};
+function approvalLabel(count) {
+  return count > 1 ? `waiting for approval (${count})` : "waiting for approval";
+}
 var IDLE_ICON = "~";
 var FIRST_ROW_LINE = 2;
 function planLayout(state, rows, cols) {
@@ -4484,7 +4658,7 @@ function taskLines(state, row, index, cols) {
   const icon = paint(rawIcon);
   const kind = running ? style.yellow("RUN") : task.type === "user" ? style.yellow("MAN") : style.grey(" AI");
   const caret = selected ? style.cyan("\u276F") : " ";
-  const orderLabel = parent ? (0, import_core21.taskOrderLabel)(task, parent) : String(task.order).padStart(2);
+  const orderLabel = parent ? (0, import_core23.taskOrderLabel)(task, parent) : String(task.order).padStart(2);
   const indent = parent ? "  " : "";
   const head = `${indent}${caret} ${icon} ${orderLabel} ${kind} `;
   const titleRoom = Math.max(1, cols - width(head));
@@ -4505,22 +4679,25 @@ function taskLines(state, row, index, cols) {
   const mode = task.type === "ai" ? `mode: ${task.taskMode ?? "default"}${modeInfo?.autonomous ? style.yellow(" \u26A1") : ""}` : "";
   const runner = task.assignedRunner ?? "";
   const bodyPad = parent ? "      " : "    ";
-  const activity = idle ? "quiet \u2014 t opens its terminal" : running ? "working" : "";
-  const meta = [activity, runner, model].filter(Boolean).join(" \xB7 ");
+  const structured = task.transport?.kind === "structured";
+  const waiting = task.status === "awaiting_user" && task.awaitingReason ? AWAITING_LABEL[task.awaitingReason] : "";
+  const activity = task.awaitingApproval ? `${approvalLabel(task.awaitingApproval)} \u2014 t opens it` : idle ? structured ? "quiet" : "quiet \u2014 t opens its terminal" : running ? "working" : waiting;
+  const meta = [activity, runner, structured ? "structured" : "", model].filter(Boolean).join(" \xB7 ");
   if (meta) lines.push(style.grey(truncate(`${bodyPad}${meta}`, cols)));
+  if (task.transport?.fallback) lines.push(style.yellow(truncate(`${bodyPad}terminal: ${task.transport.fallback}`, cols)));
   if (effort || mode) lines.push(style.grey(truncate(`${bodyPad}${[effort, mode].filter(Boolean).join(" \xB7 ")}`, cols)));
   if (task.isolation?.state === "conflict") {
     const where = task.isolation.conflictRepo && task.isolation.conflictRepo !== "." ? ` in ${task.isolation.conflictRepo}` : "";
-    const files = task.isolation.conflictFiles?.length ? ` (${(0, import_core21.capConflictFiles)(task.isolation.conflictFiles)})` : "";
+    const files = task.isolation.conflictFiles?.length ? ` (${(0, import_core23.capConflictFiles)(task.isolation.conflictFiles)})` : "";
     lines.push(style.red(truncate(`${bodyPad}\u26A0 merge conflict${where}${files} \u2014 its work is kept on its own branch`, cols)));
   }
   if (task.isolation?.state === "repairing") {
-    const files = task.isolation.conflictFiles?.length ? ` in ${(0, import_core21.capConflictFiles)(task.isolation.conflictFiles)}` : "";
+    const files = task.isolation.conflictFiles?.length ? ` in ${(0, import_core23.capConflictFiles)(task.isolation.conflictFiles)}` : "";
     const attempt = task.isolation.repair ? ` (attempt ${task.isolation.repair.attempt}/${task.isolation.repair.limit})` : "";
     lines.push(style.yellow(truncate(`${bodyPad}\u21BB repairing conflict${files}${attempt}`, cols)));
   }
   if (task.isolation?.state === "integrated" && task.isolation.repairedFiles?.length) {
-    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${(0, import_core21.capConflictFiles)(task.isolation.repairedFiles)}`, cols)));
+    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${(0, import_core23.capConflictFiles)(task.isolation.repairedFiles)}`, cols)));
   }
   let editorLine;
   if (expanded) {
@@ -4534,7 +4711,7 @@ function taskLines(state, row, index, cols) {
       }
     }
     if (modeInfo?.autonomous) {
-      lines.push(...taskText("Autonomy", "Runs without permission prompts. Toggle with /auto.", cols, bodyPad));
+      lines.push(...taskText("Autonomy", "Runs without permission prompts (Full auto). Change the level with /auto.", cols, bodyPad));
     }
     const editableSeed = task.prompt ?? task.description ?? task.title;
     if (task.description && task.description !== task.title && task.description !== editableSeed) {
@@ -4596,6 +4773,9 @@ function helpLayout(rows, 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")
   );
+  body.push(
+    style.grey("in a task view (t or /terminal on a structured task): ctrl-r removes the selected queued message \xB7 ctrl-x interrupts \xB7 ctrl-y allows a tool request \xB7 ctrl-t allows it for the task \xB7 ctrl-g denies it, with the composer text as the note \xB7 alt\u2190/\u2192 changes attempt \xB7 esc returns")
+  );
   const lines = body.map((line) => truncate(line, Math.max(1, cols - 2)));
   const room = Math.max(1, rows - 2);
   return { lines, room, maxScroll: Math.max(0, lines.length - room) };
@@ -4605,7 +4785,7 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
-var import_core22 = require("@ordewell/core");
+var import_core24 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
@@ -4614,7 +4794,7 @@ function render(state) {
     renderSkills(state, cols),
     ...body,
     renderStatus(state, cols),
-    ...renderInput(state, cols),
+    ...renderInput(state),
     ...renderFooter(state, cols)
   ];
   const frame2 = lines.slice(Math.max(0, lines.length - rows)).map((l) => pad(l, cols));
@@ -4700,8 +4880,9 @@ function renderSkills(state, cols) {
   const badges = SKILL_IDS.map(
     (id) => state.skills[id] ? style.green(`\u25CF ${id}`) : style.grey(`\u25CB ${id}`)
   );
-  const auto = state.autonomous ? style.yellow("\u25CF auto") : style.grey("\u25CB auto");
-  return truncate([...badges, auto].join(" "), cols);
+  const auto = state.autonomous ? style.yellow("\u25CF Full auto") : style.green("\u25CF Auto");
+  const terminal = state.runnerTransport === "terminal" ? [style.yellow("\u25CF terminal")] : [];
+  return truncate([...badges, auto, ...terminal].join(" "), cols);
 }
 function scrolledBackMark(state) {
   return state.focus !== "plan" && state.scroll > 0 ? "\u2191 scrolled back \xB7 pgdn for live" : "";
@@ -4746,10 +4927,10 @@ function paintSpans(text, base, spans) {
   }
   return out + text.slice(cursor);
 }
-function renderInput(state, cols) {
-  const prompt = state.focus === "plan" ? style.grey("\u276F ") : style.cyan("\u276F ");
+function renderInput(state) {
+  const prompt = state.taskView ? style.accent(`${chatPromptLabel(state)} `) : state.focus === "plan" ? style.grey("\u276F ") : style.cyan("\u276F ");
   const lines = chatInputWrap(state);
-  const room = chatEditorRoom(cols, lines !== null);
+  const room = chatEditorRoomFor(state, lines !== null);
   const { text, cursor } = state.editor;
   const continuation = " ".repeat(width(prompt));
   const spans = highlightSpans(text);
@@ -4792,16 +4973,18 @@ function renderBody(state, rows, cols) {
   const chatCols = chatPaneWidth(state);
   const chat = renderChat(state, rows, chatCols);
   const plan = renderPlan(state, rows, planCols);
-  const divider = `${ERASE_TO_END}${atColumn(chatCols + 1)}${style.grey("\u2502")}`;
+  const border = state.taskView ? style.accent("\u2502") : style.grey("\u2502");
+  const divider = `${ERASE_TO_END}${atColumn(chatCols + 1)}${border}`;
   return Array.from(
     { length: rows },
     (_, i) => `${pad(chat[i] ?? "", chatCols)}${divider}${pad(plan[i] ?? "", planCols)}`
   );
 }
 function renderChat(state, rows, cols) {
-  const { lines, footer, anchor, maxScroll } = chatLayout(state, rows, cols);
+  const { lines, header, footer, anchor, maxScroll } = chatLayout(state, rows, cols);
   const back = Math.min(state.scroll, maxScroll);
-  return [...fit(lines.slice(0, lines.length - back), rows - footer.length, anchor), ...footer];
+  const body = Math.max(0, rows - header.length - footer.length);
+  return [...header, ...fit(lines.slice(0, lines.length - back), body, anchor), ...footer];
 }
 function renderPlan(state, rows, cols) {
   const layout = planLayout(state, rows, cols);
@@ -4867,7 +5050,7 @@ function renderHandoff(state, overlay, rows, cols) {
     return frame(`Diff \u2014 ${handoffBranch(handoff)}`, [...shown, "", style.grey(`${more}enter or esc goes back`)], rows, cols);
   }
   const landed = handoff.landed.length === 0 ? [style.grey("Nothing landed on it.")] : handoff.landed.map((task) => {
-    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core22.capConflictFiles)(task.repairedFiles)})`) : "";
+    const repaired = task.repairedFiles?.length ? style.yellow(` \u2014 repaired (${(0, import_core24.capConflictFiles)(task.repairedFiles)})`) : "";
     return `  ${style.green("\u2713")} #${task.order} ${task.title}${repaired}`;
   });
   const actions = handoffActions(handoff).map((action, index) => {
@@ -4957,7 +5140,7 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core26 = require("@ordewell/core");
+var import_core30 = require("@ordewell/core");
 
 // src/tui/reducers/shared.ts
 function step(state, effects = []) {
@@ -5006,10 +5189,10 @@ function handleApprovalKey(state, overlay, key) {
 }
 
 // src/tui/reducers/commands.ts
-var import_core25 = require("@ordewell/core");
+var import_core28 = require("@ordewell/core");
 
 // src/tui/reducers/pickers.ts
-var import_core23 = require("@ordewell/core");
+var import_core25 = require("@ordewell/core");
 var import_plan_utils2 = require("@ordewell/core/plan-utils");
 var DEFAULT_EFFORT = "__runner_default__";
 function picker(title, items, action, extra = {}) {
@@ -5028,11 +5211,11 @@ function modelDetail(m) {
 function providerErrorHint(state) {
   const failed = Object.keys(state.providerErrors ?? {});
   if (failed.length === 0) return void 0;
-  const names = failed.map((p) => import_core23.ALL_PROVIDERS[p]?.label ?? p);
+  const names = failed.map((p) => import_core25.ALL_PROVIDERS[p]?.label ?? p);
   return `\u26A0 Unavailable (key or fetch failed): ${names.join(", ")} \u2014 showing working providers only.`;
 }
 function plannerModelItems(state) {
-  const runner = (0, import_core23.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core25.runnerForProvider)(state.plannerProvider);
   if (!runner) return state.orchestratorModels.map((m) => ({ id: m.id, label: m.label, detail: modelDetail(m) }));
   const items = state.models.filter((m) => m.runners?.includes(runner)).map((m) => ({
     id: m.id,
@@ -5046,7 +5229,7 @@ function plannerModelItems(state) {
   return items.length > 0 ? items : [{ id: "", label: `No ${runner} models discovered yet`, detail: "run /refresh", disabled: true }];
 }
 function plannerEffortItems(state) {
-  const runner = (0, import_core23.runnerForProvider)(state.plannerProvider);
+  const runner = (0, import_core25.runnerForProvider)(state.plannerProvider);
   if (!runner) {
     return [{ id: "", label: "Thinking effort applies to a coding-agent planner", detail: "switch with /planner", disabled: true }];
   }
@@ -5155,21 +5338,21 @@ function pickerItemsFor(state, action) {
 }
 function plannerItems(state) {
   const installed = new Set(state.runners.map((r) => r.id));
-  const agents = import_core23.CLI_PROVIDERS.map((id) => {
-    const runner = (0, import_core23.runnerForProvider)(id);
+  const agents = import_core25.CLI_PROVIDERS.map((id) => {
+    const runner = (0, import_core25.runnerForProvider)(id);
     const ready = installed.has(runner);
     return {
       id,
-      label: import_core23.ALL_PROVIDERS[id].label,
+      label: import_core25.ALL_PROVIDERS[id].label,
       detail: ready ? "coding agent \xB7 no API key needed" : "CLI not installed or not on PATH",
       selected: state.plannerProvider === id,
       disabled: !ready
     };
   });
-  const vendors = import_core23.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
+  const vendors = import_core25.PROVIDER_PRIORITY.filter((id) => state.configuredProviders.includes(id)).map((id) => ({
     id,
-    label: import_core23.ALL_PROVIDERS[id].label,
-    detail: import_core23.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core25.ALL_PROVIDERS[id].label,
+    detail: import_core25.ALL_PROVIDERS[id].apiKeyEnvVar,
     selected: state.plannerProvider === id
   }));
   return vendors.length > 0 ? [...agents, ...vendors] : [...agents, { id: "", label: "No API providers configured", detail: "add a key with /key", disabled: true }];
@@ -5250,6 +5433,139 @@ function handleMouseSelect(state, key) {
   return step({ ...state, selection: null }, [{ type: "copyText", text: selectedText({ ...state, selection: moved }) }]);
 }
 
+// src/tui/reducers/taskView.ts
+var import_core26 = 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_core26.EMPTY_TASK_LOG,
+    attempts: [],
+    attempt: 0,
+    pending: [],
+    loaded: false,
+    followLatest: true,
+    queuedIndex: 0
+  };
+  return step({ ...state, taskView, focus: "chat", scroll: 0 }, [{ type: "openTaskLog", sessionId, taskId }]);
+}
+function openTaskTerminalOrView(state, sessionId, taskId) {
+  const task = findTask(state.tasks, taskId);
+  if (task?.transport?.kind === "structured") return openTaskView(state, sessionId, taskId);
+  return step(state, [{ type: "openTaskTerminal", sessionId, taskId }]);
+}
+function continueTaskStep(state, sessionId, taskId, text) {
+  const opened = state.taskView?.taskId === taskId ? step({ ...state, taskView: { ...state.taskView, followLatest: true } }) : openTaskView(state, sessionId, taskId);
+  const watch = state.status !== "executing";
+  return step(opened.state, [...opened.effects, { type: "continueTask", sessionId, taskId, text, ...watch ? { watch: true } : {} }]);
+}
+function clampQueueIndex(tv) {
+  const max = Math.max(0, tv.view.queued.length - 1);
+  return tv.queuedIndex <= max ? tv : { ...tv, queuedIndex: max };
+}
+function applyLive(tv, attempt, events) {
+  if (attempt <= 0) return tv;
+  let next = tv;
+  if (attempt > next.attempt) {
+    if (!next.followLatest) {
+      return next.attempts.includes(attempt) ? next : { ...next, attempts: [...next.attempts, attempt] };
+    }
+    next = {
+      ...next,
+      view: import_core26.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_core26.reduceTaskLog, next.view) });
+}
+function taskLogAbandoned(state) {
+  const tv = state.taskView;
+  if (!tv || tv.loaded) return state;
+  let next = { ...tv, pending: [], loaded: true };
+  for (const batch of tv.pending) next = applyLive(next, batch.attempt, batch.events);
+  return { ...state, taskView: clampQueueIndex(next) };
+}
+function taskLogArrived(state, action) {
+  const tv = state.taskView;
+  if (!tv || tv.taskId !== action.taskId) return state;
+  if (!tv.loaded) {
+    return { ...state, taskView: { ...tv, pending: [...tv.pending, { attempt: action.attempt, events: action.events }] } };
+  }
+  return { ...state, taskView: applyLive(tv, action.attempt, action.events) };
+}
+function announceApprovals(state, action) {
+  if (state.taskView?.taskId === action.taskId) return state;
+  const task = findTask(state.tasks, action.taskId);
+  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" ? say(s, "system", `\xB7 Task ${task?.order ?? "?"} waits for approval: ${(0, import_core26.runnerToolSubject)(event.tool, event.args)} \u2014 t on it to answer`) : s, state);
+  return spoken !== state ? { ...spoken, scroll: state.scroll } : spoken;
+}
+function taskLogLoaded(state, action) {
+  const tv = state.taskView;
+  if (!tv || tv.taskId !== action.taskId) return state;
+  const loaded = action.attempt >= 1 ? {
+    ...tv,
+    view: (0, import_core26.replayTaskLog)(action.events),
+    attempts: action.attempts ?? tv.attempts,
+    attempt: action.attempt
+  } : { ...tv, attempts: action.attempts ?? tv.attempts };
+  let next = { ...loaded, pending: [], loaded: true };
+  for (const batch of tv.pending) {
+    if (batch.attempt === action.attempt) continue;
+    next = applyLive(next, batch.attempt, batch.events);
+  }
+  return { ...state, taskView: clampQueueIndex(next) };
+}
+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."));
+  }
+  const note = decision === "deny" ? state.editor.text.trim() : "";
+  const answer = decision === "deny" ? { decision, ...note ? { note } : {} } : { decision };
+  const next = note ? { ...state, editor: { ...state.editor, text: "", cursor: 0 } } : state;
+  return step(next, [{ type: "answerTaskApproval", sessionId, approvalId: approval.approvalId, answer }]);
+}
+function handleTaskViewKey(state, key) {
+  const tv = state.taskView;
+  if (!tv || !state.sessionId) return null;
+  if (key.name === "alt-left" || key.name === "alt-right") {
+    const index = tv.attempts.indexOf(tv.attempt);
+    if (index < 0) return null;
+    const target = key.name === "alt-left" ? index - 1 : index + 1;
+    const attempt = tv.attempts[target];
+    if (attempt === void 0) {
+      return step(say(state, "system", target < 0 ? "This is the first attempt." : "This is the latest attempt."));
+    }
+    return step(
+      { ...state, taskView: { ...tv, followLatest: false } },
+      [{ type: "loadTaskAttempt", sessionId: state.sessionId, taskId: tv.taskId, attempt }]
+    );
+  }
+  if (key.name === "ctrl-r") {
+    const queued = tv.view.queued[tv.queuedIndex];
+    if (!queued) return step(say(state, "system", "No queued message to remove."));
+    return step(state, [{ type: "removeTaskMessage", sessionId: state.sessionId, taskId: tv.taskId, messageId: queued.id }]);
+  }
+  if (key.name === "ctrl-x") {
+    return step(state, [{ type: "interruptTask", sessionId: state.sessionId, taskId: tv.taskId }]);
+  }
+  if (key.name === "ctrl-y") return answerApproval(state, tv, state.sessionId, "allow");
+  if (key.name === "ctrl-t") return answerApproval(state, tv, state.sessionId, "allowForTask");
+  if (key.name === "ctrl-g") return answerApproval(state, tv, state.sessionId, "deny");
+  if (key.name === "ctrl-n" || key.name === "ctrl-p") {
+    const count = tv.view.queued.length;
+    if (count === 0) return null;
+    const delta = key.name === "ctrl-n" ? 1 : -1;
+    const queuedIndex = Math.max(0, Math.min(count - 1, tv.queuedIndex + delta));
+    return step({ ...state, taskView: { ...tv, queuedIndex } });
+  }
+  return null;
+}
+
 // src/tui/reducers/taskEdits.ts
 var import_plan_utils3 = require("@ordewell/core/plan-utils");
 function openTaskRunnerPicker(state, task) {
@@ -5520,9 +5836,7 @@ function handlePlanKey(state, key) {
     return step(state, [taskActionEffect(state, state.sessionId, task.id, action)]);
   }
   if (key.char === "d") return confirmRemoveTask(state, task);
-  if (key.char === "t") {
-    return step(state, [{ type: "openTaskTerminal", sessionId: state.sessionId, taskId: task.id }]);
-  }
+  if (key.char === "t") return openTaskTerminalOrView(state, state.sessionId, task.id);
   if (key.char === "x" && task.isolation?.state === "conflict") {
     return step(state, [{ type: "resolveConflict", sessionId: state.sessionId, taskId: task.id }]);
   }
@@ -5555,9 +5869,9 @@ function commitTaskEdit(state, task, editor) {
 }
 
 // src/tui/reducers/turnQueue.ts
-var import_core24 = require("@ordewell/core");
+var import_core27 = require("@ordewell/core");
 function drainQueue(state, settled) {
-  const next = (0, import_core24.drainNext)(state.queuedPrompts);
+  const next = (0, import_core27.drainNext)(state.queuedPrompts);
   const ended = disarmStop({ ...settled, stopRequested: false });
   if (!next) return step(ended);
   const spoken = say(ended, "user", next.text);
@@ -5576,14 +5890,14 @@ function stopPlanning(state, sessionId) {
   return step(queueToEditor(cutTurn({ ...dismissed, stopArmed: false, stopRequested: true })), [{ type: "cancelPlanning", sessionId }]);
 }
 function queueToEditor(state) {
-  const all = (0, import_core24.unsendAll)(state.queuedPrompts);
+  const all = (0, import_core27.unsendAll)(state.queuedPrompts);
   if (!all) return state;
   return { ...state, queuedPrompts: all.rest, editor: { ...state.editor, text: all.text, cursor: all.text.length } };
 }
 function unsendLatest(state) {
-  const latest = (0, import_core24.unsendLatest)(state.queuedPrompts);
+  const latest = (0, import_core27.unsendLatest)(state.queuedPrompts);
   if (!latest) return step(state);
-  const text = (0, import_core24.aheadOfDraft)(latest.text, state.editor.text);
+  const text = (0, import_core27.aheadOfDraft)(latest.text, state.editor.text);
   return step({
     ...state,
     queuedPrompts: latest.rest,
@@ -5600,7 +5914,7 @@ function plannerEscape(state) {
 }
 
 // src/tui/reducers/commands.ts
-var KNOWN_PROVIDERS2 = Object.keys(import_core25.ALL_PROVIDERS);
+var KNOWN_PROVIDERS2 = Object.keys(import_core28.ALL_PROVIDERS);
 function runCommand(state, { name, args }) {
   if (!findCommand(name)) {
     return fail3(state, `Unknown command: /${name} \u2014 type /help to see what's available.`);
@@ -5641,6 +5955,8 @@ function runCommand(state, { name, args }) {
       return runners(state, args);
     case "auto":
       return setAutonomous(state, args[0]);
+    case "transport":
+      return setTransport(state, args[0]);
     case "parallel":
       return setMaxParallel(state, args[0]);
     case "mouse":
@@ -5678,11 +5994,13 @@ function runCommand(state, { name, args }) {
         (sessionId, taskId) => step(state, [{ type: "removeTask", sessionId, taskId }])
       );
     case "terminal":
-      return taskCommand(
-        state,
-        args[0],
-        (sessionId, taskId) => step(state, [{ type: "openTaskTerminal", sessionId, taskId }])
-      );
+      return taskCommand(state, args[0], (sessionId, taskId) => openTaskTerminalOrView(state, sessionId, taskId));
+    case "continue":
+      return taskCommand(state, args[0], (sessionId, taskId) => {
+        const text = args.slice(1).join(" ").trim();
+        if (!text) return fail3(state, "Usage: /continue <id> <message>");
+        return continueTaskStep(state, sessionId, taskId, text);
+      });
     case "task-runner":
       return taskRunnerCommand(state, args);
     case "task-model":
@@ -5749,10 +6067,11 @@ function newSession(state) {
     handoff: null,
     sessionId: null,
     goal: "",
+    taskView: null,
     tasks: [],
     planApproved: false,
-    conversation: import_core25.EMPTY_CONVERSATION,
-    turnGate: import_core25.NO_TURN,
+    conversation: import_core28.EMPTY_CONVERSATION,
+    turnGate: import_core28.NO_TURN,
     selectedTask: 0,
     expandedTaskId: null,
     taskEditor: null,
@@ -5763,14 +6082,14 @@ 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_core25.EMPTY_HOLD,
+    queuedPrompts: import_core28.EMPTY_HOLD,
     stopArmed: false,
     overlay: state.overlay?.kind === "approval" ? null : state.overlay
   }, closeEffects);
 }
 function setModel(state, args) {
   if (args[0] === "set" && args[1]) {
-    const runner = (0, import_core25.runnerForProvider)(state.plannerProvider);
+    const runner = (0, import_core28.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}.`);
@@ -5843,16 +6162,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core25.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core28.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core25.ALL_PROVIDERS[id].label,
-    detail: import_core25.ALL_PROVIDERS[id].apiKeyEnvVar,
+    label: import_core28.ALL_PROVIDERS[id].label,
+    detail: import_core28.ALL_PROVIDERS[id].apiKeyEnvVar,
     selected: state.configuredProviders.includes(id)
   }));
   return step({ ...state, overlay: { kind: "picker", picker: picker("API provider key", items, { kind: "set-key" }) } });
 }
 function keyPrompt(provider) {
-  const meta = import_core25.ALL_PROVIDERS[provider];
+  const meta = import_core28.ALL_PROVIDERS[provider];
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -5929,15 +6248,21 @@ 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_core25.parseMaxParallel)(arg);
+  const limit = (0, import_core28.parseMaxParallel)(arg);
   if (limit === null) return fail3(state, "Usage: /parallel [<number of tasks, 1 or more>]");
   return step({ ...state, maxParallel: limit }, [{ type: "setMaxParallel", limit }]);
 }
 function setAutonomous(state, arg) {
-  const enabled = resolveToggle(arg, state.autonomous);
-  if (enabled === null) return fail3(state, "Usage: /auto [on|off]");
+  if (arg === void 0) return step(say(state, "system", `Autonomy level: ${(0, import_core28.autonomyLevelLabel)(state.autonomous)} \u2014 /auto full or /auto auto changes it for new plans.`));
+  const enabled = (0, import_core28.parseAutonomyLevel)(arg);
+  if (enabled === null) return fail3(state, "Usage: /auto [full|auto]");
   return step({ ...state, autonomous: enabled }, [{ type: "setAutonomous", enabled }]);
 }
+function setTransport(state, arg) {
+  const value = arg?.toLowerCase() ?? (state.runnerTransport === "structured" ? "terminal" : "structured");
+  if (!(0, import_core28.isRunnerTransport)(value)) return fail3(state, "Usage: /transport [terminal|structured]");
+  return step(state, [{ type: "setTransport", transport: value }]);
+}
 function setMouseCapture(state, arg) {
   const enabled = resolveToggle(arg, state.mouseCapture);
   if (enabled === null) return fail3(state, "Usage: /mouse [on|off]");
@@ -6185,6 +6510,7 @@ function choose(state, picker2, item) {
 }
 
 // src/tui/reducers/incoming.ts
+var import_core29 = 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 : {};
@@ -6215,6 +6541,7 @@ function toTaskView2(t, index) {
     prompt: typeof t.prompt === "string" ? sanitize(t.prompt) : void 0,
     type: t.type === "user" ? "user" : "ai",
     status: planLabel(t.status, "pending"),
+    awaitingReason: t.status === "awaiting_user" && (0, import_core29.isAwaitingReason)(t.awaitingReason) ? t.awaitingReason : void 0,
     dependencies: Array.isArray(t.dependencies) ? t.dependencies.map((id) => planLabel(id)) : [],
     assignedRunner: typeof t.assignedRunner === "string" ? planLabel(t.assignedRunner) : void 0,
     taskMode: typeof t.taskMode === "string" ? planLabel(t.taskMode) : void 0,
@@ -6245,6 +6572,7 @@ function applySettings(state, settings) {
     plannerProvider: typeof settings.aiProvider === "string" ? settings.aiProvider : state.plannerProvider,
     plannerEffort: typeof settings.plannerThinkingEffort === "string" ? settings.plannerThinkingEffort : state.plannerEffort,
     maxParallel: typeof settings.maxParallel === "number" ? settings.maxParallel : state.maxParallel,
+    runnerTransport: (0, import_core29.isRunnerTransport)(settings.runnerTransport) ? settings.runnerTransport : state.runnerTransport,
     allowlist: settings.modelAllowlist && typeof settings.modelAllowlist === "object" ? settings.modelAllowlist : state.allowlist
   };
 }
@@ -6279,20 +6607,32 @@ function followSession(state, message) {
   const heard = turnActivity(hear(state, message));
   if (message.type === "approval_request") {
     const { id, kind, subject, scope, detail } = message;
+    if (kind === "runner_tool") return heard;
     return enqueueApproval(heard, { id, kind, subject, scope, ...detail ? { detail } : {} });
   }
   return message.type === "approval_settled" ? dropApproval(heard, message.id) : heard;
 }
 
 // src/tui/reducer.ts
+function holdReadingPlace(before, after) {
+  if (before.scroll <= 0 || after.scroll !== before.scroll) return after;
+  if (before.taskView?.taskId !== after.taskView?.taskId) return after;
+  const grown = chatScrollMax(after) - chatScrollMax(before);
+  return grown > 0 ? { ...after, scroll: clamp(after.scroll + grown, chatScrollMax(after)) } : after;
+}
 function reduce(state, action) {
+  const result = reduceAction(state, action);
+  if (action.type !== "sessionMessage" && action.type !== "taskLog") return result;
+  return { ...result, state: holdReadingPlace(state, result.state) };
+}
+function reduceAction(state, action) {
   switch (action.type) {
     case "key":
       return handleKey2(state, action.key);
     // Isolation belongs to one session's plan, and task ids repeat across
     // sessions, so nothing of the last one's may carry over into this.
     case "sessionStarted":
-      return step(clearIsolation({ ...state, sessionId: action.sessionId, goal: action.goal }));
+      return step(clearIsolation({ ...state, sessionId: action.sessionId, goal: action.goal, taskView: null }));
     // 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.
@@ -6301,14 +6641,15 @@ function reduce(state, action) {
         ...clearIsolation(state),
         sessionId: null,
         goal: "",
+        taskView: null,
         pendingApprovals: [],
-        queuedPrompts: import_core26.EMPTY_HOLD,
+        queuedPrompts: import_core30.EMPTY_HOLD,
         stopArmed: false,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
       });
     case "chatRestored":
       if (stale(state, action.sessionId)) return step(state);
-      return step({ ...state, conversation: (0, import_core26.fromTranscript)(action.history, action.researchLog, action.plannerUsage), scroll: 0 });
+      return step({ ...state, conversation: (0, import_core30.fromTranscript)(action.history, action.researchLog, action.plannerUsage), scroll: 0 });
     case "planUpdated": {
       if (stale(state, action.sessionId)) return step(state);
       const isolation = isolationOfPlan(action.plan);
@@ -6340,6 +6681,15 @@ function reduce(state, action) {
     case "sessionMessage":
       if (stale(state, action.sessionId)) return step(state);
       return step(followSession(state, action.message));
+    case "taskLog":
+      if (stale(state, action.sessionId)) return step(state);
+      return step(announceApprovals(taskLogArrived(state, action), action));
+    case "taskViewRequested":
+      if (stale(state, action.sessionId)) return step(state);
+      return openTaskView(state, action.sessionId, action.taskId);
+    case "taskLogLoaded":
+      if (stale(state, action.sessionId)) return step(state);
+      return step(taskLogLoaded(state, action));
     // A settled transcript line, not a research step: nothing ever settles a
     // task's start, so as a step it stayed "⋯" forever and was counted into
     // the planner's next "(+N more)".
@@ -6348,12 +6698,12 @@ function reduce(state, action) {
       const existing = findTask(state.tasks, action.taskId);
       if (existing && isTaskRunning(existing)) return step(state);
       const tasks = state.tasks.map((t) => t.id === action.taskId && !isTaskRunning(t) ? { ...t, status: "in_progress" } : t);
-      const spoken = say(state, "system", (0, import_core26.taskStartedNotice)(action.title, action.runner));
+      const spoken = say(state, "system", (0, import_core30.taskStartedNotice)(action.title, action.runner));
       return step({ ...spoken, tasks, status: "executing", busyLabel: runLabel(tasks) });
     }
     case "taskStatus": {
       if (stale(state, action.sessionId) || !state.tasks.some((t) => t.id === action.taskId)) return step(state);
-      const tasks = state.tasks.map((t) => t.id === action.taskId ? { ...t, status: action.status } : t);
+      const tasks = state.tasks.map((t) => t.id === action.taskId ? { ...t, status: action.status, awaitingReason: void 0 } : t);
       const status = runStatus(state, tasks);
       return step({ ...state, status, tasks, busyLabel: status === "executing" ? runLabel(tasks) : state.busyLabel });
     }
@@ -6366,9 +6716,13 @@ function reduce(state, action) {
         if (update === void 0) return t;
         const idleSince = update.idleSince ?? null;
         const isolation = update.isolation ?? t.isolation;
-        if (update.status !== t.status || idleSince !== (t.idleSince ?? null) || !sameIsolation(isolation, t.isolation)) {
+        const transport = update.transport;
+        const awaitingReason = update.awaitingReason;
+        const continuable = update.continuable === true;
+        const awaitingApproval = update.awaitingApproval;
+        if (update.status !== t.status || idleSince !== (t.idleSince ?? null) || !sameIsolation(isolation, t.isolation) || !sameTransport(transport, t.transport) || awaitingReason !== t.awaitingReason || continuable !== (t.continuable ?? false) || awaitingApproval !== t.awaitingApproval) {
           changed = true;
-          return { ...t, status: update.status, idleSince, isolation };
+          return { ...t, status: update.status, idleSince, isolation, transport, awaitingReason, continuable, awaitingApproval };
         }
         return t;
       });
@@ -6443,11 +6797,12 @@ function reduce(state, action) {
         ...clearIsolation(state),
         sessionId: action.sessionId,
         goal: action.goal,
+        taskView: null,
         status: "idle",
         busyLabel: "",
         planApproved: false,
         pendingApprovals: [],
-        queuedPrompts: import_core26.EMPTY_HOLD,
+        queuedPrompts: import_core30.EMPTY_HOLD,
         stopArmed: false,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
       });
@@ -6467,6 +6822,7 @@ function reduce(state, action) {
         orchestratorModel: action.orchestratorModel ?? state.orchestratorModel
       }, ["set-planner", "set-task-runner"]));
     case "failed": {
+      state = taskLogAbandoned(state);
       const quiet = plannerInFlight(state) && state.stopRequested;
       const reported = { ...quiet ? state : say(state, "error", action.message), status: "idle", busyLabel: "" };
       if (!plannerInFlight(state)) return step(reported);
@@ -6502,6 +6858,9 @@ function reduce(state, action) {
       return step(disarmStop(state));
   }
 }
+function sameTransport(a, b) {
+  return a?.kind === b?.kind && a?.fallback === b?.fallback;
+}
 function runStatus(state, tasks) {
   if (tasks.some(isTaskRunning)) return "executing";
   if (tasks.some((t) => t.status === "awaiting_user")) return "executing";
@@ -6520,6 +6879,10 @@ function handleKey2(state, key) {
   }
   if (key.name === "ctrl-l") return step({ ...state, conversation: wiped(state.conversation), scroll: 0 });
   if (key.name === "ctrl-o" && state.focus === "chat" && !state.overlay) return toggleDetail(state);
+  if (key.name === "escape" && state.taskView && !state.overlay) {
+    if (state.editor.text) return step({ ...state, editor: { ...state.editor, text: "", cursor: 0 } });
+    return step({ ...state, taskView: null, scroll: 0 });
+  }
   if (key.name === "escape") {
     const stopped = plannerEscape(state);
     if (stopped) return stopped;
@@ -6543,12 +6906,16 @@ function handleKey2(state, key) {
     return step({ ...state, focus: state.focus === "chat" ? "plan" : "chat" });
   }
   if (state.focus === "plan") return handlePlanKey(state, key);
+  if (state.taskView) {
+    const handled = handleTaskViewKey(state, key);
+    if (handled) return handled;
+  }
   if (key.name === "enter") return submit(state);
   if (key.name === "escape") return step({ ...state, editor: { ...state.editor, text: "", cursor: 0 } });
   const scroll = scrollDelta(key, state);
   if (scroll !== null) return scrollChat(state, scroll);
   const multilineEditor = state.editor.text.includes("\n");
-  const room = chatEditorRoom(state.cols, true);
+  const room = chatEditorRoomFor(state, true);
   return step({ ...state, editor: applyKey(state.editor, key, multilineEditor ? room : void 0) });
 }
 function submit(state) {
@@ -6557,8 +6924,14 @@ function submit(state) {
   const cleared = { ...state, editor: commit(state.editor) };
   const command = parseSlash(text);
   if (command && findCommand(command.name)?.source !== "skill") return runCommand(cleared, command);
+  if (state.taskView) {
+    if (!state.sessionId) return step(state);
+    const taskId = state.taskView.taskId;
+    if (continuesTask(findTask(state.tasks, taskId))) return continueTaskStep(cleared, state.sessionId, taskId, text);
+    return step(cleared, [{ type: "sendTaskMessage", sessionId: state.sessionId, taskId, text }]);
+  }
   if (plannerInFlight(state)) {
-    return step({ ...cleared, queuedPrompts: (0, import_core26.holdPrompt)(state.queuedPrompts, text) });
+    return step({ ...cleared, queuedPrompts: (0, import_core30.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 };
@@ -6618,10 +6991,10 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process4 = require("child_process");
-var import_core28 = require("@ordewell/core");
+var import_core32 = require("@ordewell/core");
 
 // src/tui/inbound.ts
-var import_core27 = require("@ordewell/core");
+var import_core31 = require("@ordewell/core");
 var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
   "planner_message",
   "planner_turn_started",
@@ -6831,7 +7204,15 @@ function dispatchLifecycle(dispatch, event, sessionId) {
     case "status_update": {
       const updates = {};
       for (const task of event.tasks ?? []) {
-        updates[String(task.id)] = { status: String(task.status), idleSince: task.idleSince ?? null, isolation: task.isolation };
+        updates[String(task.id)] = {
+          status: String(task.status),
+          idleSince: task.idleSince ?? null,
+          isolation: task.isolation,
+          transport: task.transport,
+          awaitingReason: (0, import_core31.isAwaitingReason)(task.awaitingReason) ? task.awaitingReason : void 0,
+          ...task.continuable ? { continuable: true } : {},
+          awaitingApproval: typeof task.awaitingApproval === "number" && task.awaitingApproval > 0 ? task.awaitingApproval : void 0
+        };
       }
       dispatch({ type: "tasksStatus", updates, sessionId });
       return;
@@ -6842,7 +7223,7 @@ function dispatchLifecycle(dispatch, event, sessionId) {
     // The extension shows these in its checkpoint panel; here they are
     // transcript lines, which is the TUI's equivalent surface.
     case "checkpoint":
-      dispatch({ type: "notice", message: `\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core27.truncateCheckpointSummary)(event.summary)}` });
+      dispatch({ type: "notice", message: `\xB7 Checkpoint \u2014 ${event.taskTitle}: ${(0, import_core31.truncateCheckpointSummary)(event.summary)}` });
       return;
     case "review_needed":
       dispatch({ type: "notice", message: "Plan needs your sign-off \u2014 /approve to continue." });
@@ -6875,6 +7256,12 @@ function dispatchLifecycle(dispatch, event, sessionId) {
     case "isolation_handoff":
       dispatch({ type: "isolationHandoff", handoff: { repos: event.repos, landed: event.landed }, sessionId });
       return;
+    // A structured task's log as it happens (ADR-0018, P1): the task view is
+    // its only reader, and the reducer drops it unless that view is open on
+    // this task. The run's watcher itself does nothing with it.
+    case "task_log":
+      dispatch({ type: "taskLog", taskId: String(event.taskId), attempt: event.attempt, events: event.events, sessionId });
+      return;
     // Raw runner chatter. Listed rather than defaulted, so a new lifecycle
     // variant fails to compile here until someone decides what a run's watcher
     // does with it.
@@ -7025,17 +7412,80 @@ async function perform(effect, deps) {
       }
       return;
     }
+    // The card settles when the task log reports the answer, not here.
+    case "answerTaskApproval": {
+      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." });
+      }
+      return;
+    }
+    // A task with a saved log ran structured, whatever its `transport` says
+    // after a reload; it has no tmux window, so open the log rather than fail.
     case "openTaskTerminal": {
+      const saved = await api.getTaskLogAttempts(effect.sessionId, effect.taskId, workspace).catch(() => []);
+      if (saved.length > 0) {
+        dispatch({ type: "taskViewRequested", sessionId: effect.sessionId, taskId: effect.taskId });
+        return;
+      }
       const result = await deps.openTerminal(effect.sessionId, effect.taskId);
       dispatch(result.ok ? { type: "notice", message: result.message } : { type: "failed", message: result.message });
       return;
     }
+    // The saved log is read off disk (ADR-0018, P1) so the view opens with the
+    // task's history; the live `task_log` stream then catches it up in place.
+    case "openTaskLog": {
+      const attempts = await api.getTaskLogAttempts(effect.sessionId, effect.taskId, workspace);
+      if (attempts.length === 0) {
+        dispatch({ type: "taskLogLoaded", taskId: effect.taskId, attempts: [], attempt: 0, events: [], sessionId: effect.sessionId });
+        return;
+      }
+      const attempt = attempts[attempts.length - 1];
+      const events = await api.getTaskLog(effect.sessionId, effect.taskId, attempt, workspace);
+      dispatch({ type: "taskLogLoaded", taskId: effect.taskId, attempts, attempt, events, sessionId: effect.sessionId });
+      return;
+    }
+    case "loadTaskAttempt": {
+      const events = await api.getTaskLog(effect.sessionId, effect.taskId, effect.attempt, workspace);
+      dispatch({ type: "taskLogLoaded", taskId: effect.taskId, attempt: effect.attempt, events, sessionId: effect.sessionId });
+      return;
+    }
+    // The daemon queues the message (or delivers it to a waiting task) and
+    // broadcasts the `task_log` event that shows it; nothing to dispatch here.
+    case "sendTaskMessage":
+      await api.sendTaskMessage(effect.sessionId, effect.taskId, effect.text);
+      return;
+    // The daemon starts the new attempt; its `task_log` and status arrive over
+    // the execution stream, which a TUI not already watching a run holds open.
+    case "continueTask": {
+      const { sessionId, taskId, text } = effect;
+      const request = () => api.continueTask(sessionId, taskId, text);
+      await (effect.watch ? withExecutionStream(deps, sessionId, request) : request());
+      await refreshPlan(deps, sessionId);
+      return;
+    }
+    case "removeTaskMessage": {
+      const { removed } = await api.removeQueuedTaskMessage(effect.sessionId, effect.taskId, effect.messageId);
+      if (!removed) dispatch({ type: "notice", message: "That message was already delivered to the task." });
+      return;
+    }
+    case "interruptTask":
+      await api.interruptTask(effect.sessionId, effect.taskId);
+      dispatch({ type: "notice", message: "Interrupting the task\u2026" });
+      return;
     case "command": {
       const result = await api.sendCommand(effect.name, { action: effect.action });
       if (result.settings) dispatch({ type: "settingsLoaded", settings: result.settings });
       dispatch({ type: "notice", message: `${effect.name} is ${effect.action}.` });
       return;
     }
+    case "setTransport": {
+      const result = await api.sendCommand("transport", { action: effect.transport });
+      if (result.settings) dispatch({ type: "settingsLoaded", settings: result.settings });
+      dispatch({ type: "notice", message: `Runner transport is ${effect.transport} \u2014 it applies from the next run.` });
+      return;
+    }
     case "setModel":
       await api.updateSettings({ orchestratorModel: effect.modelId });
       deps.setEnvVar("ORCHESTRATOR_MODEL", effect.modelId);
@@ -7043,7 +7493,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Orchestrator model set to ${effect.modelId}.` });
       return;
     case "setPlanner": {
-      const meta = import_core28.ALL_PROVIDERS[effect.provider];
+      const meta = import_core32.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown planner: ${effect.provider}`);
       const env = { AI_PROVIDER: effect.provider };
       const settings = await api.updateSettings({ env });
@@ -7055,7 +7505,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core28.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
+        message: `${(0, import_core32.isCliProvider)(effect.provider) ? `Planning with ${meta.label} \u2014 no API key needed.` : `Planner set to ${meta.label}.`} ${plannerModelNotice(recall2)}`
       });
       await loadModels(deps);
       return;
@@ -7067,7 +7517,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Planner effort set to ${effect.effort || "the runner default"}.` });
       return;
     case "setApiKey": {
-      const meta = import_core28.ALL_PROVIDERS[effect.provider];
+      const meta = import_core32.ALL_PROVIDERS[effect.provider];
       if (!meta) throw new Error(`Unknown provider: ${effect.provider}`);
       await api.updateSettings({ env: { [meta.apiKeyEnvVar]: effect.key } });
       deps.setEnvVar(meta.apiKeyEnvVar, effect.key);
@@ -7105,7 +7555,7 @@ async function perform(effect, deps) {
       return;
     case "setAutonomous":
       deps.setEnvVar("ORDEWELL_AUTONOMOUS_MODE", String(effect.enabled));
-      dispatch({ type: "notice", message: `Autonomous mode ${effect.enabled ? "on" : "off"}.` });
+      dispatch({ type: "notice", message: `Autonomy level: ${(0, import_core32.autonomyLevelLabel)(effect.enabled)} for new plans.` });
       return;
     case "setMouseCapture":
       deps.setMouseCapture(effect.enabled);
@@ -7238,7 +7688,7 @@ function osc52(text) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core28.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core32.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -7348,13 +7798,18 @@ var CONTROL2 = {
   "": "ctrl-c",
   "": "ctrl-d",
   "": "ctrl-e",
+  "\x07": "ctrl-g",
   "\v": "ctrl-k",
   "\f": "ctrl-l",
   "": "ctrl-n",
   "": "ctrl-o",
   "": "ctrl-p",
+  "": "ctrl-r",
+  "": "ctrl-t",
   "": "ctrl-u",
-  "": "ctrl-w"
+  "": "ctrl-w",
+  "": "ctrl-x",
+  "": "ctrl-y"
 };
 var ESCAPES = {
   "\x1B[A": "up",
@@ -7623,7 +8078,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core29.assertWorkspaceExists)(workspace);
+    (0, import_core33.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -7632,7 +8087,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  registerSkillCommands((0, import_core29.createSkillsService)(workspace).listSkills());
+  registerSkillCommands((0, import_core33.createSkillsService)(workspace).listSkills());
   const explicitPort = flag(subArgs, "--port") || process.env.ORDEWELL_PORT;
   const targetPort = explicitPort ? resolvePort(subArgs) : await findFreePort();
   const { port, owned: ownedAtLaunch } = await ensureDaemonOwned(targetPort, { detached: false });
@@ -7649,7 +8104,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
       workspace,
       port,
       dispatch: (action) => app.dispatch(action),
-      newSessionId: () => (0, import_core29.mintSessionId)(),
+      newSessionId: () => (0, import_core33.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
@@ -7725,6 +8180,7 @@ var COMMANDS = {
   key: handleKey,
   runners: handleRunners,
   auto: handleAuto,
+  transport: handleTransport,
   refresh: handleRefresh,
   setup: handleSetup,
   plugins: handlePlugins,
@@ -7738,6 +8194,7 @@ var COMMANDS = {
   "force-start": handleForceStart,
   "retry": handleRetry,
   "cancel": handleCancel,
+  continue: handleContinue,
   "add-task": handleAddTask,
   "remove-task": handleRemoveTask,
   "task-runner": handleTaskRunner,
@@ -7770,7 +8227,7 @@ function cliVersion() {
 // src/main.ts
 var TUI_FLAGS = /* @__PURE__ */ new Set(["--workspace", "--port"]);
 async function main() {
-  (0, import_core30.migrateOldConfigDir)();
+  (0, import_core34.migrateOldConfigDir)();
   loadEnvFile();
   const argv = process.argv.slice(2);
   if (TUI_FLAGS.has(argv[0] ?? "")) argv.unshift("tui");