@algosuite/vo-mcp 0.2.0-beta.1 → 0.2.0-beta.4

package/dist/runner-cli.js

@@ -155,12 +155,65 @@ import fs from "node:fs";
 function repoRoot() {
   return process.env.VO_CODE_RUNNER_REPO || process.cwd();
 }
+function clonesRoot() {
+  return process.env.VO_CODE_RUNNER_CLONES_ROOT || "";
+}
+var VALID_REPO_SLUG = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+var TRACKED_WORKTREES = /* @__PURE__ */ new Map();
 function sanitize(value, fallback) {
   const cleaned = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return cleaned || fallback;
 }
+function cloneDirForSlug(repoSlug, clonesRootDir) {
+  if (!clonesRootDir || !repoSlug || !VALID_REPO_SLUG.test(String(repoSlug))) return null;
+  const [owner, name] = String(repoSlug).split("/");
+  if (owner === "." || owner === ".." || name === "." || name === "..") return null;
+  if (owner.startsWith("-") || name.startsWith("-")) return null;
+  return path.join(clonesRootDir, `${sanitize(owner, "owner")}__${sanitize(name, "repo")}`);
+}
+function resolveTaskRoot(repoSlug) {
+  const root = clonesRoot();
+  if (root && !path.isAbsolute(root)) {
+    throw new Error(
+      `[vo-mcp runner] VO_CODE_RUNNER_CLONES_ROOT must be an absolute path (got '${root}')`
+    );
+  }
+  const dir = cloneDirForSlug(repoSlug, root);
+  if (!dir) return { root: repoRoot(), multiRepo: false };
+  if (!fs.existsSync(path.join(dir, ".git"))) {
+    fs.mkdirSync(clonesRoot(), { recursive: true });
+    const [owner, name] = String(repoSlug).split("/");
+    const tmpDir = `${dir}.tmp-${process.pid}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+    const cl = spawnSync(
+      "git",
+      ["clone", "--no-tags", `https://github.com/${owner}/${name}.git`, tmpDir],
+      { encoding: "utf8", timeout: 6e5 }
+    );
+    if (cl.status !== 0 || !fs.existsSync(path.join(tmpDir, ".git"))) {
+      try {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+      throw new Error(
+        `[vo-mcp runner] clone failed for ${repoSlug}: ${String(cl.stderr || cl.error || "").slice(0, 200)}`
+      );
+    }
+    try {
+      fs.renameSync(tmpDir, dir);
+    } catch {
+      try {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+      if (!fs.existsSync(path.join(dir, ".git"))) {
+        throw new Error(`[vo-mcp runner] clone race left no usable clone for ${repoSlug}`);
+      }
+    }
+  }
+  return { root: dir, multiRepo: true };
+}
 function createFixWorktree(kind, error = {}) {
-  const root = repoRoot();
+  const { root, multiRepo } = resolveTaskRoot(error.repo);
   const safeKind = sanitize(kind, "task");
   const safeTarget = sanitize(error.source || error.tester || "run", "run").slice(0, 24);
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -174,18 +227,56 @@ function createFixWorktree(kind, error = {}) {
     { cwd: root, encoding: "utf8", timeout: 12e4 }
   );
   if (add.status === 0 && fs.existsSync(worktreeDir)) {
+    TRACKED_WORKTREES.set(worktreeName, { worktreeDir, root });
     return { worktreeDir, worktreeName };
   }
-  console.error(
-    `[vo-mcp runner] worktree isolation unavailable: ${String(add.stderr || add.error || "").slice(0, 200)}`
-  );
+  const detail = String(add.stderr || add.error || "").slice(0, 200);
+  if (multiRepo) {
+    throw new Error(`[vo-mcp runner] worktree create failed for ${error.repo}: ${detail}`);
+  }
+  console.error(`[vo-mcp runner] worktree isolation unavailable: ${detail}`);
   return { worktreeDir: root, worktreeName: "" };
 }
 function cleanupFixWorktree(worktreeName) {
   if (!worktreeName) return;
-  const root = repoRoot();
-  const worktreeDir = path.join(root, ".agent-worktrees", worktreeName);
+  const tracked = TRACKED_WORKTREES.get(worktreeName);
+  const root = tracked ? tracked.root : repoRoot();
+  const worktreeDir = tracked ? tracked.worktreeDir : path.join(root, ".agent-worktrees", worktreeName);
   spawnSync("git", ["worktree", "remove", "--force", worktreeDir], { cwd: root, timeout: 12e4 });
+  TRACKED_WORKTREES.delete(worktreeName);
+}
+function finalizeWorktree(worktreeName, meta = {}) {
+  if (!worktreeName) return;
+  if (meta.preserveReason) {
+    preserveFailedWorktree(worktreeName, { ...meta, reason: meta.preserveReason });
+  } else {
+    cleanupFixWorktree(worktreeName);
+  }
+}
+function preserveFailedWorktree(worktreeName, meta = {}) {
+  if (!worktreeName) return null;
+  const tracked = TRACKED_WORKTREES.get(worktreeName);
+  const root = tracked ? tracked.root : repoRoot();
+  const worktreeDir = tracked ? tracked.worktreeDir : path.join(root, ".agent-worktrees", worktreeName);
+  const entry = {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    worktreeName,
+    worktreeDir,
+    branch: meta.branch || `vo/${worktreeName}`,
+    taskId: meta.taskId || null,
+    repo: meta.repo || null,
+    prompt: String(meta.prompt || "").slice(0, 300),
+    reason: String(meta.reason || "task failed").slice(0, 300)
+  };
+  try {
+    const ledger = path.join(root, ".agent-worktrees", "recovery-ledger.jsonl");
+    fs.mkdirSync(path.dirname(ledger), { recursive: true });
+    fs.appendFileSync(ledger, JSON.stringify(entry) + "\n", "utf8");
+    console.error(`[vo-mcp runner] Preserved worktree ${worktreeName} (reason: ${entry.reason})`);
+  } catch (err) {
+    console.error(`[vo-mcp runner] Failed to write recovery ledger: ${err.message}`);
+  }
+  return entry;
 }
 
 // src/runner/spend-cap-shim.mjs
@@ -324,6 +415,57 @@ function createControlPlaneClient({
       if (!res.ok) throw new Error(`weekly-tokens failed: HTTP ${res.status}`);
       return true;
     },
+    /**
+     * Send a liveness heartbeat (M2). The control-plane upserts it under the
+     * authenticated operator so the web shows a TRUE "runner online" signal.
+     * Best-effort caller; throws on 401/non-ok so the daemon can log + retry.
+     */
+    async postHeartbeat({ runnerId, operatorId, uptimeSec, activeTasks, version, servedRepos, servedOperators }) {
+      const body = { runner_id: runnerId };
+      if (operatorId) body.operator_id = operatorId;
+      if (typeof uptimeSec === "number") body.uptime_sec = uptimeSec;
+      if (typeof activeTasks === "number") body.active_tasks = activeTasks;
+      if (version) body.version = version;
+      if (Array.isArray(servedRepos) && servedRepos.length > 0) body.served_repos = servedRepos;
+      if (Array.isArray(servedOperators) && servedOperators.length > 0) {
+        body.served_operator_ids = servedOperators;
+      }
+      const res = await req("POST", "/api/v1/runner/heartbeat", body);
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("heartbeat unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`heartbeat failed: HTTP ${res.status}`);
+      return true;
+    },
+    /**
+     * Mint a short-lived (~1h), repo-scoped GitHub App installation token for
+     * THIS runner's operator (M3). The control-plane keys the mint on the
+     * authenticated operator (ctx.operator_id), so the token covers only that
+     * operator's installation.
+     *
+     * Returns { token, expiresAt } on success, or `null` on ANY non-success —
+     * 503 (App not configured / dormant), 404 (operator has no installation),
+     * other non-2xx, or a network error. `null` is the signal to the caller to
+     * fall back to the runner's own ambient `gh` auth, so a dormant or
+     * unmapped App NEVER blocks a PR the runner could open itself. Never throws.
+     *
+     * The minted token is only usable for push + PR if the GitHub App grants
+     * BOTH `Contents: write` (git push) AND `Pull requests: write` (gh pr
+     * create) — see docs/vo/github-app-setup-2026-06-18.md. A token missing
+     * either scope fails at push (→ ambient fallback) or at `gh pr create`.
+     */
+    async getInstallationToken() {
+      try {
+        const res = await req("POST", "/api/v1/github/installation-token", {});
+        if (!res.ok) return null;
+        const json = await res.json();
+        if (!json || !json.token) return null;
+        return { token: json.token, expiresAt: json.expires_at || null };
+      } catch {
+        return null;
+      }
+    },
     /**
      * Read the operator's dispatch-mode config (Fast→Ultracode effort setting).
      * Returns the mode string ('fast'|'standard'|'deep'|'ultra'|'ultracode'),
@@ -344,7 +486,152 @@ function createControlPlaneClient({
 
 // ../../scripts/virtual-office/code-runner/claude-runner.mjs
 import { spawn } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
+
+// ../../scripts/virtual-office/code-runner/anthropic-key-store.mjs
+import { createRequire as createRequire2 } from "node:module";
 import { spawnSync as spawnSync2 } from "node:child_process";
+var require2 = createRequire2(import.meta.url);
+var KEY_SERVICE = "algosuite-vo";
+var KEY_ACCOUNT = "anthropic-api-key";
+var _entryCtor;
+var _loadTried = false;
+function defaultEntryCtor() {
+  if (_loadTried) return _entryCtor;
+  _loadTried = true;
+  try {
+    _entryCtor = require2("@napi-rs/keyring").Entry;
+  } catch {
+    _entryCtor = null;
+  }
+  return _entryCtor;
+}
+function getAnthropicKey({ EntryCtor = defaultEntryCtor() } = {}) {
+  if (!EntryCtor) return null;
+  try {
+    return new EntryCtor(KEY_SERVICE, KEY_ACCOUNT).getPassword() || null;
+  } catch {
+    return null;
+  }
+}
+var PREFER_LOGIN_ENV = "VO_RUNNER_PREFER_LOGIN";
+function isTruthyFlag(v) {
+  const s = String(v ?? "").trim().toLowerCase();
+  return s === "1" || s === "true" || s === "yes" || s === "on";
+}
+function withAnthropicKey(baseEnv = {}, { getKey = getAnthropicKey } = {}) {
+  if (isTruthyFlag(baseEnv[PREFER_LOGIN_ENV])) {
+    const next = { ...baseEnv };
+    delete next.ANTHROPIC_API_KEY;
+    return next;
+  }
+  if (baseEnv.ANTHROPIC_API_KEY) return { ...baseEnv };
+  const key = getKey();
+  return key ? { ...baseEnv, ANTHROPIC_API_KEY: key } : { ...baseEnv };
+}
+function describeAnthropicAuthSource(baseEnv = {}, { getKey = getAnthropicKey } = {}) {
+  if (isTruthyFlag(baseEnv[PREFER_LOGIN_ENV])) {
+    return "claude auth login (VO_RUNNER_PREFER_LOGIN set \u2014 any API key ignored)";
+  }
+  if (baseEnv.ANTHROPIC_API_KEY) return "ANTHROPIC_API_KEY from environment";
+  if (getKey()) return "ANTHROPIC_API_KEY from OS keychain";
+  return "claude auth login session (no API key set)";
+}
+var AUTH_ERROR_RE = /\b401\b|invalid[^.]{0,24}(authentication|credential)|authentication_error|unauthorized|not[ _-]?authenticated/i;
+function augmentAuthError(summary) {
+  const s = String(summary ?? "");
+  if (!AUTH_ERROR_RE.test(s)) return s;
+  return `${s}
+\u21B3 Anthropic auth failed on the runner. The \`claude\` CLI is a SEPARATE install/login from the Claude Desktop app and the Claude Code IDE extension \u2014 signing into those does NOT authenticate it. Fix: run \`claude auth login\` (Claude subscription) on the runner machine, or clear any stale ANTHROPIC_API_KEY (env / OS keychain / .env.local) and set VO_RUNNER_PREFER_LOGIN=1 \u2014 then restart the runner. Verify with \`claude -p "say hi"\`.`;
+}
+function probeClaudeLoginState({ spawn: spawn2 = spawnSync2 } = {}) {
+  try {
+    const st = spawn2("claude", ["auth", "status"], {
+      shell: process.platform === "win32",
+      windowsHide: true,
+      timeout: 5e3,
+      encoding: "utf8"
+    });
+    const parsed = JSON.parse(String(st.stdout || "").trim() || "{}");
+    return typeof parsed.loggedIn === "boolean" ? parsed.loggedIn : null;
+  } catch {
+    return null;
+  }
+}
+
+// ../../scripts/virtual-office/code-runner/sandbox/sandbox-docker.mjs
+import { spawnSync as spawnSync3 } from "node:child_process";
+var DEFAULT_SANDBOX_IMAGE = "vo-agent-sandbox";
+function buildDockerArgs({
+  worktreeDir,
+  image = DEFAULT_SANDBOX_IMAGE,
+  agentBin = "claude",
+  agentArgs = [],
+  passEnv = ["ANTHROPIC_API_KEY"],
+  network = "bridge",
+  memory = "4g",
+  cpus = "2",
+  pids = "512",
+  user,
+  shadowGit = true,
+  readOnlyWork = false,
+  extraDockerArgs = []
+} = {}) {
+  if (!worktreeDir) throw new Error("buildDockerArgs: worktreeDir is required");
+  const args = [
+    "run",
+    "--rm",
+    "-i",
+    // keep stdin open so the runner can feed the prompt (injection-safe)
+    "--network",
+    String(network),
+    "--cap-drop",
+    "ALL",
+    "--security-opt",
+    "no-new-privileges",
+    "--memory",
+    String(memory),
+    "--cpus",
+    String(cpus),
+    "--pids-limit",
+    String(pids),
+    // Read-only root + tmpfs scratch: the ONLY persistent writable path is the
+    // host-backed /work mount, so the agent can't tamper with the image or
+    // stash anything off-worktree.
+    "--read-only",
+    "--tmpfs",
+    "/tmp:rw,nosuid,nodev",
+    "-e",
+    "HOME=/tmp/agent-home"
+  ];
+  if (shadowGit) args.push("--tmpfs", "/work/.git:rw,nosuid,nodev,size=2m");
+  if (user) args.push("--user", String(user));
+  for (const k of passEnv) {
+    if (k && /^[A-Z_][A-Z0-9_]*$/i.test(k)) args.push("-e", k);
+  }
+  args.push("-v", `${worktreeDir}:/work${readOnlyWork ? ":ro" : ""}`, "-w", "/work");
+  args.push(...extraDockerArgs);
+  args.push(image, agentBin, ...agentArgs);
+  return args;
+}
+
+// ../../scripts/virtual-office/code-runner/context7-mcp.mjs
+var CONTEXT7_URL = "https://mcp.context7.com/mcp";
+function context7McpConfig(env2 = process.env) {
+  if (env2.VO_ENABLE_CONTEXT7 !== "1") return null;
+  const url = env2.VO_CONTEXT7_URL && env2.VO_CONTEXT7_URL.trim() || CONTEXT7_URL;
+  const server = { type: "http", url };
+  if (env2.CONTEXT7_API_KEY && env2.CONTEXT7_API_KEY.trim()) {
+    server.headers = { CONTEXT7_API_KEY: env2.CONTEXT7_API_KEY.trim() };
+  }
+  return { mcpServers: { context7: server } };
+}
+function context7McpArgs(env2 = process.env) {
+  const cfg = context7McpConfig(env2);
+  return cfg ? ["--mcp-config", JSON.stringify(cfg)] : [];
+}
+
+// ../../scripts/virtual-office/code-runner/claude-runner.mjs
 var DEFAULT_PERMISSION_MODE = "acceptEdits";
 function extractText(content) {
   if (typeof content === "string") return content.trim();
@@ -379,7 +666,7 @@ function parseStreamEvent(line) {
   }
   return null;
 }
-function buildClaudeArgs({ permissionMode = DEFAULT_PERMISSION_MODE, maxTurns, model } = {}) {
+function buildClaudeArgs({ permissionMode = DEFAULT_PERMISSION_MODE, maxTurns, model, env: env2 = process.env } = {}) {
   const args = [
     "-p",
     "--output-format",
@@ -394,12 +681,14 @@ function buildClaudeArgs({ permissionMode = DEFAULT_PERMISSION_MODE, maxTurns, m
   if (model) {
     args.push("--model", String(model));
   }
+  args.push(...context7McpArgs(env2));
   return args;
 }
-function runClaudeTask({
+function runAgentTask({
+  runner,
   prompt,
   cwd,
-  claudeBin = "claude",
+  bin = runner.binary,
   permissionMode,
   maxTurns,
   model,
@@ -409,19 +698,39 @@ function runClaudeTask({
   shouldCancel = async () => false,
   cancelPollMs = 5e3,
   maxWallClockMs = 0,
-  spawnImpl = spawn
+  spawnImpl = spawn,
+  sandbox = null
 }) {
-  return new Promise((resolve) => {
-    const args = buildClaudeArgs({ permissionMode, maxTurns, model });
-    const child = spawnImpl(claudeBin, args, {
+  return new Promise((resolve2) => {
+    const args = runner.buildArgs({ permissionMode, maxTurns, model, prompt });
+    const spawnEnv = typeof runner.applyAuthEnv === "function" ? runner.applyAuthEnv(env2) : env2;
+    if (typeof runner.describeAuth === "function") {
+      try {
+        console.error(`[runner] agent auth: ${runner.describeAuth(spawnEnv)}`);
+      } catch {
+      }
+    }
+    let spawnBin = bin;
+    let spawnArgs = args;
+    let spawnOpts = runner.getSpawnOptions({ bin: spawnBin });
+    if (sandbox && sandbox.mode === "docker") {
+      spawnArgs = buildDockerArgs({
+        worktreeDir: cwd,
+        image: sandbox.image,
+        agentBin: bin,
+        agentArgs: args,
+        network: sandbox.network,
+        user: sandbox.user,
+        ...sandbox.passEnv ? { passEnv: sandbox.passEnv } : {}
+      });
+      spawnBin = sandbox.dockerBin || "docker";
+      spawnOpts = { windowsHide: true };
+    }
+    const child = spawnImpl(spawnBin, spawnArgs, {
       cwd,
-      env: { ...env2 },
+      env: spawnEnv,
       stdio: ["pipe", "pipe", "pipe"],
-      // Windows: `claude` is a `.cmd` shim → spawn needs a shell to resolve it
-      // (without it: spawn ENOENT). Safe because the prompt goes via stdin
-      // below, never argv, so the shell never sees untrusted input.
-      shell: process.platform === "win32",
-      windowsHide: true
+      ...spawnOpts
     });
     try {
       child.stdin.write(String(prompt));
@@ -456,7 +765,7 @@ function runClaudeTask({
       while ((nl = buffer.indexOf("\n")) >= 0) {
         const line = buffer.slice(0, nl);
         buffer = buffer.slice(nl + 1);
-        const evt = parseStreamEvent(line);
+        const evt = runner.parseEvent(line);
         if (!evt) continue;
         if (evt.kind === "progress") {
           try {
@@ -480,7 +789,7 @@ function runClaudeTask({
     child.on("error", (err) => {
       clearInterval(poll);
       if (wallTimer) clearTimeout(wallTimer);
-      resolve({ ...result, ok: false, summary: `spawn error: ${err.message}` });
+      resolve2({ ...result, ok: false, summary: `spawn error: ${err.message}` });
     });
     const poll = setInterval(() => {
       Promise.resolve().then(() => shouldCancel()).then((cancel) => {
@@ -496,7 +805,7 @@ function runClaudeTask({
       clearInterval(poll);
       if (wallTimer) clearTimeout(wallTimer);
       if (timedOut) {
-        resolve({
+        resolve2({
           ...result,
           ok: false,
           timedOut: true,
@@ -505,13 +814,13 @@ function runClaudeTask({
         return;
       }
       if (killed) {
-        resolve({ ...result, ok: false, killed: true, summary: "cancelled by operator" });
+        resolve2({ ...result, ok: false, killed: true, summary: "cancelled by operator" });
         return;
       }
       if (!result.summary && code !== 0) {
-        result.summary = stderrTail.slice(-500) || `claude exited ${code}`;
+        result.summary = stderrTail.slice(-500) || `${bin} exited ${code}`;
       }
-      resolve({ ...result, ok: result.ok && code === 0 });
+      resolve2({ ...result, ok: result.ok && code === 0, summary: augmentAuthError(result.summary) });
     });
   });
 }
@@ -531,6 +840,18 @@ var ClaudeRunner = class {
       windowsHide: true
     };
   }
+  /**
+   * Fill ANTHROPIC_API_KEY from the OS keychain when not already set (M4 BYO),
+   * so a friend who ran `vo-mcp set-key` authenticates without an env var.
+   * Explicit env wins; no key stored → unchanged (Claude Code login as before).
+   */
+  applyAuthEnv(env2 = process.env) {
+    return withAnthropicKey(env2);
+  }
+  /** Describe which Anthropic auth source the spawn will use (for runner logs). */
+  describeAuth(env2 = process.env) {
+    return describeAnthropicAuthSource(env2);
+  }
   /**
    * Best-effort auth check: is `claude` on PATH and can we verify login?
    * Never throws. If we can't cheaply detect auth, we return installed:true
@@ -538,30 +859,34 @@ var ClaudeRunner = class {
    */
   async checkAuth() {
     try {
-      const { status, error } = spawnSync2("claude", ["--version"], {
+      const probe = spawnSync4("claude", ["--version"], {
         shell: process.platform === "win32",
         windowsHide: true,
         timeout: 3e3,
         stdio: "ignore"
       });
-      if (error) {
+      if (probe.error) {
         return {
           installed: false,
           authenticated: false,
-          message: `claude not found on PATH: ${error.message}`
+          message: "claude CLI not found on PATH \u2014 it is a SEPARATE install from the Claude Desktop app and the Claude Code IDE extension. Install: npm install -g @anthropic-ai/claude-code, then sign in: claude auth login."
         };
       }
-      if (status !== 0) {
+      if (probe.status !== 0) {
+        return { installed: true, authenticated: false, message: "claude binary exists but --version failed (auth unclear)" };
+      }
+      const loggedIn = probeClaudeLoginState();
+      if (loggedIn === false) {
         return {
           installed: true,
           authenticated: false,
-          message: "claude binary exists but --version failed (auth unclear)"
+          message: "claude CLI is installed but NOT logged in \u2014 its login is SEPARATE from the Claude Desktop app and the Claude Code IDE extension. Run: claude auth login (Claude subscription), then restart the runner."
         };
       }
       return {
         installed: true,
         authenticated: true,
-        message: "claude binary found (auth check is best-effort)"
+        message: loggedIn === true ? "claude CLI installed and logged in (claude auth status)" : "claude binary found (login state unknown \u2014 auth check is best-effort)"
       };
     } catch (err) {
       return {
@@ -574,10 +899,368 @@ var ClaudeRunner = class {
 };
 var claudeRunner = new ClaudeRunner();
 
+// ../../scripts/virtual-office/code-runner/codex-runner.mjs
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// ../../scripts/virtual-office/code-runner/agent-key-store.mjs
+import { createRequire as createRequire3 } from "node:module";
+var require3 = createRequire3(import.meta.url);
+var KEY_SERVICE2 = "algosuite-vo";
+var PROVIDER_ENV = {
+  anthropic: ["ANTHROPIC_API_KEY"],
+  openai: ["OPENAI_API_KEY", "CODEX_API_KEY"],
+  cursor: ["CURSOR_API_KEY"]
+};
+var PROVIDER_ALIAS = {
+  claude: "anthropic",
+  anthropic: "anthropic",
+  codex: "openai",
+  openai: "openai",
+  cursor: "cursor"
+};
+function resolveProvider(name) {
+  const key = String(name || "").trim().toLowerCase();
+  return PROVIDER_ALIAS[key] || null;
+}
+function accountFor(provider) {
+  return `${provider}-api-key`;
+}
+var _entryCtor2;
+var _loadTried2 = false;
+function defaultEntryCtor2() {
+  if (_loadTried2) return _entryCtor2;
+  _loadTried2 = true;
+  try {
+    _entryCtor2 = require3("@napi-rs/keyring").Entry;
+  } catch {
+    _entryCtor2 = null;
+  }
+  return _entryCtor2;
+}
+function getAgentKey(provider, { EntryCtor = defaultEntryCtor2() } = {}) {
+  const p = resolveProvider(provider);
+  if (!p || !EntryCtor) return null;
+  try {
+    return new EntryCtor(KEY_SERVICE2, accountFor(p)).getPassword() || null;
+  } catch {
+    return null;
+  }
+}
+function withAgentKey(provider, baseEnv = {}, { getKey = getAgentKey } = {}) {
+  const p = resolveProvider(provider);
+  const vars = p && PROVIDER_ENV[p] || [];
+  const out = { ...baseEnv };
+  if (!p || vars.length === 0) return out;
+  if (vars.some((v) => out[v])) return out;
+  const key = getKey(p);
+  if (!key) return out;
+  for (const v of vars) out[v] = key;
+  return out;
+}
+
+// ../../scripts/virtual-office/code-runner/codex-runner.mjs
+function resolveCodexBinary({
+  env: env2 = process.env,
+  platform = process.platform,
+  exists = existsSync2
+} = {}) {
+  if (platform !== "win32") return "codex";
+  const appData = String(env2.APPDATA || "").trim();
+  if (appData) {
+    const npmVendorBinary = join2(
+      appData,
+      "npm",
+      "node_modules",
+      "@openai",
+      "codex",
+      "node_modules",
+      "@openai",
+      "codex-win32-x64",
+      "vendor",
+      "x86_64-pc-windows-msvc",
+      "bin",
+      "codex.exe"
+    );
+    if (exists(npmVendorBinary)) return npmVendorBinary;
+  }
+  return "codex";
+}
+function buildCodexArgs({ model } = {}) {
+  const args = ["exec", "--json", "-c", 'approval_policy="never"', "--sandbox", "danger-full-access"];
+  if (model) {
+    args.push("--model", String(model));
+  }
+  args.push("-");
+  return args;
+}
+function itemText(item) {
+  if (!item) return "";
+  if (typeof item.text === "string") return item.text;
+  if (typeof item.message === "string") return item.message;
+  if (Array.isArray(item.content)) {
+    return item.content.map((b) => typeof b === "string" ? b : typeof b?.text === "string" ? b.text : "").join("");
+  }
+  return "";
+}
+function parseCodexEvent(line) {
+  const trimmed = String(line || "").trim();
+  if (!trimmed) return null;
+  let evt;
+  try {
+    evt = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (!evt || typeof evt !== "object") return null;
+  const type = evt.type;
+  if (type === "item.completed" && evt.item) {
+    const it = evt.item.type;
+    if (it === "agent_message" || it === "assistant_message") {
+      const text = itemText(evt.item).trim();
+      return text ? { kind: "progress", text } : null;
+    }
+    return null;
+  }
+  if (type === "turn.completed") {
+    return { kind: "result", isError: false, costUsd: null, summary: "completed", numTurns: null };
+  }
+  if (type === "turn.failed" || type === "error") {
+    const msg = evt.error && (evt.error.message || evt.error) || evt.message || "codex run failed";
+    return { kind: "result", isError: true, costUsd: null, summary: String(msg), numTurns: null };
+  }
+  return null;
+}
+var CodexRunner = class {
+  get binary() {
+    return resolveCodexBinary();
+  }
+  buildArgs(opts = {}) {
+    return buildCodexArgs(opts);
+  }
+  parseEvent(line) {
+    return parseCodexEvent(line);
+  }
+  getSpawnOptions({ bin } = {}) {
+    const effectiveBin = String(bin || this.binary || "");
+    return {
+      shell: process.platform === "win32" && !/\.exe$/i.test(effectiveBin),
+      windowsHide: true
+    };
+  }
+  /**
+   * Fill the OpenAI credential env var(s) (OPENAI_API_KEY / CODEX_API_KEY) from
+   * the OS keychain when not already set, so a BYO friend who ran
+   * `vo-mcp set-key --provider codex` authenticates without an env var. Explicit
+   * env wins; no key stored → unchanged (a prior `codex login` still works).
+   */
+  applyAuthEnv(env2 = process.env) {
+    return withAgentKey("openai", env2);
+  }
+  /** Best-effort: is `codex` on PATH? Never throws. */
+  async checkAuth() {
+    try {
+      const bin = this.binary;
+      const { status, error } = spawnSync5(bin, ["--version"], {
+        ...this.getSpawnOptions({ bin }),
+        windowsHide: true,
+        timeout: 3e3,
+        stdio: "ignore"
+      });
+      if (error) {
+        return { installed: false, authenticated: false, message: `codex not found on PATH: ${error.message}` };
+      }
+      if (status !== 0) {
+        return { installed: true, authenticated: false, message: "codex exists but --version failed (auth unclear)" };
+      }
+      return { installed: true, authenticated: true, message: "codex binary found (auth check is best-effort)" };
+    } catch (err) {
+      return { installed: false, authenticated: false, message: `checkAuth probe failed: ${err.message}` };
+    }
+  }
+};
+var codexRunner = new CodexRunner();
+
+// ../../scripts/virtual-office/code-runner/cursor-runner.mjs
+import { spawnSync as spawnSync6 } from "node:child_process";
+function buildCursorArgs({ model, prompt } = {}) {
+  const args = ["-p", "--output-format", "stream-json", "--force"];
+  if (model) {
+    args.push("--model", String(model));
+  }
+  const p = String(prompt ?? "");
+  if (p.length > 0) {
+    args.push(p);
+  }
+  return args;
+}
+function messageText(message) {
+  if (!message) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => typeof b === "string" ? b : typeof b?.text === "string" ? b.text : "").join("");
+  }
+  return "";
+}
+function parseCursorEvent(line) {
+  const trimmed = String(line || "").trim();
+  if (!trimmed) return null;
+  let evt;
+  try {
+    evt = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (!evt || typeof evt !== "object") return null;
+  if (evt.type === "assistant") {
+    const text = messageText(evt.message).trim();
+    return text ? { kind: "progress", text } : null;
+  }
+  if (evt.type === "result") {
+    const isError = Boolean(evt.is_error) || evt.subtype === "error";
+    return {
+      kind: "result",
+      isError,
+      costUsd: null,
+      summary: typeof evt.result === "string" && evt.result.length > 0 ? evt.result : evt.subtype || (isError ? "error" : "completed"),
+      numTurns: null
+    };
+  }
+  return null;
+}
+var CursorRunner = class {
+  get binary() {
+    return "cursor-agent";
+  }
+  buildArgs(opts = {}) {
+    return buildCursorArgs(opts);
+  }
+  parseEvent(line) {
+    return parseCursorEvent(line);
+  }
+  getSpawnOptions() {
+    return {
+      shell: process.platform === "win32",
+      windowsHide: true
+    };
+  }
+  /**
+   * Fill CURSOR_API_KEY from the OS keychain when not already set, so a BYO
+   * friend who ran `vo-mcp set-key --provider cursor` authenticates without an
+   * env var. Explicit env wins; no key stored → a prior `cursor-agent login`.
+   */
+  applyAuthEnv(env2 = process.env) {
+    return withAgentKey("cursor", env2);
+  }
+  /** Best-effort: is `cursor-agent` on PATH? Never throws. */
+  async checkAuth() {
+    try {
+      const { status, error } = spawnSync6("cursor-agent", ["--version"], {
+        shell: process.platform === "win32",
+        windowsHide: true,
+        timeout: 3e3,
+        stdio: "ignore"
+      });
+      if (error) {
+        return { installed: false, authenticated: false, message: `cursor-agent not found on PATH: ${error.message}` };
+      }
+      if (status !== 0) {
+        return { installed: true, authenticated: false, message: "cursor-agent exists but --version failed (auth unclear)" };
+      }
+      return {
+        installed: true,
+        authenticated: true,
+        message: "cursor-agent found (EXPERIMENTAL: headless mode may need a TTY; auth check is best-effort)"
+      };
+    } catch (err) {
+      return { installed: false, authenticated: false, message: `checkAuth probe failed: ${err.message}` };
+    }
+  }
+};
+var cursorRunner = new CursorRunner();
+
+// ../../scripts/virtual-office/code-runner/agent-runner-interface.mjs
+function validateAgentRunner(runner) {
+  if (!runner || typeof runner !== "object") {
+    throw new TypeError("AgentRunner must be an object");
+  }
+  if (typeof runner.binary !== "string" || runner.binary.length === 0) {
+    throw new TypeError("AgentRunner.binary must be a non-empty string");
+  }
+  if (typeof runner.buildArgs !== "function") {
+    throw new TypeError("AgentRunner.buildArgs must be a function");
+  }
+  if (typeof runner.parseEvent !== "function") {
+    throw new TypeError("AgentRunner.parseEvent must be a function");
+  }
+  if (typeof runner.getSpawnOptions !== "function") {
+    throw new TypeError("AgentRunner.getSpawnOptions must be a function");
+  }
+  if (typeof runner.checkAuth !== "function") {
+    throw new TypeError("AgentRunner.checkAuth must be a function");
+  }
+}
+
+// ../../scripts/virtual-office/code-runner/resolve-runner.mjs
+var DEFAULT_AGENT = "claude";
+var RUNNERS = {
+  claude: claudeRunner,
+  codex: codexRunner,
+  cursor: cursorRunner
+};
+function listAgents() {
+  return Object.keys(RUNNERS);
+}
+function inferAgentFromBin(bin) {
+  const raw = String(bin || "").trim().toLowerCase();
+  if (!raw) return null;
+  const base = raw.replace(/\\/g, "/").split("/").pop() || raw;
+  if (base.includes("codex")) return "codex";
+  if (base.includes("cursor-agent") || base === "cursor" || base.startsWith("cursor.")) return "cursor";
+  if (base.includes("claude")) return "claude";
+  return null;
+}
+function inferAgentFromEnvBin(env2) {
+  for (const bin of [env2.VO_CODE_RUNNER_BIN, env2.VO_CODE_RUNNER_CLAUDE_BIN]) {
+    const agent = inferAgentFromBin(bin);
+    if (agent) return { agent, bin };
+  }
+  return null;
+}
+function resolveRunner(env2 = process.env, { warn = () => {
+} } = {}) {
+  const explicitAgent = String(env2.VO_CODE_RUNNER_AGENT || env2.VO_AGENT || "").trim();
+  const inferred = explicitAgent ? null : inferAgentFromEnvBin(env2);
+  const raw = String(explicitAgent || inferred?.agent || DEFAULT_AGENT).trim().toLowerCase();
+  let agent = raw;
+  let fellBack = false;
+  let runner = RUNNERS[agent];
+  if (inferred && runner) {
+    try {
+      warn(`VO_CODE_RUNNER_AGENT not set; inferred "${agent}" from runner binary "${inferred.bin}"`);
+    } catch {
+    }
+  }
+  if (!runner) {
+    try {
+      warn(`unknown VO_CODE_RUNNER_AGENT "${raw}"; falling back to "${DEFAULT_AGENT}" (known: ${listAgents().join(", ")})`);
+    } catch {
+    }
+    agent = DEFAULT_AGENT;
+    runner = RUNNERS[DEFAULT_AGENT];
+    fellBack = true;
+  }
+  validateAgentRunner(runner);
+  const runnerBin = env2.VO_CODE_RUNNER_BIN || (inferred && inferred.agent === agent ? inferred.bin : "") || (agent === "claude" ? env2.VO_CODE_RUNNER_CLAUDE_BIN : "") || runner.binary;
+  return { agent, runner, runnerBin, fellBack };
+}
+
 // ../../scripts/virtual-office/code-runner/rate-limit-resume.mjs
 import { appendFileSync, mkdirSync as mkdirSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join2, dirname as dirname2 } from "node:path";
+import { join as join3, dirname as dirname2 } from "node:path";
 
 // ../../scripts/ci/rate-limit-detector-core.mjs
 var RATE_LIMIT_RE = /\b(?:usage limit reached|usage limit|rate[ _-]?limit(?:ed|_error)?|too many requests|\b429\b|limit (?:will )?reset)/i;
@@ -612,7 +1295,7 @@ function detectRateLimit(text, { now = null } = {}) {
 
 // ../../scripts/virtual-office/code-runner/rate-limit-resume.mjs
 function resumeQueuePath() {
-  return join2(homedir2(), ".claude", "resume-queue.jsonl");
+  return join3(homedir2(), ".claude", "resume-queue.jsonl");
 }
 function buildResumeEntry({ task = {}, resumeAfter = null, summary = "", at } = {}) {
   return {
@@ -674,9 +1357,65 @@ function classifyFailureForResume({
 }
 
 // ../../scripts/virtual-office/code-runner/publish.mjs
-import { spawnSync as spawnSync3 } from "node:child_process";
-function run(cmd, args, cwd, { timeout = 18e4, raw = false } = {}) {
-  const r = spawnSync3(cmd, args, { cwd, encoding: "utf8", timeout });
+import { spawnSync as spawnSync7 } from "node:child_process";
+
+// ../../scripts/virtual-office/code-runner/git-resilience.mjs
+var TRANSIENT_CODES = /* @__PURE__ */ new Set([
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ENETUNREACH",
+  "EHOSTUNREACH",
+  "EPIPE"
+]);
+var TRANSIENT_RE = /\b(?:ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|EPIPE)\b|\b50[234]\b|timed?[ _-]?out|connection (?:reset|refused|closed|timed out)|could not resolve host|couldn't resolve host|failed to connect|unable to access|temporary failure|remote end hung up|early eof|rpc failed|the remote end hung up unexpectedly|operation timed out|gnutls_handshake|ssl_read|recv failure/i;
+function isTransientGitError(err) {
+  if (!err) return false;
+  if (err.code && TRANSIENT_CODES.has(err.code)) return true;
+  const msg = String(err.message || err);
+  if (/non-fast-forward|fast[- ]forward|\(fetch first\)|permission denied|authentication failed|\b40[134]\b|merge conflict|nothing to commit|did not match any/i.test(msg)) {
+    return false;
+  }
+  return TRANSIENT_RE.test(msg);
+}
+function computeGitBackoffMs(attempt, { baseMs = 5e3, capMs = 3e4, rng = Math.random } = {}) {
+  const exp = Math.min(capMs, baseMs * Math.pow(2, Math.max(0, attempt)));
+  return Math.floor(exp / 2 + rng() * (exp / 2));
+}
+function sleepSync(ms) {
+  if (!(ms > 0)) return;
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+  }
+}
+function retryTransient(fn, { attempts = 3, baseMs = 5e3, capMs = 3e4, sleep: sleep2 = sleepSync, rng = Math.random, onRetry } = {}) {
+  let lastErr;
+  for (let i = 0; i < attempts; i += 1) {
+    try {
+      return fn(i);
+    } catch (err) {
+      lastErr = err;
+      if (i >= attempts - 1 || !isTransientGitError(err)) throw err;
+      const delayMs = computeGitBackoffMs(i, { baseMs, capMs, rng });
+      if (typeof onRetry === "function") onRetry({ err, attempt: i + 1, delayMs });
+      sleep2(delayMs);
+    }
+  }
+  throw lastErr;
+}
+
+// ../../scripts/virtual-office/code-runner/publish.mjs
+function gitRetryLog(op) {
+  return ({ attempt, delayMs, err }) => {
+    const why = String(err && err.message || err).replace(/\s+/g, " ").slice(0, 120);
+    console.error(`[publish] transient ${op} failure (attempt ${attempt}): ${why} \u2014 retrying in ${Math.round(delayMs / 1e3)}s`);
+  };
+}
+function run(cmd, args, cwd, { timeout = 18e4, raw = false, env: env2 } = {}) {
+  const r = spawnSync7(cmd, args, { cwd, encoding: "utf8", timeout, ...env2 ? { env: env2 } : {} });
   if (r.error) throw r.error;
   if (r.status !== 0) {
     throw new Error(`${cmd} ${args[0]} failed (exit ${r.status}): ${(r.stderr || "").slice(-300)}`);
@@ -735,6 +1474,84 @@ function listCommittedFiles(cwd, base = "origin/main") {
 function compactTitle(s, max = 100) {
   return String(s || "").replace(/\s+/g, " ").trim().slice(0, max) || "code-task";
 }
+function installationTokenEnv(githubToken, baseEnv = process.env) {
+  if (!githubToken) return void 0;
+  return { ...baseEnv, GH_TOKEN: githubToken, GITHUB_TOKEN: githubToken };
+}
+function pushArgs(branch, { withToken = false } = {}) {
+  if (withToken) {
+    return [
+      "-c",
+      "credential.helper=",
+      "-c",
+      "credential.helper=!gh auth git-credential",
+      "push",
+      "origin",
+      branch
+    ];
+  }
+  return ["push", "origin", branch];
+}
+function pushPlan(branch, githubToken) {
+  if (githubToken) {
+    return {
+      primary: { args: pushArgs(branch, { withToken: true }), env: installationTokenEnv(githubToken), tokenUsed: true },
+      fallback: { args: pushArgs(branch), env: void 0, tokenUsed: false }
+    };
+  }
+  return { primary: { args: pushArgs(branch), env: void 0, tokenUsed: false }, fallback: null };
+}
+function pushBranch(worktreeDir, branch, githubToken, runFn = run) {
+  const { primary, fallback } = pushPlan(branch, githubToken);
+  try {
+    runFn("git", primary.args, worktreeDir, { env: primary.env });
+    return primary.tokenUsed;
+  } catch (err) {
+    if (!fallback) throw err;
+    runFn("git", fallback.args, worktreeDir, { env: fallback.env });
+    return fallback.tokenUsed;
+  }
+}
+function resolveOrCreateBranch(worktreeDir, branchPrefix, runFn = run) {
+  let branch = "";
+  try {
+    branch = runFn("git", ["branch", "--show-current"], worktreeDir, { timeout: 3e4 });
+  } catch {
+  }
+  if (!branch || branch === "main" || branch === "HEAD") {
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    branch = `${branchPrefix}-${stamp}`;
+    runFn("git", ["checkout", "-b", branch], worktreeDir);
+  }
+  return branch;
+}
+function commitWorkLocally(worktreeDir, files, { title, branchPrefix = "vo/code-task", botName = "vo-code-runner", botEmail = "vo-code-runner@algosuite.ai", maxFiles = 200, runFn = run } = {}) {
+  const cleaned = (files || []).filter((f) => !isAgentScratch(f));
+  if (cleaned.length === 0) throw new Error("commitWorkLocally: only scratch files, nothing to commit");
+  const toAdd = cleaned.slice(0, maxFiles);
+  runFn("git", ["config", "user.name", botName], worktreeDir);
+  runFn("git", ["config", "user.email", botEmail], worktreeDir);
+  const branch = resolveOrCreateBranch(worktreeDir, branchPrefix, runFn);
+  for (let i = 0; i < toAdd.length; i += 100) {
+    runFn("git", ["add", "--", ...toAdd.slice(i, i + 100)], worktreeDir, { timeout: 12e4 });
+  }
+  runFn("git", ["commit", "--no-verify", "-m", compactTitle(title, 180)], worktreeDir);
+  return { branch, truncated: cleaned.length > maxFiles };
+}
+function existingPrUrl(worktreeDir, branch, githubToken = null, runFn = run) {
+  try {
+    const out = runFn(
+      "gh",
+      ["pr", "list", "--head", branch, "--state", "open", "--json", "url,number", "--limit", "1"],
+      worktreeDir,
+      { env: githubToken ? installationTokenEnv(githubToken) : void 0 }
+    );
+    const arr = JSON.parse(out || "[]");
+    if (Array.isArray(arr) && arr[0] && arr[0].url) return { url: String(arr[0].url), number: Number(arr[0].number) };
+  } catch {
+  }
+  return null;
+}
 function openCodeTaskPr(worktreeDir, files, {
   title,
   body,
@@ -744,63 +1561,43 @@ function openCodeTaskPr(worktreeDir, files, {
   maxFiles = 200,
   // Safety net: the agent already COMMITTED its work to a branch (despite the
   // preamble). Skip add+commit; just push the existing branch and open the PR.
-  alreadyCommitted = false
+  alreadyCommitted = false,
+  // Optional GitHub App installation token (M3). When present, push + PR
+  // authenticate as the App; a push failure transparently falls back to the
+  // runner's ambient gh auth. Absent → ambient gh exactly.
+  githubToken = null,
+  // Open as DRAFT — used to auto-publish partial/timed-out work for recovery.
+  draft = false
 } = {}) {
   if (!Array.isArray(files) || files.length === 0) {
     throw new Error("openCodeTaskPr: no files to commit");
   }
-  const cleaned = files.filter((f) => !isAgentScratch(f));
-  if (!alreadyCommitted && cleaned.length === 0) {
-    throw new Error("openCodeTaskPr: only scratch files, nothing to commit");
-  }
-  const toAdd = cleaned.slice(0, maxFiles);
-  run("git", ["config", "user.name", botName], worktreeDir);
-  run("git", ["config", "user.email", botEmail], worktreeDir);
-  let branch = "";
-  try {
-    branch = run("git", ["branch", "--show-current"], worktreeDir, { timeout: 3e4 });
-  } catch {
-  }
+  let branch;
+  let truncated = false;
   if (alreadyCommitted) {
-    if (!branch || branch === "main" || branch === "HEAD") {
-      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      branch = `${branchPrefix}-${stamp}`;
-      run("git", ["checkout", "-b", branch], worktreeDir);
-    }
-    run("git", ["push", "origin", branch], worktreeDir);
+    branch = resolveOrCreateBranch(worktreeDir, branchPrefix);
   } else {
-    if (!branch || branch === "main" || branch === "HEAD") {
-      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      branch = `${branchPrefix}-${stamp}`;
-      run("git", ["fetch", "origin", "main"], worktreeDir, { timeout: 6e4 });
-      run("git", ["checkout", "-b", branch, "origin/main"], worktreeDir);
-    }
-    for (const f of toAdd) {
-      run("git", ["add", "--", f], worktreeDir, { timeout: 6e4 });
-    }
-    const commitMsg = compactTitle(title, 180);
-    run("git", ["commit", "--no-verify", "-m", commitMsg], worktreeDir);
-    run("git", ["push", "origin", branch], worktreeDir);
+    const committed = commitWorkLocally(worktreeDir, files, { title, branchPrefix, botName, botEmail, maxFiles });
+    branch = committed.branch;
+    truncated = committed.truncated;
   }
-  const out = run(
-    "gh",
-    [
-      "pr",
-      "create",
-      "--base",
-      "main",
-      "--head",
-      branch,
-      "--title",
-      compactTitle(title),
-      "--body",
-      String(body || "")
-    ],
-    worktreeDir
+  const tokenUsed = retryTransient(() => pushBranch(worktreeDir, branch, githubToken), {
+    onRetry: gitRetryLog("git push")
+  });
+  const existing = existingPrUrl(worktreeDir, branch, tokenUsed ? githubToken : null);
+  if (existing) return { prUrl: existing.url, prNumber: existing.number, branch, truncated, resumed: true };
+  const out = retryTransient(
+    () => run(
+      "gh",
+      ["pr", "create", "--base", "main", "--head", branch, "--title", compactTitle(title), "--body", String(body || ""), ...draft ? ["--draft"] : []],
+      worktreeDir,
+      { env: tokenUsed ? installationTokenEnv(githubToken) : void 0 }
+    ),
+    { onRetry: gitRetryLog("gh pr create") }
   );
   const m = out.match(/https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)/);
   if (!m) throw new Error("gh pr create returned no parseable PR URL");
-  return { prUrl: m[0], prNumber: Number(m[1]), branch, truncated: cleaned.length > maxFiles };
+  return { prUrl: m[0], prNumber: Number(m[1]), branch, truncated };
 }
 
 // ../../scripts/virtual-office/code-runner/dispatch-onboarding.mjs
@@ -866,11 +1663,11 @@ ${String(taskPrompt ?? "").trim()}
 
 // ../../scripts/virtual-office/code-runner/session-spool-forwarder.mjs
 import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import { readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
-var SPOOL_DIR = join3(homedir3(), ".vo", "session-spool");
-var CLOUD_MAP_FILE = join3(homedir3(), ".vo", "session-cloud-map.json");
+var SPOOL_DIR = join4(homedir3(), ".vo", "session-spool");
+var CLOUD_MAP_FILE = join4(homedir3(), ".vo", "session-cloud-map.json");
 var STALE_MS = 60 * 60 * 1e3;
 var ACTIVE_SILENCE_MS = 10 * 60 * 1e3;
 function deriveUuid(seed) {
@@ -902,9 +1699,9 @@ async function readSpool(spoolDir = SPOOL_DIR) {
   for (const f of files) {
     if (!f.endsWith(".json")) continue;
     try {
-      const record = JSON.parse(await readFile(join3(spoolDir, f), "utf8"));
+      const record = JSON.parse(await readFile(join4(spoolDir, f), "utf8"));
       if (record && typeof record.session_key === "string") {
-        out.push({ full: join3(spoolDir, f), record });
+        out.push({ full: join4(spoolDir, f), record });
       }
     } catch {
     }
@@ -983,14 +1780,266 @@ async function forwardSessionSpool(deps) {
   return { forwarded, pruned };
 }
 
+// ../../scripts/virtual-office/code-runner/rate-limit-resume-scheduler.mjs
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { dirname as dirname3, join as join5, resolve } from "node:path";
+
+// ../../scripts/virtual-office/code-runner/rate-limit-resume-scheduler-core.mjs
+var MAX_ATTEMPTS = 5;
+var MAX_DISPATCH_PER_RUN = 10;
+var NULL_RESUME_AFTER_BACKOFF_MS = 15 * 60 * 1e3;
+function stableTaskKey(entry) {
+  return `${entry && entry.repo || ""}\0${entry && entry.prompt || ""}`;
+}
+function selectDueEntries({ entries = [], now, alreadyDispatched = /* @__PURE__ */ new Set(), attemptsByKey = {} } = {}) {
+  if (!now) throw new Error("selectDueEntries: now is required");
+  const nowMs = new Date(now).getTime();
+  if (!Number.isFinite(nowMs)) throw new Error("selectDueEntries: invalid now timestamp");
+  const due = [];
+  const exhausted = [];
+  const seen = new Set(alreadyDispatched);
+  for (const e of entries) {
+    const { code_task_id, resume_after, at, attempts } = e || {};
+    if (!code_task_id) continue;
+    if (seen.has(code_task_id)) continue;
+    const stableAttempts = Number(attemptsByKey[stableTaskKey(e)] || 0);
+    if (Math.max(typeof attempts === "number" ? attempts : 0, stableAttempts) >= MAX_ATTEMPTS) {
+      exhausted.push(e);
+      continue;
+    }
+    let isDue = false;
+    if (resume_after === null || resume_after === void 0) {
+      const entryAtMs = new Date(at).getTime();
+      if (Number.isFinite(entryAtMs)) {
+        const attemptCount = typeof attempts === "number" ? attempts : 0;
+        const backoffMs = NULL_RESUME_AFTER_BACKOFF_MS * Math.pow(2, attemptCount);
+        const dueAtMs = entryAtMs + backoffMs;
+        isDue = nowMs >= dueAtMs;
+      }
+    } else {
+      const resumeMs = new Date(resume_after).getTime();
+      if (Number.isFinite(resumeMs)) {
+        isDue = nowMs >= resumeMs;
+      }
+    }
+    if (isDue) {
+      due.push(e);
+      seen.add(code_task_id);
+      if (due.length >= MAX_DISPATCH_PER_RUN) break;
+    }
+  }
+  return { due, exhausted };
+}
+function reconcileQueue({ entries = [], dispatchedIds = /* @__PURE__ */ new Set(), exhaustedIds = /* @__PURE__ */ new Set() } = {}) {
+  return entries.filter((e) => {
+    const { code_task_id } = e || {};
+    if (!code_task_id) return false;
+    if (dispatchedIds.has(code_task_id)) return false;
+    if (exhaustedIds.has(code_task_id)) return false;
+    return true;
+  });
+}
+
+// ../../scripts/virtual-office/code-runner/rate-limit-resume-scheduler.mjs
+var ATTEMPTS_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+function log(msg) {
+  console.log(`[rate-limit-scheduler ${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}`);
+}
+function readQueue(queuePath) {
+  if (!existsSync3(queuePath)) return [];
+  const content = readFileSync2(queuePath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim());
+  const entries = [];
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      log(`warn: malformed queue line: ${line.slice(0, 100)}`);
+    }
+  }
+  return entries;
+}
+function writeQueue(queuePath, entries) {
+  mkdirSync3(dirname3(queuePath), { recursive: true });
+  const lines = entries.map((e) => JSON.stringify(e)).join("\n");
+  writeFileSync2(queuePath, lines + (entries.length > 0 ? "\n" : ""), "utf-8");
+}
+function attemptsStorePath() {
+  return join5(dirname3(resumeQueuePath()), "resume-attempts.json");
+}
+function readAttemptsStore() {
+  const p = attemptsStorePath();
+  if (!existsSync3(p)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync2(p, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeAttemptsStore(store) {
+  const p = attemptsStorePath();
+  mkdirSync3(dirname3(p), { recursive: true });
+  writeFileSync2(p, JSON.stringify(store, null, 2), "utf-8");
+}
+function countsFromStore(store) {
+  const counts = {};
+  for (const [k, v] of Object.entries(store)) {
+    counts[k] = v && typeof v.count === "number" ? v.count : 0;
+  }
+  return counts;
+}
+function bumpAttempts(store, key, nowIso) {
+  const prev = store[key] && typeof store[key].count === "number" ? store[key].count : 0;
+  store[key] = { count: prev + 1, lastSeen: nowIso };
+}
+function pruneAttemptsStore(store, nowIso) {
+  const nowMs = new Date(nowIso).getTime();
+  const out = {};
+  for (const [k, v] of Object.entries(store)) {
+    const t = v && v.lastSeen ? new Date(v.lastSeen).getTime() : 0;
+    if (Number.isFinite(t) && nowMs - t < ATTEMPTS_TTL_MS) out[k] = v;
+  }
+  return out;
+}
+async function runScheduler({ env: env2 = process.env } = {}) {
+  const enabled = env2.VO_RATE_LIMIT_RESUME === "1";
+  if (!enabled) {
+    log("VO_RATE_LIMIT_RESUME not enabled; no-op");
+    return { dispatched: 0, exhausted: 0, kept: 0 };
+  }
+  const queuePath = resumeQueuePath();
+  const entries = readQueue(queuePath);
+  if (entries.length === 0) {
+    log("queue empty; nothing to do");
+    return { dispatched: 0, exhausted: 0, kept: 0 };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const alreadyDispatched = /* @__PURE__ */ new Set();
+  const attemptsStore = readAttemptsStore();
+  const attemptsByKey = countsFromStore(attemptsStore);
+  const { due, exhausted } = selectDueEntries({ entries, now, alreadyDispatched, attemptsByKey });
+  log(`queue: ${entries.length} total, ${due.length} due, ${exhausted.length} exhausted`);
+  if (due.length === 0 && exhausted.length === 0) {
+    log("no due or exhausted entries; queue unchanged");
+    writeAttemptsStore(pruneAttemptsStore(attemptsStore, now));
+    return { dispatched: 0, exhausted: 0, kept: entries.length };
+  }
+  const client = createControlPlaneClient({ env: env2 });
+  const dispatchedIds = /* @__PURE__ */ new Set();
+  const exhaustedIds = new Set(exhausted.map((e) => e.code_task_id));
+  for (const entry of due) {
+    const { code_task_id, repo, prompt, attempts } = entry;
+    try {
+      const task = {
+        repo,
+        prompt,
+        _resume_attempts: (typeof attempts === "number" ? attempts : 0) + 1
+      };
+      await client.enqueueCodeTask(task);
+      bumpAttempts(attemptsStore, stableTaskKey(entry), now);
+      log(`dispatched: ${code_task_id} (stable attempts ${attemptsStore[stableTaskKey(entry)].count})`);
+      dispatchedIds.add(code_task_id);
+      alreadyDispatched.add(code_task_id);
+    } catch (err) {
+      log(`dispatch failed for ${code_task_id}: ${err.message}`);
+    }
+  }
+  const kept = reconcileQueue({ entries, dispatchedIds, exhaustedIds });
+  writeQueue(queuePath, kept);
+  writeAttemptsStore(pruneAttemptsStore(attemptsStore, now));
+  if (exhausted.length > 0) {
+    log(`WARN: ${exhausted.length} task(s) gave up after ${MAX_ATTEMPTS} rate-limit retries and were DROPPED from the queue: ${exhausted.map((e) => e.code_task_id).join(", ")}`);
+  }
+  if (due.length >= MAX_DISPATCH_PER_RUN) {
+    log(`WARN: hit the per-run dispatch cap (${MAX_DISPATCH_PER_RUN}); more rate-limited tasks remain queued and will resume on the next run`);
+  }
+  log(`done: dispatched ${dispatchedIds.size}, exhausted ${exhaustedIds.size}, kept ${kept.length}`);
+  return {
+    dispatched: dispatchedIds.size,
+    exhausted: exhaustedIds.size,
+    kept: kept.length
+  };
+}
+var isMainModule = (() => {
+  try {
+    const argv1 = process.argv[1] ? resolve(process.argv[1]) : "";
+    const here = new URL(import.meta.url).pathname.replace(/^\/([a-zA-Z]):\//, "$1:/");
+    return resolve(here) === argv1;
+  } catch {
+    return false;
+  }
+})();
+if (isMainModule) {
+  runScheduler().catch((err) => {
+    console.error("[rate-limit-scheduler] fatal:", err);
+    process.exit(1);
+  });
+}
+
+// ../../scripts/virtual-office/code-runner/loop-ticks.mjs
+var HEARTBEAT_MS = 6e4;
+var DEFAULT_RESUME_SCHEDULE_SEC = 300;
+function makeLoopTicks({
+  client,
+  cfg,
+  env: env2,
+  log: log3,
+  getActive,
+  // Injectable for tests; default to the real scheduler + wall clock.
+  runResumeScheduler = runScheduler,
+  now: nowFn = () => Date.now()
+}) {
+  let lastSessionForward = 0;
+  let lastHeartbeat = 0;
+  let lastResumeSchedule = 0;
+  let resumeRunning = false;
+  return function tick() {
+    const now = nowFn();
+    if (cfg.sessionForwardSec > 0 && now - lastSessionForward >= cfg.sessionForwardSec * 1e3) {
+      lastSessionForward = now;
+      forwardSessionSpool({
+        baseUrl: String(env2.VO_CONTROL_PLANE_URL || "").replace(/\/$/, ""),
+        token: env2.VO_CONTROL_PLANE_ADMIN_TOKEN || "",
+        operatorSeed: cfg.operatorSeed
+      }).catch(() => {
+      });
+    }
+    if (now - lastHeartbeat >= HEARTBEAT_MS) {
+      lastHeartbeat = now;
+      const servedRepos = Array.isArray(cfg.servedRepos) ? cfg.servedRepos.slice(0, 100) : [];
+      const servedOperators = Array.isArray(cfg.servedOperators) ? cfg.servedOperators.slice(0, 100) : [];
+      const baseHeartbeat = {
+        runnerId: cfg.runnerId,
+        ...servedRepos.length > 0 ? { servedRepos } : {},
+        ...servedOperators.length > 0 ? { servedOperators } : {},
+        uptimeSec: Math.floor(process.uptime()),
+        activeTasks: getActive()
+      };
+      const operatorIds = servedOperators.length > 0 ? servedOperators : [void 0];
+      for (const operatorId of operatorIds) {
+        client.postHeartbeat({ ...baseHeartbeat, ...operatorId ? { operatorId } : {} }).catch((e) => log3(`heartbeat failed: ${e.message}`));
+      }
+    }
+    const resumeSec = Number(env2.VO_RESUME_SCHEDULE_SEC) > 0 ? Number(env2.VO_RESUME_SCHEDULE_SEC) : DEFAULT_RESUME_SCHEDULE_SEC;
+    if (!resumeRunning && now - lastResumeSchedule >= resumeSec * 1e3) {
+      lastResumeSchedule = now;
+      resumeRunning = true;
+      Promise.resolve(runResumeScheduler({ env: env2 })).catch((e) => log3(`resume-scheduler tick failed: ${e.message}`)).finally(() => {
+        resumeRunning = false;
+      });
+    }
+  };
+}
+
 // ../../scripts/virtual-office/code-runner/pr-watcher.mjs
 import { homedir as homedir4 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 import { readFile as readFile2, writeFile as writeFile2, mkdir } from "node:fs/promises";
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 var CI_FIX_MARKER = "[VO-CI-FIX]";
 function ghViewPr(prNumber, repo) {
-  const r = spawnSync4(
+  const r = spawnSync8(
     "gh",
     ["pr", "view", String(prNumber), "-R", repo, "--json", "state,statusCheckRollup,headRefName"],
     { encoding: "utf8", timeout: 3e4 }
@@ -998,7 +2047,7 @@ function ghViewPr(prNumber, repo) {
   if (r.status !== 0) throw new Error((r.stderr || "gh pr view failed").slice(-200));
   return JSON.parse(r.stdout || "{}");
 }
-var DEFAULT_STATE_FILE = join4(homedir4(), ".vo", "dispatched-prs.json");
+var DEFAULT_STATE_FILE = join6(homedir4(), ".vo", "dispatched-prs.json");
 var FAIL_CONCLUSIONS = /* @__PURE__ */ new Set([
   "FAILURE",
   "TIMED_OUT",
@@ -1061,7 +2110,7 @@ async function readState(stateFile) {
 }
 async function writeState(stateFile, state) {
   try {
-    await mkdir(join4(stateFile, ".."), { recursive: true });
+    await mkdir(join6(stateFile, ".."), { recursive: true });
     await writeFile2(stateFile, JSON.stringify(state, null, 2), "utf8");
   } catch {
   }
@@ -1078,7 +2127,7 @@ async function trackDispatchedPr({ prNumber, repo, branch, taskId }, { stateFile
   };
   await writeState(stateFile, state);
 }
-async function runWatchCycle({ viewPr, enqueueFix, log: log2 = () => {
+async function runWatchCycle({ viewPr, enqueueFix, log: log3 = () => {
 }, now = () => Date.now(), maxFixAttempts = 1, stateFile = DEFAULT_STATE_FILE }) {
   const state = await readState(stateFile);
   const prNumbers = Object.keys(state);
@@ -1091,7 +2140,7 @@ async function runWatchCycle({ viewPr, enqueueFix, log: log2 = () => {
     try {
       view = await viewPr(prNumber, entry.repo);
     } catch (err) {
-      log2(`watch: pr #${prNumber} view failed: ${err.message}`);
+      log3(`watch: pr #${prNumber} view failed: ${err.message}`);
       continue;
     }
     checked += 1;
@@ -1101,21 +2150,21 @@ async function runWatchCycle({ viewPr, enqueueFix, log: log2 = () => {
     if (action === "untrack") {
       delete state[prNumber];
       untracked += 1;
-      log2(`watch: pr #${prNumber} is ${pr.state} \u2014 untracked`);
+      log3(`watch: pr #${prNumber} is ${pr.state} \u2014 untracked`);
     } else if (action === "fix") {
       entry.fixAttempts = (entry.fixAttempts || 0) + 1;
       entry.lastCheckedAt = now();
       try {
         await enqueueFix({ prNumber: Number(prNumber), repo: entry.repo, branch: pr.branch || entry.branch, failedChecks: pr.failedChecks });
         fixed += 1;
-        log2(`watch: pr #${prNumber} CI failing (${pr.failedChecks.join(", ") || "unknown"}) \u2014 dispatched fix ${entry.fixAttempts}/${maxFixAttempts}`);
+        log3(`watch: pr #${prNumber} CI failing (${pr.failedChecks.join(", ") || "unknown"}) \u2014 dispatched fix ${entry.fixAttempts}/${maxFixAttempts}`);
       } catch (err) {
         entry.enqueueErrors = (entry.enqueueErrors || 0) + 1;
         if (entry.enqueueErrors >= MAX_ENQUEUE_ERRORS) {
-          log2(`watch: pr #${prNumber} fix enqueue failed ${entry.enqueueErrors}x \u2014 giving up: ${err.message}`);
+          log3(`watch: pr #${prNumber} fix enqueue failed ${entry.enqueueErrors}x \u2014 giving up: ${err.message}`);
         } else {
           entry.fixAttempts = Math.max(0, (entry.fixAttempts || 1) - 1);
-          log2(`watch: pr #${prNumber} fix enqueue failed (${entry.enqueueErrors}/${MAX_ENQUEUE_ERRORS}): ${err.message}`);
+          log3(`watch: pr #${prNumber} fix enqueue failed (${entry.enqueueErrors}/${MAX_ENQUEUE_ERRORS}): ${err.message}`);
         }
       }
     } else {
@@ -1127,17 +2176,17 @@ async function runWatchCycle({ viewPr, enqueueFix, log: log2 = () => {
     if (cappedFailing && e.trackedAt && now() - e.trackedAt > STALE_MS2) {
       delete state[n];
       untracked += 1;
-      log2(`watch: pr #${n} capped + failing + tracked >24h ago \u2014 pruned from watch state`);
+      log3(`watch: pr #${n} capped + failing + tracked >24h ago \u2014 pruned from watch state`);
     }
   }
   await writeState(stateFile, state);
   return { checked, fixed, untracked };
 }
-function makeWatchRunner({ client, viewPr = ghViewPr, log: log2, maxFixAttempts }) {
+function makeWatchRunner({ client, viewPr = ghViewPr, log: log3, maxFixAttempts }) {
   return () => runWatchCycle({
     viewPr,
     enqueueFix: ({ prNumber, repo, branch, failedChecks }) => client.enqueueCodeTask({ repo, prompt: buildCiFixPrompt({ prNumber, repo, branch, failedChecks }) }),
-    log: log2,
+    log: log3,
     maxFixAttempts
   });
 }
@@ -1198,15 +2247,15 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
     res.end(JSON.stringify({ ok: false, error: "not_found" }));
   };
 }
-function startControlServer({ port, getStatus, requestStop, allowedOrigin, log: log2 = () => {
+function startControlServer({ port, getStatus, requestStop, allowedOrigin, log: log3 = () => {
 } }) {
   const server = createServer(buildControlHandler({ getStatus, requestStop, allowedOrigin }));
-  server.on("error", (e) => log2(`control server error: ${e.message} (in-product runner control disabled)`));
-  server.listen(port, "127.0.0.1", () => log2(`control server on http://127.0.0.1:${port} (allow ${allowedOrigin})`));
+  server.on("error", (e) => log3(`control server error: ${e.message} (in-product runner control disabled)`));
+  server.listen(port, "127.0.0.1", () => log3(`control server on http://127.0.0.1:${port} (allow ${allowedOrigin})`));
   server.unref?.();
   return server;
 }
-function startDaemonControl({ cfg, requestStop, getActiveCount, isRunning, startedAt, log: log2 = () => {
+function startDaemonControl({ cfg, requestStop, getActiveCount, isRunning, startedAt, log: log3 = () => {
 } }) {
   if (!cfg.controlEnabled) return null;
   return startControlServer({
@@ -1218,12 +2267,13 @@ function startDaemonControl({ cfg, requestStop, getActiveCount, isRunning, start
       pid: process.pid,
       runnerId: cfg.runnerId,
       servedRepos: cfg.servedRepos,
+      servedOperators: cfg.servedOperators,
       watchEnabled: cfg.watchEnabled,
       activeTasks: getActiveCount(),
       startedAt: new Date(startedAt).toISOString(),
       uptimeSec: Math.round((Date.now() - startedAt) / 1e3)
     }),
-    log: log2
+    log: log3
   });
 }
 
@@ -1527,6 +2577,59 @@ async function resolveModelFamily(family, options = {}) {
 }
 
 // ../../scripts/virtual-office/code-runner/model-router.mjs
+var TASK_MODEL_AGENTS = ["claude", "codex", "cursor"];
+var DEFAULT_AGENT2 = "claude";
+var AGENT_TIER_FAMILIES = {
+  claude: {
+    cheap: "anthropic-balanced",
+    mid: "anthropic-flagship",
+    best: "anthropic-flagship"
+  },
+  codex: {
+    // Codex model names are account/runtime dependent. A ChatGPT-account Codex
+    // CLI rejects some registry/fallback ids, so let the CLI choose its default.
+    cheap: null,
+    mid: null,
+    best: null
+  },
+  // Cursor's supported remote model ids are account/runtime dependent. Let the
+  // CLI pick its own default unless the operator overrides it elsewhere.
+  cursor: {
+    cheap: null,
+    mid: null,
+    best: null
+  }
+};
+var AGENT_TIER_FALLBACKS = {
+  claude: {
+    cheap: "claude-sonnet-4-6",
+    mid: "claude-opus-4-7",
+    best: "claude-opus-4-8"
+  },
+  codex: {
+    cheap: null,
+    mid: null,
+    best: null
+  },
+  cursor: {
+    cheap: null,
+    mid: null,
+    best: null
+  }
+};
+var AGENT_MODEL_COMPATIBILITY = {
+  claude: (model) => /^claude-/i.test(String(model || "")),
+  codex: (model) => /^(?:gpt-|o\d|codex)/i.test(String(model || "")),
+  cursor: () => true
+};
+function normalizeAgent(agent = DEFAULT_AGENT2) {
+  const normalized = String(agent || DEFAULT_AGENT2).trim().toLowerCase();
+  return TASK_MODEL_AGENTS.includes(normalized) ? normalized : DEFAULT_AGENT2;
+}
+function modelCompatibleWithAgent(agent, model) {
+  if (!model) return true;
+  return AGENT_MODEL_COMPATIBILITY[agent]?.(model) ?? false;
+}
 function classifyTier(prompt) {
   const text = String(prompt || "").trim();
   if (!text) return "mid";
@@ -1543,30 +2646,34 @@ function classifyTier(prompt) {
   }
   return "mid";
 }
-async function resolveModelForTier(tier, { resolveModelFamily: resolver = resolveModelFamily } = {}) {
+async function resolveModelForTier(tier, { agent = DEFAULT_AGENT2, resolveModelFamily: resolver = resolveModelFamily } = {}) {
   const t = String(tier || "mid").trim();
-  if (t === "cheap") {
-    const resolved2 = await resolver("anthropic-balanced");
-    return resolved2 || "claude-sonnet-4-6";
-  }
-  if (t === "best") {
-    const resolved2 = await resolver("anthropic-flagship");
-    return resolved2 || "claude-opus-4-8";
-  }
-  const resolved = await resolver("anthropic-flagship");
-  return resolved || "claude-opus-4-7";
-}
-async function resolveTaskModel(task) {
+  const normalizedAgent = normalizeAgent(agent);
+  const families = AGENT_TIER_FAMILIES[normalizedAgent];
+  const fallbacks = AGENT_TIER_FALLBACKS[normalizedAgent];
+  const effectiveTier = t === "cheap" || t === "best" ? t : "mid";
+  const family = families[effectiveTier];
+  if (!family) {
+    return fallbacks[effectiveTier];
+  }
+  const resolved = await resolver(family);
+  if (resolved && modelCompatibleWithAgent(normalizedAgent, resolved)) return resolved;
+  return fallbacks[effectiveTier];
+}
+async function resolveTaskModel(task, { agent = DEFAULT_AGENT2 } = {}) {
   const tier = task.tier && task.tier !== "auto" ? task.tier : classifyTier(task.prompt);
-  const model = await resolveModelForTier(tier);
+  const model = await resolveModelForTier(tier, { agent });
   return { tier, model };
 }
 
 // ../../scripts/virtual-office/code-runner/apply-effort-mode.mjs
-async function resolveEffortDispatch({ client, task, env: env2, basePrompt, resolveModel = resolveTaskModel }) {
+async function resolveEffortDispatch({ client, task, agent = "claude", env: env2, basePrompt, resolveModel = resolveTaskModel }) {
   const dispatchMode = await client.getDispatchMode().catch(() => "standard");
   const effortConfig = resolveEffortMode(dispatchMode);
-  const { tier, model } = await resolveModel({ ...task, tier: task.tier ?? effortConfig.tier });
+  const { tier, model } = await resolveModel(
+    { ...task, tier: task.tier ?? effortConfig.tier },
+    { agent }
+  );
   return {
     dispatchMode,
     tier,
@@ -1619,8 +2726,73 @@ function describeClaimScoping(cfg = {}, env2 = {}) {
   return lines;
 }
 
+// ../../scripts/virtual-office/code-runner/reconnect-backoff.mjs
+function makeReconnectBackoff({
+  baseMs = 5e3,
+  capMs = 6e4,
+  jitter = 0.2,
+  log: log3 = () => {
+  },
+  random = Math.random
+} = {}) {
+  let consecutiveFailures = 0;
+  return {
+    /**
+     * Record a failed poll. Logs once as an outage begins, then quieter retry
+     * lines. Returns the delay (ms) the caller should sleep before retrying.
+     * @param {unknown} err
+     * @returns {number} delayMs
+     */
+    onFailure(err) {
+      consecutiveFailures += 1;
+      const exp = Math.min(capMs, baseMs * 2 ** (consecutiveFailures - 1));
+      const delta = exp * jitter * (random() * 2 - 1);
+      const delayMs = Math.round(Math.min(capMs, Math.max(baseMs, exp + delta)));
+      const reason = err && err.message ? err.message : String(err);
+      const secs = Math.max(1, Math.round(delayMs / 1e3));
+      log3(
+        consecutiveFailures === 1 ? `\u26A0 lost connection to control-plane \u2014 retrying in ${secs}s: ${reason}` : `\u26A0 still offline (${consecutiveFailures} consecutive) \u2014 retrying in ${secs}s: ${reason}`
+      );
+      return delayMs;
+    },
+    /**
+     * Record a successful poll. On the FIRST success after an outage, logs
+     * "✓ reconnected" and resets the backoff. Returns true iff it was a recovery.
+     * @returns {boolean} reconnected
+     */
+    onSuccess() {
+      if (consecutiveFailures === 0) return false;
+      const prior = consecutiveFailures;
+      consecutiveFailures = 0;
+      log3(`\u2713 reconnected to control-plane after ${prior} failed attempt(s)`);
+      return true;
+    },
+    /** Current consecutive-failure count (0 ⇒ healthy). */
+    get failures() {
+      return consecutiveFailures;
+    },
+    /** True while the connection is considered degraded/offline. */
+    get degraded() {
+      return consecutiveFailures > 0;
+    }
+  };
+}
+function installProcessSafetyNet({ log: log3 = () => {
+}, proc = process } = {}) {
+  if (proc.__voRunnerSafetyNet) return false;
+  proc.__voRunnerSafetyNet = true;
+  const describe = (e) => e && e.stack ? e.stack : e && e.message ? e.message : String(e);
+  proc.on("unhandledRejection", (reason) => {
+    log3(`unhandledRejection (kept alive): ${describe(reason)}`);
+  });
+  proc.on("uncaughtException", (err) => {
+    log3(`uncaughtException (kept alive): ${describe(err)}`);
+  });
+  return true;
+}
+
 // ../../scripts/virtual-office/code-runner-daemon.mjs
-function log(msg) {
+function log2(msg) {
   console.log(`[code-runner ${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}`);
 }
 var RATE_LIMIT_RESUME_ENABLED = process.env.VO_RATE_LIMIT_RESUME === "1";
@@ -1628,7 +2800,8 @@ var parseList = (s) => String(s || "").split(/[\s,]+/).map((x) => x.trim()).filt
 function loadConfig(env2 = process.env) {
   return {
     runnerId: env2.VO_CODE_RUNNER_ID || `vo-code-runner-${os.hostname()}`,
-    claudeBin: env2.VO_CODE_RUNNER_CLAUDE_BIN || "claude",
+    // BYO multi-agent: {agent, runner, runnerBin} — VO_CODE_RUNNER_AGENT (claude|codex).
+    ...resolveRunner(env2, { warn: (m) => log2(`agent-select: ${m}`) }),
     permissionMode: env2.VO_CODE_RUNNER_PERMISSION_MODE || "acceptEdits",
     maxConcurrency: Math.max(1, Number(env2.VO_CODE_TASK_MAX_CONCURRENCY || 2) || 2),
     pollSec: Math.max(1, Number(env2.VO_CODE_RUNNER_POLL_SEC || 5) || 5),
@@ -1643,9 +2816,8 @@ function loadConfig(env2 = process.env) {
     sessionForwardSec: Math.max(0, Number(env2.VO_SESSION_FORWARD_SEC ?? 30) || 0),
     operatorSeed: env2.VO_LOCAL_OPERATOR_SEED || env2.VO_CODE_RUNNER_ID || `local-${os.hostname()}`,
     cancelPollMs: Math.max(1e3, Number(env2.VO_CODE_RUNNER_CANCEL_POLL_MS || 2500) || 2500),
-    // HARD enforced spend bound (max_budget_usd can only be checked post-hoc).
-    // Default 30 min; set 0 to disable.
-    maxWallClockMs: Math.max(0, Number(env2.VO_CODE_RUNNER_MAX_WALL_CLOCK_MS ?? 18e5) || 18e5),
+    // Hard cap OFF by default (0=no timer; work preserved via #7218 draft-PR). Set ms>0 to enforce; invalid→0.
+    maxWallClockMs: ((n) => Number.isFinite(n) && n >= 0 ? n : 0)(Number(env2.VO_CODE_RUNNER_MAX_WALL_CLOCK_MS ?? NaN)),
     // Active PR watcher: monitor each dispatched PR's CI + auto-dispatch ONE fix
     // on failure (never auto-merges). Off: VO_CODE_RUNNER_WATCH=0; cap/interval below.
     watchEnabled: env2.VO_CODE_RUNNER_WATCH !== "0",
@@ -1663,10 +2835,10 @@ var numOrUndef = (x) => typeof x === "number" ? x : void 0;
 async function safeProgress(client, id, patch) {
   try {
     const r = await client.postProgress(id, patch);
-    if (r && r.terminal) log(`task ${id} is terminal server-side; stopping updates`);
+    if (r && r.terminal) log2(`task ${id} is terminal server-side; stopping updates`);
     return r;
   } catch (err) {
-    log(`progress post failed for ${id}: ${err.message}`);
+    log2(`progress post failed for ${id}: ${err.message}`);
     return null;
   }
 }
@@ -1698,16 +2870,19 @@ function buildPrBody(task, run2, files) {
 async function processOneTask(client, task, cfg) {
   const id = task.code_task_id;
   let worktreeName = "";
+  let preserveReason = null;
   try {
-    const wt = createFixWorktree("code-task", { source: id.slice(0, 8) });
+    const wt = createFixWorktree("code-task", { source: id.slice(0, 8), repo: task.repo });
     worktreeName = wt.worktreeName;
-    const { dispatchMode, tier, model, permissionMode: effectivePermissionMode, maxTurns: effectiveMaxTurns, prompt: effortPrompt } = await resolveEffortDispatch({ client, task, env: process.env, basePrompt: composeDispatchPrompt(task.prompt, { repo: task.repo }) });
-    await safeProgress(client, id, { message: `${cfg.runnerId} spawning ${model} (${tier}, effort ${dispatchMode})` });
+    if (!worktreeName || !wt.worktreeDir) throw new Error("worktree isolation failure \u2014 refusing to run in the main tree");
+    const { dispatchMode, tier, model, permissionMode: effectivePermissionMode, maxTurns: effectiveMaxTurns, prompt: effortPrompt } = await resolveEffortDispatch({ client, task, agent: cfg.agent, env: process.env, basePrompt: composeDispatchPrompt(task.prompt, { repo: task.repo }) });
+    await safeProgress(client, id, { message: `${cfg.runnerId} spawning ${cfg.agent}:${model || "default"} (${tier}, effort ${dispatchMode})` });
     const cap = typeof task.max_budget_usd === "number" ? task.max_budget_usd : resolveSpendCapUsd();
-    const run2 = await runClaudeTask({
+    const run2 = await runAgentTask({
+      runner: cfg.runner,
+      bin: cfg.runnerBin,
       prompt: effortPrompt,
       cwd: wt.worktreeDir,
-      claudeBin: cfg.claudeBin,
       permissionMode: effectivePermissionMode,
       maxTurns: effectiveMaxTurns,
       model,
@@ -1723,10 +2898,12 @@ async function processOneTask(client, task, cfg) {
       maxWallClockMs: cfg.maxWallClockMs
     });
     if (run2.killed) {
-      log(`task ${id} cancelled by operator`);
+      preserveReason = "cancelled by operator \u2014 work preserved for recovery";
+      log2(`task ${id} cancelled by operator`);
       return;
     }
     if (run2.timedOut) {
+      preserveReason = "wall-clock timeout \u2014 partial work preserved for recovery";
       await safeProgress(client, id, {
         status: "failed",
         message: run2.summary,
@@ -1736,18 +2913,22 @@ async function processOneTask(client, task, cfg) {
       return;
     }
     if (typeof task.max_turns === "number" && typeof run2.numTurns === "number" && run2.numTurns > task.max_turns) {
-      log(`task ${id} WARNING: agent ran ${run2.numTurns} turns > max_turns ${task.max_turns}`);
+      log2(`task ${id} WARNING: agent ran ${run2.numTurns} turns > max_turns ${task.max_turns}`);
     }
     if (typeof run2.costUsd === "number" && cap > 0 && run2.costUsd > cap) {
-      log(
-        `task ${id}: usage ~$${run2.costUsd.toFixed(2)} (est, API-equivalent \u2014 not billed on a subscription) exceeded soft cap $${cap}; publishing the agent's work anyway`
-      );
+      log2(`task ${id}: usage ~$${run2.costUsd.toFixed(2)} (est, API-equivalent, not billed on a subscription) exceeded soft cap $${cap}; publishing anyway`);
     }
+    let partial = false;
     if (!run2.ok) {
       const v = classifyFailureForResume({ enabled: RATE_LIMIT_RESUME_ENABLED, run: run2, task });
-      if (v.rateLimited) log(`task ${id}: RATE_LIMITED (resumeAfter=${v.resumeAfter || "backoff"}); queued (${v.recorded ? "ok" : "queue-write-failed"})`);
-      await safeProgress(client, id, { ...v.progress, cost_usd: numOrUndef(run2.costUsd) });
-      return;
+      if (v.rateLimited) {
+        log2(`task ${id}: RATE_LIMITED (resumeAfter=${v.resumeAfter || "backoff"}); queued (${v.recorded ? "ok" : "queue-write-failed"})`);
+        await safeProgress(client, id, { ...v.progress, cost_usd: numOrUndef(run2.costUsd) });
+        return;
+      }
+      partial = true;
+      preserveReason = `${run2.summary || "incomplete"} \u2014 partial work preserved`;
+      log2(`task ${id}: ${run2.summary || "failed"} \u2014 publishing partial work as a draft PR`);
     }
     let files = listChangedFiles(wt.worktreeDir);
     let alreadyCommitted = false;
@@ -1756,33 +2937,37 @@ async function processOneTask(client, task, cfg) {
       if (committed.length > 0) {
         files = committed;
         alreadyCommitted = true;
-        log(`task ${id}: agent committed ${committed.length} file(s) to a branch; recovering`);
+        log2(`task ${id}: agent committed ${committed.length} file(s) to a branch; recovering`);
       }
     }
     const scratch = files.filter(isAgentScratch);
     if (scratch.length > 0) {
       files = files.filter((f) => !isAgentScratch(f));
-      log(`task ${id}: dropped ${scratch.length} scratch file(s): ${scratch.join(", ")}`);
+      log2(`task ${id}: dropped ${scratch.length} scratch file(s): ${scratch.join(", ")}`);
     }
     if (files.length === 0) {
       await safeProgress(client, id, {
-        status: "failed",
-        message: "agent made no file changes",
-        result: "no_changes",
+        status: partial ? "failed" : "no_changes_needed",
+        message: partial ? "agent made no file changes" : "agent completed \u2014 no change needed (already fixed / nothing to do)",
+        result: partial ? "no_changes" : String(run2.summary || "no_changes_needed").slice(0, 2e3),
         cost_usd: numOrUndef(run2.costUsd)
       });
+      if (!partial) log2(`task ${id}: agent completed successfully with no changes (already fixed)`);
       return;
     }
     const fresh = await client.getTask(id).catch(() => null);
     if (fresh && fresh.status === "cancelled") {
-      log(`task ${id} cancelled before PR open; discarding changes`);
+      log2(`task ${id} cancelled before PR open; discarding changes`);
       return;
     }
     await safeProgress(client, id, { message: `opening PR for ${files.length} changed file(s)` });
+    const githubToken = (await client.getInstallationToken())?.token ?? null;
     const pr = openCodeTaskPr(wt.worktreeDir, files, {
-      title: `code-task: ${task.prompt}`,
+      title: `${partial ? "\u26A0 PARTIAL (timed out) \u2014 " : ""}code-task: ${task.prompt}`,
       body: buildPrBody(task, run2, files),
-      alreadyCommitted
+      alreadyCommitted,
+      githubToken,
+      draft: partial
     });
     await safeProgress(client, id, {
       status: "pr_opened",
@@ -1792,18 +2977,19 @@ async function processOneTask(client, task, cfg) {
       result: String(run2.summary).slice(0, 2e3),
       cost_usd: numOrUndef(run2.costUsd)
     });
-    log(`task ${id} \u2192 PR ${pr.prUrl}`);
-    if (cfg.watchEnabled && !String(task.prompt || "").includes(CI_FIX_MARKER)) {
+    log2(`task ${id} \u2192 PR ${pr.prUrl}`);
+    if (cfg.watchEnabled && !partial && !String(task.prompt || "").includes(CI_FIX_MARKER)) {
       await trackDispatchedPr({
         prNumber: pr.prNumber,
         repo: task.repo,
         branch: pr.branch,
         taskId: id
-      }).catch((e) => log(`watch: track failed for #${pr.prNumber}: ${e.message}`));
+      }).catch((e) => log2(`watch: track failed for #${pr.prNumber}: ${e.message}`));
     }
   } catch (err) {
     const msg = err && err.message ? err.message : String(err);
-    log(`task ${id} error: ${msg}`);
+    log2(`task ${id} error: ${msg}`);
+    preserveReason = `runner error: ${msg}`.slice(0, 280);
     await safeProgress(client, id, {
       status: "failed",
       message: `runner error: ${msg}`.slice(0, 1500),
@@ -1811,7 +2997,7 @@ async function processOneTask(client, task, cfg) {
     }).catch(() => {
     });
   } finally {
-    if (worktreeName) cleanupFixWorktree(worktreeName);
+    if (worktreeName) finalizeWorktree(worktreeName, { preserveReason, taskId: id, repo: task.repo, prompt: task.prompt });
   }
 }
 async function main({ env: env2 = process.env, once: once2 = false } = {}) {
@@ -1822,10 +3008,11 @@ async function main({ env: env2 = process.env, once: once2 = false } = {}) {
   const stop = (sig) => {
     if (stopping) return;
     stopping = true;
-    log(`${sig} received \u2014 draining ${active} active task(s), no new claims`);
+    log2(`${sig} received \u2014 draining ${active} active task(s), no new claims`);
   };
   process.on("SIGINT", () => stop("SIGINT"));
   process.on("SIGTERM", () => stop("SIGTERM"));
+  installProcessSafetyNet({ log: log2 });
   const startedAt = Date.now();
   const controlServer = startDaemonControl({
     cfg,
@@ -1833,33 +3020,26 @@ async function main({ env: env2 = process.env, once: once2 = false } = {}) {
     getActiveCount: () => active,
     isRunning: () => !stopping,
     startedAt,
-    log
+    log: log2
   });
-  log(
-    `up as ${cfg.runnerId} \u2192 ${env2.VO_CONTROL_PLANE_URL} (concurrency ${cfg.maxConcurrency}, poll ${cfg.pollSec}s, once=${once2})`
+  log2(
+    `up as ${cfg.runnerId} \u2192 ${env2.VO_CONTROL_PLANE_URL} (agent ${cfg.agent} [${cfg.runnerBin}], concurrency ${cfg.maxConcurrency}, poll ${cfg.pollSec}s, once=${once2})`
   );
-  for (const line of describeClaimScoping(cfg, env2)) log(line);
-  log(
+  for (const line of describeClaimScoping(cfg, env2)) log2(line);
+  log2(
     cfg.watchEnabled ? `PR watcher ON \u2014 auto-fix ${cfg.watchMaxFix}/PR on CI failure, never auto-merges, every ${cfg.watchIntervalSec}s (VO_CODE_RUNNER_WATCH=0 to disable)` : "PR watcher OFF (VO_CODE_RUNNER_WATCH=0)"
   );
-  let lastSessionForward = 0;
   let lastWatchCycle = 0;
-  const runWatch = makeWatchRunner({ client, log, maxFixAttempts: cfg.watchMaxFix });
+  const runWatch = makeWatchRunner({ client, log: log2, maxFixAttempts: cfg.watchMaxFix });
+  const loopTick = makeLoopTicks({ client, cfg, env: env2, log: log2, getActive: () => active });
+  const backoff = makeReconnectBackoff({ baseMs: cfg.pollSec * 1e3, log: log2 });
   while (!stopping) {
-    if (cfg.sessionForwardSec > 0 && Date.now() - lastSessionForward >= cfg.sessionForwardSec * 1e3) {
-      lastSessionForward = Date.now();
-      forwardSessionSpool({
-        baseUrl: String(env2.VO_CONTROL_PLANE_URL || "").replace(/\/$/, ""),
-        token: env2.VO_CONTROL_PLANE_ADMIN_TOKEN || "",
-        operatorSeed: cfg.operatorSeed
-      }).catch(() => {
-      });
-    }
+    loopTick();
     if (cfg.watchEnabled && Date.now() - lastWatchCycle >= cfg.watchIntervalSec * 1e3) {
       lastWatchCycle = Date.now();
       runWatch().then((r) => {
-        if (r.checked > 0) log(`watch: ${r.checked} PR(s) checked, ${r.fixed} fix(es), ${r.untracked} untracked`);
-      }).catch((e) => log(`watch cycle error: ${e.message}`));
+        if (r.checked > 0) log2(`watch: ${r.checked} PR(s) checked, ${r.fixed} fix(es), ${r.untracked} untracked`);
+      }).catch((e) => log2(`watch cycle error: ${e.message}`));
     }
     if (active >= cfg.maxConcurrency) {
       await sleep(cfg.pollSec * 1e3);
@@ -1868,21 +3048,24 @@ async function main({ env: env2 = process.env, once: once2 = false } = {}) {
     let task;
     try {
       task = await client.claim(cfg.runnerId, cfg.servedRepos, cfg.servedOperators);
+      backoff.onSuccess();
     } catch (err) {
-      log(`claim error: ${err.message}`);
-      if (once2) break;
-      await sleep(cfg.pollSec * 1e3);
+      if (once2) {
+        log2(`claim error: ${err.message}`);
+        break;
+      }
+      await sleep(backoff.onFailure(err));
       continue;
     }
     if (!task) {
       if (once2) {
-        log("no pending task; --once exiting");
+        log2("no pending task; --once exiting");
         break;
       }
       await sleep(cfg.pollSec * 1e3);
       continue;
     }
-    log(`claimed task ${task.code_task_id} (${task.repo})`);
+    log2(`claimed task ${task.code_task_id} (${task.repo})`);
     active += 1;
     const done = processOneTask(client, task, cfg).finally(() => {
       active -= 1;
@@ -1896,12 +3079,9 @@ async function main({ env: env2 = process.env, once: once2 = false } = {}) {
     await sleep(500);
   }
   if (controlServer) controlServer.close();
-  log("stopped");
+  log2("stopped");
 }
-var invokedDirectly = process.argv[1] && fileURLToPath2(import.meta.url) === process.argv[1] && // Bundle-safe: only self-start when THIS file is the real entry, not when the
-// module is inlined into a bundle (e.g. @algosuite/vo-mcp's dist/runner-cli.js,
-// which calls main() itself — without this, `node dist/runner-cli.js` would
-// start a SECOND daemon loop and double-claim tasks).
+var invokedDirectly = process.argv[1] && fileURLToPath2(import.meta.url) === process.argv[1] && // Bundle-safe: self-start only when THIS file is the real entry (not inlined into vo-mcp's runner-cli.js ⇒ double-claim).
 import.meta.url.endsWith("code-runner-daemon.mjs");
 if (invokedDirectly) {
   const once2 = process.argv.includes("--once");