catherd-cli 0.2.1 → 1.1.0

package/src/core/codex-events.ts

@@ -1,49 +0,0 @@
-import type { Tokens } from "../types.ts";
-
-export interface CodexParse {
-  thread: string | null;
-  tokens: Tokens;
-  turnFailed: boolean;
-  failure: string | null;
-  limit: boolean;
-  cliTooOld: boolean;
-  lastEvent: string | null;
-}
-
-const LIMIT = /usage limit|rate limit reached|quota exceeded|try again later/i;
-const TOO_OLD = /not supported when using Codex with a ChatGPT account/i;
-
-export function parseCodexEvents(lines: string[]): CodexParse {
-  const p: CodexParse = {
-    thread: null,
-    tokens: { input: 0, cached: 0, output: 0 },
-    turnFailed: false,
-    failure: null,
-    limit: false,
-    cliTooOld: false,
-    lastEvent: null,
-  };
-  for (const line of lines) {
-    if (!line.trim().startsWith("{")) continue;
-    let e: Record<string, any>;
-    try {
-      e = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    p.lastEvent = e.item?.type ? `${e.type}/${e.item.type}` : e.type;
-    const msg: string = e.message ?? e.error?.message ?? e.item?.message ?? "";
-    if (TOO_OLD.test(msg)) p.cliTooOld = true;
-    if (e.type === "thread.started") p.thread = e.thread_id ?? null;
-    else if (e.type === "turn.completed" && e.usage) {
-      p.tokens.input += e.usage.input_tokens ?? 0;
-      p.tokens.cached += e.usage.cached_input_tokens ?? 0;
-      p.tokens.output += e.usage.output_tokens ?? 0;
-    } else if (e.type === "turn.failed") {
-      p.turnFailed = true;
-      p.failure = msg || "turn failed";
-      if (LIMIT.test(msg)) p.limit = true;
-    }
-  }
-  return p;
-}

package/src/core/codex.ts

@@ -1,166 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, symlinkSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { dataDir } from "../paths.ts";
-import {
-  ROLE_SANDBOX,
-  THREAD_HEAVY_INPUT,
-  splitRung,
-  type Role,
-  type RungId,
-  type RunRecord,
-  type RunStatus,
-} from "../types.ts";
-import { parseCodexEvents } from "./codex-events.ts";
-import { changedSince, parseReplyStatus, snapshotOwned } from "./reply.ts";
-import {
-  appendRunRecord,
-  clearLive,
-  type LiveMarker,
-  rolePaths,
-  rotateRound,
-  writeLive,
-} from "./runstore.ts";
-import { readLines, runChild } from "./spawn.ts";
-
-export interface DispatchOpts {
-  runDir: string;
-  name: string;
-  role: Role;
-  rung: RungId;
-  cwd: string;
-  thread?: string;
-  ownedFiles: string[];
-  isolated?: boolean;
-  idleSecs?: number;
-  onProgress?: (p: { secs: number; lastEvent: string | null }) => void;
-}
-
-export function userCodexHome(): string {
-  return process.env.CODEX_HOME || join(homedir(), ".codex");
-}
-
-/** Isolated runs only. `--ignore-user-config` alone still loads the global AGENTS.md, so the home goes too. */
-export function codexHome(): string {
-  const home = join(dataDir(), "codex-home");
-  mkdirSync(home, { recursive: true });
-  const auth = join(userCodexHome(), "auth.json");
-  const link = join(home, "auth.json");
-  if (!existsSync(link) && existsSync(auth)) symlinkSync(auth, link);
-  return home;
-}
-
-export function codexArgs(o: DispatchOpts, replyPath: string): string[] {
-  const { model, effort } = splitRung(o.rung);
-  const sandbox = ROLE_SANDBOX[o.role];
-  const common = [
-    ...(o.isolated ? ["--ignore-user-config"] : []),
-    "-m",
-    model,
-    "-c",
-    `model_reasoning_effort=${effort}`,
-    "--json",
-    "-o",
-    replyPath,
-  ];
-  return o.thread
-    ? ["exec", "resume", ...common, "-c", `sandbox_mode=${sandbox}`, o.thread, "-"]
-    : ["exec", ...common, "-s", sandbox, "-"];
-}
-
-function imagesFor(home: string, thread: string | null, since: number): string[] {
-  if (!thread) return [];
-  const dir = join(home, "generated_images", thread);
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir)
-    .filter((f) => /\.(png|webp|jpe?g)$/i.test(f))
-    .map((f) => join(dir, f))
-    .filter((f) => statSync(f).mtimeMs >= since - 1000)
-    .sort();
-}
-
-/** Builds and appends the record from the files a finished run left. `code` is null after a reconcile. */
-export function finalizeCodex(runDir: string, live: LiveMarker, code: number | null): RunRecord {
-  const p = rolePaths(runDir, live.name);
-  const ev = parseCodexEvents(readLines(p.jsonl));
-  const reply = existsSync(p.out) ? readFileSync(p.out, "utf8") : "";
-  const err = existsSync(p.err) ? readFileSync(p.err, "utf8") : "";
-  const status: RunStatus =
-    ev.cliTooOld || /not supported when using Codex with a ChatGPT account/i.test(err)
-      ? "cli-too-old"
-      : ev.limit
-        ? "limit"
-        : ev.turnFailed
-          ? "failed"
-          : code !== 0 && !reply.trim()
-            ? "failed"
-            : "ok";
-  const rs = parseReplyStatus(reply);
-  const started = Date.parse(live.startedAt);
-  const thread = ev.thread ?? live.thread;
-  const record: RunRecord = {
-    name: live.name,
-    role: live.role,
-    backend: "codex",
-    rung: live.rung,
-    thread,
-    status,
-    startedAt: live.startedAt,
-    secs: Math.round((Date.now() - started) / 1000),
-    pid: live.pid,
-    tokens: ev.tokens,
-    costUsd: null,
-    changedOwned: changedSince(live.cwd, new Map(Object.entries(live.before)), live.ownedFiles),
-    replyStatus: rs.status,
-    replyWhy: rs.why,
-    threadHeavy: ev.tokens.input > THREAD_HEAVY_INPUT,
-    isolated: live.isolated,
-    images: imagesFor(live.isolated ? codexHome() : userCodexHome(), thread, started),
-    error: status === "ok" ? null : (ev.failure ?? (err.trim().split("\n").at(-1) || `exit ${code}`)),
-    replyPath: p.out,
-  };
-  appendRunRecord(runDir, record);
-  clearLive(runDir, live.name);
-  return record;
-}
-
-export async function runCodex(o: DispatchOpts): Promise<RunRecord> {
-  const p = rolePaths(o.runDir, o.name);
-  rotateRound(o.runDir, o.name);
-  const isolated = o.isolated ?? false;
-  const before = Object.fromEntries(snapshotOwned(o.cwd, o.ownedFiles));
-  const startedAt = new Date().toISOString();
-  let live: LiveMarker | null = null;
-  let lastEvent: string | null = null;
-  const res = await runChild("codex", codexArgs(o, p.out), {
-    cwd: o.cwd,
-    env: isolated ? { ...process.env, CODEX_HOME: codexHome() } : process.env,
-    stdinFile: o.thread ? p.fix : p.brief,
-    stdoutFile: p.jsonl,
-    stderrFile: p.err,
-    onSpawn: ({ pid }) => {
-      live = {
-        name: o.name,
-        role: o.role,
-        backend: "codex",
-        rung: o.rung,
-        pid,
-        thread: o.thread ?? null,
-        startedAt,
-        cwd: o.cwd,
-        ownedFiles: o.ownedFiles,
-        isolated,
-        before,
-      };
-      writeLive(o.runDir, live);
-    },
-    onLines: (lines) => {
-      lastEvent = parseCodexEvents(lines).lastEvent ?? lastEvent;
-    },
-    tickMs: Number(process.env.CATHERD_TICK_MS ?? 60_000),
-    onTick: () =>
-      o.onProgress?.({ secs: Math.round((Date.now() - Date.parse(startedAt)) / 1000), lastEvent }),
-  });
-  if (!live) throw new Error("catherd: codex did not start");
-  return finalizeCodex(o.runDir, live, res.code);
-}

package/src/core/harness.ts

@@ -1,89 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { RunRecord } from "../types.ts";
-import { appendJsonl, readJsonl, rolePaths } from "./runstore.ts";
-
-export interface HarnessRow {
-  at: string;
-  name: string;
-  backend: "codex" | "opencode";
-  isolated: boolean;
-  firstTurnInput: number;
-}
-
-export interface HarnessCost {
-  backend: "codex" | "opencode";
-  nativeRuns: number;
-  isolatedRuns: number;
-  nativeMedian: number | null;
-  isolatedMedian: number | null;
-  extraPerRun: number | null;
-}
-
-export function firstTurnInput(jsonlFile: string): number | null {
-  if (!existsSync(jsonlFile)) return null;
-  for (const line of readFileSync(jsonlFile, "utf8").split("\n")) {
-    if (!line.includes('"turn.completed"')) continue;
-    try {
-      return (JSON.parse(line) as { usage?: { input_tokens?: number } }).usage?.input_tokens ?? null;
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-
-export function recordHarness(runDir: string, r: RunRecord): void {
-  const n = firstTurnInput(rolePaths(runDir, r.name).jsonl);
-  // ponytail: opencode's stream has no token usage, so only Codex runs feed the estimate
-  if (n === null) return;
-  const row: HarnessRow = {
-    at: new Date().toISOString(),
-    name: r.name,
-    backend: r.backend,
-    isolated: r.isolated,
-    firstTurnInput: n,
-  };
-  appendJsonl(join(runDir, "harness.jsonl"), row);
-}
-
-function median(xs: number[]): number | null {
-  if (xs.length === 0) return null;
-  const s = [...xs].sort((a, b) => a - b);
-  const m = s.length >> 1;
-  return s.length % 2 ? (s[m] as number) : Math.round(((s[m - 1] as number) + (s[m] as number)) / 2);
-}
-
-export function harnessCosts(runDirs: string[]): HarnessCost[] {
-  const rows = runDirs.flatMap((d) => readJsonl<HarnessRow>(join(d, "harness.jsonl")));
-  return (["codex", "opencode"] as const).flatMap((backend) => {
-    const native = rows.filter((r) => r.backend === backend && !r.isolated).map((r) => r.firstTurnInput);
-    const isolated = rows.filter((r) => r.backend === backend && r.isolated).map((r) => r.firstTurnInput);
-    if (native.length === 0 && isolated.length === 0) return [];
-    const n = median(native);
-    const i = median(isolated);
-    return [
-      {
-        backend,
-        nativeRuns: native.length,
-        isolatedRuns: isolated.length,
-        nativeMedian: n,
-        isolatedMedian: i,
-        extraPerRun: n !== null && i !== null ? n - i : null,
-      },
-    ];
-  });
-}
-
-const k = (n: number) => `~${Math.round(n / 1000)}k`;
-const runs = (n: number) => `${n} run${n === 1 ? "" : "s"}`;
-
-export function formatHarness(h: HarnessCost): string {
-  if (h.extraPerRun !== null && h.nativeMedian !== null && h.isolatedMedian !== null) {
-    return `your ${h.backend} customizations add ${k(h.extraPerRun)} input tokens per run (first turn: native ${k(h.nativeMedian)} over ${runs(h.nativeRuns)}, isolated ${k(h.isolatedMedian)} over ${runs(h.isolatedRuns)})`;
-  }
-  const native = h.nativeMedian !== null;
-  const med = (native ? h.nativeMedian : h.isolatedMedian) as number;
-  const n = native ? h.nativeRuns : h.isolatedRuns;
-  return `${h.backend} ${native ? "native" : "isolated"}: median first-turn input ${k(med)} tokens over ${runs(n)}; no ${native ? "isolated" : "native"} runs to compare`;
-}

package/src/core/lanes.ts

@@ -1,67 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { Difficulty, Kind, Role, RungId } from "../types.ts";
-import { appendJsonl, readJsonl } from "./runstore.ts";
-
-/** Ids of runs, roles and lanes end up in file names, so they never hold a separator or start with a dot. */
-export const ID = /^[A-Za-z0-9][\w.-]*$/;
-
-export function ownedFilesOf(laneText: string): string[] {
-  for (const line of laneText.split("\n")) {
-    const m = /^\s*[*_]*owns[*_]*\s*:[*_]*\s*(.*)$/i.exec(line);
-    if (m) {
-      return (m[1] ?? "")
-        .split(",")
-        .map((s) => s.trim().replace(/^`+|`+$/g, ""))
-        .filter(Boolean);
-    }
-  }
-  return [];
-}
-
-export function fastCheckOf(laneText: string): string | null {
-  for (const line of laneText.split("\n")) {
-    const m = /^\s*[*_]*fast check[*_]*\s*:[*_]*\s*(.*)$/i.exec(line);
-    if (m) return (m[1] ?? "").trim().replace(/^`+|`+$/g, "") || null;
-  }
-  return null;
-}
-
-export function readLane(runDir: string, lane: string): string {
-  if (!ID.test(lane)) throw new Error(`catherd: bad lane id "${lane}"`);
-  const file = join(runDir, "lanes", `${lane}.md`);
-  if (!existsSync(file))
-    throw new Error(`catherd: no lane file lanes/${lane}.md; write it with write_run_file first`);
-  return readFileSync(file, "utf8");
-}
-
-export const CLIMB_REASONS = [
-  "check-failed-twice",
-  "blocker",
-  "same-defect",
-  "refused",
-  "blocked",
-  "unchanged",
-] as const;
-export type ClimbReason = (typeof CLIMB_REASONS)[number];
-
-export interface LaneRoute {
-  at: string;
-  lane: string;
-  role: Role;
-  rung: RungId;
-  ladder: RungId[];
-  source: "route" | "climb";
-  from: RungId | null;
-  reason: string | null;
-  kind: Kind | null;
-  difficulty: Difficulty | null;
-  jev: "jev" | "default";
-}
-
-const routesFile = (runDir: string) => join(runDir, "routes.jsonl");
-
-export const appendRoute = (runDir: string, r: LaneRoute): void => appendJsonl(routesFile(runDir), r);
-export const readRoutes = (runDir: string): LaneRoute[] => readJsonl<LaneRoute>(routesFile(runDir));
-export const currentRoute = (runDir: string, lane: string): LaneRoute | undefined =>
-  readRoutes(runDir).findLast((r) => r.lane === lane);

package/src/core/lock.ts

@@ -1,111 +0,0 @@
-import { closeSync, mkdirSync, openSync, readFileSync, rmSync, writeSync } from "node:fs";
-import { availableParallelism } from "node:os";
-import { join } from "node:path";
-import { defineCommand } from "citty";
-import { dataDir } from "../paths.ts";
-import { loadProfile } from "../profile/profile.ts";
-
-/** Kept for interface parity across plans; reclaim here is immediate (pid liveness), not a stale-mtime window. */
-export const LOCK_STALE_MS = 5_000;
-
-export function heavySlots(setting: number | "cpus/2" | undefined): number {
-  if (typeof setting === "number") return Math.max(1, Math.floor(setting));
-  return Math.max(1, Math.floor(availableParallelism() / 2));
-}
-
-/** --slots, then CATHERD_LOCK_SLOTS, then the active profile's lock.heavy, then half the cores. */
-export function resolveSlots(flag?: string): number {
-  const raw = flag ?? process.env.CATHERD_LOCK_SLOTS;
-  if (raw) {
-    if (raw === "cpus/2") return heavySlots("cpus/2");
-    const n = Number(raw);
-    if (!Number.isFinite(n)) throw new Error(`catherd lock: slots must be a number or cpus/2, got "${raw}"`);
-    return heavySlots(n);
-  }
-  try {
-    return heavySlots(loadProfile().lock.heavy);
-  } catch (e) {
-    console.error(`catherd lock: ${(e as Error).message}; using half the CPU cores`);
-    return heavySlots("cpus/2");
-  }
-}
-
-function pidAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (e) {
-    return (e as NodeJS.ErrnoException).code === "EPERM";
-  }
-}
-
-/** Exclusive create (`wx`): fails EEXIST when another process already holds the slot. A held slot
- * whose pid is dead is reclaimed by removing the file and retrying, with no mtime bookkeeping. */
-function tryTake(file: string, label: string): boolean {
-  try {
-    const fd = openSync(file, "wx");
-    writeSync(fd, JSON.stringify({ pid: process.pid, label }));
-    closeSync(fd);
-    return true;
-  } catch (e) {
-    if ((e as NodeJS.ErrnoException).code !== "EEXIST") throw e;
-    try {
-      const { pid } = JSON.parse(readFileSync(file, "utf8")) as { pid: number };
-      if (!pidAlive(pid)) {
-        rmSync(file, { force: true });
-        return tryTake(file, label);
-      }
-    } catch {
-      // corrupt or mid-write: leave it for its holder, try again on the next poll
-    }
-    return false;
-  }
-}
-
-export async function acquire(
-  slots: number,
-  label: string,
-  pollMs = 2000,
-): Promise<{ slot: number; release: () => Promise<void> }> {
-  const dir = join(dataDir(), "locks");
-  mkdirSync(dir, { recursive: true });
-  for (;;) {
-    for (let i = 0; i < slots; i++) {
-      const file = join(dir, `slot-${i}`);
-      if (!tryTake(file, label)) continue;
-      return {
-        slot: i,
-        release: async () => {
-          rmSync(file, { force: true });
-        },
-      };
-    }
-    await new Promise((r) => setTimeout(r, pollMs));
-  }
-}
-
-export const lockCommand = defineCommand({
-  meta: { name: "lock", description: "Run a heavy command behind the machine-wide semaphore" },
-  args: {
-    slots: { type: "string", description: "Slots (default: CATHERD_LOCK_SLOTS, else half the CPU cores)" },
-  },
-  async run({ args, rawArgs }) {
-    const sep = rawArgs.indexOf("--");
-    const [cmd, ...rest] = sep < 0 ? [] : rawArgs.slice(sep + 1);
-    if (!cmd) {
-      console.error("usage: catherd lock [--slots N] -- <command> [args...]");
-      process.exitCode = 2;
-      return;
-    }
-    const held = await acquire(resolveSlots(args.slots), cmd);
-    try {
-      const proc = Bun.spawn([cmd, ...rest], { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
-      process.exitCode = await proc.exited;
-    } catch (e) {
-      console.error(`catherd lock: ${(e as Error).message}`);
-      process.exitCode = 1;
-    } finally {
-      await held.release();
-    }
-  },
-});

package/src/core/opencode.ts

@@ -1,207 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { dataDir } from "../paths.ts";
-import { ROLE_SANDBOX, splitRung, type RunRecord, type RunStatus } from "../types.ts";
-import type { DispatchOpts } from "./codex.ts";
-import { changedSince, parseReplyStatus, snapshotOwned } from "./reply.ts";
-import {
-  appendRunRecord,
-  clearLive,
-  type LiveMarker,
-  rolePaths,
-  rotateRound,
-  writeLive,
-} from "./runstore.ts";
-import { readLines, runChild } from "./spawn.ts";
-
-/** An empty config home for isolated runs; opencode's credentials and session db live in its data dir, which stays. */
-export function opencodeConfigHome(): string {
-  const dir = join(dataDir(), "opencode-home", "config");
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-export function opencodeArgs(o: DispatchOpts, brief: string): string[] {
-  const { model, effort } = splitRung(o.rung);
-  const spec = effort === "default" ? model : `${model}#${effort}`;
-  const sandbox = ROLE_SANDBOX[o.role];
-  const mode =
-    sandbox === "read-only"
-      ? ["--agent", "explore", "--auto"]
-      : sandbox === "danger-full-access"
-        ? ["--auto"]
-        : [];
-  // The background service resolves config, so only a private server sees the isolated XDG_CONFIG_HOME.
-  const server = o.isolated ? ["--standalone"] : [];
-  return [
-    "run",
-    ...server,
-    "--format",
-    "json",
-    "-m",
-    spec,
-    ...mode,
-    ...(o.thread ? ["-s", o.thread] : []),
-    brief,
-  ];
-}
-
-function api(cwd: string, ...a: string[]): string {
-  // env must be explicit: Bun's default env is a snapshot from when this process launched, not
-  // the current process.env, so a runtime PATH/FAKE_* override would otherwise be invisible here.
-  const proc = Bun.spawnSync(["opencode", "api", ...a], { cwd, env: process.env, stdout: "pipe" });
-  return proc.stdout?.toString("utf8") ?? "";
-}
-
-/** Verified live on opencode 2.0.15: no "status":"running" field exists. `.data` is newest-first;
- * the session is idle iff the newest entry has `type: "idle"`, and busy otherwise (an in-flight
- * assistant message, still streaming a tool). */
-function sessionBusy(cwd: string, session: string): boolean {
-  try {
-    const res = JSON.parse(api(cwd, "GET", `/api/session/${session}/message`) || "{}");
-    return res?.data?.[0]?.type !== "idle";
-  } catch {
-    return false;
-  }
-}
-
-function parse(lines: string[]) {
-  let session: string | null = null;
-  const texts: string[] = [];
-  const errors: string[] = [];
-  for (const l of lines) {
-    let e: Record<string, any>;
-    try {
-      e = JSON.parse(l);
-    } catch {
-      continue;
-    }
-    session ??= e.sessionID ?? null;
-    if (e.type === "text" && e.part?.text) texts.push(e.part.text);
-    if (e.type === "error") errors.push(e.error?.message ?? "error");
-  }
-  return { session, texts, errors };
-}
-
-export function finalizeOpencode(
-  runDir: string,
-  live: LiveMarker,
-  code: number | null,
-  timedOut = false,
-): RunRecord {
-  const p = rolePaths(runDir, live.name);
-  const ev = parse(readLines(p.jsonl));
-  const session = ev.session ?? live.thread;
-  const reply = ev.texts.join("\n");
-  writeFileSync(p.out, reply);
-  let cost = 0;
-  if (session) {
-    try {
-      cost = Number(JSON.parse(api(live.cwd, "GET", `/api/session/${session}`) || "{}")?.data?.cost ?? 0);
-    } catch {
-      cost = 0;
-    }
-  }
-  const status: RunStatus = timedOut
-    ? "timeout"
-    : ev.errors.length
-      ? "failed"
-      : code !== 0 && !reply
-        ? "failed"
-        : "ok";
-  const rs = parseReplyStatus(reply);
-  const record: RunRecord = {
-    name: live.name,
-    role: live.role,
-    backend: "opencode",
-    rung: live.rung,
-    thread: session,
-    status,
-    startedAt: live.startedAt,
-    secs: Math.round((Date.now() - Date.parse(live.startedAt)) / 1000),
-    pid: live.pid,
-    tokens: { input: 0, cached: 0, output: 0 },
-    costUsd: cost,
-    changedOwned: changedSince(live.cwd, new Map(Object.entries(live.before)), live.ownedFiles),
-    replyStatus: rs.status,
-    replyWhy: rs.why,
-    threadHeavy: false,
-    isolated: live.isolated,
-    images: [],
-    error:
-      status === "ok"
-        ? null
-        : timedOut
-          ? "no event within the idle limit and not busy"
-          : (ev.errors.at(-1) ?? `exit ${code}`),
-    replyPath: p.out,
-  };
-  appendRunRecord(runDir, record);
-  clearLive(runDir, live.name);
-  return record;
-}
-
-export async function runOpencode(o: DispatchOpts): Promise<RunRecord> {
-  const p = rolePaths(o.runDir, o.name);
-  rotateRound(o.runDir, o.name);
-  const brief = readFileSync(o.thread ? p.fix : p.brief, "utf8");
-  const isolated = o.isolated ?? false;
-  const before = Object.fromEntries(snapshotOwned(o.cwd, o.ownedFiles));
-  const startedAt = new Date().toISOString();
-  const idleMs = (o.idleSecs ?? 600) * 1000;
-  let session: string | null = o.thread ?? null;
-  let lastEventAt = Date.now();
-  let timedOut = false;
-  let kill: (() => void) | null = null;
-  let live: LiveMarker | null = null;
-
-  // A quiet session that the server says is not running a tool is stuck: interrupt it server-side
-  // (killing the client alone leaves it running and editing files), then stop the client.
-  const watchdog = setInterval(
-    () => {
-      if (Date.now() - lastEventAt < idleMs) return;
-      if (session && sessionBusy(o.cwd, session)) {
-        lastEventAt = Date.now();
-        return;
-      }
-      timedOut = true;
-      if (session) api(o.cwd, "POST", `/api/session/${session}/interrupt`);
-      kill?.();
-    },
-    Math.min(1000, idleMs),
-  );
-
-  const res = await runChild("opencode", opencodeArgs(o, brief), {
-    cwd: o.cwd,
-    env: isolated ? { ...process.env, XDG_CONFIG_HOME: opencodeConfigHome() } : process.env,
-    stdoutFile: p.jsonl,
-    stderrFile: p.err,
-    pollMs: 250,
-    onSpawn: ({ pid, kill: k }) => {
-      kill = k;
-      live = {
-        name: o.name,
-        role: o.role,
-        backend: "opencode",
-        rung: o.rung,
-        pid,
-        thread: o.thread ?? null,
-        startedAt,
-        cwd: o.cwd,
-        ownedFiles: o.ownedFiles,
-        isolated,
-        before,
-      };
-      writeLive(o.runDir, live);
-    },
-    onLines: (lines) => {
-      lastEventAt = Date.now();
-      session ??= parse(lines).session;
-    },
-    tickMs: Number(process.env.CATHERD_TICK_MS ?? 60_000),
-    onTick: () =>
-      o.onProgress?.({ secs: Math.round((Date.now() - Date.parse(startedAt)) / 1000), lastEvent: null }),
-  }).finally(() => clearInterval(watchdog));
-  if (!live) throw new Error("catherd: opencode did not start");
-  return finalizeOpencode(o.runDir, live, res.code, timedOut);
-}