@ordewell/cli 0.6.0 → 0.6.2

package/dist/main.js

@@ -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)
@@ -412,6 +413,8 @@ var ApiClient = class _ApiClient {
   static defaultWorkspace;
   port;
   workspace;
+  /** A session's open execution stream, so a new one can end it: one run is reported once. */
+  executionStreams = /* @__PURE__ */ new Map();
   constructor(port, workspace) {
     this.port = port || DEFAULT_PORT;
     this.workspace = workspace ?? _ApiClient.defaultWorkspace ?? process.cwd();
@@ -713,6 +716,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) {
@@ -837,26 +851,36 @@ var ApiClient = class _ApiClient {
   }
   streamExecution(sessionId, onEvent, onReady) {
     return new Promise((resolve3, reject) => {
+      this.executionStreams.get(sessionId)?.();
       const socket = this.openSessionSocket(sessionId);
       let resolved = false;
       let opened = false;
+      const forget = () => {
+        if (this.executionStreams.get(sessionId) === end) this.executionStreams.delete(sessionId);
+      };
+      const end = () => {
+        forget();
+        if (resolved) return;
+        resolved = true;
+        socket.close();
+        resolve3();
+      };
+      this.executionStreams.set(sessionId, end);
       socket.on("open", () => {
         opened = true;
         onReady?.();
       });
       socket.on("message", (data) => {
+        if (resolved) return;
         try {
           const event = JSON.parse(data.toString());
           onEvent(event);
-          if ((event.type === "execution_complete" || event.type === "execution_stopped" || event.type === "isolation_blocked") && !resolved) {
-            resolved = true;
-            socket.close();
-            resolve3();
-          }
+          if (event.type === "execution_complete" || event.type === "execution_stopped") end();
         } catch {
         }
       });
       socket.on("error", (err) => {
+        forget();
         if (!opened) onReady?.(err);
         if (!resolved) {
           resolved = true;
@@ -864,6 +888,7 @@ var ApiClient = class _ApiClient {
         }
       });
       socket.on("close", () => {
+        forget();
         if (!opened) onReady?.(new Error("Execution stream closed before connecting"));
         if (!resolved) {
           resolved = true;
@@ -1252,7 +1277,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 +1289,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 +1484,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 +1559,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 +1617,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 +1652,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 +1700,12 @@ async function followExecution(api, sessionId, start, onBlocked) {
       lastPrinted = output;
     }
   }
+  let pausedAtGate = false;
+  let noteBlocked = () => {
+  };
+  const blockedSeen = new Promise((resolve3) => {
+    noteBlocked = resolve3;
+  });
   let settleReady = () => {
   };
   const streamReady = new Promise((resolve3, reject) => {
@@ -1674,6 +1722,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.");
@@ -1693,6 +1744,7 @@ Done. ${summary.completed || 0} completed, ${summary.failed || 0} failed, ${summ
     if (event.type === "isolation_blocked") {
       blocked = event.message;
       dirtyRepos = event.repos ?? [];
+      noteBlocked();
     }
     if (event.type === "isolation_handoff") {
       const n = event.landed.length;
@@ -1710,7 +1762,7 @@ Run finished on ${handoffBranch(event)}${where} \u2014 ${n} task${n === 1 ? "" :
   void stream.catch(settleReady);
   await streamReady.catch(streamFailed);
   await start();
-  await stream.catch(streamFailed);
+  await Promise.race([stream, blockedSeen]).catch(streamFailed);
   if (blocked === null) return;
   if (!onBlocked) {
     await api.stopExecution(sessionId);
@@ -2330,13 +2382,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,9 +2675,6 @@ 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 }) {
@@ -2808,8 +2867,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 +2889,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 +2899,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 +2947,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 +3036,7 @@ function clearIsolation(state) {
   return {
     ...state,
     handoff: null,
+    gate: null,
     tasks: mapTasks(state.tasks, ({ isolation: _dropped, ...task }) => task)
   };
 }
@@ -2972,16 +3054,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 +3088,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);
@@ -3600,6 +3672,24 @@ 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_core33 = require("@ordewell/core");
@@ -3757,6 +3847,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" },
@@ -4271,6 +4362,7 @@ function initialState(overrides = {}) {
     selection: null,
     workspace: process.cwd(),
     handoff: null,
+    gate: null,
     overlay: null,
     pendingApprovals: [],
     queuedPrompts: import_core22.EMPTY_HOLD,
@@ -4346,6 +4438,7 @@ function footerHints(state) {
       "e effort",
       "M mode",
       "D deps",
+      "O ops",
       "f start",
       "E run plan",
       "S stop",
@@ -4577,7 +4670,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";
@@ -4656,7 +4750,7 @@ 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_core23.taskOrderLabel)(task, parent) : String(task.order).padStart(2);
   const indent = parent ? "  " : "";
@@ -4696,6 +4790,16 @@ function taskLines(state, row, index, cols) {
     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_core23.capConflictFiles)(task.isolation.repairedFiles)}`, cols)));
   }
@@ -4710,6 +4814,12 @@ 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 (Full auto). Change the level with /auto.", cols, bodyPad));
     }
@@ -5040,7 +5150,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);
@@ -5596,6 +5706,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);
@@ -5752,6 +5890,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>.");
@@ -5832,9 +5979,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") {
@@ -6009,6 +6158,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,
@@ -6021,11 +6172,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.`);
 }
@@ -6346,6 +6497,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);
   }
@@ -6551,7 +6706,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;
@@ -6576,7 +6733,7 @@ function applySettings(state, settings) {
     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;
@@ -6584,8 +6741,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) {
@@ -6705,7 +6862,7 @@ function reduceAction(state, action) {
       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);
@@ -6720,15 +6877,20 @@ function reduceAction(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);
@@ -6861,9 +7023,16 @@ function reduceAction(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) {
@@ -7211,10 +7380,13 @@ function dispatchLifecycle(dispatch, event, sessionId) {
           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
+          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":
@@ -7626,10 +7798,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;
     }
@@ -7643,8 +7816,8 @@ async function perform(effect, deps) {
       await refreshPlan(deps, effect.sessionId);
       dispatch({ type: "notice", message: `Removed the run's worktrees and task branches; ${effect.branch} is kept.` });
       return;
-    // Spawns runners again, so it needs the stream a run needs — the blocked
-    // one closed itself when nothing started.
+    // Spawns runners again, so it needs the stream a run needs. Opening it ends
+    // the blocked run's, which stayed open to show the ops tasks still running.
     case "isolationContinue": {
       const { sessionId } = effect;
       await withExecutionStream(deps, sessionId, () => effect.mode === "stash" ? api.continueWithStash(sessionId) : api.continueWithoutIsolation(sessionId));
@@ -8202,6 +8375,7 @@ var COMMANDS = {
   "task-effort": handleTaskEffort,
   "task-mode": handleTaskMode,
   "task-deps": handleTaskDeps,
+  "task-ops": handleTaskOps,
   terminal: handleTerminal,
   "sessions": handleSessions,
   fork: handleFork,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ordewell/cli",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Ordewell CLI and TUI — plan, run and verify coding-agent tasks from the terminal.",
   "license": "Apache-2.0",
   "author": "Alessandro Costanzo Ciano",
@@ -49,8 +49,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ordewell/core": "^0.6.0",
-    "@ordewell/web": "^0.6.0",
+    "@ordewell/core": "^0.6.2",
+    "@ordewell/web": "^0.6.2",
     "string-width": "^7.2.0",
     "ws": "^8.18.0"
   },