@ordewell/core 0.6.0 → 0.6.2

package/dist/index.mjs

@@ -15,7 +15,7 @@ import {
   resolveTaskMode,
   runnerModesFrom,
   validatePlanModification
-} from "./chunk-OM4D274O.mjs";
+} from "./chunk-M4KXBEFJ.mjs";
 import {
   CHECKPOINT_TRUNCATE_LENGTH,
   EMPTY_CONVERSATION,
@@ -76,7 +76,7 @@ import {
   unsendLatest,
   usageLine,
   validateTaskEdit
-} from "./chunk-2SOVKO7P.mjs";
+} from "./chunk-I6U3PVHL.mjs";
 import {
   PLAN_ENVELOPE_KEY,
   PlanParseError,
@@ -105,7 +105,7 @@ import {
   updateTaskInPlan,
   validateModifiedPlan,
   warningsText
-} from "./chunk-EDGUFCIR.mjs";
+} from "./chunk-JRZPSNRO.mjs";
 import {
   resolveOrderLabel,
   taskOrderLabel
@@ -121,12 +121,14 @@ import {
   migratePlanStateIsolation,
   repoRootOf,
   taskIsolationOf
-} from "./chunk-C44UWIAD.mjs";
+} from "./chunk-N66ZHFGN.mjs";
 
 // src/models/TaskLog.ts
 var HEAD_LINES = 60;
 var TAIL_LINES = 40;
 var MAX_LINE_CHARS = 2e3;
+var DIGEST_ARGS_CHARS = 120;
+var DIGEST_MESSAGE_CHARS = 1e3;
 function capLine(line) {
   return line.length > MAX_LINE_CHARS ? `${line.slice(0, MAX_LINE_CHARS)}\u2026` : line;
 }
@@ -209,6 +211,33 @@ function coalesceTaskLog(events) {
   }
   return out;
 }
+function digestTaskLog(events, maxCalls) {
+  const outcomes = /* @__PURE__ */ new Map();
+  let lastText;
+  let lastError;
+  for (const event of events) {
+    if (event.type === "tool_result") outcomes.set(event.id, event.success);
+    else if (event.type === "text") lastText = event.text;
+    else if (event.type === "error") lastError = event.message;
+  }
+  const lines = [];
+  for (const event of events) {
+    if (event.type !== "tool_call") continue;
+    const outcome = outcomes.get(event.id);
+    const args = event.args.length > DIGEST_ARGS_CHARS ? `${event.args.slice(0, DIGEST_ARGS_CHARS)}\u2026` : event.args;
+    lines.push(`- ${event.name} ${args} \u2192 ${outcome === void 0 ? "no result" : outcome ? "ok" : "failed"}`);
+  }
+  const omitted = lines.length - maxCalls;
+  const out = omitted > 0 ? [`\u2026 ${omitted} earlier call${omitted === 1 ? "" : "s"} omitted \u2026`, ...lines.slice(omitted)] : lines;
+  const gap = () => out.length > 0 ? [""] : [];
+  const said2 = lastText?.trim();
+  if (said2) {
+    const end = said2.length > DIGEST_MESSAGE_CHARS ? `\u2026${said2.slice(-DIGEST_MESSAGE_CHARS)}` : said2;
+    out.push(...gap(), "Its last message:", ...end.split("\n").map((l) => `  ${l}`));
+  }
+  if (lastError) out.push(...gap(), `It stopped with an error: ${lastError}`);
+  return out.join("\n");
+}
 
 // src/interfaces/IFileSystem.ts
 var GREP_DEFAULT_HEAD_LIMIT = 100;
@@ -2446,6 +2475,8 @@ function lex(command, nested, dialect) {
   let unsafeRedirect;
   let processSubstitution = false;
   let unbalanced = false;
+  let grouped = false;
+  let joinedBy;
   let tokens = [];
   let expandable = false;
   let current = "";
@@ -2475,13 +2506,14 @@ function lex(command, nested, dialect) {
     current = "";
     started = false;
   };
-  const endSegment = (nextPiped) => {
+  const endSegment = (nextPiped, next = "other") => {
     endToken();
-    if (tokens.length > 0) segments.push({ ...toSegment(tokens, piped, dialect), expandable, inputs });
+    if (tokens.length > 0) segments.push({ ...toSegment(tokens, piped, dialect), expandable, inputs, joinedBy });
     tokens = [];
     inputs = [];
     expandable = false;
     piped = nextPiped;
+    joinedBy = next;
   };
   let i = 0;
   while (i < command.length) {
@@ -2603,17 +2635,18 @@ function lex(command, nested, dialect) {
     }
     if (c === "(" || c === ")") {
       endToken();
+      grouped = true;
       i++;
       continue;
     }
     if (c === "|") {
       const double = command[i + 1] === "|";
-      endSegment(!double);
+      endSegment(!double, double ? "other" : "pipe");
       i += double || command[i + 1] === "&" ? 2 : 1;
       continue;
     }
     if (c === "&" || c === ";" || c === "\n") {
-      endSegment(false);
+      endSegment(false, c === "&" && command[i + 1] === "&" ? "and" : "other");
       i += command[i + 1] === c ? 2 : 1;
       continue;
     }
@@ -2631,7 +2664,7 @@ function lex(command, nested, dialect) {
   }
   if (quote !== "") unbalanced = true;
   endSegment(false);
-  return { segments, unsafeRedirect, processSubstitution, unbalanced };
+  return { segments, unsafeRedirect, processSubstitution, unbalanced, grouped };
 }
 function binaryName(token, dialect) {
   const base = token.split(/[/\\]/).pop() ?? "";
@@ -2771,10 +2804,11 @@ function unwrap(seg, dialect) {
   }
   return { seg: { ...current, assignments }, wrappers, runner };
 }
-function lexAll(command, dialect) {
+function lexAll(command, dialect, cdpathSet = false) {
   const queue = [];
   const top = lex(command, queue, dialect);
   const all = { ...top, segments: top.segments.filter((s) => s.binary) };
+  if (!top.grouped && queue.length === 0 && !cdpathSet) followCd(all.segments);
   for (let depth = 0; depth < 32 && queue.length > 0; depth++) {
     const inner = lex(queue.shift(), queue, dialect);
     all.segments.push(...inner.segments.filter((s) => s.binary));
@@ -2784,15 +2818,32 @@ function lexAll(command, dialect) {
   }
   return all;
 }
+function literalCdTarget(seg) {
+  if (seg.binary !== "cd" || seg.assignments.length > 0 || seg.expandable || seg.inputs.length > 0) return void 0;
+  if (seg.args.length !== 1) return void 0;
+  const [target] = seg.args;
+  return target === "" || target.startsWith("-") || target.startsWith("~") || /[*?[]/.test(target) ? void 0 : target;
+}
+function followCd(segments) {
+  if (segments.some((s) => s.joinedBy === "other")) return;
+  let chain = [];
+  segments.forEach((seg, i) => {
+    seg.cwd = chain;
+    const inPipeline = seg.joinedBy === "pipe" || segments[i + 1]?.joinedBy === "pipe";
+    const target = inPipeline ? void 0 : literalCdTarget(seg);
+    if (target !== void 0) chain = [...chain, target];
+  });
+}
 function looksLikePath(arg) {
   if (arg.startsWith("--") && arg.includes("=")) return looksLikePath(arg.slice(arg.indexOf("=") + 1));
   return arg.startsWith("/") || arg.startsWith("~") || arg.startsWith("../") || arg === ".." || arg.startsWith("./") || /^[A-Za-z]:/.test(arg) || arg.startsWith("\\") || arg.startsWith("..\\") || arg.startsWith(".\\") || /(^|[\\/])\.\.([\\/]|$)/.test(arg);
 }
-function pathLikeArgs(command, opts = {}) {
+function pathRefs(command, opts = {}) {
   const dialect = dialectFor(opts.dialect);
-  return lexAll(command, dialect).segments.flatMap((seg) => {
+  return lexAll(command, dialect, opts.cdpathSet).segments.flatMap((seg) => {
     const patterns = patternArgs(seg);
-    return [...seg.args.filter((_, i) => !patterns.has(i)), ...seg.inputs].flatMap(pathIn);
+    const cwd = seg.cwd ?? [];
+    return [...seg.args.filter((_, i) => !patterns.has(i)), ...seg.inputs].flatMap(pathIn).map((path26) => ({ path: path26, cwd }));
   });
 }
 function pathIn(a) {
@@ -2956,7 +3007,8 @@ function scopeFor(seg) {
   }
   return [seg.binary, ...lead].join(" ");
 }
-function isAuto(seg) {
+function isAuto(seg, opts) {
+  if (seg.binary === "cd") return !opts.cdpathSet && literalCdTarget(seg) !== void 0;
   if (!AUTO_COMMANDS.includes(seg.binary)) return false;
   if (seg.expandable) return false;
   if (seg.binary !== "git") return true;
@@ -3051,7 +3103,7 @@ function classifyCommand(command, opts = {}) {
   const trimmed = command.trim();
   if (!trimmed) return { tier: "refuse", scope: "", reason: "Empty command." };
   const dialect = dialectFor(opts.dialect);
-  const { segments, unsafeRedirect, processSubstitution, unbalanced } = lexAll(trimmed, dialect);
+  const { segments, unsafeRedirect, processSubstitution, unbalanced } = lexAll(trimmed, dialect, opts.cdpathSet);
   if (unbalanced) {
     return {
       tier: "refuse",
@@ -3088,7 +3140,7 @@ function classifyCommand(command, opts = {}) {
       };
     }
   }
-  const nonAuto = unwrapped.filter((u) => u.runner !== void 0 || !isAuto(u.seg));
+  const nonAuto = unwrapped.filter((u) => u.runner !== void 0 || !isAuto(u.seg, opts));
   if (nonAuto.length === 0) return { tier: "auto", scope: "" };
   const scope = [...new Set(nonAuto.map((u) => u.runner ? `${u.runner} ${scopeFor(u.seg)}` : scopeFor(u.seg)))].sort().join(" + ");
   return { tier: "ask", scope };
@@ -3168,11 +3220,15 @@ function expandHome(target) {
   if (target === "~" || target.startsWith("~/")) return path2.join(home, target.slice(1));
   return path2.join(path2.dirname(home), target.slice(1));
 }
-function resolveWithin(root, target) {
-  const abs = path2.resolve(root, expandHome(target));
+function resolveWithin(root, target, from = root) {
+  const abs = path2.resolve(from, expandHome(target));
   const rel = path2.relative(root, abs);
   return { abs, inside: rel === "" || !rel.startsWith("..") && !path2.isAbsolute(rel) };
 }
+function resolveRef(root, ref) {
+  const from = ref.cwd.reduce((dir, target) => resolveWithin(root, target, dir).abs, root);
+  return resolveWithin(root, ref.path, from);
+}
 function grantScopeFor(abs, kind) {
   if (kind === "directory") return path2.join(abs, "*");
   const parent = path2.dirname(abs);
@@ -3378,14 +3434,17 @@ ${refs.output.trim()}`);
   outsidePaths(command) {
     const root = this.getWorkspaceRoot();
     const found = /* @__PURE__ */ new Map();
-    for (const p of pathLikeArgs(command, { dialect: this.researchShell.dialect })) {
-      const { abs, inside } = resolveWithin(root, p);
+    for (const ref of pathRefs(command, this.policyOptions())) {
+      const { abs, inside } = resolveRef(root, ref);
       if (inside || isInertDevice(abs)) continue;
       const scope = grantScopeFor(abs, "file");
       if (!found.has(scope)) found.set(scope, abs);
     }
     return [...found].map(([scope, abs]) => ({ abs, scope }));
   }
+  policyOptions() {
+    return { dialect: this.researchShell.dialect, cdpathSet: !!process.env.CDPATH };
+  }
   /**
    * Three tiers (see `commandPolicy.ts`): read-only inspection runs silently,
    * anything else asks once and is remembered, and writes are refused outright
@@ -3397,7 +3456,7 @@ ${refs.output.trim()}`);
    * directory the next command names.
    */
   async bash(command, signal) {
-    const { tier, scope, reason } = classifyCommand(command, { dialect: this.researchShell.dialect });
+    const { tier, scope, reason } = classifyCommand(command, this.policyOptions());
     if (tier === "refuse") {
       return { success: false, output: `Command refused: ${reason}`, truncated: false };
     }
@@ -3896,10 +3955,78 @@ function buildGrepArgs(pattern, opts, root) {
 function buildGlobArgs(pattern, root) {
   return ["--files", ...SORT_BY_RECENCY, "--glob", pattern, ...exclusionArgs(), "--", root];
 }
-function buildFallbackGrepArgs(pattern, opts, root) {
+var GREP_PCRE_PROBE_ARGS = ["-P", "-e", "x", "/dev/null"];
+function grepRegexFromProbe(exitCode) {
+  return exitCode === 0 || exitCode === 1 ? "pcre" : "ere";
+}
+function toPosixClasses(pattern) {
+  const CLASS_ESCAPES = { s: "[:space:]", w: "[:alnum:]_", d: "[:digit:]", t: "	" };
+  let out = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "\\") {
+      out += pattern.slice(i, i + 2);
+      i += 2;
+      continue;
+    }
+    if (c !== "[") {
+      out += c;
+      i++;
+      continue;
+    }
+    const start = i;
+    i++;
+    let negate = false;
+    if (pattern[i] === "^") {
+      negate = true;
+      i++;
+    }
+    let body = "";
+    let closeBracket = false;
+    let openBracket = false;
+    let dash = false;
+    let closed = false;
+    while (i < pattern.length) {
+      const ch = pattern[i];
+      if (ch === "]") {
+        closed = true;
+        i++;
+        break;
+      }
+      if (ch === "[" && pattern[i + 1] === ":") {
+        const end = pattern.indexOf(":]", i + 2);
+        if (end !== -1) {
+          body += pattern.slice(i, end + 2);
+          i = end + 2;
+          continue;
+        }
+      }
+      if (ch === "\\" && i + 1 < pattern.length) {
+        const e = pattern[i + 1];
+        i += 2;
+        if (e in CLASS_ESCAPES) body += CLASS_ESCAPES[e];
+        else if (e === "]") closeBracket = true;
+        else if (e === "[") openBracket = true;
+        else if (e === "-") dash = true;
+        else body += e;
+        continue;
+      }
+      body += ch;
+      i++;
+    }
+    if (!closed) {
+      out += pattern.slice(start);
+      break;
+    }
+    out += `[${negate ? "^" : ""}${closeBracket ? "]" : ""}${body}${openBracket ? "[" : ""}${dash ? "-" : ""}]`;
+  }
+  return out;
+}
+function buildFallbackGrepArgs(pattern, opts, root, regex = "pcre") {
   const args = ["-r", "-n"];
   if (opts.literal) args.push("-F");
-  else args.push("-P");
+  else args.push(regex === "pcre" ? "-P" : "-E");
   if (opts.caseInsensitive) args.push("-i");
   if (opts.outputMode === "files") args.push("-l");
   if (opts.outputMode === "count") args.push("-c");
@@ -3909,7 +4036,7 @@ function buildFallbackGrepArgs(pattern, opts, root) {
   }
   if (opts.include) args.push(`--include=${opts.include}`);
   for (const dir of SEARCH_EXCLUSIONS) args.push(`--exclude-dir=${dir}`);
-  args.push("-e", pattern, root);
+  args.push("-e", !opts.literal && regex === "ere" ? toPosixClasses(pattern) : pattern, root);
   return args;
 }
 function globSegmentToRegex(segment) {
@@ -5143,6 +5270,18 @@ function leftoverMarkerFiles(check) {
   const files = check.split(/\r?\n/).flatMap((line) => /^(.+):\d+: leftover conflict marker$/.exec(line)?.[1] ?? []);
   return [...new Set(files)];
 }
+function rawDiffStates(raw) {
+  const parts = raw.split("\0");
+  const states = {};
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    const meta = parts[i].trim();
+    const file = parts[i + 1];
+    if (!meta.startsWith(":") || !file) continue;
+    const [, mode, , blob] = meta.slice(1).split(" ");
+    states[file] = `${mode}:${blob}`;
+  }
+  return states;
+}
 function settleStatus(record, status) {
   record.status = status;
   delete record.repairBase;
@@ -5242,6 +5381,8 @@ var GitWorktreeIsolation = class {
   adminChains = /* @__PURE__ */ new Map();
   waiting = [];
   draining = false;
+  /** Landings and Merge all take turns on this, so a merge never reads an integration branch mid-landing. */
+  turns = Promise.resolve();
   async isActive(workspaceRoot) {
     if (!this.deps.config.worktreeIsolation) return { active: false, reason: "disabled" };
     const version = await this.tryGit(void 0, ["--version"]);
@@ -5598,6 +5739,62 @@ var GitWorktreeIsolation = class {
       return !linked.has(rel) && !linked.has(rel.split("/")[0]);
     });
   }
+  async findInHead(run) {
+    const found = [];
+    for (const record of Object.values(run.tasks)) {
+      if (record.status !== "merged" || record.inHead) continue;
+      if (!await this.headContains(run, record)) continue;
+      record.inHead = true;
+      found.push(record.taskId);
+    }
+    return found;
+  }
+  async headContains(run, record) {
+    for (const repo of run.repos) {
+      const entry = record.repos[repo.path];
+      if (!entry?.changed) continue;
+      const merged = await this.tryGit(repo.root, ["merge-base", "--is-ancestor", entry.landedTip ?? repo.integrationBranch, "HEAD"]);
+      if (!merged.ok) return false;
+    }
+    return true;
+  }
+  async snapshotTree(workspaceRoot, exclude) {
+    const scan = await this.scanGroup(workspaceRoot);
+    if ("refused" in scan) return null;
+    const repos = (await this.committedRepos(workspaceRoot, scan.paths)).filter((repoPath) => !exclude.includes(repoPath));
+    if (repos.length === 0) return null;
+    const snapshot = {};
+    for (const repoPath of repos) {
+      const states = await this.trackedStates(repoRootOf(workspaceRoot, repoPath));
+      if (states) snapshot[repoPath] = states;
+    }
+    return snapshot;
+  }
+  async changedSince(workspaceRoot, snapshot) {
+    const changed = [];
+    for (const [repoPath, before] of Object.entries(snapshot)) {
+      const now = await this.trackedStates(repoRootOf(workspaceRoot, repoPath));
+      if (!now) continue;
+      for (const [file, state] of Object.entries(now)) {
+        if (before[file] !== state) changed.push(repoPath === SELF_REPO ? file : `${repoPath}/${file}`);
+      }
+    }
+    return changed.sort();
+  }
+  /**
+   * Each tracked file that differs from HEAD, with what it holds. `git stash
+   * create` records the working tree as a commit without touching the tree,
+   * the index or the stash, so a file changed again is told apart from one
+   * left as it was. Null when git cannot tell — a merge in progress, say.
+   */
+  async trackedStates(root) {
+    const stash = await this.tryGit(root, ["stash", "create"]);
+    if (!stash.ok) return null;
+    const commit = stash.stdout.trim();
+    if (!commit) return {};
+    const diff = await this.tryGit(root, ["diff", "--raw", "--no-abbrev", "--no-renames", "-z", "HEAD", commit]);
+    return diff.ok ? rawDiffStates(diff.stdout) : null;
+  }
   /**
    * One section per repo with changes. A repo below the workspace root gets a
    * header and paths prefixed with its own, so the whole reads as one patch
@@ -5615,7 +5812,10 @@ var GitWorktreeIsolation = class {
     }
     return diff;
   }
-  async mergeIntoCheckedOut(run) {
+  mergeIntoCheckedOut(run) {
+    return this.inTurn(() => this.mergeAll(run));
+  }
+  async mergeAll(run) {
     const partial = await this.settleLanding(run);
     if (partial.length > 0) return { outcome: "blocked", blocked: partial.map((repo) => ({ repo, reason: "partial-landing", files: [] })) };
     const repos = await this.reposWithWork(run);
@@ -5749,7 +5949,7 @@ var GitWorktreeIsolation = class {
           if (entry2.run.id === runId && (pick < 0 || entry2.task.order < this.waiting[pick].task.order)) pick = i;
         });
         const [entry] = this.waiting.splice(pick, 1);
-        entry.settle(await this.land(entry.task, entry.run, entry.persist).catch(() => "failed"));
+        entry.settle(await this.inTurn(() => this.land(entry.task, entry.run, entry.persist)).catch(() => "failed"));
       }
     } finally {
       this.draining = false;
@@ -5801,6 +6001,10 @@ var GitWorktreeIsolation = class {
         return (await this.settleLanding(run)).length === 0 ? this.stopLanding(record, outcome, repo, files, error) : this.stopLanding(record, "failed", repo);
       }
     }
+    for (const repo of changed) {
+      const tip = await this.tryGit(repo.root, ["rev-parse", "--verify", "-q", repo.integrationBranch]);
+      if (tip.ok) record.repos[repo.path].landedTip = tip.stdout.trim();
+    }
     delete run.landing;
     settleStatus(record, "merged");
     delete record.conflictRepo;
@@ -6075,6 +6279,11 @@ var GitWorktreeIsolation = class {
   async abortMerge(cwd) {
     if (!(await this.tryGit(cwd, ["merge", "--abort"])).ok) await this.tryGit(cwd, ["reset", "--hard"]);
   }
+  inTurn(fn) {
+    const turn = this.turns.then(fn, fn);
+    this.turns = turn.catch(() => void 0);
+    return turn;
+  }
   admin(repoKey, fn) {
     const prior = this.adminChains.get(repoKey) ?? Promise.resolve();
     const next = prior.then(fn, fn);
@@ -6491,8 +6700,22 @@ function researchPhaseBlock(harnessMode) {
     "- Research and questions can interleave \u2014 you can explore a file, then ask a question grounded in it, in one response"
   ].join("\n");
 }
-var ISOLATED_PARALLELISM_RULE = "- Each AI task runs in its own git worktree, and its work is merged in afterwards, so tasks that edit the same files can still run in parallel. Never add a dependency just because two tasks touch the same file \u2014 keep dependencies for genuine logical ordering.";
+var ISOLATED_PARALLELISM_RULE = "- Each change task runs in its own git worktree, and its work is merged in afterwards, so tasks that edit the same files can still run in parallel. Never add a dependency just because two tasks touch the same file \u2014 keep dependencies for genuine logical ordering.";
 var OVERLAP_AVOIDANCE_RULE = "- For parallel tasks, specify different target files to avoid merge conflicts.";
+function opsTaskSection(conversation) {
+  return [
+    "",
+    "CHANGE AND OPS TASKS:",
+    "- Every AI task is either a change task or an ops task. Decide by one test: is the task's result a change to files in the repository?",
+    '- A change task (the default) edits repository files. Omit "ops".',
+    `- An ops task changes no repository files: it acts on systems outside the repository (a cloud CLI, a deployment, a pipeline, a provisioned resource) or on the git refs and history of the user's branch (push, tag, reword commits). Set "ops": true. Only top-level "ai" tasks can be ops; a subtask runs with its parent.`,
+    `- Ops tasks run in the user's own checkout, after the user has merged the change tasks they depend on. Give an ops task a dependency on every change task whose result it acts on \u2014 "deploy the fix" depends on the fix.`,
+    '- Split a request that mixes the two into a change task and an ops task that depends on it: "bump the version and redeploy" is a change task that bumps and commits the version, then an ops task that pushes and watches the pipeline.',
+    "- Ops tasks run in parallel as their dependencies allow. Two ops tasks whose git operations would collide (a push and a reword of the same branch) must not run in parallel \u2014 make one depend on the other.",
+    "- An ops task runs until what it acts on has finished: one that watches a pipeline reports done only when the pipeline has ended.",
+    ...conversation ? [`- A question is not a task. "What is the frontend's URL?" is answered in this conversation, from your research; never make a task of it.`] : []
+  ];
+}
 var SHARED_APPEND_FILE_RULE = "- Tasks that run in parallel must not each append to the same shared file (changelogs, registries, index lists) \u2014 give that edit to the final task, or to one task the others depend on.";
 function repoGroupSection(isolated) {
   if (!isolated) return [];
@@ -6572,6 +6795,7 @@ function buildConversationBody(goal, context, modelsJson, runners, modeGuide, mo
     '      "taskMode": "' + modeExamples + '",',
     '      "autonomy": "AFK|HITL",',
     '      "sliceType": "AFK|HITL",',
+    '      "ops": true,',
     '      "userStoriesCovered": ["user story text"],',
     '      "subtasks": [{ "id": "sub-id-string", "order": 1, "title": "Sub-step title", "description": "What it accomplishes", "type": "ai", "dependencies": [], "prompt": "Detailed instructions", "autonomy": "AFK|HITL", "sliceType": "AFK|HITL", "subtasks": [] }]',
     "    }",
@@ -6597,6 +6821,7 @@ function buildConversationBody(goal, context, modelsJson, runners, modeGuide, mo
     SHARED_APPEND_FILE_RULE,
     ...variant.isolatedExecution ? [ISOLATED_PARALLELISM_RULE] : [],
     ...repoGroupSection(variant.isolatedExecution),
+    ...opsTaskSection(true),
     "",
     "RULES:",
     "- Do NOT wrap the JSON in markdown code blocks. Output ONLY the JSON object when committing the plan.",
@@ -6672,6 +6897,7 @@ function corePlannerPrompt(isolatedExecution) {
     '      "taskMode": "{{MODE_EXAMPLES}}",',
     '      "autonomy": "AFK|HITL",',
     '      "sliceType": "AFK|HITL",',
+    '      "ops": true,',
     '      "userStoriesCovered": ["user story text"],',
     '      "subtasks": [{ "id": "sub-id-string", "order": 1, "title": "Sub-step title", "description": "What it accomplishes", "type": "ai", "dependencies": [], "prompt": "Detailed instructions", "autonomy": "AFK|HITL", "sliceType": "AFK|HITL", "subtasks": [] }]',
     "    }",
@@ -6699,6 +6925,7 @@ function corePlannerPrompt(isolatedExecution) {
     SHARED_APPEND_FILE_RULE,
     isolatedExecution ? ISOLATED_PARALLELISM_RULE : "- Slices that touch different areas of the codebase are naturally parallel.",
     ...repoGroupSection(isolatedExecution),
+    ...opsTaskSection(false),
     "",
     "RULES:",
     '- Mark as type "ai" any task the coding assistant can do autonomously.',
@@ -7500,14 +7727,15 @@ function nonPromptingFs(fs16) {
     listDir: (p, depth) => withinWorkspace(p) ? fs16.listDir(p, depth) : Promise.resolve(outsideRefusal(p)),
     bash: async (command, signal) => {
       const dialect = resolveResearchShell().dialect;
-      const { tier, reason } = classifyCommand(command, { dialect });
+      const policy = { dialect, cdpathSet: !!process.env.CDPATH };
+      const { tier, reason } = classifyCommand(command, policy);
       if (tier !== "auto") {
         return refused2(
           tier === "refuse" ? `Command refused: ${reason}` : `"${command}" needs user approval, and research agents run in the background where nothing can be approved. Use the read-only research tools, and note in your digest that this command would answer the question.`
         );
       }
-      const escaping = pathLikeArgs(command, { dialect }).find((p) => !withinWorkspace(p));
-      if (escaping) return outsideRefusal(escaping);
+      const escaping = pathRefs(command, policy).find((ref) => !resolveRef(fs16.getWorkspaceRoot(), ref).inside);
+      if (escaping) return outsideRefusal(escaping.path);
       return fs16.bash(command, signal);
     }
   };
@@ -8702,6 +8930,17 @@ You are running as: ${currentTask.assignedRunner}` : "";
     lines.join("\n") + footer + runnerNote
   ].join("\n");
 }
+function renderPreviousAttempt(output) {
+  const tail = output.trim() ? defuseMarkers(output.trim()).split("\n").map((l) => "  " + l).join("\n") : "  (no output captured)";
+  return [
+    "## Previous attempt",
+    "",
+    "This task ran before and did not finish. What it did outside the repository was not undone: before acting, check what already exists \u2014 resources, deployments, pushed refs \u2014 and do not repeat a step that already took effect.",
+    "",
+    "The end of its output:",
+    tail
+  ].join("\n");
+}
 function renderCompletionMarker(task) {
   return `
 
@@ -8753,6 +8992,7 @@ function composeAugmentedPrompt(task, allTasks, opts) {
   const flat = flattenTasks(allTasks);
   const outputs = collectDirectDependencyOutputs(task, flat);
   if (outputs.length > 0) blocks.push(renderPriorOutputs(outputs));
+  if (opts?.previousAttempt !== void 0) blocks.push(renderPreviousAttempt(opts.previousAttempt));
   if (opts?.tddEnabled) {
     blocks.push(renderTddInstruction());
   }
@@ -8765,9 +9005,9 @@ function composeAugmentedPrompt(task, allTasks, opts) {
 
 ${basePrompt}${marker2}`;
 }
-function composeContinuationPrompt(task, message) {
+function composeContinuationPrompt(task, message, opts = {}) {
   const reminder = [
-    "(Ordewell) You are continuing this task in the same session. Your working directory was recreated from the integration branch: work from your earlier attempt is there only if it landed, so check the files before relying on them."
+    opts.ops ? "(Ordewell) You are continuing this task in the same session, in the same checkout. What your earlier attempt did outside the repository was not undone: check what already exists before acting again." : "(Ordewell) You are continuing this task in the same session. Your working directory was recreated from the integration branch: work from your earlier attempt is there only if it landed, so check the files before relying on them."
   ];
   if (isHitlTask(task)) {
     reminder.push(`If you reach a decision that needs human judgment, print one line holding only the checkpoint marker and wait for ORDEWELL_CONTINUE or ORDEWELL_REJECT. ${CHECKPOINT_MARKER_HOWTO}.`);
@@ -8811,6 +9051,12 @@ var VerdictEngine = class {
   idleSince = /* @__PURE__ */ new Map();
   /** Tasks waiting on the user, whose silence is expected rather than a sign of a stuck runner. */
   idlePaused = /* @__PURE__ */ new Set();
+  /**
+   * Open tool approvals per structured task. They arrive mid-turn and leave the
+   * status alone (ADR-0018, W1), but a task waiting on one is waiting on the
+   * user, so it is not idle either.
+   */
+  openApprovals = /* @__PURE__ */ new Map();
   onVerdict(listener) {
     this.listeners.push(listener);
   }
@@ -8839,7 +9085,7 @@ var VerdictEngine = class {
   }
   /** Restart the silence timer on fresh output; broadcasts the null transition if it was idle. */
   touchIdle(taskId, gen) {
-    if (this.idlePaused.has(taskId)) return;
+    if (this.idlePaused.has(taskId) || this.openApprovals.get(taskId)?.size) return;
     const existing = this.idleTimers.get(taskId);
     if (existing) clearTimeout(existing);
     if (this.idleSince.get(taskId)) {
@@ -8921,7 +9167,10 @@ ${line}
     });
     if (isStructuredSession(session)) {
       session.onEvent((event) => {
-        if (event.type === "turn_start" && this.generations.get(task.id) === gen) this.resumeIdle(task.id);
+        if (this.generations.get(task.id) !== gen) return;
+        if (event.type === "turn_start") this.resumeIdle(task.id);
+        else if (event.type === "permission_request" && !event.decided) this.approvalOpened(task.id, event.id);
+        else if (event.type === "permission_decided" || event.type === "permission_withdrawn") this.approvalClosed(task.id, event.id, gen);
       });
     }
     session.onExit((exitCode) => {
@@ -8932,6 +9181,18 @@ ${line}
       for (const l of this.listeners) l(task.id, verdict);
     });
   }
+  approvalOpened(taskId, approvalId) {
+    const open = this.openApprovals.get(taskId) ?? /* @__PURE__ */ new Set();
+    open.add(approvalId);
+    this.openApprovals.set(taskId, open);
+    this.clearIdle(taskId);
+  }
+  approvalClosed(taskId, approvalId, gen) {
+    const open = this.openApprovals.get(taskId);
+    if (!open?.delete(approvalId) || open.size) return;
+    this.openApprovals.delete(taskId);
+    this.touchIdle(taskId, gen);
+  }
   /** Scan only the new text plus the unmatched carry, so a long run stays linear. */
   scanCheckpoints(taskId, session, text) {
     const scan = (this.checkpointCarry.get(taskId) ?? "") + text;
@@ -8953,6 +9214,7 @@ ${line}
     this.checkpointCarry.delete(taskId);
     this.pausedSessions.delete(taskId);
     this.idlePaused.delete(taskId);
+    this.openApprovals.delete(taskId);
     this.clearIdle(taskId);
   }
   /** Manual "Mark complete" override: a pass verdict that bypasses evidence. */
@@ -8990,6 +9252,7 @@ ${line}
     this.idleTimers.clear();
     this.idleSince.clear();
     this.idlePaused.clear();
+    this.openApprovals.clear();
     this.generations.clear();
   }
   decide(task, exitCode) {
@@ -9507,6 +9770,8 @@ var PlanStore = class {
   _planTasks = [];
   _allTasks = [];
   _taskMap = /* @__PURE__ */ new Map();
+  /** Task id → the top-level task it hangs under, itself for a top-level task. */
+  _rootMap = /* @__PURE__ */ new Map();
   _planRunners = ["claude-code"];
   _onMutate = null;
   _executionLog = [];
@@ -9544,6 +9809,14 @@ var PlanStore = class {
   get(taskId) {
     return this._taskMap.get(taskId);
   }
+  /**
+   * Whether a task runs as an ops task (ADR-0020). Only a top-level AI task
+   * can be one; a subtask runs with the top-level task it hangs under.
+   */
+  isOps(taskId) {
+    const root = this._rootMap.get(taskId);
+    return root?.type === "ai" && root.ops === true;
+  }
   /** A copy of the task tree, detached from the store: later status changes do not reach it. */
   snapshot() {
     return cloneTasks(this._planTasks);
@@ -9638,6 +9911,7 @@ ${taskB.description}`,
       assignedRunner: taskA.assignedRunner,
       assignedModel: taskA.assignedModel,
       taskMode: taskA.taskMode,
+      ops: taskA.ops === true && taskB.ops === true,
       order: Math.min(taskA.order, taskB.order)
     });
     const mergedId = merged.id;
@@ -9667,7 +9941,8 @@ ${taskB.description}`,
         taskMode: spec.taskMode ?? original.taskMode,
         autonomy: spec.autonomy ?? original.autonomy,
         sliceType: spec.sliceType ?? original.sliceType,
-        userStoriesCovered: spec.userStoriesCovered ?? original.userStoriesCovered
+        userStoriesCovered: spec.userStoriesCovered ?? original.userStoriesCovered,
+        ops: spec.ops ?? original.ops
       }));
     });
     const tailId = finalized[finalized.length - 1].id;
@@ -9721,8 +9996,14 @@ ${taskB.description}`,
       this.setStatus(id, "pending");
       task.verdict = void 0;
       task.outputSummary = void 0;
+      delete task.forcedPastGate;
     }
   }
+  /** Kept on the task: it was force-started past its merge gate, before these dependencies' work was merged (ADR-0020). */
+  setForcedPastGate(id, dependencies) {
+    const task = this._taskMap.get(id);
+    if (task) task.forcedPastGate = dependencies;
+  }
   /** A reason outlives nothing: any status but `awaiting_user` drops it. */
   setStatus(id, status) {
     const task = this._taskMap.get(id);
@@ -9805,6 +10086,10 @@ ${taskB.description}`,
     for (const task of this._allTasks) {
       this._taskMap.set(task.id, task);
     }
+    this._rootMap.clear();
+    for (const root of this._planTasks) {
+      for (const task of flattenTasks([root])) this._rootMap.set(task.id, root);
+    }
   }
   validateAssignedRunners() {
     for (const task of this._allTasks) {
@@ -9858,9 +10143,9 @@ var IsolationRunController = class {
   /** Copied paths already reported for the current run: every task gets the same copies. */
   reportedCopies = /* @__PURE__ */ new Set();
   /**
-   * How the open run executes; null while no run is open. A run is one
-   * Execute-Plan or one manual task run, from its start until it settles or
-   * is stopped.
+   * How the open run executes; null while no run is open, `undecided` until
+   * its first change task asks. A run is one Execute-Plan or one manual task
+   * run, from its start until it settles or is stopped.
    */
   mode = null;
   /** Resolver task id → the conflicted task it resolves; see {@link linkResolver}. */
@@ -9884,6 +10169,10 @@ var IsolationRunController = class {
   get isOpen() {
     return this.mode !== null;
   }
+  /** The open run has decided whether it isolates. */
+  get decided() {
+    return this.mode === "isolated" || this.mode === "shared";
+  }
   /** The open run executes in worktrees. */
   get isolating() {
     return this.mode === "isolated" && this.run !== null;
@@ -9940,13 +10229,22 @@ var IsolationRunController = class {
       this.tell("warn", `Could not prune leftover worktrees: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  /** Open a run if none is, leaving whether it isolates to its first change task. */
+  open() {
+    if (this.mode) return;
+    this.mode = "undecided";
+    this.listener.opened();
+  }
   /**
-   * Open a run if none is: decide once, at its start, whether it executes in
-   * worktrees. `resume` is what a dirty tree parks until the user chooses how
-   * to go on. Resolves false when the run did not start.
+   * Decide once per run, as its first change task starts, whether it executes
+   * in worktrees (ADR-0020): an ops task needs none, so a run of only ops
+   * tasks never asks. `resume` is what a dirty tree parks until the user
+   * chooses how to go on. Resolves false while the run waits on that choice.
    */
-  open(resume) {
-    if (this.mode) return Promise.resolve(true);
+  decide(resume) {
+    this.open();
+    if (this.decided) return Promise.resolve(true);
+    if (this.blockedStart) return Promise.resolve(false);
     this.opening ??= this.activate(resume).finally(() => {
       this.opening = null;
     });
@@ -9961,8 +10259,8 @@ var IsolationRunController = class {
    * the safe rule then.
    */
   async plannerLayout() {
-    if (this.mode) return this.isolating && this.run ? layoutOf(this.run) : false;
-    const decision = await this.decide(this.workspaceRoot());
+    if (this.decided) return this.isolating && this.run ? layoutOf(this.run) : false;
+    const decision = await this.assess(this.workspaceRoot());
     return decision.mode === "isolated" ? decision.layout : false;
   }
   /**
@@ -9997,7 +10295,7 @@ var IsolationRunController = class {
       const { cwd: cwd2 } = await this.isolation.reopen(task, this.run);
       return { cwd: cwd2, worktree: true };
     }
-    if (!this.isolating || !this.run) {
+    if (opts.ops || !this.isolating || !this.run) {
       await this.release(task.id, { keep: false });
       return { cwd: this.workspaceRoot(), worktree: false };
     }
@@ -10042,18 +10340,71 @@ var IsolationRunController = class {
     }
     this.listener.changed();
   }
-  /** Close the open run. An isolated one hands its integration branch over for review. */
+  /**
+   * Close the open run. An isolated one hands its integration branch over for
+   * review — unless the user merged everything it landed at merge gates
+   * already, which leaves nothing to hand over, so it is cleared up as a Merge
+   * all would have.
+   */
   async close() {
     const mode = this.mode;
     this.mode = null;
-    if (mode !== "isolated" || !this.run) return;
+    const run = this.run;
+    if (mode !== "isolated" || !run) return;
+    await this.refreshInHead();
+    const records = Object.values(run.tasks);
+    if (records.length > 0 && records.every((r) => r.status === "merged" && r.inHead)) {
+      this.tell("info", "Everything this run landed is merged into your branch already.");
+      await this.clearMerged(run);
+      return;
+    }
     try {
-      this.listener.handoff(await this.isolation.handoff(this.run));
+      this.listener.handoff(await this.isolation.handoff(run));
     } catch (err) {
       this.tell("warn", `Could not hand the run's integration branch over: ${err instanceof Error ? err.message : String(err)}`);
     }
     this.listener.changed();
   }
+  /**
+   * Whether a task's landed work still waits to be merged into the user's
+   * branch — what holds an ops or user task at its merge gate (ADR-0020). A
+   * task with no record never landed anything to wait for.
+   */
+  awaitsMerge(taskId) {
+    const record = this.run?.tasks[taskId];
+    return !!record && record.status === "merged" && !record.inHead;
+  }
+  /**
+   * Look again for landed work the user has merged — by Merge all, or by hand
+   * with git. Resolves true when some was found.
+   */
+  async refreshInHead() {
+    const run = this.run;
+    if (!run || !Object.values(run.tasks).some((r) => r.status === "merged" && !r.inHead)) return false;
+    const found = await this.isolation.findInHead(run).catch(() => []);
+    if (found.length > 0) this.listener.changed();
+    return found.length > 0;
+  }
+  /**
+   * The tracked state of the workspace as an ops task starts, for
+   * {@link filesChangedSince} (ADR-0020). Null where the check does not run:
+   * a run that shares the workspace root, where every task's edits land in
+   * it, or a workspace git cannot isolate at all.
+   */
+  async snapshotWorkspace() {
+    if (this.mode === "shared") return null;
+    const root = this.workspaceRoot();
+    if (!this.isolating) {
+      const availability = await this.isolation.isActive(root).catch(() => null);
+      if (!availability || !availability.active && availability.reason !== "dirty") return null;
+    }
+    return this.isolation.snapshotTree(root, this.run?.sharedRepos ?? []).catch(() => null);
+  }
+  /** Tracked files changed since `snapshot`; none when the run has since gone on in the workspace root. */
+  async filesChangedSince(snapshot) {
+    if (!snapshot || this.mode === "shared") return [];
+    return this.isolation.changedSince(this.workspaceRoot(), snapshot).catch(() => []);
+  }
   /**
    * A stop or a plan load: the open run ends without a handoff and a parked
    * start is dropped. `keepOpen` spares a run the scheduler is still driving.
@@ -10084,19 +10435,23 @@ var IsolationRunController = class {
   }
   /**
    * "Merge all": the run's integration branches into whatever the user has
-   * checked out, in every repo or none. Once everything merged, the run has
-   * nothing left to hand over, so it is cleared up and forgotten; a branch
-   * the user's HEAD somehow does not contain stays for the next run's sweep.
+   * checked out, in every repo or none. During a run it merges what has
+   * landed so far and the run goes on (ADR-0020): its branches stay for the
+   * tasks still to land. Once a settled run merged everything, it has nothing
+   * left to hand over, so it is cleared up and forgotten; a branch the user's
+   * HEAD somehow does not contain stays for the next run's sweep.
    */
   async merge() {
     const run = this.requireRun();
+    const repaired = handoffOf(run).landed.filter((t) => t.repairedFiles?.length);
     const result = await this.isolation.mergeIntoCheckedOut(run);
     const branch = integrationBranchNameOf(run);
     const group = run.repos.some((r) => r.path !== SELF_REPO);
-    const repaired = handoffOf(run).landed.filter((t) => t.repairedFiles?.length);
     const { level, message } = describeMergeResult(result, branch, group, repaired);
     this.tell(level, message);
-    if (result.outcome === "merged") await this.clearMerged(run);
+    if (result.outcome !== "merged") return result;
+    await this.refreshInHead();
+    if (!this.isOpen) await this.clearMerged(run);
     return result;
   }
   /** Worktrees and task branches go; the integration branch and the record stay for review and merge. */
@@ -10128,7 +10483,7 @@ var IsolationRunController = class {
     this.resolvers = {};
     this.listener.changed();
   }
-  async decide(root) {
+  async assess(root) {
     const availability = await this.isolation.isActive(root);
     const continued = this.continuableRun(root);
     const continuing = continued !== null;
@@ -10143,7 +10498,7 @@ var IsolationRunController = class {
   }
   async activate(resume) {
     const root = this.workspaceRoot();
-    const decision = await this.decide(root);
+    const decision = await this.assess(root);
     if (decision.mode === "blocked") {
       this.blockedStart = resume;
       this.blockedRepos = decision.repos;
@@ -10170,8 +10525,8 @@ var IsolationRunController = class {
     return true;
   }
   begin(mode) {
+    this.open();
     this.mode = mode;
-    this.listener.opened();
   }
   /** What earlier runs left merged in the group goes; a failure here is worth a word, never a stopped run. */
   async sweep() {
@@ -10518,8 +10873,9 @@ var MessageQueue = class {
 // src/services/readiness.ts
 function selectReadyTasks(input) {
   const { store, onHold, runs, active, maxParallel } = input;
-  if (active >= maxParallel) return { ready: [], candidateCount: 0, excluded: [] };
+  if (active >= maxParallel) return { ready: [], candidateCount: 0, excluded: [], gated: [] };
   const availableSlots = maxParallel - active;
+  const gated = [];
   const candidates = store.allTasks.filter((t) => {
     if (t.status !== "pending" && t.status !== "approved") return false;
     if (t.type === "user") return false;
@@ -10527,13 +10883,21 @@ function selectReadyTasks(input) {
     if (onHold.has(t.id)) return false;
     if (isBlocked(t, store)) return false;
     if (!t.dependencies.every((depId) => dependencyMet(depId, store, runs))) return false;
+    if (store.isOps(t.id)) {
+      if (input.merging) return false;
+      if (mergeGate(t, store, runs).length > 0) {
+        gated.push(t);
+        return false;
+      }
+    }
     return true;
   });
-  const excluded = store.allTasks.filter((t) => t.type === "ai" && t.prompt && !candidates.includes(t)).map((task) => ({ task, reasons: exclusionReasons(task, store, onHold, runs) }));
+  const excluded = store.allTasks.filter((t) => t.type === "ai" && t.prompt && !candidates.includes(t)).map((task) => ({ task, reasons: exclusionReasons(task, input) }));
   return {
     ready: candidates.sort((a, b) => a.order - b.order).slice(0, availableSlots),
     candidateCount: candidates.length,
-    excluded
+    excluded,
+    gated
   };
 }
 function isBlocked(task, store) {
@@ -10546,12 +10910,19 @@ function dependencyMet(depId, store, runs) {
   const record = runs.openRecord(depId);
   return !record || record.status === "merged";
 }
-function exclusionReasons(task, store, onHold, runs) {
+function mergeGate(task, store, runs) {
+  if (task.type !== "user" && !store.isOps(task.id)) return [];
+  return task.dependencies.filter((depId) => store.isCompleted(depId) && runs.awaitsMerge(depId));
+}
+function exclusionReasons(task, input) {
+  const { store, onHold, runs } = input;
   const reasons = [];
   if (task.status !== "pending" && task.status !== "approved") reasons.push(`status=${task.status}`);
   if (onHold.has(task.id)) reasons.push("on-hold");
   if (isBlocked(task, store)) reasons.push("blocked");
   if (!task.dependencies.every((depId) => dependencyMet(depId, store, runs))) reasons.push("deps");
+  if (mergeGate(task, store, runs).length > 0) reasons.push("merge-gate");
+  if (input.merging && store.isOps(task.id)) reasons.push("merging");
   return reasons;
 }
 
@@ -12545,9 +12916,502 @@ ${item.text}` : item.text });
 
 // src/services/harness/OpenCodeAdapter.ts
 import { randomBytes as randomBytes2 } from "crypto";
+
+// src/services/harness/OpenCodeV2.ts
+var STREAM_CONNECT_TIMEOUT_MS = 5e3;
+var ACTIVE_POLL_INTERVAL_MS = 1e3;
+var IDLE_POLLS_BEFORE_START = 3;
+var PLANNER_RULES = [
+  { action: "question", resource: "*", effect: "deny" },
+  { action: "edit", resource: "*", effect: "deny" }
+];
+var TASK_RULES = [{ action: "question", resource: "*", effect: "deny" }];
+var AUTO_APPROVALS = "auto";
+function newTurnState() {
+  return { seen: /* @__PURE__ */ new Set(), toolNames: /* @__PURE__ */ new Map(), stepModels: /* @__PURE__ */ new Map(), textRuns: /* @__PURE__ */ new Map(), children: /* @__PURE__ */ new Map(), briefs: /* @__PURE__ */ new Map(), heldFrames: /* @__PURE__ */ new Map(), streamedMessages: /* @__PURE__ */ new Set() };
+}
+function splitModelId(id) {
+  const slash = id.indexOf("/");
+  if (slash <= 0 || slash === id.length - 1) return null;
+  return { providerID: id.slice(0, slash), id: id.slice(slash + 1) };
+}
+function delay(ms, signal) {
+  return new Promise((resolve7) => {
+    const timer = setTimeout(resolve7, ms);
+    timer.unref?.();
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      resolve7();
+    }, { once: true });
+  });
+}
+function contentText(content) {
+  return (content ?? []).filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("\n");
+}
+function subagentDigest(output) {
+  const inner = output.match(/<subagent[^>]*>\n?([\s\S]*?)\n?<\/subagent>/);
+  return inner ? inner[1] : output;
+}
+function permissionReply(decision) {
+  if (decision.decision === "allow") return { decision: "once" };
+  if (decision.decision === "allowForTask") return { decision: "always" };
+  const note = decision.note?.trim();
+  return note ? { decision: "reject", message: note } : { decision: "reject" };
+}
+var OpenCodeV2 = class {
+  constructor(host, opts, role) {
+    this.host = host;
+    this.opts = opts;
+    this.role = role;
+    this.agent = opts.kind === "task" ? opts.flags.permissionMode : "plan";
+    const split = opts.model ? splitModelId(opts.model) : null;
+    const variant = opts.kind === "task" ? opts.flags.effort : opts.effort;
+    if (split) this.model = { ...split, ...variant ? { variant } : {} };
+  }
+  host;
+  opts;
+  role;
+  sessionId = null;
+  model = null;
+  agent;
+  turn = null;
+  turnHasText = false;
+  interruptRequested = false;
+  /** A task's requests waiting for an answer, by request id, with the session that asked. */
+  openPermissions = /* @__PURE__ */ new Map();
+  nativeSessionId() {
+    return this.sessionId;
+  }
+  async start() {
+    const resume = this.opts.resumeSessionId;
+    if (resume) {
+      const existing = await this.host.json("GET", `/api/session/${resume}`).catch(() => null);
+      if (existing?.data?.id) {
+        this.sessionId = existing.data.id;
+        if (this.model) await this.host.request("POST", `/api/session/${this.sessionId}/model`, { model: this.model }).catch(() => void 0);
+        await this.host.request("POST", `/api/session/${this.sessionId}/agent`, { agent: this.agent }).catch(() => void 0);
+        await this.applyInstructions();
+        return;
+      }
+      if (this.opts.kind === "task") throw new Error(`OpenCode could not resume session ${resume}: the server does not know it.`);
+    }
+    const created = await this.host.json("POST", "/api/session", {
+      agent: this.agent,
+      ...this.model ? { model: this.model } : {},
+      permissions: this.role === "planner" ? PLANNER_RULES : TASK_RULES
+    });
+    if (!created?.data?.id) throw new Error(`The OpenCode ${this.role} server did not return a session id.`);
+    this.sessionId = created.data.id;
+    await this.applyInstructions();
+  }
+  /** The planner's system prompt rides on the session as an instruction entry — a prompt has no system field. */
+  async applyInstructions() {
+    if (this.opts.kind !== "planner" || !this.opts.systemPrompt) return;
+    const response = await this.host.request("PUT", `/api/experimental/session/${this.sessionId}/instructions/entries/ordewell-planner`, { value: this.opts.systemPrompt });
+    if (!response.ok) throw new Error(`OpenCode did not take the planner instructions: ${response.status} ${response.statusText}`);
+  }
+  async send(message, onEvent, signal, onActivity) {
+    if (!this.sessionId) throw new Error(`OpenCode ${this.role} session is not started`);
+    if (this.host.isExited()) {
+      onEvent({ type: "error", message: this.host.exitMessage() });
+      return;
+    }
+    const state = newTurnState();
+    this.turnHasText = false;
+    this.interruptRequested = false;
+    let markDone = () => {
+    };
+    const ended = new Promise((resolve7) => {
+      markDone = resolve7;
+    });
+    const turn = { live: false, done: false, outcome: null, failure: null, ended, finish: () => {
+      turn.done = true;
+      markDone();
+    } };
+    this.turn = turn;
+    const closeStream = await this.openStream(state, turn, onEvent, onActivity);
+    const poll = new AbortController();
+    try {
+      try {
+        await this.host.json("POST", `/api/session/${this.sessionId}/prompt`, { text: message }, signal);
+      } catch (err) {
+        if (signal?.aborted) return;
+        onEvent({ type: "error", message: `OpenCode did not take the message: ${err instanceof Error ? err.message : String(err)}` });
+        return;
+      }
+      void this.pollActive(turn, poll.signal);
+      const aborted = new Promise((resolve7) => {
+        if (signal?.aborted) resolve7();
+        signal?.addEventListener("abort", () => resolve7(), { once: true });
+      });
+      await Promise.race([turn.ended, aborted, this.host.processEnded]);
+      if (signal?.aborted) return;
+      if (!turn.done) {
+        onEvent({ type: "error", message: this.host.exitMessage() });
+        return;
+      }
+      await this.readBack(state, onEvent);
+      for (const id of [...this.openPermissions.keys()]) {
+        this.openPermissions.delete(id);
+        onEvent({ type: "permission_cancelled", id });
+      }
+      if (turn.outcome === "interrupted" || this.interruptRequested) onEvent({ type: "turn_end", interrupted: true });
+      else if (turn.outcome === "failed") onEvent({ type: "error", message: turn.failure ?? "OpenCode reported that the turn failed." });
+      else onEvent({ type: "turn_end" });
+    } finally {
+      this.turn = null;
+      poll.abort();
+      await closeStream();
+    }
+  }
+  /**
+   * The stream can drop the end frame while still delivering the rest, so the
+   * turn also asks which sessions are running. A session that is not, after
+   * this turn's work was seen, is over; one never seen working after a few
+   * polls had already finished before the stream connected.
+   */
+  async pollActive(turn, signal) {
+    let idlePolls = 0;
+    while (!turn.done && !signal.aborted) {
+      await delay(ACTIVE_POLL_INTERVAL_MS, signal);
+      if (turn.done || signal.aborted) return;
+      const active = await this.host.json("GET", "/api/session/active").catch(() => null);
+      if (!active?.data) continue;
+      if (this.sessionId && this.sessionId in active.data) {
+        turn.live = true;
+        idlePolls = 0;
+        continue;
+      }
+      idlePolls++;
+      if (turn.live || idlePolls >= IDLE_POLLS_BEFORE_START) {
+        const messages = await this.messages();
+        const idle = [...messages ?? []].reverse().find((m) => m.type === "idle");
+        if (idle?.outcome === "failed" || idle?.outcome === "interrupted" || idle?.outcome === "succeeded") turn.outcome ??= idle.outcome;
+        turn.outcome ??= "succeeded";
+        if (!turn.done) turn.finish();
+      }
+    }
+  }
+  async messages() {
+    const response = await this.host.json("GET", `/api/session/${this.sessionId}/message`).catch(() => null);
+    return Array.isArray(response?.data) ? response.data : null;
+  }
+  /**
+   * Whatever of the turn's own replies the stream missed. A message whose text
+   * the stream delivered adds nothing here; one that lost its text frames still
+   * reaches the plain-text channel, where the done marker is looked for.
+   */
+  async readBack(state, onEvent) {
+    const messages = await this.messages();
+    if (!messages) return;
+    const latestUser = messages.findIndex((m) => m.type === "user");
+    const own = latestUser < 0 ? messages : messages.slice(0, latestUser);
+    for (const message of [...own].reverse()) {
+      if (message.type !== "assistant" || !message.id || state.streamedMessages.has(message.id)) continue;
+      (message.content ?? []).forEach((part, index) => {
+        if (part.type === "text" && part.text) this.emitText(`${message.id}:readback:${index}`, part.text, state, onEvent);
+      });
+    }
+  }
+  /**
+   * Abort the running turn, keeping the server and its session. OpenCode
+   * acknowledges with `session.execution.interrupted`, which also ends the turn.
+   */
+  async interrupt(timeoutMs) {
+    if (!this.sessionId || this.host.isExited()) return false;
+    const turn = this.turn;
+    this.interruptRequested = true;
+    const response = await this.host.json("POST", `/api/session/${this.sessionId}/interrupt`).catch(() => null);
+    if (!response) return false;
+    if (!turn || turn.done) return true;
+    let timer;
+    const timedOut = new Promise((resolve7) => {
+      timer = setTimeout(() => resolve7(false), timeoutMs);
+      timer.unref?.();
+    });
+    const acknowledged = await Promise.race([turn.ended.then(() => true), this.host.processEnded.then(() => false), timedOut]);
+    clearTimeout(timer);
+    return acknowledged;
+  }
+  answerPermission(id, decision) {
+    const sessionId = this.openPermissions.get(id);
+    if (sessionId === void 0) return false;
+    this.openPermissions.delete(id);
+    void this.replyPermission(id, sessionId, permissionReply(decision)).catch(() => {
+    });
+    return true;
+  }
+  async replyPermission(id, sessionId, reply) {
+    await this.host.request("POST", `/api/session/${sessionId}/permission/${id}/reply`, reply);
+  }
+  async openStream(state, turn, onEvent, onActivity) {
+    const streamAbort = new AbortController();
+    let connected = () => {
+    };
+    const ready = new Promise((resolve7) => {
+      connected = resolve7;
+    });
+    const live = this.streamEvents(streamAbort.signal, (frame) => this.onFrame(frame, state, turn, onEvent), connected, onActivity);
+    await Promise.race([ready, new Promise((r) => {
+      const t = setTimeout(r, STREAM_CONNECT_TIMEOUT_MS);
+      t.unref?.();
+    })]);
+    return async () => {
+      streamAbort.abort();
+      await live.catch(() => {
+      });
+    };
+  }
+  async streamEvents(signal, onFrame, onConnected, onActivity) {
+    const response = await this.host.openEvents(signal).catch(() => null);
+    const body = response?.body;
+    if (!body) {
+      onConnected();
+      return;
+    }
+    onConnected();
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (; ; ) {
+      const { done, value } = await reader.read().catch(() => ({ done: true, value: void 0 }));
+      if (done) return;
+      onActivity?.();
+      buffer += decoder.decode(value, { stream: true });
+      let newline;
+      while ((newline = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        if (!line.startsWith("data:")) continue;
+        try {
+          onFrame(JSON.parse(line.slice(5).trim()));
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * One frame. Only this session and its children are followed: the stream is
+   * the whole server's, and another client's session is none of this turn's business.
+   */
+  onFrame(frame, state, turn, onEvent) {
+    const data = frame.data;
+    if (!data || !frame.type) return;
+    if (frame.type === "session.created") {
+      if (data.parentID && data.parentID === this.sessionId && data.sessionID && !state.children.has(data.sessionID)) state.children.set(data.sessionID, null);
+      return;
+    }
+    const session = data.sessionID;
+    if (!session) return;
+    const isChild = session !== this.sessionId;
+    if (isChild && !state.children.has(session)) return;
+    if (!isChild) {
+      if (frame.type === "session.execution.started") {
+        turn.live = true;
+        return;
+      }
+      if (frame.type === "session.execution.succeeded" || frame.type === "session.execution.failed" || frame.type === "session.execution.interrupted") {
+        if (!turn.live || turn.done) return;
+        turn.outcome = frame.type === "session.execution.succeeded" ? "succeeded" : frame.type === "session.execution.failed" ? "failed" : "interrupted";
+        if (turn.outcome === "failed") turn.failure = data.error?.message ?? data.error?.type ?? null;
+        turn.finish();
+        return;
+      }
+    }
+    if (frame.type === "permission.asked") {
+      if (this.role === "task") this.askPermission(data, session, state, onEvent);
+      else this.denyPermission(data, session, state, onEvent);
+      return;
+    }
+    if (frame.type === "permission.replied") {
+      const id = data.requestID;
+      if (id && this.openPermissions.delete(id)) onEvent({ type: "permission_cancelled", id });
+      return;
+    }
+    let subagentId;
+    if (isChild) {
+      const owner = state.children.get(session);
+      if (!owner) {
+        state.heldFrames.set(session, [...state.heldFrames.get(session) ?? [], frame]);
+        return;
+      }
+      subagentId = owner;
+    }
+    this.onContentFrame(frame, data, state, turn, onEvent, subagentId);
+  }
+  onContentFrame(frame, data, state, turn, onEvent, subagentId) {
+    const message = data.assistantMessageID ?? "";
+    switch (frame.type) {
+      case "session.step.started":
+        if (message && data.model?.providerID && data.model.id) state.stepModels.set(message, `${data.model.providerID}/${data.model.id}`);
+        return;
+      case "session.reasoning.delta":
+        if (data.delta) onEvent({ type: "thinking_delta", text: data.delta, subagentId });
+        return;
+      case "session.reasoning.ended": {
+        const key = `reasoning:${message}:${data.ordinal ?? 0}`;
+        if (!data.text || state.seen.has(key)) return;
+        state.seen.add(key);
+        onEvent({ type: "thinking", text: data.text, subagentId });
+        return;
+      }
+      case "session.text.delta":
+        if (!subagentId && data.delta) this.onTextDelta(`${message}:${data.ordinal ?? 0}`, data.delta, state, onEvent);
+        return;
+      case "session.text.ended":
+        if (subagentId || !data.text) return;
+        if (message) state.streamedMessages.add(message);
+        this.emitText(`${message}:${data.ordinal ?? 0}`, data.text, state, onEvent);
+        return;
+      case "session.tool.input.started":
+        if (data.id && data.name) state.toolNames.set(data.id, data.name);
+        return;
+      case "session.tool.called": {
+        const id = data.id;
+        if (!id || state.seen.has(`call:${id}`)) return;
+        state.seen.add(`call:${id}`);
+        const input = data.input ?? {};
+        const name = state.toolNames.get(id) ?? "tool";
+        const brief = typeof input.description === "string" ? input.description : typeof input.prompt === "string" ? input.prompt : "";
+        state.briefs.set(id, brief);
+        onEvent({ type: "tool_call", id, name, args: input, subagentId });
+        return;
+      }
+      case "session.tool.progress":
+        if (!subagentId) this.adoptChild(data, state, onEvent, turn);
+        return;
+      case "session.tool.success":
+      case "session.tool.failed": {
+        const id = data.id;
+        if (!id || state.seen.has(`result:${id}`)) return;
+        state.seen.add(`result:${id}`);
+        const success = frame.type === "session.tool.success";
+        const output = success ? contentText(data.content) : data.error?.message ?? data.error?.type ?? "";
+        onEvent({ type: "tool_result", id, name: state.toolNames.get(id) ?? "tool", output, success, subagentId });
+        if (!subagentId) this.finishChild(id, success, output, state, onEvent);
+        return;
+      }
+      case "session.step.ended":
+      case "session.step.failed":
+        this.countUsage(data, state, onEvent, subagentId);
+        return;
+      default:
+    }
+  }
+  adoptChild(data, state, onEvent, turn) {
+    const child = data.metadata?.sessionID;
+    const callId = data.id;
+    if (!child || !callId || state.children.get(child)) return;
+    const model = state.stepModels.get(data.assistantMessageID ?? "");
+    onEvent({ type: "subagent_started", subagentId: callId, brief: state.briefs.get(callId) ?? "", ...model ? { model } : {} });
+    state.children.set(child, callId);
+    const held = state.heldFrames.get(child) ?? [];
+    state.heldFrames.delete(child);
+    for (const frame of held) this.onFrame(frame, state, turn, onEvent);
+  }
+  finishChild(callId, success, output, state, onEvent) {
+    if (![...state.children.values()].includes(callId)) return;
+    onEvent({ type: "subagent_finished", subagentId: callId, outcome: success ? "done" : "failed", digest: subagentDigest(output) });
+  }
+  /** One model call's usage, once, when its step ends. Zeros mean the call failed before the provider answered. */
+  countUsage(data, state, onEvent, subagentId) {
+    const message = data.assistantMessageID;
+    const tokens = data.tokens;
+    if (!message || !tokens || state.seen.has(`usage:${message}`)) return;
+    state.seen.add(`usage:${message}`);
+    const prompt = partedPromptUsage({ uncached: tokens.input, cacheRead: tokens.cache?.read, cacheWrite: tokens.cache?.write });
+    const outputTokens = (tokens.output ?? 0) + (tokens.reasoning ?? 0);
+    if ((prompt.inputTokens ?? 0) + outputTokens === 0) return;
+    const record = { source: "opencode", ...prompt, outputTokens };
+    const model = state.stepModels.get(message);
+    if (model) record.model = model;
+    if (typeof data.cost === "number" && data.cost > 0) record.reportedCost = { amount: data.cost, currency: "USD" };
+    if (subagentId) record.subagentId = subagentId;
+    onEvent({ type: "usage", record });
+  }
+  /** One complete reply text, once. A message can carry text on both sides of a tool call, so each run after the first opens a paragraph. */
+  emitText(id, text, state, onEvent) {
+    if (state.seen.has(`text:${id}`)) return;
+    state.seen.add(`text:${id}`);
+    if (!text.trim()) return;
+    const lead = state.textRuns.get(id)?.lead ?? (this.turnHasText ? "\n\n" : "");
+    onEvent({ type: "assistant_text", text: `${lead}${text}` });
+    this.turnHasText = true;
+  }
+  /**
+   * Stream one piece of a reply text. The paragraph break goes out with the
+   * first visible delta, so the deltas add up to exactly the text the completed
+   * run then re-sends; a run that is only whitespace so far is held back.
+   */
+  onTextDelta(id, delta, state, onEvent) {
+    if (state.seen.has(`text:${id}`)) return;
+    const run = state.textRuns.get(id) ?? { held: "", lead: null };
+    state.textRuns.set(id, run);
+    if (run.lead !== null) {
+      onEvent({ type: "assistant_text_delta", text: delta });
+      return;
+    }
+    run.held += delta;
+    if (!run.held.trim()) return;
+    run.lead = this.turnHasText ? "\n\n" : "";
+    this.turnHasText = true;
+    onEvent({ type: "assistant_text_delta", text: `${run.lead}${run.held}` });
+  }
+  permissionRequest(ask) {
+    const id = ask.id;
+    if (!id) return null;
+    const scope = (ask.resources ?? []).join(", ");
+    return {
+      type: "permission_request",
+      id,
+      name: ask.action ?? "permission",
+      detail: JSON.stringify(scope ? { scope } : {}),
+      input: ask.resources ? { resources: ask.resources } : {},
+      // The patterns `always` would grant: the runner's own offer, and the only grounds for "Allow for this task".
+      ...ask.save?.length ? { suggestions: ask.save } : {},
+      ...ask.source?.id ? { toolUseId: ask.source.id } : {}
+    };
+  }
+  /**
+   * Deny one planner request. OpenCode blocks the turn until it is answered, so
+   * this must answer: `reject` rather than a silent drop is the "absent answer
+   * is a denial" invariant ADR-0008 states. The refusal is announced so the
+   * timeline shows the planner reaching for something it may not have.
+   */
+  denyPermission(ask, session, state, onEvent) {
+    const request = this.permissionRequest(ask);
+    if (!request || state.seen.has(`perm:${request.id}`)) return;
+    state.seen.add(`perm:${request.id}`);
+    onEvent(request);
+    void this.replyPermission(request.id, session, { decision: "reject" }).catch(() => {
+    });
+  }
+  /**
+   * A task's request. Under a mode whose manifest sets `approvals: auto` it is
+   * answered at once with what `opencode run --auto` answers, so the same plan
+   * behaves the same on both transports (ADR-0001), and announced already
+   * decided so the log still shows it. Any other mode leaves it open for an
+   * approval card.
+   */
+  askPermission(ask, session, state, onEvent) {
+    const request = this.permissionRequest(ask);
+    if (!request || state.seen.has(`perm:${request.id}`)) return;
+    state.seen.add(`perm:${request.id}`);
+    if (this.opts.kind === "task" && this.opts.flags.modeSettings.approvals === AUTO_APPROVALS) {
+      onEvent({ ...request, decided: { decision: "allow" } });
+      void this.replyPermission(request.id, session, { decision: "once" }).catch(() => {
+      });
+      return;
+    }
+    this.openPermissions.set(request.id, session);
+    onEvent(request);
+  }
+};
+
+// src/services/harness/OpenCodeAdapter.ts
 var SERVER_READY_TIMEOUT_MS = 3e4;
 var STDERR_TAIL_CHARS2 = 4e3;
-var STREAM_CONNECT_TIMEOUT_MS = 5e3;
+var STREAM_CONNECT_TIMEOUT_MS2 = 5e3;
 var RECOVERY_POLL_INTERVAL_MS = 2e3;
 var RECOVERY_TIMEOUT_MS = 9e5;
 var STATUS_POLL_INTERVAL_MS = 1e3;
@@ -12560,8 +13424,8 @@ var DISABLED_TOOLS = {
   todowrite: false
 };
 var TASK_DISABLED_TOOLS = { question: false };
-var AUTO_APPROVALS = "auto";
-function splitModelId(id) {
+var AUTO_APPROVALS2 = "auto";
+function splitModelId2(id) {
   const slash = id.indexOf("/");
   if (slash <= 0 || slash === id.length - 1) return null;
   return { providerID: id.slice(0, slash), modelID: id.slice(slash + 1) };
@@ -12617,7 +13481,7 @@ function unwrapFileToolOutput(output) {
   const inner = output.match(/<content>\n?([\s\S]*?)\n?<\/content>/);
   return inner ? inner[1] : output;
 }
-function delay(ms, signal) {
+function delay2(ms, signal) {
   return new Promise((resolve7) => {
     const timer = setTimeout(resolve7, ms);
     timer.unref?.();
@@ -12627,10 +13491,10 @@ function delay(ms, signal) {
     }, { once: true });
   });
 }
-function newTurnState() {
+function newTurnState2() {
   return { seen: /* @__PURE__ */ new Set(), assistantMessages: /* @__PURE__ */ new Set(), partTypes: /* @__PURE__ */ new Map(), textRuns: /* @__PURE__ */ new Map(), children: /* @__PURE__ */ new Map(), heldFrames: /* @__PURE__ */ new Map() };
 }
-function permissionReply(decision) {
+function permissionReply2(decision) {
   if (decision.decision === "allow") return { reply: "once" };
   if (decision.decision === "allowForTask") return { reply: "always" };
   const note = decision.note?.trim();
@@ -12667,6 +13531,8 @@ var OpenCodeAdapter = class {
   interruptRequested = false;
   /** A task's requests waiting for an answer, by request id, with the session that asked. */
   openPermissions = /* @__PURE__ */ new Map();
+  /** Set once the server turns out to speak the 2.x API, which then owns the session. */
+  v2 = null;
   async start(opts) {
     if (opts.kind === "task") this.task = opts;
     else this.planner = opts;
@@ -12681,14 +13547,14 @@ var OpenCodeAdapter = class {
       throw new ExecutableNotFoundError("opencode", PATH);
     }
     const workspaceEnv = await (this.deps.workspaceEnv ?? workspaceEnvOf)(opts.cwd);
-    const password = opts.kind === "task" ? randomBytes2(24).toString("base64url") : null;
+    const password = randomBytes2(24).toString("base64url");
     this.process = this.deps.spawn(launch.file, launch.args, {
-      env: runnerEnv(PATH, password ? { ...workspaceEnv, OPENCODE_SERVER_USERNAME: SERVER_USERNAME, OPENCODE_SERVER_PASSWORD: password } : workspaceEnv),
+      env: runnerEnv(PATH, { ...workspaceEnv, OPENCODE_SERVER_USERNAME: SERVER_USERNAME, OPENCODE_SERVER_PASSWORD: password }),
       stdio: ["pipe", "pipe", "pipe"],
       cwd: opts.cwd,
       windowsVerbatimArguments: launch.verbatim
     });
-    if (password) this.authorization = `Basic ${Buffer.from(`${SERVER_USERNAME}:${password}`).toString("base64")}`;
+    this.authorization = `Basic ${Buffer.from(`${SERVER_USERNAME}:${password}`).toString("base64")}`;
     this.process.stdin?.on("error", () => {
     });
     const banner = new Promise((resolve7) => {
@@ -12725,6 +13591,24 @@ ${err.message}`).slice(-STDERR_TAIL_CHARS2);
 
 ${this.stderrTail.trim()}` : ""}`);
     }
+    if (await this.speaksV2()) {
+      this.v2 = new OpenCodeV2({
+        request: (method, path26, body, signal) => this.request(method, path26, body, signal),
+        json: (method, path26, body, signal) => this.json(method, path26, body, signal),
+        openEvents: (signal) => this.deps.fetch(`${this.baseUrl}/api/event`, { signal, headers: this.headers() }),
+        processEnded: this.processEnded,
+        isExited: () => this.exited,
+        exitMessage: () => this.exitMessage()
+      }, opts, this.role());
+      try {
+        await this.v2.start();
+      } catch (err) {
+        this.dispose();
+        throw err;
+      }
+      this.sessionId = this.v2.nativeSessionId();
+      return;
+    }
     if (opts.resumeSessionId) {
       const existing = await this.json("GET", `/session/${opts.resumeSessionId}`).catch(() => null);
       if (existing?.id) {
@@ -12748,12 +13632,17 @@ ${this.stderrTail.trim()}` : ""}`);
       onEvent({ type: "error", message: this.exitMessage() });
       return;
     }
+    if (this.v2) {
+      await this.v2.send(message, onEvent, signal, onActivity);
+      if (signal?.aborted) this.dispose();
+      return;
+    }
     if (this.task) return this.sendTask(this.task, message, onEvent, signal, onActivity);
-    const turn = newTurnState();
+    const turn = newTurnState2();
     this.turnHasText = false;
     const closeStream = await this.openStream(turn, onEvent, onActivity);
     try {
-      const model = this.planner?.model ? splitModelId(this.planner.model) : null;
+      const model = this.planner?.model ? splitModelId2(this.planner.model) : null;
       const body = {
         parts: [{ type: "text", text: message }],
         // The read-only guarantee: OpenCode's own plan agent has no write tools.
@@ -12794,7 +13683,7 @@ ${this.stderrTail.trim()}` : ""}`);
    * {@link recoverReply}, never applies.
    */
   async sendTask(task, message, onEvent, signal, onActivity) {
-    const state = newTurnState();
+    const state = newTurnState2();
     this.turnHasText = false;
     this.interruptRequested = false;
     let markDone = () => {
@@ -12810,7 +13699,7 @@ ${this.stderrTail.trim()}` : ""}`);
     const closeStream = await this.openStream(state, onEvent, onActivity);
     const poll = new AbortController();
     try {
-      const model = task.model ? splitModelId(task.model) : null;
+      const model = task.model ? splitModelId2(task.model) : null;
       const body = {
         parts: [{ type: "text", text: message }],
         // The manifest's meaning of the task's mode (ADR-0001): for OpenCode a mode is an agent.
@@ -12890,7 +13779,7 @@ ${this.stderrTail.trim()}` : ""}`);
    */
   async pollStatus(turn, signal) {
     while (!turn.done && !signal.aborted) {
-      await delay(STATUS_POLL_INTERVAL_MS, signal);
+      await delay2(STATUS_POLL_INTERVAL_MS, signal);
       if (turn.done || signal.aborted) return;
       const busy = await this.sessionBusy();
       if (busy === true) turn.live = true;
@@ -12937,6 +13826,7 @@ ${this.stderrTail.trim()}` : ""}`);
    */
   async interrupt(timeoutMs) {
     if (!this.process || !this.sessionId || this.exited) return false;
+    if (this.v2) return this.v2.interrupt(timeoutMs);
     const turn = this.taskTurn;
     this.interruptRequested = true;
     const posted = await this.json("POST", `/session/${this.sessionId}/abort`).then(() => true, () => false);
@@ -12957,13 +13847,23 @@ ${this.stderrTail.trim()}` : ""}`);
     void this.processEnded.then(() => listener(this.exitCode));
   }
   answerPermission(id, decision) {
+    if (this.v2) return this.process ? this.v2.answerPermission(id, decision) : false;
     const sessionId = this.openPermissions.get(id);
     if (sessionId === void 0 || !this.process) return false;
     this.openPermissions.delete(id);
-    void this.replyPermission(id, sessionId, permissionReply(decision)).catch(() => {
+    void this.replyPermission(id, sessionId, permissionReply2(decision)).catch(() => {
     });
     return true;
   }
+  /**
+   * OpenCode 2.x replaced the 1.x HTTP surface rather than extending it, and
+   * only 2.x answers `/api/info` with its version. A 1.x server — or one that
+   * answers with anything else — keeps the 1.x protocol this class speaks.
+   */
+  async speaksV2() {
+    const info = await this.json("GET", "/api/info").catch(() => null);
+    return typeof info === "object" && info !== null && typeof info.version === "string";
+  }
   role() {
     return this.task ? "task" : "planner";
   }
@@ -13014,7 +13914,7 @@ ${this.stderrTail.trim()}` : ""}`);
       if (pending?.info?.time?.completed || pending?.info?.error) return pending;
       if (pending) onActivity?.();
       if (Date.now() >= deadline) return null;
-      await delay(RECOVERY_POLL_INTERVAL_MS, signal);
+      await delay2(RECOVERY_POLL_INTERVAL_MS, signal);
     }
   }
   newestAssistantId(messages) {
@@ -13227,7 +14127,7 @@ ${this.stderrTail.trim()}` : ""}`);
       ...ask.always?.length ? { suggestions: ask.always } : {},
       ...ask.tool?.callID ? { toolUseId: ask.tool.callID } : {}
     };
-    if (this.task?.flags.modeSettings.approvals === AUTO_APPROVALS) {
+    if (this.task?.flags.modeSettings.approvals === AUTO_APPROVALS2) {
       onEvent({ ...request, decided: { decision: "allow" } });
       void this.replyPermission(id, sessionId, { reply: "once" }).catch(() => {
       });
@@ -13261,7 +14161,7 @@ ${this.stderrTail.trim()}` : ""}`);
     });
     const live = this.streamEvents(streamAbort.signal, (frame) => this.onFrame(frame, turn, onEvent), connected, onActivity);
     await Promise.race([streamReady, new Promise((r) => {
-      const t = setTimeout(r, STREAM_CONNECT_TIMEOUT_MS);
+      const t = setTimeout(r, STREAM_CONNECT_TIMEOUT_MS2);
       t.unref?.();
     })]);
     return async () => {
@@ -13426,6 +14326,10 @@ var TaskOrchestrator = class _TaskOrchestrator {
    * pending and nothing ran until the user also re-ran the whole plan.
    */
   haltedByFailure = false;
+  /** A Merge all is under way: no ops task starts until it ends (ADR-0020). */
+  merging = false;
+  /** The last "waiting for Merge all" notice, so a run paused at a gate says it once, not on every tick. */
+  gateNotice = "";
   /** The workspace's own variables for a task's cwd (ADR-0016); swapped out in tests. */
   workspaceEnv;
   /** What the workspace env has already warned about, so a run says it once, not per task. */
@@ -13446,6 +14350,7 @@ var TaskOrchestrator = class _TaskOrchestrator {
   observers = [];
   tddEnabled;
   readRunnerTransport;
+  previousAttemptFromLog;
   /**
    * The setting as the latest run copied it when it opened. Every spawn of
    * that run uses this, so flipping the setting mid-run changes the next run
@@ -13465,6 +14370,7 @@ var TaskOrchestrator = class _TaskOrchestrator {
     this.workspaceEnv = deps.workspaceEnv;
     this.tddEnabled = deps.tddEnabled;
     this.readRunnerTransport = deps.runnerTransport;
+    this.previousAttemptFromLog = deps.previousAttemptFromLog;
     this.store.onMutate = () => this.emit("onTaskChanged");
     this.verifier.onVerdict((taskId, verdict) => this.onVerdict(taskId, verdict));
     this.verifier.onCheckpoint((taskId, summary) => {
@@ -13520,7 +14426,8 @@ var TaskOrchestrator = class _TaskOrchestrator {
       workspaceRoot,
       workspaceEnv: options.workspaceEnv ?? ((cwd) => resolveWorkspaceEnv(cwd)),
       tddEnabled: options.tddEnabled ?? (() => false),
-      runnerTransport: options.runnerTransport ?? (() => "terminal")
+      runnerTransport: options.runnerTransport ?? (() => "terminal"),
+      previousAttemptFromLog: options.previousAttemptFromLog ?? (() => null)
     });
     return orchestrator;
   }
@@ -13528,6 +14435,18 @@ var TaskOrchestrator = class _TaskOrchestrator {
   getIdleSince(taskId) {
     return this.verifier.getIdleSince(taskId);
   }
+  /**
+   * What an ops retry is told about the attempt before. The saved log is read
+   * whether or not the session was reloaded, so both behave alike; the terminal
+   * buffer is the fallback for a runner that has no log. A reload clears the
+   * attempt count along with the buffer, so a retry made since is what says
+   * there was an attempt to report on.
+   */
+  opsPreviousAttempt(taskId) {
+    const saved = this.previousAttemptFromLog(taskId) ?? this.output.liveTail(taskId, { maxLines: OPS_RETRY_TAIL_LINES })?.text;
+    if (saved !== void 0) return saved;
+    return (this.retryCounts.get(taskId) ?? 0) > 0 ? "Its output is not available: this session was reloaded since it ran." : void 0;
+  }
   /** Recent clean output of a task's latest attempt, running or ended; null if it never ran. */
   getLiveOutput(taskId, opts) {
     return this.output.liveTail(taskId, opts);
@@ -13734,9 +14653,48 @@ var TaskOrchestrator = class _TaskOrchestrator {
   async reviewRunDiff() {
     return this.runs.reviewDiff();
   }
-  /** "Merge all"; a run that merged everything is cleared up and forgotten. */
+  /**
+   * "Merge all"; a settled run that merged everything is cleared up and
+   * forgotten. During a run it merges what has landed and the run goes on:
+   * the tasks waiting at a merge gate for that work then start (ADR-0020).
+   * Never while an ops task runs, and no ops task starts until it ends — the
+   * one overlap the plan cannot order, because the merge is the user's.
+   */
   async mergeRun() {
-    return this.runs.merge();
+    const ops = [...this.attempts.values()].find((a) => a.ops);
+    if (ops) {
+      const title = this.store.get(ops.taskId)?.title ?? ops.taskId;
+      throw new TaskControlError(`Ops task "${title}" is running in your checkout \u2014 Merge all once it has finished.`);
+    }
+    this.merging = true;
+    let result;
+    try {
+      result = await this.runs.merge();
+    } finally {
+      this.merging = false;
+    }
+    await this.tick();
+    return result;
+  }
+  /**
+   * The run as a surface offers Merge all mid-run (ADR-0020): what has landed
+   * and is not merged, and whether the run is paused at its gates with nothing
+   * else running. Null while no task waits at a gate.
+   */
+  mergeGateView() {
+    const handoff = this.runs.view()?.handoff;
+    if (!handoff || !this.store.allTasks.some((t) => this.getMergeGate(t.id).length > 0)) return null;
+    return { paused: this.running && this.attempts.size === 0, repos: handoff.repos, landed: handoff.landed };
+  }
+  /**
+   * The dependencies an ops or user task waits on at its merge gate: those
+   * whose landed work is not in the user's branch yet (ADR-0020). Empty once
+   * the task has started, and for every other task.
+   */
+  getMergeGate(taskId) {
+    const task = this.store.get(taskId);
+    if (!task || task.status !== "pending" && task.status !== "approved") return [];
+    return mergeGate(task, this.store, this.runs);
   }
   /** Worktrees and task branches go; the integration branch and the record stay for review and merge. */
   async cleanupRun() {
@@ -13836,7 +14794,7 @@ var TaskOrchestrator = class _TaskOrchestrator {
       this.emit("onReviewNeeded", { tasks: this.store.planTasks, planRunners: this.store.planRunners });
       return;
     }
-    if (!await this.runs.open(() => this.start()) || this.running) return;
+    this.runs.open();
     console.log(`[TaskOrchestrator] Starting with ${this.store.allTasks.length} tasks (${this.store.allTasks.filter((t) => t.type === "ai" && t.prompt).length} AI ready)`);
     this.running = true;
     this.haltedByFailure = false;
@@ -13878,13 +14836,17 @@ var TaskOrchestrator = class _TaskOrchestrator {
     const summary = await this.output.finalText({ ...attempt, completionMarker: task.completionMarker }, doneToken);
     if (this.attempts.get(taskId) !== attempt) return;
     const landing = verdict.outcome === "pass" ? await this.land(attempt, () => this.landing.landPassed(task, attempt)) : null;
+    const changedFiles = landing && attempt.ops ? await this.runs.filesChangedSince(attempt.snapshot) : [];
     const unresumedReason = this.unresumed(attempt) ? unresumedMessage(task, `${attempt.runner} could not find its saved session`) : null;
     if (this.attempts.get(taskId) !== attempt) return;
     this.endAttempt(taskId, "verdict");
     this.store.setTaskVerdict(taskId, verdict);
     console.error(`[TaskOrchestrator] Output summary:
 ${summary || "(empty \u2014 no output captured)"}`);
-    if (landing) {
+    if (changedFiles.length > 0) {
+      this.store.markAwaitingUser(taskId, "files-changed");
+      this.tell("warn", `Ops task "${task.title}" finished, but changed tracked files in your checkout: ${capConflictFiles(changedFiles)}. An ops task must not change repository files, so nothing was committed \u2014 look at the changes, then mark it complete or retry it.`);
+    } else if (landing) {
       await this.applyLanding(task, landing, () => this.notifications.info(`Task "${task.title}" completed.`));
     } else if (classifyRunnerStop(attempt.session?.getOutput() ?? "") === "usage-limit") {
       this.store.markAwaitingUser(taskId);
@@ -13986,21 +14948,35 @@ ${summary || "(empty \u2014 no output captured)"}`);
     });
   }
   getReadyTasks() {
-    if (!this.running) return [];
+    return this.readiness().ready;
+  }
+  readiness() {
+    if (!this.running) return { ready: [], candidateCount: 0, excluded: [], gated: [] };
     const maxParallel = this.config.maxParallelSessions;
     const active = this.attempts.size;
-    const { ready, candidateCount, excluded } = selectReadyTasks({
+    const readiness = selectReadyTasks({
       store: this.store,
       onHold: this.onHold,
       runs: this.runs,
       active,
-      maxParallel
+      maxParallel,
+      merging: this.merging
     });
-    for (const { task, reasons } of excluded) {
+    for (const { task, reasons } of readiness.excluded) {
       console.log(`[TaskOrchestrator] excluded: #${task.order} "${task.title}" \u2014 ${reasons.join(", ")}`);
     }
-    console.log(`[TaskOrchestrator] getReadyTasks: ${candidateCount} candidates, ${Math.max(0, maxParallel - active)} slots, maxParallel=${maxParallel}`);
-    return ready;
+    console.log(`[TaskOrchestrator] getReadyTasks: ${readiness.candidateCount} candidates, ${Math.max(0, maxParallel - active)} slots, maxParallel=${maxParallel}`);
+    return readiness;
+  }
+  /**
+   * Open the run a task starts in, and for a change task decide whether it
+   * isolates (ADR-0020): an ops task needs no worktree, so it never waits on
+   * that choice. False while a dirty tree waits on the user; `resume` is what
+   * their choice replays.
+   */
+  async openFor(taskId, resume) {
+    this.runs.open();
+    return this.store.isOps(taskId) || this.runs.decide(resume);
   }
   /**
    * Cancel a running (or scheduled) task: kill its session and return it to
@@ -14128,7 +15104,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
     const runner = this.store.resolveTaskRunner(task);
     const route = routeTransport("structured", runner, this.registry);
     if (route.transport !== "structured") throw new TaskControlError(`Task "${task.title}" cannot be continued: ${route.fallback}. Use Retry instead.`);
-    if (!await this.runs.open(() => this.continueTask(taskId, message))) return;
+    if (!await this.openFor(taskId, () => this.continueTask(taskId, message))) return;
     if (this.attempts.has(taskId) || !continuability(task).ok) return;
     this.retryCounts.set(taskId, (this.retryCounts.get(taskId) ?? 0) + 1);
     this.endAttempt(taskId, "retry");
@@ -14150,10 +15126,29 @@ ${summary || "(empty \u2014 no output captured)"}`);
     const task = this.store.get(taskId);
     if (!task || task.type !== "ai") return;
     if (this.attempts.has(taskId)) return;
-    if (!await this.runs.open(() => this.forceStartTask(taskId))) return;
+    this.refuseOpsDuringMerge(task);
+    if (!await this.openFor(taskId, () => this.forceStartTask(taskId))) return;
     this.onHold.delete(taskId);
+    this.notePastGate(task);
     await this.startTask(task);
   }
+  refuseOpsDuringMerge(task) {
+    if (this.merging && this.store.isOps(task.id)) {
+      throw new TaskControlError(`A Merge all is under way \u2014 ops task "${task.title}" can start once it has finished.`);
+    }
+  }
+  /**
+   * A force start passes a merge gate (ADR-0020), and the surface confirmed it
+   * first; the choice is kept on the task and said, because the work it acts
+   * on is not in the user's branch.
+   */
+  notePastGate(task) {
+    const unmerged = mergeGate(task, this.store, this.runs);
+    if (unmerged.length === 0) return;
+    const titles = unmerged.map((id) => `"${this.store.get(id)?.title ?? id}"`);
+    this.store.setForcedPastGate(task.id, titles);
+    this.tell("warn", `Task "${task.title}" was force-started before the work of ${titles.join(", ")} was merged into your branch.`);
+  }
   /**
    * Run exactly one task outside full-plan scheduling. The active/starting
    * session still contributes to {@link hasLiveWork} so every surface exposes
@@ -14164,8 +15159,10 @@ ${summary || "(empty \u2014 no output captured)"}`);
     if (this.hasLiveWork) return;
     const task = this.store.get(taskId);
     if (!task || task.type !== "ai") return;
-    if (!await this.runs.open(() => this.runTask(taskId))) return;
+    this.refuseOpsDuringMerge(task);
+    if (!await this.openFor(taskId, () => this.runTask(taskId))) return;
     this.onHold.delete(taskId);
+    this.notePastGate(task);
     await this.startTask(task);
   }
   getCompletedCount() {
@@ -14205,7 +15202,11 @@ ${summary || "(empty \u2014 no output captured)"}`);
       }
       return;
     }
-    const ready = this.getReadyTasks();
+    let readiness = this.readiness();
+    const atGate = readiness.gated.length > 0 || this.store.allTasks.some((t) => t.type === "user" && this.getMergeGate(t.id).length > 0);
+    if (atGate && await this.runs.refreshInHead()) readiness = this.readiness();
+    if (!this.running) return;
+    const { ready } = readiness;
     console.log(`[TaskOrchestrator] tick(): ${ready.length} ready, ${this.attempts.size} active, queue=${this.messageQueue.length}`);
     if (ready.length === 0 && this.attempts.size === 0) {
       const remaining = this.store.allTasks.filter((t) => t.status !== "completed");
@@ -14225,14 +15226,29 @@ ${summary || "(empty \u2014 no output captured)"}`);
         this.emit("onExecutionComplete");
       } else {
         this.notifications.info("Remaining tasks require user action or are on hold.");
+        this.sayGate();
         this.emit("onTaskChanged");
         this.emit("onTick");
       }
       return;
     }
-    for (const task of ready) await this.startTask(task);
+    for (const task of ready) {
+      if (this.store.isOps(task.id) ? this.merging : !await this.runs.decide(() => this.tick())) continue;
+      await this.startTask(task);
+    }
     this.emit("onTick");
   }
+  /**
+   * A run paused at merge gates says so, as plainly as a task that waits on
+   * the user: which tasks wait, and that Merge all lets them go on (ADR-0020).
+   */
+  sayGate() {
+    const waiting = this.store.allTasks.filter((t) => this.getMergeGate(t.id).length > 0);
+    const notice = waiting.length === 0 ? "" : `Waiting for Merge all: ${waiting.map((t) => `"${t.title}"`).join(", ")} ${waiting.length === 1 ? "needs" : "need"} work that is not merged into your branch yet.`;
+    if (notice === this.gateNotice) return;
+    this.gateNotice = notice;
+    if (notice) this.tell("info", notice);
+  }
   async startTask(task, continuation = null) {
     if (this.attempts.has(task.id)) return;
     const attempt = {
@@ -14246,6 +15262,8 @@ ${summary || "(empty \u2014 no output captured)"}`);
       integration: null,
       repair: this.landing.nextRepair(task.id),
       continuation,
+      ops: this.store.isOps(task.id),
+      snapshot: null,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       decided: false
     };
@@ -14271,18 +15289,22 @@ ${summary || "(empty \u2014 no output captured)"}`);
    */
   async spawnAttempt(task, attempt) {
     try {
-      const { cwd, worktree } = await this.runs.attemptCwd(task, { repair: attempt.repair !== null });
+      const { cwd, worktree } = await this.runs.attemptCwd(task, { repair: attempt.repair !== null, ops: attempt.ops });
       attempt.cwd = cwd;
       attempt.worktree = worktree;
+      if (attempt.ops) attempt.snapshot = await this.runs.snapshotWorkspace();
       if (this.attempts.get(task.id) !== attempt) {
         if (attempt.worktree && !this.attempts.has(task.id)) await this.runs.release(task.id, { keep: attempt.repair !== null });
         this.abandonSpawn(task, attempt);
         return false;
       }
-      const finalPrompt = attempt.continuation ? composeContinuationPrompt(task, attempt.continuation.message) : composeAugmentedPrompt(attempt.repair ? { ...task, prompt: this.landing.repairPrompt(task) } : task, this.store.planTasks, {
+      const finalPrompt = attempt.continuation ? composeContinuationPrompt(task, attempt.continuation.message, { ops: attempt.ops }) : composeAugmentedPrompt(attempt.repair ? { ...task, prompt: this.landing.repairPrompt(task) } : task, this.store.planTasks, {
         planMapEnabled: this.config.planMapEnabled,
         // A merge to resolve is not new behaviour to drive test-first.
-        tddEnabled: !attempt.repair && this.tddEnabled()
+        tddEnabled: !attempt.repair && this.tddEnabled(),
+        // An ops task's effects outlive a failed attempt and are never rolled
+        // back, so the next one is told what the last one did (ADR-0020).
+        previousAttempt: attempt.ops ? this.opsPreviousAttempt(task.id) : void 0
       });
       this.lingering.close(task.id);
       const env = await this.envForTask(cwd);
@@ -14459,6 +15481,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
     return ended;
   }
 };
+var OPS_RETRY_TAIL_LINES = 60;
 function unresumedMessage(task, why) {
   return `Could not continue task "${task.title}": ${why}. Retry starts it afresh.`;
 }
@@ -16916,7 +17939,7 @@ Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.
     return tasks.map((t) => {
       const isMan = t.type === "user";
       const runFields = isMan ? `steps:${t.userSteps?.length ?? 0}` : `${t.assignedModel ? `model:${t.assignedModel.modelId} ` : ""}mode:${t.taskMode ?? "build"} effort:${t.thinkingEffort ?? "-"}`;
-      return `#${t.order} id=${t.id} "${t.title}" [${t.status}] type:${isMan ? "MAN" : "AI"} runner:${t.assignedRunner} ${runFields} autonomy:${t.autonomy ?? "-"} slice:${t.sliceType ?? "-"} deps:[${t.dependencies.map((d) => orderOf.get(d) ?? d).join(", ")}]`;
+      return `#${t.order} id=${t.id} "${t.title}" [${t.status}] type:${isMan ? "MAN" : t.ops ? "AI ops" : "AI"} runner:${t.assignedRunner} ${runFields} autonomy:${t.autonomy ?? "-"} slice:${t.sliceType ?? "-"} deps:[${t.dependencies.map((d) => orderOf.get(d) ?? d).join(", ")}]`;
     });
   }
 };
@@ -17413,6 +18436,7 @@ var SessionEventRelay = class {
     this.statusOwed = this.statusHeld;
     if (this.statusHeld) return;
     plan.tasks = this.store.snapshot();
+    const gate = this.orchestrator.mergeGateView();
     this.broadcast({
       type: "status_update",
       tasks: this.store.allTasks.map((t) => serializeTaskStatus(
@@ -17420,8 +18444,10 @@ var SessionEventRelay = class {
         this.orchestrator.getIdleSince(t.id),
         this.orchestrator.getTaskIsolation(t.id),
         this.orchestrator.getQueuedTaskMessages(t.id),
-        this.awaitingApproval(t.id)
-      ))
+        this.awaitingApproval(t.id),
+        this.orchestrator.getMergeGate(t.id)
+      )),
+      ...gate ? { gate } : {}
     });
   }
   /**
@@ -17897,6 +18923,13 @@ var PlanEditError = class extends Error {
     this.name = "PlanEditError";
   }
 };
+var OPS_RETRY_DIGEST_CALLS = 20;
+function lastAttemptDigest(location, taskId) {
+  const attempt = listTaskLogAttempts(location, taskId).pop();
+  if (attempt === void 0) return null;
+  const events = readTaskLog(location, taskId, attempt);
+  return events.length > 0 ? digestTaskLog(events, OPS_RETRY_DIGEST_CALLS) : null;
+}
 function sessionRuntimeSettings(settings) {
   return { ...plannerRuntimeToggles(settings), modelAllowlist: settings.modelAllowlist, runnerTransport: settings.runnerTransport };
 }
@@ -17981,7 +19014,8 @@ function createSession(deps) {
     registry: deps.registry,
     workspaceRoot: deps.workspaceRoot,
     tddEnabled: () => deps.settings().tddEnabled,
-    runnerTransport: () => deps.settings().runnerTransport ?? "terminal"
+    runnerTransport: () => deps.settings().runnerTransport ?? "terminal",
+    previousAttemptFromLog: (taskId) => lastAttemptDigest(session.taskLogLocation, taskId)
   });
   const usage = new PlannerUsageLedger();
   const events = new SessionEventRelay({
@@ -18754,6 +19788,14 @@ var Session = class {
   isolationView() {
     return this.orchestrator.isolationView();
   }
+  /** The dependencies a task waits on at its merge gate (ADR-0020); empty when it waits for no Merge all. */
+  mergeGate(taskId) {
+    return this.orchestrator.getMergeGate(taskId);
+  }
+  /** What Merge all would merge mid-run, while any task waits at a merge gate; null otherwise. */
+  mergeGateView() {
+    return this.orchestrator.mergeGateView();
+  }
   /** The run's integration branch against its base ref, as a unified diff. */
   async reviewRunDiff() {
     if (!this.orchestrator.isolationRecord) throw new PlanEditError("This plan has no isolated run");
@@ -18763,10 +19805,12 @@ var Session = class {
    * "Merge all": each repo's integration branch into whatever the user has
    * checked out there — every repo, or none if any cannot take it. The one
    * irreversible step of isolated execution, so this explicit call is the
-   * only way it ever happens.
+   * only way it ever happens. During a run it merges what has landed so far,
+   * which is what opens a merge gate (ADR-0020); it waits for no ops task,
+   * and refuses while one runs.
    */
   async mergeRun() {
-    this.requireSettledRun();
+    if (!this.orchestrator.isolationRecord) throw new PlanEditError("This plan has no isolated run");
     const result = await this.orchestrator.mergeRun();
     this.broadcast({ type: "isolation_merge", result });
     return result;
@@ -18856,7 +19900,8 @@ var Session = class {
    * falls through to the no-op `store.update` below instead of throwing.
    */
   async updateTask(taskId, changes) {
-    if ((changes.dependencies || changes.type || changes.assignedModel || changes.taskMode) && this.store.get(taskId)) {
+    if ("ops" in changes) changes = { ...changes, ops: changes.ops === true ? true : void 0 };
+    if ((changes.dependencies || changes.type || changes.assignedModel || changes.taskMode || "ops" in changes) && this.store.get(taskId)) {
       const check = validateTaskEdit("direct", this.store.planTasks, taskId, changes, this.editCatalog());
       if (!check.ok) throw new PlanEditError(check.error ?? "Those changes are not valid");
       if (check.clear?.length) {
@@ -21133,6 +22178,7 @@ export {
   FsPluginStore,
   GIT_READONLY_SUBCOMMANDS,
   GREP_DEFAULT_HEAD_LIMIT,
+  GREP_PCRE_PROBE_ARGS,
   GeminiService,
   HeadlessRunner,
   HeadlessSession,
@@ -21272,6 +22318,7 @@ export {
   dependencyCandidates,
   dependentsOf,
   describeMergeResult,
+  digestTaskLog,
   discoverGeminiModels,
   drainNext,
   effectiveAllowlist,
@@ -21304,6 +22351,7 @@ export {
   getStateDir,
   globalDataDir,
   grantScopeFor,
+  grepRegexFromProbe,
   hasHiddenDetail,
   hasTmux,
   holdPrompt,