@ordewell/cli 0.5.6 → 0.6.1

package/dist/main.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/main.ts
-var import_core33 = require("@ordewell/core");
+var import_core34 = require("@ordewell/core");
 
 // src/utils/env.ts
 var import_fs = require("fs");
@@ -109,7 +109,7 @@ Planning:
   ordewell fork                   Continue in a copy of the conversation and its tasks
   ordewell compact                Condense the conversation into a summary (tasks are kept)
   ordewell rewind [<n>]           Fork the conversation from before message <n> (no <n>: list them)
-  ordewell handoff [action]       Review, merge, discard or clean up a finished isolated run
+  ordewell handoff [action]       Review, merge, discard or clean up an isolated run
 
 Tasks (<id> is an order number or a task ID):
   ordewell add-task --title "..."  Add a task to the current plan
@@ -117,7 +117,7 @@ Tasks (<id> is an order number or a task ID):
   ordewell complete <id>          Mark a task complete (alias: mark-complete)
   ordewell uncomplete <id>        Mark a completed task not done
   ordewell skip <id>              Skip a task (marks it complete so dependents can run)
-  ordewell force-start <id>       Start a task now, ignoring dependencies
+  ordewell force-start <id>       Start a task now, ignoring dependencies (asks past a merge gate)
   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
@@ -130,6 +130,7 @@ Per-task assignment (omit the value to list the options):
   ordewell task-effort <id> [level]    Set a task's thinking effort ("default" to clear)
   ordewell task-mode <id> [mode]       Set a task's runner mode
   ordewell task-deps <id> [a,b|none]   Set which earlier tasks a task waits for
+  ordewell task-ops <id> [on|off]      Make a task an ops task (runs in your checkout once its dependencies are merged) or a change task
 
 Planner, models and runners:
   ordewell planner [<provider>]   Choose who plans \u2014 an API provider or a coding agent (no API key)
@@ -138,8 +139,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 transport [terminal|structured]   Experimental: run Claude Code tasks over its protocol, from the next run
+  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)
@@ -212,7 +213,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
@@ -713,6 +714,17 @@ var ApiClient = class _ApiClient {
     }
     return { plan: res.data.plan, summary: res.data.summary, keptMessages: res.data.keptMessages };
   }
+  /** The dependencies a task waits on at its merge gate (ADR-0020); empty when nothing gates it. */
+  async getMergeGate(sessionId, taskId) {
+    const res = await this.httpRequest(
+      "GET",
+      `/api/plans/${sessionId}/tasks/${taskId}/merge-gate`
+    );
+    if (res.status !== 200) {
+      throw new Error(res.data?.error || "Could not read the merge gate");
+    }
+    return res.data.mergeGate ?? [];
+  }
   async reviewRunDiff(sessionId) {
     const res = await this.httpRequest("GET", `/api/plans/${sessionId}/isolation/diff`);
     if (res.status !== 200) {
@@ -1252,7 +1264,7 @@ Plan: ${tasks.length} task${tasks.length === 1 ? "" : "s"} (${aiCount} AI, ${man
   console.log(`Session: ${sessionId}
 `);
   for (const t of tasks) {
-    const typeIcon = t.type === "user" ? "[MAN]" : "[ AI]";
+    const typeIcon = t.type === "user" ? "[MAN]" : t.ops ? "[OPS]" : "[ AI]";
     const deps = t.dependencies?.length ? ` \u2190 ${t.dependencies.join(", ")}` : "";
     console.log(`  ${(0, import_core7.taskOrderLabel)(t).padStart(2)}. ${typeIcon} ${t.title}${modelSuffix(t)}${deps}`);
     for (const sub of t.subtasks || []) {
@@ -1264,6 +1276,9 @@ Plan: ${tasks.length} task${tasks.length === 1 ? "" : "s"} (${aiCount} AI, ${man
   if (manCount > 0) {
     console.log("\n  [MAN] = manual step \u2014 run `ordewell tui` to work through it");
   }
+  if (tasks.some((t) => t.ops)) {
+    console.log("  [OPS] = ops task \u2014 runs in your checkout once the work it depends on is merged (`ordewell handoff merge`)");
+  }
 }
 var PLANNER_ENV = ["AI_PROVIDER", "ORCHESTRATOR_MODEL", "ORDEWELL_PLANNER_EFFORT"];
 async function forwardPlannerEnv(api) {
@@ -1456,7 +1471,7 @@ function isolationOfPlan(plan) {
       // `tasksStatus` update fills it in once the stream catches up.
       ...repairedFiles ? { repairedFiles } : {}
     };
-    if (state === "integrated") {
+    if (state === "integrated" && record.inHead !== true) {
       landed.push({ taskId, order: Number(record.order ?? 0), title: String(record.title ?? taskId), changed, ...repairedFiles ? { repairedFiles } : {} });
     }
   }
@@ -1531,6 +1546,9 @@ function iconFor(status) {
 // src/commands/run.ts
 var import_core9 = require("@ordewell/core");
 
+// src/commands/shared.ts
+var import_readline2 = require("readline");
+
 // src/catalog.ts
 function normalizeCatalog(result) {
   const runnersByModel = /* @__PURE__ */ new Map();
@@ -1586,6 +1604,16 @@ function fail(...lines) {
   for (const line of lines) console.error(line);
   process.exit(1);
 }
+async function askYesNo(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = (0, import_readline2.createInterface)({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await new Promise((resolve3) => rl.question(`${question} [y/N] `, resolve3));
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
 function writeEnv(env) {
   const envFile = findEnvFile();
   for (const [key, value] of Object.entries(env)) {
@@ -1611,7 +1639,8 @@ function toTaskView(task) {
     assignedRunner: task.assignedRunner || void 0,
     taskMode: task.taskMode || void 0,
     assignedModel: task.assignedModel ?? void 0,
-    subtasks: [...task.subtasks ?? []].sort((a, b) => a.order - b.order).map(toTaskView)
+    subtasks: [...task.subtasks ?? []].sort((a, b) => a.order - b.order).map(toTaskView),
+    ...task.ops ? { ops: true } : {}
   };
 }
 function taskViews(plan) {
@@ -1658,6 +1687,7 @@ async function followExecution(api, sessionId, start, onBlocked) {
       lastPrinted = output;
     }
   }
+  let pausedAtGate = false;
   let settleReady = () => {
   };
   const streamReady = new Promise((resolve3, reject) => {
@@ -1674,6 +1704,9 @@ async function followExecution(api, sessionId, start, onBlocked) {
     }
     if (event.type === "status_update" && event.tasks) {
       printStatus(event.tasks);
+      const paused = event.gate?.paused === true;
+      if (paused && !pausedAtGate) process.stderr.write("\xB7 Paused for Merge all \u2014 `ordewell handoff merge` merges what has landed, and the waiting tasks start.\n");
+      pausedAtGate = paused;
     }
     if (event.type === "review_needed") {
       console.log("\nPlan needs your sign-off \u2014 run `ordewell approve` to continue.");
@@ -2277,7 +2310,7 @@ async function handleVerify(subArgs, api) {
 }
 
 // src/commands/transport.ts
-var describe = (transport) => `Runner transport (experimental): ${transport === "structured" ? "structured" : "terminal"} \u2014 applies from the next run`;
+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));
@@ -2330,13 +2363,23 @@ async function withResolvedTask(subArgs, usage, injectedApi, run) {
   }
   await run(api, sessionId, taskId, plan);
 }
+var PASSES_GATE = /* @__PURE__ */ new Set(["run", "force-start"]);
+async function confirmPastGate(subArgs, api, sessionId, taskId, confirm) {
+  if (hasFlag(subArgs, "--yes")) return;
+  const unmerged = await api.getMergeGate(sessionId, taskId).catch(() => []);
+  if (unmerged.length === 0) return;
+  const question = `This task waits for Merge all: the work of ${unmerged.map((d) => `#${d.order} ${d.title}`).join(", ")} is not merged into your branch yet, so it would act without it. Starting it now is kept on the task. Start it anyway?`;
+  if (!await confirm(question)) fail("Not started \u2014 nothing was changed. Pass --yes to start it without a prompt.");
+}
 function makeHandler(action, command = action) {
-  return async function handle(subArgs, injectedApi) {
+  const yes = PASSES_GATE.has(action) ? " [--yes]" : "";
+  return async function handle(subArgs, injectedApi, confirm = askYesNo) {
     await withResolvedTask(
       subArgs,
-      `Usage: ordewell ${command} <task-id-or-order> [--session-id <id>] [--workspace /path]`,
+      `Usage: ordewell ${command} <task-id-or-order> [--session-id <id>] [--workspace /path]${yes}`,
       injectedApi,
       async (api, sessionId, taskId) => {
+        if (PASSES_GATE.has(action)) await confirmPastGate(subArgs, api, sessionId, taskId, confirm);
         try {
           await api.taskControl(sessionId, taskId, action);
           console.log(PAST_TENSE[action]);
@@ -2613,22 +2656,19 @@ async function handleRewind(subArgs, injectedApi) {
   console.log(fork.rewoundMessage);
 }
 
-// src/commands/handoff.ts
-var import_readline2 = require("readline");
-
 // src/tui/transcript.ts
 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_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_core15.followTurn)(state.conversation, state.turnGate, message));
@@ -2808,8 +2848,12 @@ var reposOf2 = (handoff) => handoff.repos.map((r) => r.path).join(", ");
 var HANDOFF_USAGE = `/handoff [${HANDOFF_ACTIONS.map((a) => a.id).join("|")}]`;
 var diffRoom = (rows) => Math.max(1, rows - 3);
 var fail2 = (state, content) => ({ state: say(state, "error", content), effects: [] });
+function currentHandoff(state) {
+  return state.gate?.handoff ?? state.handoff;
+}
+var midRun = (state) => state.status === "executing";
 function handoffCommand(state, arg) {
-  if (!state.sessionId || !state.handoff) return fail2(state, "No isolated run to hand off \u2014 a plan that ran in worktrees leaves one here.");
+  if (!state.sessionId || !currentHandoff(state)) return fail2(state, "No isolated run to hand off \u2014 a plan that ran in worktrees leaves one here.");
   if (arg === void 0) return { state: { ...state, overlay: { kind: "handoff", index: 0, diff: null } }, effects: [] };
   const action = HANDOFF_ACTIONS.find((a) => a.id === arg.toLowerCase());
   if (!action) return fail2(state, `Usage: ${HANDOFF_USAGE}`);
@@ -2826,7 +2870,8 @@ function handoffArrived(state, handoff) {
   return state.overlay ? told : { ...told, overlay: { kind: "handoff", index: 0, diff: null } };
 }
 function runHandoffAction(state, id) {
-  const { sessionId, handoff } = state;
+  const { sessionId } = state;
+  const handoff = currentHandoff(state);
   if (!sessionId || !handoff) return fail2(state, "No isolated run to hand off.");
   const closed = { ...state, overlay: null };
   switch (id) {
@@ -2835,6 +2880,20 @@ function runHandoffAction(state, id) {
     case "cleanup":
       return { state: closed, effects: [{ type: "isolationCleanup", sessionId, branch: handoffBranch(handoff) }] };
     case "merge":
+      if (midRun(state)) {
+        return {
+          state: {
+            ...state,
+            overlay: {
+              kind: "confirm",
+              title: isRepoGroup(handoff) ? "Merge what has landed into your branches?" : "Merge what has landed into your branch?",
+              message: `Merge ${handoffBranch(handoff)} as it stands now into whatever ${isRepoGroup(handoff) ? `each of ${reposWithWork(handoff).join(", ")} has` : "you have"} checked out. Ordewell never does this on its own. The run goes on: tasks waiting for Merge all start once it has merged, and later tasks land on the same branch for the next Merge all. A merge that conflicts is aborted, and your ${isRepoGroup(handoff) ? "trees stay" : "tree stays"} as ${isRepoGroup(handoff) ? "they were" : "it was"}.${repairedNotice(handoff)}`,
+              action: { kind: "merge-run" }
+            }
+          },
+          effects: []
+        };
+      }
       return {
         state: {
           ...state,
@@ -2869,20 +2928,23 @@ function runHandoffAction(state, id) {
 }
 function confirmedHandoff(state, kind) {
   const closed = { ...state, overlay: null };
-  if (!state.sessionId || !state.handoff) return { state: closed, effects: [] };
-  const { sessionId, handoff } = state;
+  const handoff = currentHandoff(state);
+  if (!state.sessionId || !handoff) return { state: closed, effects: [] };
+  const { sessionId } = state;
   const repaired = repairedLanded(handoff);
   const effect = kind === "merge-run" ? {
     type: "isolationMerge",
     sessionId,
     branch: handoffBranch(handoff),
     ...isRepoGroup(handoff) ? { group: true } : {},
-    ...repaired.length > 0 ? { repaired } : {}
+    ...repaired.length > 0 ? { repaired } : {},
+    ...midRun(state) ? { midRun: true } : {}
   } : { type: "isolationDiscard", sessionId, branch: handoffBranch(handoff) };
   return { state: closed, effects: [effect] };
 }
 function showDiff(state, diff) {
-  if (diff.trim() === "") return say(state, "system", `Nothing differs from ${state.handoff ? handoffBase(state.handoff, 8) : "the base commit"}.`);
+  const handoff = currentHandoff(state);
+  if (diff.trim() === "") return say(state, "system", `Nothing differs from ${handoff ? handoffBase(handoff, 8) : "the base commit"}.`);
   const index = state.overlay?.kind === "handoff" ? state.overlay.index : 0;
   const lines = sanitize(diff.replace(/\t/g, "    ")).split("\n");
   return { ...state, overlay: { kind: "handoff", index, diff: { lines, scroll: 0 } } };
@@ -2955,6 +3017,7 @@ function clearIsolation(state) {
   return {
     ...state,
     handoff: null,
+    gate: null,
     tasks: mapTasks(state.tasks, ({ isolation: _dropped, ...task }) => task)
   };
 }
@@ -2972,16 +3035,6 @@ function isolationForPlan(tasks, record, previous) {
 
 // src/commands/handoff.ts
 var USAGE4 = "Usage: ordewell handoff [review|merge|discard|cleanup] [--session-id <id>] [--workspace /path] [--yes]";
-async function askYesNo(question) {
-  if (!process.stdin.isTTY) return false;
-  const rl = (0, import_readline2.createInterface)({ input: process.stdin, output: process.stderr });
-  try {
-    const answer = await new Promise((resolve3) => rl.question(`${question} [y/N] `, resolve3));
-    return /^y(es)?$/i.test(answer.trim());
-  } finally {
-    rl.close();
-  }
-}
 async function handleHandoff(subArgs, injectedApi, confirm = askYesNo) {
   const action = positionals(subArgs)[0]?.toLowerCase();
   if (action === void 0) {
@@ -3016,7 +3069,7 @@ async function handleHandoff(subArgs, injectedApi, confirm = askYesNo) {
       return;
     }
     case "merge": {
-      await confirmed((group ? `Merge ${branch} into the branch checked out in each of ${reposWithWork(handoff).join(", ")}? Nothing is merged unless every repository can take it; once all have, the run's worktrees and branches are removed.` : `Merge ${branch} into the branch you have checked out? Once merged, the run's worktrees and branches are removed.`) + repairedNotice(handoff));
+      await confirmed((group ? `Merge ${branch} into the branch checked out in each of ${reposWithWork(handoff).join(", ")}? Nothing is merged unless every repository can take it; once a finished run has merged everything, its worktrees and branches are removed.` : `Merge ${branch} into the branch you have checked out? Once a finished run has merged everything, its worktrees and branches are removed.`) + repairedNotice(handoff));
       const { ok, message } = mergeOutcome(await attempt(() => api.mergeRun(sessionId)), branch, group, repairedLanded(handoff));
       if (ok) console.log(message);
       else fail(message);
@@ -3208,6 +3261,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);
@@ -3232,21 +3286,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);
@@ -3278,7 +3332,7 @@ async function handleApprove(subArgs, injectedApi) {
 // src/tui/terminalLauncher.ts
 var import_child_process3 = require("child_process");
 var import_util = require("util");
-var import_core19 = 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);
@@ -3298,16 +3352,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_core19.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_core19.tmuxSessionName)(port);
-  const socket = (0, import_core19.tmuxSocketName)(port);
-  const base = (0, import_core19.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}"]);
@@ -3317,7 +3371,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)}`;
@@ -3599,9 +3653,27 @@ Dependencies \xB7 #${task.order} ${task.title}
     console.log(dependencies.length > 0 ? `Task #${task.order} now depends on ${dependencies.length} task${dependencies.length === 1 ? "" : "s"}.` : `Task #${task.order} no longer depends on anything.`);
   });
 }
+var OPS_USAGE = "Usage: ordewell task-ops <task-id-or-order> [on|off] [--session-id <id>]";
+async function handleTaskOps(subArgs, injectedApi) {
+  await withTask(subArgs, OPS_USAGE, injectedApi, async (api, sessionId, task, tasks, value) => {
+    if (!value) {
+      console.log(`
+#${task.order} ${task.title} is ${task.ops ? "an ops task: it runs in your checkout once the work it depends on is merged" : "a change task: it runs in its own worktree"}.`);
+      console.log(`
+  ${OPS_USAGE}`);
+      return;
+    }
+    const to = value.toLowerCase();
+    if (to !== "on" && to !== "off") fail(OPS_USAGE);
+    if (task.type !== "ai") fail("Only an AI task can be an ops task \u2014 a manual task already runs outside any worktree.");
+    if (!tasks.some((t) => t.id === task.id)) fail("A subtask runs with its parent; make the parent an ops task instead.");
+    await api.updateTask(sessionId, task.id, { ops: to === "on" });
+    console.log(to === "on" ? `Task #${task.order} is an ops task: it runs in your checkout once the work it depends on is merged.` : `Task #${task.order} is a change task: it runs in its own worktree.`);
+  });
+}
 
 // src/tui/index.ts
-var import_core32 = require("@ordewell/core");
+var import_core33 = require("@ordewell/core");
 
 // src/tui/editor.ts
 function emptyEditor() {
@@ -3756,6 +3828,7 @@ var SLASH_COMMANDS = [
   { name: "task-effort", usage: "/task-effort <id> [level]", description: "Choose or set a task's thinking effort", category: "tasks" },
   { name: "task-mode", usage: "/task-mode <id> [mode]", description: "Choose or set a task's runner mode", category: "tasks" },
   { name: "task-deps", usage: "/task-deps <id>", description: "Edit which earlier tasks a task waits for", category: "tasks" },
+  { name: "task-ops", usage: "/task-ops <id> [on|off]", description: "Make a task an ops task \u2014 run in your checkout once its dependencies are merged \u2014 or a change task", category: "tasks" },
   // Models & providers
   { name: "planner", usage: "/planner [<provider>]", description: "Choose who plans \u2014 an API provider or a coding agent (no API key)", category: "models" },
   { name: "model", usage: "/model [set <id>]", description: "Show or set the orchestrator model", category: "models" },
@@ -3763,8 +3836,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: "transport", usage: "/transport [terminal|structured]", description: "Experimental: run Claude Code tasks over its protocol instead of a terminal, from the next run", 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
@@ -3849,7 +3922,7 @@ function tokenCompletions(token) {
 }
 
 // src/tui/blocks.ts
-var import_core20 = require("@ordewell/core");
+var import_core21 = require("@ordewell/core");
 
 // src/tui/markdown.ts
 function renderMarkdown(source, cols) {
@@ -4057,16 +4130,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_core20.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_core20.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_core20.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)));
@@ -4187,7 +4260,7 @@ function tokenLine(blocks, cols) {
 }
 
 // src/tui/state.ts
-var import_core21 = require("@ordewell/core");
+var import_core22 = require("@ordewell/core");
 var SKILL_IDS = ["tdd", "verify"];
 function noSkills() {
   return { tdd: false, verify: false };
@@ -4234,9 +4307,9 @@ function findTask(tasks, id) {
 function initialState(overrides = {}) {
   return {
     editor: emptyEditor(),
-    conversation: import_core21.EMPTY_CONVERSATION,
+    conversation: import_core22.EMPTY_CONVERSATION,
     taskView: null,
-    turnGate: import_core21.NO_TURN,
+    turnGate: import_core22.NO_TURN,
     detailAll: false,
     status: "idle",
     busyLabel: "",
@@ -4261,18 +4334,19 @@ function initialState(overrides = {}) {
     orchestratorModel: "",
     plannerProvider: "",
     plannerEffort: "",
-    maxParallel: import_core21.DEFAULT_MAX_PARALLEL,
+    maxParallel: import_core22.DEFAULT_MAX_PARALLEL,
     configuredProviders: [],
     allowlist: {},
     autonomous: true,
-    runnerTransport: "terminal",
+    runnerTransport: "structured",
     mouseCapture: true,
     selection: null,
     workspace: process.cwd(),
     handoff: null,
+    gate: null,
     overlay: null,
     pendingApprovals: [],
-    queuedPrompts: import_core21.EMPTY_HOLD,
+    queuedPrompts: import_core22.EMPTY_HOLD,
     stopArmed: false,
     stopArmToken: 0,
     stopRequested: false,
@@ -4320,7 +4394,7 @@ function chatEditorRoomFor(state, active) {
 }
 
 // src/tui/layout.ts
-var import_core22 = require("@ordewell/core");
+var import_core23 = require("@ordewell/core");
 var CHROME_ROWS = 4;
 function chatInputWrap(state) {
   const active = state.focus === "chat" && !state.overlay;
@@ -4345,6 +4419,7 @@ function footerHints(state) {
       "e effort",
       "M mode",
       "D deps",
+      "O ops",
       "f start",
       "E run plan",
       "S stop",
@@ -4359,7 +4434,7 @@ function footerHints(state) {
       "tab chat"
     ];
   }
-  const detailHint = (0, import_core22.hasHiddenDetail)(state.taskView ? state.taskView.view.blocks : 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",
@@ -4464,9 +4539,9 @@ function chatScrollMax(state) {
 }
 function plannerSetup(state) {
   const provider = state.plannerProvider;
-  const registration = import_core22.ALL_PROVIDERS[provider];
+  const registration = import_core23.ALL_PROVIDERS[provider];
   if (!registration) return { label: "not set", ready: false };
-  const runner = (0, import_core22.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 };
 }
@@ -4576,7 +4651,8 @@ var STATUS_ICON = {
 var AWAITING_LABEL = {
   input: "waiting for your input",
   checkpoint: "checkpoint",
-  conflict: "merge conflict"
+  conflict: "merge conflict",
+  "files-changed": "changed tracked files"
 };
 function approvalLabel(count) {
   return count > 1 ? `waiting for approval (${count})` : "waiting for approval";
@@ -4655,9 +4731,9 @@ function taskLines(state, row, index, cols) {
   const paint = idle ? style.cyan : STATUS_MARK[task.status] ?? ((t) => t);
   const rawIcon = idle ? IDLE_ICON : running ? SPINNER[state.spinnerFrame % SPINNER.length] : STATUS_ICON[task.status] ?? "\xB7";
   const icon = paint(rawIcon);
-  const kind = running ? style.yellow("RUN") : task.type === "user" ? style.yellow("MAN") : style.grey(" AI");
+  const kind = running ? style.yellow("RUN") : task.type === "user" ? style.yellow("MAN") : task.ops ? style.magenta("OPS") : style.grey(" AI");
   const caret = selected ? style.cyan("\u276F") : " ";
-  const orderLabel = parent ? (0, import_core22.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));
@@ -4687,16 +4763,26 @@ function taskLines(state, row, index, cols) {
   if (effort || mode) lines.push(style.grey(truncate(`${bodyPad}${[effort, mode].filter(Boolean).join(" \xB7 ")}`, cols)));
   if (task.isolation?.state === "conflict") {
     const where = task.isolation.conflictRepo && task.isolation.conflictRepo !== "." ? ` in ${task.isolation.conflictRepo}` : "";
-    const files = task.isolation.conflictFiles?.length ? ` (${(0, import_core22.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_core22.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.mergeGate?.length) {
+    const deps = task.mergeGate.map((id) => {
+      const dep = state.tasks.find((t) => t.id === id);
+      return dep ? `#${dep.order}` : id;
+    });
+    lines.push(style.yellow(truncate(`${bodyPad}\u23F8 waits for Merge all \u2014 ${deps.join(", ")} not merged into your branch yet`, cols)));
+  }
+  if (task.status === "awaiting_user" && task.awaitingReason === "files-changed") {
+    lines.push(style.yellow(truncate(`${bodyPad}\u26A0 an ops task changed tracked files \u2014 check them, then m done or /retry`, cols)));
+  }
   if (task.isolation?.state === "integrated" && task.isolation.repairedFiles?.length) {
-    lines.push(style.grey(truncate(`${bodyPad}\u21BB landed after repairing conflict in ${(0, import_core22.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) {
@@ -4709,8 +4795,14 @@ function taskLines(state, row, index, cols) {
         lines.push(...taskText("Worktree", task.isolation.worktree, cols, bodyPad));
       }
     }
+    if (task.ops) {
+      lines.push(...taskText("Ops", "Runs in your checkout, not a worktree, once the work it depends on is merged. O makes it a change task.", cols, bodyPad));
+    }
+    if (task.forcedPastGate?.length) {
+      lines.push(...taskText("Forced", `Started before the work of ${task.forcedPastGate.join(", ")} was merged into your branch.`, cols, bodyPad));
+    }
     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) {
@@ -4784,7 +4876,7 @@ function helpScrollMax(state) {
 }
 
 // src/tui/render.ts
-var import_core23 = require("@ordewell/core");
+var import_core24 = require("@ordewell/core");
 function render(state) {
   const { rows, cols } = state;
   const rowsForBody = bodyRows(state);
@@ -4879,9 +4971,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");
-  const structured = state.runnerTransport === "structured" ? [style.yellow("\u25CF structured")] : [];
-  return truncate([...badges, auto, ...structured].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" : "";
@@ -5039,7 +5131,7 @@ function renderOverlay(state, rows, cols) {
   return renderPicker(overlay.picker, rows, cols);
 }
 function renderHandoff(state, overlay, rows, cols) {
-  const handoff = state.handoff;
+  const handoff = currentHandoff(state);
   if (!handoff) return frame("Handoff", [style.grey("Nothing to hand off.")], rows, cols);
   if (overlay.diff) {
     const room = diffRoom(rows);
@@ -5049,7 +5141,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_core23.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) => {
@@ -5139,7 +5231,7 @@ function frame(title, body, rows, cols) {
 }
 
 // src/tui/reducer.ts
-var import_core29 = require("@ordewell/core");
+var import_core30 = require("@ordewell/core");
 
 // src/tui/reducers/shared.ts
 function step(state, effects = []) {
@@ -5188,10 +5280,10 @@ function handleApprovalKey(state, overlay, key) {
 }
 
 // src/tui/reducers/commands.ts
-var import_core27 = require("@ordewell/core");
+var import_core28 = require("@ordewell/core");
 
 // src/tui/reducers/pickers.ts
-var import_core24 = 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 = {}) {
@@ -5210,11 +5302,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_core24.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_core24.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,
@@ -5228,7 +5320,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_core24.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 }];
   }
@@ -5337,21 +5429,21 @@ function pickerItemsFor(state, action) {
 }
 function plannerItems(state) {
   const installed = new Set(state.runners.map((r) => r.id));
-  const agents = import_core24.CLI_PROVIDERS.map((id) => {
-    const runner = (0, import_core24.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_core24.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_core24.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_core24.ALL_PROVIDERS[id].label,
-    detail: import_core24.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 }];
@@ -5433,13 +5525,13 @@ function handleMouseSelect(state, key) {
 }
 
 // src/tui/reducers/taskView.ts
-var import_core25 = require("@ordewell/core");
+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_core25.EMPTY_TASK_LOG,
+    view: import_core26.EMPTY_TASK_LOG,
     attempts: [],
     attempt: 0,
     pending: [],
@@ -5472,13 +5564,13 @@ function applyLive(tv, attempt, events) {
     }
     next = {
       ...next,
-      view: import_core25.EMPTY_TASK_LOG,
+      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_core25.reduceTaskLog, next.view) });
+  return clampQueueIndex({ ...next, view: events.reduce(import_core26.reduceTaskLog, next.view) });
 }
 function taskLogAbandoned(state) {
   const tv = state.taskView;
@@ -5498,15 +5590,15 @@ function taskLogArrived(state, action) {
 function announceApprovals(state, action) {
   if (state.taskView?.taskId === action.taskId) return state;
   const task = findTask(state.tasks, action.taskId);
-  const spoken = action.events.reduce((s, event) => event.type === "approval_requested" ? say(s, "system", `\xB7 Task ${task?.order ?? "?"} waits for approval: ${(0, import_core25.runnerToolSubject)(event.tool, event.args)} \u2014 t on it to answer`) : s, state);
-  return state.taskView && spoken !== state ? { ...spoken, scroll: state.scroll } : spoken;
+  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_core25.replayTaskLog)(action.events),
+    view: (0, import_core26.replayTaskLog)(action.events),
     attempts: action.attempts ?? tv.attempts,
     attempt: action.attempt
   } : { ...tv, attempts: action.attempts ?? tv.attempts };
@@ -5595,6 +5687,34 @@ function confirmRemoveTask(state, task) {
     }
   });
 }
+function toggleTaskOps(state, task, subtask, to = !task.ops) {
+  if (!state.sessionId) return fail3(state, "No active plan.");
+  if (task.type !== "ai") return fail3(state, "Only an AI task can be an ops task \u2014 a manual task already runs outside any worktree.");
+  if (subtask) return fail3(state, "A subtask runs with its parent; make the parent an ops task instead.");
+  if (!!task.ops === to) return fail3(state, `#${task.order} is already ${to ? "an ops" : "a change"} task.`);
+  return step(state, [{
+    type: "updateTask",
+    sessionId: state.sessionId,
+    taskId: task.id,
+    changes: { ops: to },
+    message: to ? `Task #${task.order} is an ops task: it runs in your checkout once the work it depends on is merged.` : `Task #${task.order} is a change task: it runs in its own worktree.`
+  }]);
+}
+function confirmForceStartPastGate(state, task) {
+  const named = (task.mergeGate ?? []).map((id) => {
+    const dep = findTask(state.tasks, id);
+    return dep ? `#${dep.order} ${dep.title}` : id;
+  });
+  return step({
+    ...state,
+    overlay: {
+      kind: "confirm",
+      title: `Force start #${task.order} ${task.title}?`,
+      message: `It waits for Merge all: the work of ${named.join(", ")} is not merged into your branch yet, so it would act without it. Starting it now is kept on the task.`,
+      action: { kind: "force-start-gated", taskId: task.id }
+    }
+  });
+}
 function openTaskDepsPicker(state, task) {
   const action = { kind: "set-task-deps", taskId: task.id };
   const items = pickerItemsFor(state, action);
@@ -5751,6 +5871,15 @@ function taskEffortCommand(state, args) {
     return assignTaskEffort(state, sessionId, task, value);
   });
 }
+function taskOpsCommand(state, args) {
+  return taskCommand(state, args[0], (_sessionId, taskId) => {
+    const task = findTask(state.tasks, taskId);
+    const subtask = !state.tasks.some((t) => t.id === taskId);
+    const value = args[1]?.toLowerCase();
+    if (value !== void 0 && value !== "on" && value !== "off") return fail3(state, "Usage: /task-ops <id> [on|off]");
+    return toggleTaskOps(state, task, subtask, value === void 0 ? !task.ops : value === "on");
+  });
+}
 function addTask(state, title) {
   if (!state.sessionId) {
     return fail3(state, "No active plan to add a task to \u2014 describe a goal first, then /add-task <title>.");
@@ -5831,9 +5960,11 @@ function handlePlanKey(state, key) {
   if (key.char === "E") return step(state, [{ type: "execute", sessionId: state.sessionId }]);
   if (key.char === "S") return step(state, [{ type: "stopExecution", sessionId: state.sessionId }]);
   const action = key.char === "m" ? markAction(task) : PLAN_SHORTCUTS[key.char ?? ""];
+  if (action === "force-start" && task.mergeGate?.length) return confirmForceStartPastGate(state, task);
   if (action) {
     return step(state, [taskActionEffect(state, state.sessionId, task.id, action)]);
   }
+  if (key.char === "O") return toggleTaskOps(state, task, row.parent !== null);
   if (key.char === "d") return confirmRemoveTask(state, task);
   if (key.char === "t") return openTaskTerminalOrView(state, state.sessionId, task.id);
   if (key.char === "x" && task.isolation?.state === "conflict") {
@@ -5868,9 +5999,9 @@ function commitTaskEdit(state, task, editor) {
 }
 
 // src/tui/reducers/turnQueue.ts
-var import_core26 = require("@ordewell/core");
+var import_core27 = require("@ordewell/core");
 function drainQueue(state, settled) {
-  const next = (0, import_core26.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);
@@ -5889,14 +6020,14 @@ function stopPlanning(state, sessionId) {
   return step(queueToEditor(cutTurn({ ...dismissed, stopArmed: false, stopRequested: true })), [{ type: "cancelPlanning", sessionId }]);
 }
 function queueToEditor(state) {
-  const all = (0, import_core26.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_core26.unsendLatest)(state.queuedPrompts);
+  const latest = (0, import_core27.unsendLatest)(state.queuedPrompts);
   if (!latest) return step(state);
-  const text = (0, import_core26.aheadOfDraft)(latest.text, state.editor.text);
+  const text = (0, import_core27.aheadOfDraft)(latest.text, state.editor.text);
   return step({
     ...state,
     queuedPrompts: latest.rest,
@@ -5913,7 +6044,7 @@ function plannerEscape(state) {
 }
 
 // src/tui/reducers/commands.ts
-var KNOWN_PROVIDERS2 = Object.keys(import_core27.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.`);
@@ -6008,6 +6139,8 @@ function runCommand(state, { name, args }) {
       return taskEffortCommand(state, args);
     case "task-mode":
       return taskModeCommand(state, args);
+    case "task-ops":
+      return taskOpsCommand(state, args);
     case "task-deps":
       return taskCommand(
         state,
@@ -6020,11 +6153,11 @@ function runCommand(state, { name, args }) {
     case "retry":
     case "cancel":
     case "force-start":
-      return taskCommand(
-        state,
-        args[0],
-        (sessionId, taskId) => step(state, [taskActionEffect(state, sessionId, taskId, name)])
-      );
+      return taskCommand(state, args[0], (sessionId, taskId) => {
+        const task = findTask(state.tasks, taskId);
+        if (name === "force-start" && task?.mergeGate?.length) return confirmForceStartPastGate(state, task);
+        return step(state, [taskActionEffect(state, sessionId, taskId, name)]);
+      });
   }
   return fail3(state, `/${name} is not wired up yet.`);
 }
@@ -6069,8 +6202,8 @@ function newSession(state) {
     taskView: null,
     tasks: [],
     planApproved: false,
-    conversation: import_core27.EMPTY_CONVERSATION,
-    turnGate: import_core27.NO_TURN,
+    conversation: import_core28.EMPTY_CONVERSATION,
+    turnGate: import_core28.NO_TURN,
     selectedTask: 0,
     expandedTaskId: null,
     taskEditor: null,
@@ -6081,14 +6214,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_core27.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_core27.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}.`);
@@ -6161,16 +6294,16 @@ function setKey(state, args) {
     }
     return step(state, [{ type: "setApiKey", provider, key: args.slice(2).join(" ") }]);
   }
-  const items = import_core27.PROVIDER_PRIORITY.map((id) => ({
+  const items = import_core28.PROVIDER_PRIORITY.map((id) => ({
     id,
-    label: import_core27.ALL_PROVIDERS[id].label,
-    detail: import_core27.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_core27.ALL_PROVIDERS[provider];
+  const meta = import_core28.ALL_PROVIDERS[provider];
   return {
     kind: "prompt",
     title: `${meta.label} API key`,
@@ -6247,18 +6380,19 @@ 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_core27.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_core27.isRunnerTransport)(value)) return fail3(state, "Usage: /transport [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) {
@@ -6344,6 +6478,10 @@ function runConfirm(state, overlay) {
     if (!state.sessionId) return step(closed);
     return step(closed, [{ type: "removeTask", sessionId: state.sessionId, taskId: overlay.action.taskId }]);
   }
+  if (overlay.action.kind === "force-start-gated") {
+    if (!state.sessionId) return step(closed);
+    return step(closed, [taskActionEffect(closed, state.sessionId, overlay.action.taskId, "force-start")]);
+  }
   if (overlay.action.kind === "merge-run" || overlay.action.kind === "discard-run") {
     return confirmedHandoff(state, overlay.action.kind);
   }
@@ -6508,7 +6646,7 @@ function choose(state, picker2, item) {
 }
 
 // src/tui/reducers/incoming.ts
-var import_core28 = require("@ordewell/core");
+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 : {};
@@ -6539,7 +6677,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_core28.isAwaitingReason)(t.awaitingReason) ? t.awaitingReason : void 0,
+    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,
@@ -6549,7 +6687,9 @@ function toTaskView2(t, index) {
       thinkingEffort: typeof model.thinkingEffort === "string" ? planLabel(model.thinkingEffort) : typeof t.thinkingEffort === "string" ? planLabel(t.thinkingEffort) : void 0,
       availableVariants: Array.isArray(model.availableVariants) ? model.availableVariants.map((variant) => planLabel(variant)) : void 0
     } : void 0,
-    subtasks: Array.isArray(t.subtasks) ? [...t.subtasks].sort((a, b) => wireOrder(a) - wireOrder(b)).map((s, i) => toTaskView2(asRecord(s), i)) : void 0
+    subtasks: Array.isArray(t.subtasks) ? [...t.subtasks].sort((a, b) => wireOrder(a) - wireOrder(b)).map((s, i) => toTaskView2(asRecord(s), i)) : void 0,
+    ...t.ops === true ? { ops: true } : {},
+    ...Array.isArray(t.forcedPastGate) && t.forcedPastGate.length > 0 ? { forcedPastGate: t.forcedPastGate.map((title) => planLabel(title)) } : {}
   };
 }
 var enabledFlag = (value) => typeof value?.enabled === "boolean" ? value.enabled : void 0;
@@ -6570,11 +6710,11 @@ 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_core28.isRunnerTransport)(settings.runnerTransport) ? settings.runnerTransport : state.runnerTransport,
+    runnerTransport: (0, import_core29.isRunnerTransport)(settings.runnerTransport) ? settings.runnerTransport : state.runnerTransport,
     allowlist: settings.modelAllowlist && typeof settings.modelAllowlist === "object" ? settings.modelAllowlist : state.allowlist
   };
 }
-function runLabel(tasks) {
+function runLabel(tasks, gate = null) {
   const running = tasks.filter(isTaskRunning);
   if (running.length > 0) {
     const [first] = running;
@@ -6582,8 +6722,8 @@ function runLabel(tasks) {
     return running.length > 1 ? `${name} (+${running.length - 1} more)` : name;
   }
   const waiting = tasks.filter((t) => t.status === "awaiting_user").length;
-  if (waiting === 0) return "";
-  return waiting === 1 ? "1 task waits for you" : `${waiting} tasks wait for you`;
+  if (waiting > 0) return waiting === 1 ? "1 task waits for you" : `${waiting} tasks wait for you`;
+  return gate?.paused ? "paused for Merge all \u2014 /handoff merge" : "";
 }
 var statusText = (text) => sanitize(text).replace(/\s+/g, " ").trim();
 function inFlight(blocks) {
@@ -6612,7 +6752,18 @@ function followSession(state, message) {
 }
 
 // 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);
@@ -6630,13 +6781,13 @@ function reduce(state, action) {
         goal: "",
         taskView: null,
         pendingApprovals: [],
-        queuedPrompts: import_core29.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_core29.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);
@@ -6671,6 +6822,9 @@ function reduce(state, action) {
     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));
@@ -6682,14 +6836,14 @@ 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_core29.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, awaitingReason: void 0 } : t);
       const status = runStatus(state, tasks);
-      return step({ ...state, status, tasks, busyLabel: status === "executing" ? runLabel(tasks) : state.busyLabel });
+      return step({ ...state, status, tasks, busyLabel: status === "executing" ? runLabel(tasks, state.gate) : state.busyLabel });
     }
     case "tasksStatus": {
       if (stale(state, action.sessionId)) return step(state);
@@ -6704,15 +6858,20 @@ function reduce(state, action) {
         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) {
+        const mergeGate = update.mergeGate;
+        const forcedPastGate = update.forcedPastGate;
+        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 || !sameList(mergeGate, t.mergeGate) || !sameList(forcedPastGate, t.forcedPastGate)) {
           changed = true;
-          return { ...t, status: update.status, idleSince, isolation, transport, awaitingReason, continuable, awaitingApproval };
+          return { ...t, status: update.status, idleSince, isolation, transport, awaitingReason, continuable, awaitingApproval, mergeGate, forcedPastGate };
         }
         return t;
       });
-      if (!changed) return step(state);
-      const status = runStatus(state, tasks);
-      return step({ ...state, status, tasks, busyLabel: status === "executing" ? runLabel(tasks) : state.busyLabel });
+      const gate = action.gate === void 0 ? state.gate : action.gate;
+      const gateChanged = !sameGate(gate, state.gate);
+      if (!changed && !gateChanged) return step(state);
+      const next = { ...state, tasks, gate };
+      const status = runStatus(next, tasks);
+      return step({ ...next, status, busyLabel: status === "executing" ? runLabel(tasks, gate) : state.busyLabel });
     }
     case "queueReady": {
       if (stale(state, action.sessionId)) return step(state);
@@ -6786,7 +6945,7 @@ function reduce(state, action) {
         busyLabel: "",
         planApproved: false,
         pendingApprovals: [],
-        queuedPrompts: import_core29.EMPTY_HOLD,
+        queuedPrompts: import_core30.EMPTY_HOLD,
         stopArmed: false,
         overlay: state.overlay?.kind === "approval" ? null : state.overlay
       });
@@ -6845,9 +7004,16 @@ function reduce(state, action) {
 function sameTransport(a, b) {
   return a?.kind === b?.kind && a?.fallback === b?.fallback;
 }
+function sameList(a, b) {
+  return (a ?? []).join("\0") === (b ?? []).join("\0");
+}
+function sameGate(a, b) {
+  if (!a || !b) return a === b;
+  return a.paused === b.paused && JSON.stringify(a.handoff) === JSON.stringify(b.handoff);
+}
 function runStatus(state, tasks) {
   if (tasks.some(isTaskRunning)) return "executing";
-  if (tasks.some((t) => t.status === "awaiting_user")) return "executing";
+  if (tasks.some((t) => t.status === "awaiting_user") || state.gate?.paused) return "executing";
   return plannerInFlight(state) ? state.status : "idle";
 }
 function interrupt(state) {
@@ -6915,7 +7081,7 @@ function submit(state) {
     return step(cleared, [{ type: "sendTaskMessage", sessionId: state.sessionId, taskId, text }]);
   }
   if (plannerInFlight(state)) {
-    return step({ ...cleared, queuedPrompts: (0, import_core29.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 };
@@ -6975,10 +7141,10 @@ function createApp(deps) {
 
 // src/tui/effects.ts
 var import_child_process4 = require("child_process");
-var import_core31 = require("@ordewell/core");
+var import_core32 = require("@ordewell/core");
 
 // src/tui/inbound.ts
-var import_core30 = require("@ordewell/core");
+var import_core31 = require("@ordewell/core");
 var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
   "planner_message",
   "planner_turn_started",
@@ -7193,12 +7359,15 @@ function dispatchLifecycle(dispatch, event, sessionId) {
           idleSince: task.idleSince ?? null,
           isolation: task.isolation,
           transport: task.transport,
-          awaitingReason: (0, import_core30.isAwaitingReason)(task.awaitingReason) ? task.awaitingReason : void 0,
+          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
+          awaitingApproval: typeof task.awaitingApproval === "number" && task.awaitingApproval > 0 ? task.awaitingApproval : void 0,
+          ...task.mergeGate?.length ? { mergeGate: task.mergeGate.map(String) } : {},
+          ...task.forcedPastGate?.length ? { forcedPastGate: task.forcedPastGate.map(String) } : {}
         };
       }
-      dispatch({ type: "tasksStatus", updates, sessionId });
+      const gate = event.gate ? { paused: event.gate.paused === true, handoff: { repos: event.gate.repos, landed: event.gate.landed } } : null;
+      dispatch({ type: "tasksStatus", updates, gate, sessionId });
       return;
     }
     case "task_started":
@@ -7207,7 +7376,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_core30.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." });
@@ -7405,7 +7574,14 @@ async function perform(effect, deps) {
       }
       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;
@@ -7460,7 +7636,7 @@ async function perform(effect, deps) {
     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} (experimental) \u2014 it applies from the next run.` });
+      dispatch({ type: "notice", message: `Runner transport is ${effect.transport} \u2014 it applies from the next run.` });
       return;
     }
     case "setModel":
@@ -7470,7 +7646,7 @@ async function perform(effect, deps) {
       dispatch({ type: "notice", message: `Orchestrator model set to ${effect.modelId}.` });
       return;
     case "setPlanner": {
-      const meta = import_core31.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 });
@@ -7482,7 +7658,7 @@ async function perform(effect, deps) {
       });
       dispatch({
         type: "notice",
-        message: `${(0, import_core31.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;
@@ -7494,7 +7670,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_core31.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);
@@ -7532,7 +7708,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);
@@ -7603,10 +7779,11 @@ async function perform(effect, deps) {
       return;
     // A conflict or a refusal is an answer, not a fault: either way the user's
     // tree is exactly as it was, and the words say what to do next. A full
-    // merge leaves nothing to hand over — the daemon has cleared the run up.
+    // merge of a settled run leaves nothing to hand over — the daemon has
+    // cleared the run up; one mid-run leaves the run going (ADR-0020).
     case "isolationMerge": {
       const { ok, message } = mergeOutcome(await api.mergeRun(effect.sessionId), effect.branch, effect.group === true, effect.repaired ?? []);
-      if (ok) dispatch({ type: "runCleared", sessionId: effect.sessionId });
+      if (ok && !effect.midRun) dispatch({ type: "runCleared", sessionId: effect.sessionId });
       dispatch({ type: ok ? "notice" : "failed", message });
       return;
     }
@@ -7665,7 +7842,7 @@ function osc52(text) {
 function copySelection(deps, text) {
   if (!text) return;
   const lines = text.split("\n").length;
-  const command = (0, import_core31.clipboardCopyCommand)(deps.hasBin);
+  const command = (0, import_core32.clipboardCopyCommand)(deps.hasBin);
   if (command) {
     try {
       (deps.pipeToClipboard ?? pipeToClipboardDefault)(command, text);
@@ -8055,7 +8232,7 @@ async function handleTui(subArgs) {
   }
   const workspace = flag(subArgs, "--workspace") || process.cwd();
   try {
-    (0, import_core32.assertWorkspaceExists)(workspace);
+    (0, import_core33.assertWorkspaceExists)(workspace);
   } catch {
     console.error(
       `Workspace "${workspace}" does not exist.
@@ -8064,7 +8241,7 @@ cd into a directory that exists, or pass --workspace <path> naming one that does
     );
     process.exit(1);
   }
-  registerSkillCommands((0, import_core32.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 });
@@ -8081,7 +8258,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_core32.mintSessionId)(),
+      newSessionId: () => (0, import_core33.mintSessionId)(),
       setEnvVar: (key, value) => {
         writeEnvVar(findEnvFile(), key, value);
         process.env[key] = value;
@@ -8179,6 +8356,7 @@ var COMMANDS = {
   "task-effort": handleTaskEffort,
   "task-mode": handleTaskMode,
   "task-deps": handleTaskDeps,
+  "task-ops": handleTaskOps,
   terminal: handleTerminal,
   "sessions": handleSessions,
   fork: handleFork,
@@ -8204,7 +8382,7 @@ function cliVersion() {
 // src/main.ts
 var TUI_FLAGS = /* @__PURE__ */ new Set(["--workspace", "--port"]);
 async function main() {
-  (0, import_core33.migrateOldConfigDir)();
+  (0, import_core34.migrateOldConfigDir)();
   loadEnvFile();
   const argv = process.argv.slice(2);
   if (TUI_FLAGS.has(argv[0] ?? "")) argv.unshift("tui");