@ordewell/core 0.6.1 → 0.6.2

package/dist/index.mjs

@@ -127,6 +127,8 @@ import {
 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) {
@@ -7600,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);
     }
   };
@@ -8923,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);
   }
@@ -8951,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)) {
@@ -9033,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) => {
@@ -9044,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;
@@ -9065,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. */
@@ -9102,6 +9252,7 @@ ${line}
     this.idleTimers.clear();
     this.idleSince.clear();
     this.idlePaused.clear();
+    this.openApprovals.clear();
     this.generations.clear();
   }
   decide(task, exitCode) {
@@ -12765,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;
@@ -12780,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) };
@@ -12837,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?.();
@@ -12847,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();
@@ -12887,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;
@@ -12901,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) => {
@@ -12945,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) {
@@ -12968,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.
@@ -13014,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 = () => {
@@ -13030,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.
@@ -13110,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;
@@ -13157,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);
@@ -13177,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";
   }
@@ -13234,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) {
@@ -13447,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(() => {
       });
@@ -13481,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 () => {
@@ -13670,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
@@ -13689,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) => {
@@ -13744,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;
   }
@@ -13752,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);
@@ -14609,7 +15304,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
         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.output.liveTail(task.id, { maxLines: OPS_RETRY_TAIL_LINES })?.text : void 0
+        previousAttempt: attempt.ops ? this.opsPreviousAttempt(task.id) : void 0
       });
       this.lingering.close(task.id);
       const env = await this.envForTask(cwd);
@@ -18228,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 };
 }
@@ -18312,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({
@@ -21475,6 +22178,7 @@ export {
   FsPluginStore,
   GIT_READONLY_SUBCOMMANDS,
   GREP_DEFAULT_HEAD_LIMIT,
+  GREP_PCRE_PROBE_ARGS,
   GeminiService,
   HeadlessRunner,
   HeadlessSession,
@@ -21614,6 +22318,7 @@ export {
   dependencyCandidates,
   dependentsOf,
   describeMergeResult,
+  digestTaskLog,
   discoverGeminiModels,
   drainNext,
   effectiveAllowlist,
@@ -21646,6 +22351,7 @@ export {
   getStateDir,
   globalDataDir,
   grantScopeFor,
+  grepRegexFromProbe,
   hasHiddenDetail,
   hasTmux,
   holdPrompt,