rovecode 0.3.3 → 0.4.0-beta.2

package/src/lanes/claude.ts

@@ -1,129 +0,0 @@
-/** claude code lane adapter (#47) — agentic-clis.md §2 "claude code · claude -p", verified 2026-09-02:
- *    claude --bare -p "<goal>" --output-format stream-json --verbose --permission-mode acceptEdits
- *           --allowedTools "<list>"            (+ --resume <session_id> · + --model <m>)
- *  `--bare` loads no hooks/skills/MCP/CLAUDE.md (the CI shape) and — live-verified 2026-09-03 against
- *  claude 2.1.257 on Windows — authenticates STRICTLY with ANTHROPIC_API_KEY (`--help`: "OAuth and
- *  keychain are never read"): without a key it exits 1 in ~3 s with `apiKeySource: "none"` and a
- *  `result` whose `is_error` is true while its `subtype` still says "success" (fixture
- *  claude-live-auth-failed.jsonl). So `--bare` is emitted only when `opts.bare !== false`; the registry
- *  turns it off when the lane env carries no ANTHROPIC_API_KEY, and the lane then runs on the CLI's own
- *  login (hooks/MCP/CLAUDE.md load; `system/hook_*` events appear). `--verbose` is mandatory for
- *  stream-json. Permissions are the lane's flags: acceptEdits auto-accepts file edits in the worktree,
- *  `--allowedTools` rules (e.g. `Bash(npm test)`) grant the rest; anything else is denied in -p mode and
- *  surfaces as `permission_denials` on the result. Events (§3): system/init → log (session id, model),
- *  system/hook_* → log, assistant text → log (an `is_api_error_message` line → `api error: …`),
- *  tool_use Edit/Write → edit (issued), a tool_result WITHOUT is_error → edit wrote:true (the write
- *  confirmed, progress.ts counts it there), Bash → bash, a failed tool_result → log, result → usage (total_cost_usd +
- *  usage) then done (is_error:false) | fail. SIGINT finishes the turn, SIGTERM exits 143 → interruptFirst. */
-
-import type { AgentAdapter, LaneCommand, LaneEvent, LaneOpts, LaneParseState, LaneTask } from "./types.ts";
-import { arr, clip, contentText, isObj, obj, parseJsonLine, str, toolEvent, toolPath, toolShape, usageFrom } from "./events.ts";
-
-/** acceptEdits already covers these; stating them keeps the card honest about what the lane may do */
-export const CLAUDE_DEFAULT_ALLOW: readonly string[] = ["Read", "Edit", "Write"];
-
-const allowOf = (opts: LaneOpts): string[] => [...(opts.allowlist ?? CLAUDE_DEFAULT_ALLOW)];
-
-/** the card's auth word: `--bare` runs on ANTHROPIC_API_KEY alone (the token is never read under --bare);
- *  otherwise the CLI's own login — `oauth token` when the lane env carries CLAUDE_CODE_OAUTH_TOKEN, else `cli login` */
-const authOf = (opts: LaneOpts): string => (opts.bare !== false ? "bare" : opts.oauthToken === true ? "oauth token" : "cli login");
-
-function argv(prompt: string, opts: LaneOpts, resume?: string): LaneCommand {
-  const allow = allowOf(opts);
-  const args = [...(opts.bare === false ? [] : ["--bare"]), "-p", prompt, "--output-format", "stream-json", "--verbose", "--permission-mode", "acceptEdits"];
-  if (allow.length > 0) args.push("--allowedTools", allow.join(","));
-  if (opts.model) args.push("--model", opts.model);
-  if (resume) args.push("--resume", resume);
-  return { bin: "claude", args, cwd: opts.cwd };
-}
-
-/** tool_use id → what that call was, so the tool_result can be read as a confirmation. The path is kept
- *  because claude reports the write only at the CALL: without it a `tool_result` cannot say WHICH file
- *  was written, and progress.ts would have to count the call instead — which is the thing it must not do. */
-type PendingCall = { name: string; path: string };
-type Pending = Record<string, PendingCall>;
-const pending = (st: LaneParseState): Pending => (st.scratch["tools"] ??= {}) as Pending;
-
-function assistant(o: Record<string, unknown>, st: LaneParseState): LaneEvent[] {
-  const out: LaneEvent[] = [];
-  for (const b of arr(obj(o["message"])?.["content"])) {
-    if (!isObj(b)) continue;
-    if (b["type"] === "text") {
-      const text = (str(b["text"]) ?? "").trim();
-      if (text) { st.lastText = text; out.push({ kind: "log", text }); }
-    } else if (b["type"] === "tool_use") {
-      const name = str(b["name"]) ?? "tool", id = str(b["id"]);
-      const input = obj(b["input"]);
-      if (id) pending(st)[id] = { name, path: toolPath(input) };
-      // the CALL: no `wrote` — claude confirms nothing until the matching tool_result arrives
-      out.push(toolEvent(name, input, undefined, undefined, id ? { callId: id } : {}));
-    }
-  }
-  return out;
-}
-
-function toolResults(o: Record<string, unknown>, st: LaneParseState): LaneEvent[] {
-  const out: LaneEvent[] = [];
-  for (const b of arr(obj(o["message"])?.["content"])) {
-    if (!isObj(b) || b["type"] !== "tool_result") continue;
-    const id = str(b["tool_use_id"]) ?? "";
-    const call = pending(st)[id];
-    const name = call?.name ?? "tool";
-    delete pending(st)[id];
-    const text = clip(contentText(b["content"]), 120);
-    const failed = b["is_error"] === true;
-    const shape = toolShape(name);
-    // THE CONFIRMATION: a result for an edit/write call that did not carry is_error is claude saying the
-    // file changed. Anthropic sets is_error only on failure, so "absent" is success (fixture: two of the
-    // three results carry no is_error at all). This replaces the result LOG line for a successful write —
-    // the same one line, now structured — while a failure keeps the log line and its reason.
-    if (!failed && call !== undefined && (shape === "edit" || shape === "write") && call.path !== "?") {
-      out.push({ kind: "edit", path: call.path, op: shape === "write" ? "write" : "edit", wrote: true, ...(id ? { callId: id } : {}) });
-      continue;
-    }
-    out.push({ kind: "log", text: `${name} ${failed ? "error" : "result"}${text ? `: ${text}` : ""}` });
-  }
-  return out;
-}
-
-export const claudeAdapter: AgentAdapter = {
-  id: "claude",
-  interruptFirst: true,
-  command: (task: LaneTask, opts: LaneOpts) => argv(task.goal, opts, opts.resume),
-  resume: (sessionId: string, followUp: string, opts: LaneOpts) => argv(followUp, opts, sessionId),
-  permissionSummary: (opts) => `permission-mode acceptEdits · allow: ${allowOf(opts).join(",") || "none"} · ${authOf(opts)} · worktree`,
-  parse(line: string, st: LaneParseState): LaneEvent[] {
-    const o = parseJsonLine(line);
-    const type = o ? str(o["type"]) : undefined;
-    if (!o || !type) { st.garbage++; return []; }
-    const sid = str(o["session_id"]);
-    if (sid) st.sessionId = sid;
-    switch (type) {
-      case "system": {
-        const sub = str(o["subtype"]) ?? "?";
-        // live shape (non-bare): hook_started / hook_response carry hook_name (+ outcome on the response)
-        if (sub === "hook_started" || sub === "hook_response") return [{ kind: "log", text: `hook ${str(o["hook_name"]) ?? "?"} ${sub === "hook_started" ? "started" : str(o["outcome"]) ?? "responded"}` }];
-        if (sub !== "init") return [{ kind: "log", text: `system ${sub}` }];
-        return [{ kind: "log", text: `init · model ${str(o["model"]) ?? "?"} · ${arr(o["tools"]).length} tools${sid ? ` · session ${sid}` : ""}` }];
-      }
-      case "assistant":
-        // live shape: an API failure arrives as a synthetic assistant message (`model: "<synthetic>"`,
-        // `error`, `is_api_error_message: true`) BEFORE the is_error result — shown as an error, never
-        // kept as lastText (a done summary must not read "Not logged in")
-        if (o["is_api_error_message"] === true) return [{ kind: "log", text: `api error: ${clip(contentText(obj(o["message"])?.["content"]), 160) || str(o["error"]) || "?"}${str(o["error"]) ? ` (${str(o["error"])})` : ""}` }];
-        return assistant(o, st);
-      case "user": return toolResults(o, st);
-      case "result": {
-        const out: LaneEvent[] = [];
-        const usage = usageFrom(o["usage"], o);
-        if (usage) out.push({ kind: "usage", usage });
-        const text = str(o["result"]) ?? "";
-        const ref = st.sessionId ? { sessionId: st.sessionId } : {};
-        if (o["is_error"] === true) out.push({ kind: "fail", error: text || `result ${str(o["subtype"]) ?? "error"}`, ...ref });
-        else out.push({ kind: "done", summary: text || st.lastText || "", ...ref });
-        return out;
-      }
-      default: return [];
-    }
-  },
-};

package/src/lanes/codex.ts

@@ -1,127 +0,0 @@
-/** codex lane adapter (#47) — agentic-clis.md §2 "codex · codex exec", verified 2026-09-02:
- *    codex -a never exec --json --sandbox workspace-write -C <dir> -o <lastfile> "<goal>"
- *  `-a/--ask-for-approval never` must come BEFORE `exec` (exec falls to never anyway); stdout is the
- *  JSONL event stream under `--json`; `-o` writes the final message to a file; `--skip-git-repo-check`
- *  lets the copy-isolation fallback (a non-git root) run; `--ephemeral` is deliberately NOT passed so
- *  `exec resume <SESSION_ID>` stays possible. Permissions are granted UP FRONT by the sandbox flag —
- *  nothing can ask mid-run, which is why the card states them before start. Events (§3):
- *  thread.started → session id, item.* agent_message/reasoning → log, command_execution → bash,
- *  file_change → edit, todo_list (plan) → progress, turn.completed → usage + done, turn.failed / error
- *  → fail. No documented SIGINT-finishes-turn contract → interruptFirst false (straight tree kill). */
-
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { AgentAdapter, LaneCommand, LaneEvent, LaneOpts, LaneParseState, LaneTask } from "./types.ts";
-import { arr, clip, isObj, num, obj, parseJsonLine, str, usageFrom } from "./events.ts";
-
-export const CODEX_DEFAULT_SANDBOX = "workspace-write";
-
-function lastFile(opts: LaneOpts): string {
-  if (opts.lastMessageFile) return opts.lastMessageFile;
-  let h = 0;
-  for (const c of opts.cwd) h = (h * 31 + c.charCodeAt(0)) >>> 0;
-  return join(tmpdir(), `rovecode-codex-last-${h.toString(16)}.md`);
-}
-
-function argv(prompt: string, opts: LaneOpts, resume?: string): LaneCommand {
-  const args = ["-a", "never", "exec"];
-  if (resume) args.push("resume", resume);
-  args.push("--json", "--sandbox", opts.sandbox ?? CODEX_DEFAULT_SANDBOX, "-C", opts.cwd, "-o", lastFile(opts), "--skip-git-repo-check");
-  if (opts.model) args.push("-m", opts.model);
-  args.push(prompt);
-  return { bin: "codex", args, cwd: opts.cwd };
-}
-
-const OPS: Record<string, "edit" | "write" | "delete"> = { add: "write", create: "write", update: "edit", modify: "edit", delete: "delete", remove: "delete" };
-
-function item(phase: string, it: Record<string, unknown>, st: LaneParseState): LaneEvent[] {
-  const type = str(it["type"]) ?? "";
-  const completed = phase === "item.completed";
-  switch (type) {
-    case "agent_message": {
-      const text = (str(it["text"]) ?? "").trim();
-      if (!completed || !text) return [];
-      st.lastText = text;
-      return [{ kind: "log", text }];
-    }
-    case "reasoning": {
-      const text = (str(it["text"]) ?? "").trim();
-      return completed && text ? [{ kind: "log", text: `thinking: ${clip(text, 160)}` }] : [];
-    }
-    case "command_execution": {
-      const command = str(it["command"]) ?? "?";
-      // ONE call reported twice (item.started, then item.completed) under one item.id — the id is what
-      // stops progress.ts counting it as two (fixture codex.jsonl lines 4-5: item_1 both times)
-      const callId = str(it["id"]);
-      const idPart = callId !== undefined ? { callId } : {};
-      if (phase === "item.started") return [{ kind: "bash", command, ...idPart }];
-      if (!completed) return [];
-      const ev: LaneEvent = { kind: "bash", command, ...idPart };
-      const code = num(it["exit_code"]);
-      if (code !== undefined) ev.exitCode = code;
-      const out = clip(str(it["aggregated_output"]), 120);
-      if (out) ev.output = out;
-      return [ev];
-    }
-    case "file_change": {
-      // codex reports a change only once it HAS happened (`item.completed`, status completed), so this is
-      // a confirmation and every path in it counts as written
-      if (!completed) return [];
-      const callId = str(it["id"]);
-      return arr(it["changes"]).filter(isObj).map((c) => ({
-        kind: "edit" as const, path: str(c["path"]) ?? "?", op: OPS[str(c["kind"]) ?? ""] ?? "edit", wrote: true as const,
-        ...(callId !== undefined ? { callId } : {}),
-      }));
-    }
-    case "todo_list": {
-      const items = arr(it["items"]).filter(isObj);
-      const done = items.filter((x) => x["completed"] === true).length;
-      const next = items.find((x) => x["completed"] !== true);
-      return [{ kind: "progress", text: `plan ${done}/${items.length}${next ? ` · ${clip(str(next["text"]), 100)}` : " · complete"}` }];
-    }
-    case "mcp_tool_call":
-      return completed ? [{ kind: "log", text: `mcp ${str(it["server"]) ?? "?"}.${str(it["tool"]) ?? "?"} ${str(it["status"]) ?? "completed"}` }] : [];
-    case "web_search":
-      return completed ? [{ kind: "log", text: `search: ${clip(str(it["query"]), 120)}` }] : [];
-    default:
-      return [];
-  }
-}
-
-export const codexAdapter: AgentAdapter = {
-  id: "codex",
-  interruptFirst: false,
-  command: (task: LaneTask, opts: LaneOpts) => argv(task.goal, opts, opts.resume),
-  resume: (sessionId: string, followUp: string, opts: LaneOpts) => argv(followUp, opts, sessionId),
-  permissionSummary: (opts) => `sandbox ${opts.sandbox ?? CODEX_DEFAULT_SANDBOX} · approval never · worktree`,
-  parse(line: string, st: LaneParseState): LaneEvent[] {
-    const o = parseJsonLine(line);
-    const type = o ? str(o["type"]) : undefined;
-    if (!o || !type) { st.garbage++; return []; }
-    const sid = (): Pick<LaneEvent & { kind: "done" }, "sessionId"> => (st.sessionId ? { sessionId: st.sessionId } : {});
-    switch (type) {
-      case "thread.started": {
-        const id = str(o["thread_id"]);
-        if (id) st.sessionId = id;
-        return [{ kind: "log", text: `thread ${id ?? "?"}` }];
-      }
-      case "item.started": case "item.updated": case "item.completed": {
-        const it = obj(o["item"]);
-        return it ? item(type, it, st) : [];
-      }
-      case "turn.completed": {
-        const out: LaneEvent[] = [];
-        const usage = usageFrom(o["usage"]);
-        if (usage) out.push({ kind: "usage", usage });
-        out.push({ kind: "done", summary: st.lastText ?? "", ...sid() });
-        return out;
-      }
-      case "turn.failed":
-        return [{ kind: "fail", error: str(obj(o["error"])?.["message"]) ?? str(o["error"]) ?? "turn failed", ...sid() }];
-      case "error":
-        return [{ kind: "fail", error: str(o["message"]) ?? str(obj(o["error"])?.["message"]) ?? "error", ...sid() }];
-      default:
-        return [];
-    }
-  },
-};

package/src/lanes/events.ts

@@ -1,130 +0,0 @@
-/** Shared JSONL helpers for the lane adapters (#47): a parse that never throws, tolerant field
- *  readers (each CLI names its token fields differently), the one-line rendering of a LaneEvent
- *  (the runner's log ring / the TaskInfo preview), and the usage fold. */
-
-import type { TokenUsage } from "../core/types.ts";
-import type { LaneEvent } from "./types.ts";
-
-export type Obj = Record<string, unknown>;
-
-export const isObj = (v: unknown): v is Obj => typeof v === "object" && v !== null && !Array.isArray(v);
-export const str = (v: unknown): string | undefined => (typeof v === "string" ? v : undefined);
-export const num = (v: unknown): number | undefined => (typeof v === "number" && Number.isFinite(v) ? v : undefined);
-export const obj = (v: unknown): Obj | undefined => (isObj(v) ? v : undefined);
-export const arr = (v: unknown): unknown[] => (Array.isArray(v) ? v : []);
-
-/** One JSONL line → its object, or null for anything that is not a JSON object (never throws). */
-export function parseJsonLine(line: string): Obj | null {
-  const t = line.trim();
-  if (!t.startsWith("{")) return null;
-  try {
-    const v: unknown = JSON.parse(t);
-    return isObj(v) ? v : null;
-  } catch {
-    return null;
-  }
-}
-
-/** First non-empty line, clipped with an ellipsis. */
-export function clip(text: string | undefined, max = 160): string {
-  const one = (text ?? "").split("\n").map((l) => l.trim()).find((l) => l !== "") ?? "";
-  return one.length > max ? one.slice(0, max - 1) + "…" : one;
-}
-
-/** Text of a content field that may be a string or an array of {type:"text", text} blocks. */
-export function contentText(v: unknown): string {
-  if (typeof v === "string") return v;
-  return arr(v).map((b) => (isObj(b) && b["type"] === "text" ? str(b["text"]) ?? "" : "")).filter(Boolean).join("\n");
-}
-
-/** Tolerant token reader: Anthropic/claude `input_tokens`/`output_tokens`/`cache_read_input_tokens`/
- *  `cache_creation_input_tokens` + `total_cost_usd`; codex `input_tokens`/`cached_input_tokens`/
- *  `output_tokens`; opencode `input`/`output`/`cache.read`/`cache.write` + `cost`; agy `usage`/`stats`
- *  shapes. undefined when nothing token-like is present. */
-export function usageFrom(v: unknown, costHolder?: unknown): TokenUsage | undefined {
-  const u = obj(v);
-  if (!u) return undefined;
-  const input = num(u["input_tokens"]) ?? num(u["prompt_tokens"]) ?? num(u["input"]);
-  const output = num(u["output_tokens"]) ?? num(u["completion_tokens"]) ?? num(u["output"]);
-  if (input === undefined && output === undefined) return undefined;
-  const cache = obj(u["cache"]);
-  const cacheRead = num(u["cache_read_input_tokens"]) ?? num(u["cached_input_tokens"]) ?? num(cache?.["read"]);
-  const cacheWrite = num(u["cache_creation_input_tokens"]) ?? num(cache?.["write"]);
-  const c = obj(costHolder) ?? u;
-  const costUsd = num(c["total_cost_usd"]) ?? num(c["cost_usd"]) ?? num(c["cost"]);
-  const out: TokenUsage = { input: input ?? 0, output: output ?? 0 };
-  if (cacheRead !== undefined) out.cacheRead = cacheRead;
-  if (cacheWrite !== undefined) out.cacheWrite = cacheWrite;
-  if (costUsd !== undefined) out.costUsd = costUsd;
-  return out;
-}
-
-/** Sum two usages (opencode reports per message; the others once). */
-export function addUsage(a: TokenUsage | undefined, b: TokenUsage): TokenUsage {
-  if (!a) return { ...b };
-  const out: TokenUsage = { input: a.input + b.input, output: a.output + b.output };
-  const cr = (a.cacheRead ?? 0) + (b.cacheRead ?? 0), cw = (a.cacheWrite ?? 0) + (b.cacheWrite ?? 0);
-  if (a.cacheRead !== undefined || b.cacheRead !== undefined) out.cacheRead = cr;
-  if (a.cacheWrite !== undefined || b.cacheWrite !== undefined) out.cacheWrite = cw;
-  if (a.costUsd !== undefined || b.costUsd !== undefined) out.costUsd = (a.costUsd ?? 0) + (b.costUsd ?? 0);
-  return out;
-}
-
-/** One log line per event — the shape the log ring, the running preview and the board tail show. */
-export function renderEvent(ev: LaneEvent): string {
-  switch (ev.kind) {
-    case "log": return clip(ev.text, 200);
-    case "edit": return `${ev.op} ${ev.path}${ev.wrote === true ? " (ok)" : ""}`;
-    case "bash": {
-      const code = ev.exitCode !== undefined ? ` → exit ${ev.exitCode}` : "";
-      const out = ev.output ? ` · ${clip(ev.output, 80)}` : "";
-      return `$ ${clip(ev.command, 100)}${code}${out}`;
-    }
-    case "tool": return `tool ${ev.name}${ev.detail ? `: ${ev.detail}` : ""}`;
-    case "ask": return `ask: ${clip(ev.text, 160)}`;
-    case "progress": return `progress: ${clip(ev.text, 160)}`;
-    case "done": return `done: ${clip(ev.summary, 160) || "(no output)"}`;
-    case "fail": return `fail: ${clip(ev.error, 160) || "(no reason)"}`;
-    case "usage": {
-      const cost = ev.usage.costUsd !== undefined ? ` · $${ev.usage.costUsd.toFixed(4)}` : "";
-      return `usage: ${ev.usage.input} in · ${ev.usage.output} out${cost}`;
-    }
-  }
-}
-
-/** Which lane-event kind a tool name maps to — the one place the four CLIs' tool vocabularies meet. */
-export type ToolShape = "bash" | "write" | "edit" | "other";
-export function toolShape(name: string): ToolShape {
-  const n = name.toLowerCase();
-  if (/^(bash|shell|command|run_command|run_shell_command|execute)$/.test(n)) return "bash";
-  if (/^(write|write_file|create_file|notebookedit)$/.test(n)) return "write";
-  if (/^(edit|multiedit|edit_file|replace|str_replace|patch|apply_patch)$/.test(n)) return "edit";
-  return "other";
-}
-
-/** The path a tool's arguments name, under any of the four spellings ("?" when none). */
-export function toolPath(input: Obj | undefined): string {
-  return str(input?.["file_path"]) ?? str(input?.["filePath"]) ?? str(input?.["path"]) ?? str(input?.["file"]) ?? "?";
-}
-
-/** Tool-name → lane event for the file/shell tools every CLI has under some name.
- *
- *  `o.wrote` is the caller's promise that the CLI CONFIRMED the write (see types.ts LaneEvent): pass it
- *  only from a tool RESULT or a completed change, never from the call. `o.callId` is the CLI's own id for
- *  the call, which is what keeps lanes/progress.ts from counting one call twice when a CLI reports it
- *  at both its start and its end. */
-export function toolEvent(name: string, input: Obj | undefined, output?: string, exitCode?: number, o: { callId?: string; wrote?: true } = {}): LaneEvent {
-  const id = o.callId !== undefined && o.callId !== "" ? { callId: o.callId } : {};
-  const path = toolPath(input);
-  switch (toolShape(name)) {
-    case "bash": {
-      const ev: LaneEvent = { kind: "bash", command: str(input?.["command"]) ?? str(input?.["cmd"]) ?? "?", ...id };
-      if (output !== undefined) ev.output = output;
-      if (exitCode !== undefined) ev.exitCode = exitCode;
-      return ev;
-    }
-    case "write": return { kind: "edit", path, op: "write", ...id, ...(o.wrote ? { wrote: true } : {}) };
-    case "edit": return { kind: "edit", path, op: "edit", ...id, ...(o.wrote ? { wrote: true } : {}) };
-    default: return { kind: "tool", name, ...id, ...(output ? { detail: clip(output, 120) } : {}) };
-  }
-}

package/src/lanes/job.ts

@@ -1,142 +0,0 @@
-/** Lane JOB (#47): what core/tasks.ts TaskManager runs for a TaskInfo of kind "external" — the twin
- *  of orchestrator.ts runChild for an isolated child, with the CLI in place of agentLoop: create the
- *  lane's OWN worktree (createIsolation, detached, copy fallback in a non-git root), run the adapter's
- *  command there (lanes/runner.ts), report the log tail as the running preview (throttled, plus ONE
- *  trailing flush so a burst-then-silence CLI never leaves a stale tail on the board), then on `done`
- *  diff the worktree and merge the patch back into the parent tree exactly as isolated children do
- *  (orchestrator applyPatch; a cancelled/failed/timed-out lane's half-done edits never land), and
- *  always clean the worktree up. Two refusals BEFORE anything spawns: no isolation at all (kind "none"
- *  — the worktree AND the copy fallback failed, so the only dir left is the parent tree, where a
- *  cancelled CLI would leave half-done edits) fails the lane, and a cancel that landed while the
- *  worktree was being created ends it cancelled. Returns the SpawnResult shape TaskManager.finish()
- *  already consumes, plus the CLI's session id (resume) and the permission text the card showed. */
-
-import { applyPatch, createIsolation } from "../core/orchestrator.ts";
-import type { SpawnResult } from "../core/types.ts";
-import type { LaneSpawn } from "./process.ts";
-import { ADAPTERS, laneOptsFor, lanePermissions, type Env } from "./registry.ts";
-import { filesFromPatch, MAX_TRACKED_FILES, type LaneProgress } from "./progress.ts";
-import { runExternalLane } from "./runner.ts";
-import type { AdapterId } from "./types.ts";
-
-/** what core/tasks.ts needs from the lane layer, through one import */
-export { lanePermissions, laneRefusal } from "./registry.ts";
-export { isAdapterId, type AdapterId } from "./types.ts";
-
-export interface LaneJobDeps {
-  /** process seam; default bunLaneSpawn (tests: a fake process, never a real CLI) */
-  spawn?: LaneSpawn;
-  /** gate + option knobs; default process.env */
-  env?: Env;
-  /** SIGINT → kill grace override (tests) */
-  graceMs?: number;
-  /** wall-clock override (tests); default ROVECODE_LANE_TIMEOUT_MS / 15 min */
-  timeoutMs?: number;
-  /** isolation seam; default orchestrator createIsolation (tests: a slow stub, or one that yields kind "none") */
-  isolate?: typeof createIsolation;
-  /** silence before the waiting note (tests); default SILENT_MS */
-  silentMs?: number;
-  /** merge-back seam; default orchestrator applyPatch (tests: one that refuses, for the conflict case) */
-  apply?: typeof applyPatch;
-}
-
-/** a lane that has printed NOTHING for SILENT_MS gets a waiting note as its preview. Live finding
- *  2026-09-03: `opencode run --format json` prints no event while it retries an unreachable provider
- *  (its retries go to its own log file) — 170 s of EMPTY preview until the wall-clock cutter. */
-export const SILENT_MS = 30_000;
-const fmtMs = (ms: number): string => (ms >= 1_000 ? `${Math.round(ms / 1_000)}s` : `${ms}ms`);
-
-/** the patch's file list, capped the same way the live one is (progress.ts MAX_TRACKED_FILES) */
-function withMeasuredFiles(files: readonly string[]): Pick<LaneProgress, "filesWritten" | "filesWrittenTotal"> {
-  return { filesWritten: files.slice(0, MAX_TRACKED_FILES), filesWrittenTotal: files.length };
-}
-
-export interface LaneJobResult extends SpawnResult {
-  sessionId?: string;
-  permissions: string;
-  /** what the lane did: the CLI's own tool-call count and usage, with `filesWritten` MEASURED from the
-   *  worktree diff rather than taken from the stream (progress.ts rule 3) — absent on a refusal, because
-   *  nothing ran */
-  progress?: LaneProgress;
-  /** #82: the CLI's exit code as the runner saw it (null = the process had not exited when the reader gave up); absent on a refusal before any spawn */
-  exitCode?: number | null;
-  /** #82: the model flag the lane ran with (ROVECODE_LANE_<ID>_MODEL), when set */
-  model?: string;
-}
-
-/** running-preview updates are coalesced to at most one per PROGRESS_MS; a dropped event arms ONE trailing
- *  flush for the end of the window, cleared when the lane ends — no timer outlives the lane */
-export const PROGRESS_MS = 250;
-
-/** How a running lane reports itself. The preview is the log tail this has always sent; `progress` is what
- *  the lane has DONE so far (progress.ts) and is OPTIONAL to read — a caller written before the counters
- *  existed keeps working untouched, which is why the parameter was added rather than the callback replaced. */
-export type LaneProgressSink = (preview: string, progress?: LaneProgress) => void;
-
-export async function runLaneJob(
-  deps: LaneJobDeps, id: AdapterId, goal: string, rootDir: string, signal: AbortSignal,
-  onProgress: LaneProgressSink,
-): Promise<LaneJobResult> {
-  const adapter = ADAPTERS[id];
-  const env = deps.env ?? process.env;
-  const permissions = lanePermissions(id, env);
-  const refuse = (summary: string): LaneJobResult => ({ agent: id, ok: false, usage: { input: 0, output: 0 }, permissions, summary });
-  const iso = await (deps.isolate ?? createIsolation)(rootDir, { prefer: "worktree" });
-  let trailing: ReturnType<typeof setTimeout> | undefined, silent: ReturnType<typeof setTimeout> | undefined;
-  try {
-    // kind "none": the worktree AND the copy fallback failed, so iso.dir IS the parent tree — refuse; a
-    // `codex --sandbox workspace-write -C <live tree>` that gets cancelled would leave half-done edits there
-    if (iso.kind === "none") return refuse("isolation unavailable — an external lane never runs in the parent tree");
-    // cancelled while the worktree was being created: nothing spawns (finally removes the worktree)
-    if (signal.aborted) return refuse("cancelled before the lane started");
-    const opts = laneOptsFor(id, iso.dir, env, deps.timeoutMs !== undefined ? { timeoutMs: deps.timeoutMs } : {});
-    let last = 0, pending: readonly string[] | undefined, seen = false;
-    let latest: LaneProgress | undefined;
-    const flush = (tail: readonly string[]): void => { last = Date.now(); pending = undefined; onProgress(tail.join("\n"), latest); };
-    const silentMs = deps.silentMs ?? SILENT_MS;
-    silent = setTimeout(() => { if (!seen) onProgress(`no output from ${id} after ${fmtMs(silentMs)} — still waiting (lane timeout ${fmtMs(opts.timeoutMs)})`); }, silentMs);
-    const r = await runExternalLane(adapter, { goal }, opts, {
-      spawn: deps.spawn, signal, graceMs: deps.graceMs,
-      onEvent: (_ev, tail, progress) => {
-        seen = true;
-        latest = progress; // the newest counters ride the next flush, coalesced with the preview
-        const elapsed = Date.now() - last;
-        if (elapsed >= PROGRESS_MS) { flush(tail); return; }
-        pending = tail; // dropped: the trailing flush shows it once the window closes
-        if (trailing === undefined) trailing = setTimeout(() => { trailing = undefined; if (pending) flush(pending); }, PROGRESS_MS - elapsed);
-      },
-    });
-    const patch = await iso.diff();
-    const usage = r.usage ?? { input: 0, output: 0 };
-    // THE MEASURED FILE LIST: the diff is the tree, so it names what actually changed — a claude lane whose
-    // last write failed silently, and an agy lane that confirms nothing at all, both end up honest here.
-    const measured: LaneProgress = { ...r.progress, ...withMeasuredFiles(filesFromPatch(patch)) };
-    const base = { agent: id, usage, permissions, patch, exitCode: r.exitCode, ...(r.sessionId ? { sessionId: r.sessionId } : {}), ...(opts.model ? { model: opts.model } : {}) };
-    if (r.status !== "done") {
-      const tail = r.log.slice(-3).join("\n");
-      // progress.applied: false — this patch is returned for inspection and never merged back, so its
-      // measured files are real writes into a worktree the `finally` below is about to delete. The
-      // RESULT-level `applied` stays absent here on purpose: SpawnResult documents absent as "there was
-      // never a merge-back to attempt", which is exactly this case, and a cancelled child reports the
-      // same way. tasks.ts reads progress first, so the gate still closes.
-      return { ...base, progress: { ...measured, applied: false }, ok: false, summary: `${r.error ?? r.status}${tail ? `\nlast output: ${tail}` : ""}` };
-    }
-    let summary = r.summary || "(no output)";
-    if (patch.trim() === "" && adapter.emptyDiffNote) summary += `\nnote: ${adapter.emptyDiffNote}`;
-    if (iso.kind === "copy") summary += `\n[isolation: copy — ${rootDir} is not a git repo]`;
-    // the merge-back is the ONLY thing that makes these files true of the parent tree, and it can fail on
-    // a lane that otherwise succeeded (a concurrent task touched the same lines) — so the boolean goes into
-    // progress rather than only into the summary text, where no surface could read it
-    const applied = (deps.apply ?? applyPatch)(patch, rootDir);
-    if (!applied) summary += "\npatch-apply-failed";
-    // BOTH flags, from the ONE variable: `applied` on the result answers core/types.ts SpawnResult's
-    // question ("did the merge-back succeed", absent where none was attempted), `progress.applied`
-    // answers the surface's ("are these files in your tree", false for a lane that never merged back).
-    // They differ only for a lane that did not finish, and never contradict each other, because neither
-    // is computed twice — read the note on the non-done return for why that one carries only the second.
-    return { ...base, applied, progress: { ...measured, applied }, ok: true, summary: summary.slice(0, 4_000) };
-  } finally {
-    clearTimeout(trailing); clearTimeout(silent); // the result replaces the preview: no flush or note after the lane
-    await iso.cleanup();
-  }
-}