@algosuite/vo-mcp 0.2.0-beta.16 → 0.2.0-beta.17

package/dist/runner-cli.js

@@ -424,7 +424,7 @@ async function runProcess(command, args = [], options = {}) {
   const killGraceMs = options.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
   const forceKillTimeoutMs = options.forceKillTimeoutMs ?? DEFAULT_FORCE_KILL_TIMEOUT_MS;
   const spawnImpl = options.spawnImpl || spawn;
-  const killProcessTree = options.killProcessTree || killProcessTreeDefault;
+  const killProcessTree2 = options.killProcessTree || killProcessTreeDefault;
   const spawnOptions = {
     cwd: options.cwd,
     env: options.env,
@@ -462,7 +462,7 @@ async function runProcess(command, args = [], options = {}) {
       forceKillTimeout.unref?.();
       void (async () => {
         try {
-          await killProcessTree(child.pid, { timeoutMs: forceKillTimeoutMs });
+          await killProcessTree2(child.pid, { timeoutMs: forceKillTimeoutMs });
         } catch (error) {
           finish({ status: null, error });
         }
@@ -2142,11 +2142,11 @@ function createControlPlaneClient({
     throw new Error("VO_CONTROL_PLANE_URL is required for the code-runner daemon");
   }
   const root = resolvedBaseUrl.replace(/\/+$/, "");
-  async function req(method, path17, body, { timeoutMs } = {}) {
+  async function req(method, path18, body, { timeoutMs } = {}) {
     const bearer = await resolveBearer(env2);
     const controller = timeoutMs ? new AbortController() : null;
     let timeoutId;
-    const request = Promise.resolve(fetchImpl(`${root}${path17}`, {
+    const request = Promise.resolve(fetchImpl(`${root}${path18}`, {
       method,
       headers: {
         "content-type": "application/json",
@@ -2159,7 +2159,7 @@ function createControlPlaneClient({
     const timeout = new Promise((_, reject) => {
       timeoutId = setTimeout(() => {
         controller.abort();
-        reject(new Error(`control-plane ${path17} timed out after ${timeoutMs}ms`));
+        reject(new Error(`control-plane ${path18} timed out after ${timeoutMs}ms`));
       }, timeoutMs);
     });
     try {
@@ -2278,8 +2278,8 @@ function createControlPlaneClient({
       return json ? json.task : null;
     },
     async downloadTaskAttachment(taskId, attachmentId) {
-      const path17 = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
-      const res = await req("GET", path17);
+      const path18 = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
+      const res = await req("GET", path18);
       if (res.status === 401) cachedFirebaseToken = null;
       if (!res.ok) throw new Error(`attachment download failed: HTTP ${res.status}`);
       return Buffer.from(await res.arrayBuffer());
@@ -2792,8 +2792,8 @@ function buildDockerArgs({
   image = DEFAULT_SANDBOX_IMAGE,
   agentBin = "claude",
   agentArgs = [],
-  passEnv = ["ANTHROPIC_API_KEY"],
-  network = "bridge",
+  passEnv = [],
+  network = "none",
   memory = "4g",
   cpus = "2",
   pids = "512",
@@ -2950,6 +2950,243 @@ var init_terminal_process_cleanup = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/orphan-agent-reaper.mjs
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import os from "node:os";
+import path10 from "node:path";
+function registryRoot(tmp = os.tmpdir()) {
+  return path10.join(tmp, REGISTRY_ROOT_NAME);
+}
+function instanceDir(root, instanceId) {
+  return path10.join(root, String(instanceId).replace(/[^A-Za-z0-9_-]/g, ""));
+}
+function registerDaemonInstance({
+  root = registryRoot(),
+  instanceId,
+  daemonPid = process.pid,
+  daemonStartedAtMs = Date.now()
+} = {}) {
+  if (!instanceId) return null;
+  const dir = instanceDir(root, instanceId);
+  mkdirSync2(dir, { recursive: true });
+  const file = path10.join(dir, DAEMON_RECORD);
+  writeFileSync2(file, JSON.stringify({ daemonPid, daemonStartedAtMs, instanceId }), {
+    encoding: "utf8",
+    mode: 384
+  });
+  return file;
+}
+function recordAgentPid({
+  root = registryRoot(),
+  instanceId = process.env.VO_RUNNER_INSTANCE_ID,
+  pid,
+  agentId = "",
+  startedAtMs = Date.now()
+} = {}) {
+  if (!instanceId || !Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    const dir = instanceDir(root, instanceId);
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(
+      path10.join(dir, `${pid}.json`),
+      JSON.stringify({ pid, agentId, startedAtMs, instanceId }),
+      { encoding: "utf8", mode: 384 }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function unrecordAgentPid({
+  root = registryRoot(),
+  instanceId = process.env.VO_RUNNER_INSTANCE_ID,
+  pid
+} = {}) {
+  if (!instanceId || !Number.isInteger(pid)) return false;
+  try {
+    rmSync2(path10.join(instanceDir(root, instanceId), `${pid}.json`), { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function bootstrapOrphanReaper({ instanceId, log: log3 = () => {
+} } = {}) {
+  if (!instanceId) return { killed: 0, prunedDirs: 0 };
+  process.env.VO_RUNNER_INSTANCE_ID = instanceId;
+  try {
+    registerDaemonInstance({ instanceId });
+  } catch {
+  }
+  return reapOrphanedAgents({ currentInstanceId: instanceId, log: log3 });
+}
+function readRegistry({ root = registryRoot(), currentInstanceId } = {}) {
+  const instances = [];
+  if (!existsSync3(root)) return instances;
+  let dirents;
+  try {
+    dirents = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return instances;
+  }
+  for (const dirent of dirents) {
+    if (!dirent.isDirectory()) continue;
+    if (currentInstanceId && dirent.name === instanceDirName(currentInstanceId)) continue;
+    const dir = path10.join(root, dirent.name);
+    let daemon = null;
+    const agents = [];
+    let files;
+    try {
+      files = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const name of files) {
+      let parsed;
+      try {
+        parsed = JSON.parse(readFileSync2(path10.join(dir, name), "utf8"));
+      } catch {
+        continue;
+      }
+      if (name === DAEMON_RECORD) {
+        if (Number.isInteger(parsed?.daemonPid)) {
+          daemon = { pid: parsed.daemonPid, startedAtMs: Number(parsed.daemonStartedAtMs) || 0 };
+        }
+      } else if (Number.isInteger(parsed?.pid)) {
+        agents.push({ pid: parsed.pid, agentId: String(parsed.agentId || ""), startedAtMs: Number(parsed.startedAtMs) || 0 });
+      }
+    }
+    instances.push({ instanceId: dirent.name, dir, daemon, agents });
+  }
+  return instances;
+}
+function instanceDirName(instanceId) {
+  return String(instanceId).replace(/[^A-Za-z0-9_-]/g, "");
+}
+function creationMatches(live, recordedStartedAtMs, toleranceMs) {
+  if (!live || !Number.isFinite(live.creationMs)) return false;
+  if (!Number.isFinite(recordedStartedAtMs) || recordedStartedAtMs <= 0) return false;
+  return Math.abs(live.creationMs - recordedStartedAtMs) <= toleranceMs;
+}
+function selectOrphanKills({ instances = [], liveProcesses = /* @__PURE__ */ new Map(), toleranceMs = CREATION_MATCH_TOLERANCE_MS } = {}) {
+  const kills = [];
+  const pruneDirs = [];
+  for (const instance of instances) {
+    if (!instance.daemon) {
+      if (instance.dir) pruneDirs.push(instance.dir);
+      continue;
+    }
+    const daemonLive = liveProcesses.has(instance.daemon.pid) && creationMatches(liveProcesses.get(instance.daemon.pid), instance.daemon.startedAtMs, toleranceMs);
+    if (daemonLive) continue;
+    for (const agent of instance.agents) {
+      const live = liveProcesses.get(agent.pid);
+      if (live && creationMatches(live, agent.startedAtMs, toleranceMs)) {
+        kills.push({ pid: agent.pid, agentId: agent.agentId, instanceId: instance.instanceId });
+      }
+    }
+    if (instance.dir) pruneDirs.push(instance.dir);
+  }
+  return { kills, pruneDirs };
+}
+function listProcessCreationTimes({ platform = process.platform, spawn: spawn5 = spawnSync5 } = {}) {
+  const map = /* @__PURE__ */ new Map();
+  if (platform === "win32") {
+    const ps = "Get-CimInstance Win32_Process | ForEach-Object { '{0} {1}' -f $_.ProcessId, (([DateTimeOffset]$_.CreationDate.ToUniversalTime()).ToUnixTimeMilliseconds()) }";
+    const result2 = spawn5("powershell", ["-NoProfile", "-NonInteractive", "-Command", ps], {
+      windowsHide: true,
+      encoding: "utf8",
+      timeout: 2e4,
+      maxBuffer: 32 * 1024 * 1024
+    });
+    if (result2.error || result2.status !== 0 || typeof result2.stdout !== "string") return map;
+    for (const line of result2.stdout.split(/\r?\n/)) {
+      const m = line.trim().match(/^(\d+)\s+(-?\d+)$/);
+      if (m) map.set(Number(m[1]), { creationMs: Number(m[2]) });
+    }
+    return map;
+  }
+  const result = spawn5("ps", ["-eo", "pid=,lstart="], { encoding: "utf8", timeout: 2e4, maxBuffer: 32 * 1024 * 1024 });
+  if (result.error || result.status !== 0 || typeof result.stdout !== "string") return map;
+  for (const line of result.stdout.split(/\r?\n/)) {
+    const parsed = parsePosixPsLine(line);
+    if (parsed) map.set(parsed.pid, { creationMs: parsed.creationMs });
+  }
+  return map;
+}
+function parsePosixPsLine(line) {
+  const trimmed = String(line ?? "").trim();
+  const sp = trimmed.indexOf(" ");
+  if (sp <= 0) return null;
+  const pid = Number(trimmed.slice(0, sp));
+  const when = Date.parse(trimmed.slice(sp + 1).trim());
+  if (!Number.isInteger(pid) || pid <= 0 || !Number.isFinite(when)) return null;
+  return { pid, creationMs: when };
+}
+function killProcessTree(pid, { platform = process.platform, spawn: spawn5 = spawnSync5 } = {}) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  if (platform === "win32") {
+    const r = spawn5("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore", timeout: 15e3 });
+    return !r.error && r.status === 0;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+    return true;
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function reapOrphanedAgents({
+  root = registryRoot(),
+  currentInstanceId = process.env.VO_RUNNER_INSTANCE_ID,
+  toleranceMs = CREATION_MATCH_TOLERANCE_MS,
+  listProcesses = listProcessCreationTimes,
+  killTree = killProcessTree,
+  log: log3 = () => {
+  }
+} = {}) {
+  try {
+    const instances = readRegistry({ root, currentInstanceId });
+    if (instances.length === 0) return { killed: 0, prunedDirs: 0 };
+    const liveProcesses = listProcesses();
+    const { kills, pruneDirs } = selectOrphanKills({ instances, liveProcesses, toleranceMs });
+    let killed = 0;
+    for (const kill of kills) {
+      if (killTree(kill.pid)) {
+        killed += 1;
+        log3(`reaped orphaned agent pid ${kill.pid}${kill.agentId ? ` (${kill.agentId})` : ""} from dead instance ${kill.instanceId}`);
+      }
+    }
+    let prunedDirs = 0;
+    for (const dir of pruneDirs) {
+      try {
+        rmSync2(dir, { recursive: true, force: true });
+        prunedDirs += 1;
+      } catch {
+      }
+    }
+    if (killed > 0 || prunedDirs > 0) log3(`orphan reap: killed ${killed} agent tree(s), pruned ${prunedDirs} dead instance record(s)`);
+    return { killed, prunedDirs };
+  } catch (error) {
+    log3(`orphan reap skipped: ${error instanceof Error ? error.message : String(error)}`);
+    return { killed: 0, prunedDirs: 0 };
+  }
+}
+var REGISTRY_ROOT_NAME, DAEMON_RECORD, CREATION_MATCH_TOLERANCE_MS;
+var init_orphan_agent_reaper = __esm({
+  "../../scripts/virtual-office/code-runner/orphan-agent-reaper.mjs"() {
+    "use strict";
+    REGISTRY_ROOT_NAME = "algohq-runner-agent-pids";
+    DAEMON_RECORD = "daemon.json";
+    CREATION_MATCH_TOLERANCE_MS = 3e4;
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/claude-runner.mjs
 import { spawn as spawn2 } from "node:child_process";
 function extractText(content) {
@@ -3040,6 +3277,7 @@ function runAgentTask({
       stdio: ["pipe", "pipe", "pipe"],
       ...spawnOpts
     });
+    recordAgentPid({ pid: child.pid, agentId: spawnBin });
     try {
       child.stdin.write(String(prompt));
       child.stdin.end();
@@ -3155,6 +3393,7 @@ function runAgentTask({
       exitDrainTimer = setTimeout(() => finalizeChild({ code, signal }), exitDrainGraceMs);
     });
     child.on("close", (code, signal) => {
+      unrecordAgentPid({ pid: child.pid });
       finalizeChild({ code, signal });
     });
   });
@@ -3169,6 +3408,7 @@ var init_claude_runner = __esm({
     init_claude_args();
     init_windows_claude_launch();
     init_terminal_process_cleanup();
+    init_orphan_agent_reaper();
     ClaudeRunner = class {
       get binary() {
         return "claude";
@@ -3314,17 +3554,8 @@ var init_agent_key_store = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/codex-runner.mjs
-var codex_runner_exports = {};
-__export(codex_runner_exports, {
-  CODEX_PREFER_LOGIN_ENV: () => CODEX_PREFER_LOGIN_ENV,
-  CodexRunner: () => CodexRunner,
-  buildCodexArgs: () => buildCodexArgs,
-  codexRunner: () => codexRunner,
-  parseCodexEvent: () => parseCodexEvent,
-  resolveCodexBinary: () => resolveCodexBinary
-});
-import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
 import { win32 } from "node:path";
 function isTruthyFlag2(value) {
   return ["1", "true", "yes", "on"].includes(String(value ?? "").trim().toLowerCase());
@@ -3332,7 +3563,7 @@ function isTruthyFlag2(value) {
 function resolveCodexBinary({
   env: env2 = process.env,
   platform = process.platform,
-  exists = existsSync3
+  exists = existsSync4
 } = {}) {
   if (platform !== "win32") return "codex";
   const appData = String(env2.APPDATA || "").trim();
@@ -3367,7 +3598,7 @@ function resolveCodexBinary({
   return "codex";
 }
 function buildCodexArgs({ model, effort } = {}) {
-  const args = ["exec", "--json", "-c", 'approval_policy="never"', "--sandbox", "danger-full-access"];
+  const args = ["exec", "--json", "-c", 'approval_policy="never"', "--sandbox", "workspace-write"];
   if (model) {
     args.push("--model", String(model));
   }
@@ -3422,7 +3653,7 @@ var init_codex_runner = __esm({
     CODEX_PREFER_LOGIN_ENV = "VO_RUNNER_CODEX_PREFER_LOGIN";
     LEGACY_PREFER_LOGIN_ENV = "VO_RUNNER_PREFER_LOGIN";
     CodexRunner = class {
-      constructor({ spawn: spawn5 = spawnSync5, resolveBinary = resolveCodexBinary, env: env2 = process.env } = {}) {
+      constructor({ spawn: spawn5 = spawnSync6, resolveBinary = resolveCodexBinary, env: env2 = process.env } = {}) {
         this.spawn = spawn5;
         this.resolveBinary = resolveBinary;
         this.env = env2;
@@ -3512,7 +3743,7 @@ ${login.stderr || ""}`.trim();
 });
 
 // ../../scripts/virtual-office/code-runner/cursor-runner.mjs
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 function buildCursorArgs({ model, prompt } = {}) {
   const args = ["-p", "--output-format", "stream-json", "--force"];
   if (model) {
@@ -3591,7 +3822,7 @@ var init_cursor_runner = __esm({
       /** Best-effort: is `cursor-agent` on PATH? Never throws. */
       async checkAuth() {
         try {
-          const { status, error } = spawnSync6("cursor-agent", ["--version"], {
+          const { status, error } = spawnSync7("cursor-agent", ["--version"], {
             shell: process.platform === "win32",
             windowsHide: true,
             timeout: 3e3,
@@ -3617,45 +3848,6 @@ var init_cursor_runner = __esm({
   }
 });
 
-// ../../scripts/virtual-office/code-runner/meta-model-catalog.mjs
-function normalizeMetaEffort(value) {
-  const normalized = String(value || "").trim().toLowerCase();
-  if (["low", "medium", "high", "xhigh"].includes(normalized)) return normalized;
-  if (normalized === "max") return "xhigh";
-  return null;
-}
-function resolveMetaModelForTier() {
-  return META_DEFAULT_MODEL;
-}
-function resolveMetaEffortForTier(tier = "mid") {
-  return TIER_EFFORT[tier] || TIER_EFFORT.mid;
-}
-function resolveMetaEffortForRung(rung = "R3") {
-  return RUNG_EFFORT[rung] || RUNG_EFFORT.R3;
-}
-var META_DEFAULT_MODEL, META_API_BASE_URL, META_CONTEXT_WINDOW, META_MAX_OUTPUT_TOKENS, TIER_EFFORT, RUNG_EFFORT;
-var init_meta_model_catalog = __esm({
-  "../../scripts/virtual-office/code-runner/meta-model-catalog.mjs"() {
-    "use strict";
-    META_DEFAULT_MODEL = "muse-spark-1.1";
-    META_API_BASE_URL = "https://api.meta.ai/v1";
-    META_CONTEXT_WINDOW = 1048576;
-    META_MAX_OUTPUT_TOKENS = 131072;
-    TIER_EFFORT = Object.freeze({
-      cheap: "low",
-      mid: "medium",
-      best: "xhigh"
-    });
-    RUNG_EFFORT = Object.freeze({
-      R1: "low",
-      R2: "medium",
-      R3: "medium",
-      R4: "high",
-      R5: "xhigh"
-    });
-  }
-});
-
 // ../../scripts/virtual-office/code-runner/meta-runner.mjs
 function applyMetaAuthEnv(baseEnv = process.env) {
   const out = withAgentKey("meta", baseEnv);
@@ -3665,44 +3857,17 @@ function applyMetaAuthEnv(baseEnv = process.env) {
   return out;
 }
 function buildMetaArgs(opts = {}) {
-  const model = String(opts.model || "").trim() || META_DEFAULT_MODEL;
-  const args = [
-    "exec",
-    "--json",
-    "-c",
-    'approval_policy="never"',
-    "--sandbox",
-    "danger-full-access",
-    "-c",
-    `model_providers.${PROVIDER_SLUG}.name="Meta Muse Spark"`,
-    "-c",
-    `model_providers.${PROVIDER_SLUG}.base_url="${META_API_BASE_URL}"`,
-    "-c",
-    `model_providers.${PROVIDER_SLUG}.env_key="${META_API_KEY_ENV}"`,
-    "-c",
-    `model_providers.${PROVIDER_SLUG}.wire_api="responses"`,
-    "-c",
-    `model_provider="${PROVIDER_SLUG}"`,
-    "-c",
-    `model_context_window=${META_CONTEXT_WINDOW}`,
-    "-c",
-    `model_max_output_tokens=${META_MAX_OUTPUT_TOKENS}`,
-    "--model",
-    model
-  ];
-  const effort = normalizeMetaEffort(opts.effort);
-  if (effort) args.push("-c", `model_reasoning_effort="${effort}"`);
-  args.push("-");
-  return args;
+  void opts;
+  throw new Error(
+    "Muse Spark full-repository coding is disabled by the AlgoSuite Model Firewall policy. Use Muse only as a restricted reviewer through a sanitized task capsule."
+  );
 }
-var PROVIDER_SLUG, META_API_KEY_ENV, META_API_KEY_ALIAS, MetaRunner, metaRunner;
+var META_API_KEY_ENV, META_API_KEY_ALIAS, MetaRunner, metaRunner;
 var init_meta_runner = __esm({
   "../../scripts/virtual-office/code-runner/meta-runner.mjs"() {
     "use strict";
     init_codex_runner();
     init_agent_key_store();
-    init_meta_model_catalog();
-    PROVIDER_SLUG = "meta";
     META_API_KEY_ENV = "MODEL_API_KEY";
     META_API_KEY_ALIAS = "META_API";
     MetaRunner = class {
@@ -3731,21 +3896,10 @@ var init_meta_runner = __esm({
         return `meta muse-spark key=${hasKey ? "set" : "MISSING"} transport=codex`;
       }
       async checkAuth() {
-        const { CodexRunner: CodexRunner2 } = await Promise.resolve().then(() => (init_codex_runner(), codex_runner_exports));
-        const codex = await new CodexRunner2().checkAuth();
-        if (!codex.installed) {
-          return {
-            installed: false,
-            authenticated: false,
-            message: `codex transport not on PATH (npm i -g @openai/codex): ${codex.message}`
-          };
-        }
-        const authEnv = applyMetaAuthEnv(process.env);
-        const hasKey = Boolean(String(authEnv[META_API_KEY_ENV] || "").trim());
         return {
-          installed: true,
-          authenticated: hasKey,
-          message: hasKey ? `Muse Spark ready via ${META_API_BASE_URL}` : `store a Meta key with \`vo-mcp set-key --provider meta\` or set ${META_API_KEY_ENV}`
+          installed: false,
+          authenticated: false,
+          message: "Muse Spark coding is disabled; sanitized Model Firewall review only"
         };
       }
     };
@@ -3757,91 +3911,23 @@ var init_meta_runner = __esm({
 function resolveOaiBaseUrl(env2 = process.env) {
   return String(env2.VO_CODE_RUNNER_OAI_BASE_URL || "").trim();
 }
-function resolveOaiModel(env2 = process.env) {
-  return String(env2.VO_CODE_RUNNER_OAI_MODEL || "").trim() || DEFAULT_OAI_MODEL;
-}
-function resolveOaiWireApi(env2 = process.env) {
-  const v = String(env2.VO_CODE_RUNNER_OAI_WIRE_API || "").trim().toLowerCase();
-  return v === "chat" || v === "responses" ? v : DEFAULT_OAI_WIRE_API;
-}
-function positiveIntEnv(raw) {
-  const n = Number(String(raw ?? "").trim());
-  return Number.isInteger(n) && n > 0 ? n : null;
-}
-function resolveOaiContextWindow(env2 = process.env) {
-  return positiveIntEnv(env2.VO_CODE_RUNNER_OAI_CONTEXT_WINDOW);
-}
-function resolveOaiMaxOutputTokens(env2 = process.env) {
-  return positiveIntEnv(env2.VO_CODE_RUNNER_OAI_MAX_OUTPUT_TOKENS);
-}
-function isCleanBaseUrl(url) {
-  return /^https?:\/\/[^\s"'`]+$/.test(url);
-}
-function buildOaiArgs(opts = {}, env2 = process.env) {
-  const baseUrl = resolveOaiBaseUrl(env2);
-  if (!baseUrl) {
-    throw new Error(
-      "openai-compatible runner: set VO_CODE_RUNNER_OAI_BASE_URL to an OpenAI-compatible endpoint (e.g. https://openrouter.ai/api/v1). Refusing to run with no explicit endpoint (fail-closed)."
-    );
-  }
-  if (!isCleanBaseUrl(baseUrl)) {
-    throw new Error(
-      `openai-compatible runner: VO_CODE_RUNNER_OAI_BASE_URL="${baseUrl}" is not a clean http(s) URL.`
-    );
-  }
-  const model = opts.model && String(opts.model).trim() ? String(opts.model).trim() : resolveOaiModel(env2);
-  const wireApi = resolveOaiWireApi(env2);
-  const args = [
-    "exec",
-    "--json",
-    "-c",
-    'approval_policy="never"',
-    "--sandbox",
-    "danger-full-access",
-    "-c",
-    `model_providers.${PROVIDER_SLUG2}.name="BYO OpenAI-compatible"`,
-    "-c",
-    `model_providers.${PROVIDER_SLUG2}.base_url="${baseUrl}"`,
-    "-c",
-    `model_providers.${PROVIDER_SLUG2}.env_key="${OAI_API_KEY_ENV}"`,
-    "-c",
-    `model_providers.${PROVIDER_SLUG2}.wire_api="${wireApi}"`,
-    "-c",
-    `model_provider="${PROVIDER_SLUG2}"`,
-    "--model",
-    model
-  ];
-  if (opts.effort) {
-    args.push("-c", `model_reasoning_effort="${String(opts.effort)}"`);
-  }
-  const contextWindow = resolveOaiContextWindow(env2);
-  if (contextWindow) {
-    args.push("-c", `model_context_window=${contextWindow}`);
-  }
-  const maxOutputTokens = resolveOaiMaxOutputTokens(env2);
-  if (maxOutputTokens) {
-    args.push("-c", `model_max_output_tokens=${maxOutputTokens}`);
-  }
-  args.push("-");
-  return args;
-}
-var PROVIDER_SLUG2, OAI_API_KEY_ENV, DEFAULT_OAI_MODEL, DEFAULT_OAI_WIRE_API, OpenAICompatibleRunner, openaiCompatibleRunner;
+var OAI_API_KEY_ENV, OpenAICompatibleRunner, openaiCompatibleRunner;
 var init_openai_compatible_runner = __esm({
   "../../scripts/virtual-office/code-runner/openai-compatible-runner.mjs"() {
     "use strict";
     init_codex_runner();
     init_agent_key_store();
-    PROVIDER_SLUG2 = "vooai";
     OAI_API_KEY_ENV = "VO_CODE_RUNNER_OAI_API_KEY";
-    DEFAULT_OAI_MODEL = "deepseek/deepseek-chat";
-    DEFAULT_OAI_WIRE_API = "responses";
     OpenAICompatibleRunner = class {
       /** Codex is the transport binary. */
       get binary() {
         return resolveCodexBinary();
       }
       buildArgs(opts = {}) {
-        return buildOaiArgs(opts, process.env);
+        void opts;
+        throw new Error(
+          "OpenAI-compatible full-repository coding is disabled. Use an explicit sanitized task capsule through the AlgoSuite Model Firewall."
+        );
       }
       /** Codex JSONL events map identically → reuse the proven parser. */
       parseEvent(line) {
@@ -3865,31 +3951,10 @@ var init_openai_compatible_runner = __esm({
       }
       /** Best-effort: base URL chosen AND the codex transport is installed. */
       async checkAuth() {
-        const baseUrl = resolveOaiBaseUrl(process.env);
-        if (!baseUrl) {
-          return {
-            installed: false,
-            authenticated: false,
-            message: "set VO_CODE_RUNNER_OAI_BASE_URL to an OpenAI-compatible endpoint (fail-closed; no default)"
-          };
-        }
-        if (!isCleanBaseUrl(baseUrl)) {
-          return { installed: false, authenticated: false, message: `VO_CODE_RUNNER_OAI_BASE_URL is malformed: ${baseUrl}` };
-        }
-        const { CodexRunner: CodexRunner2 } = await Promise.resolve().then(() => (init_codex_runner(), codex_runner_exports));
-        const codexAuth = await new CodexRunner2().checkAuth();
-        if (!codexAuth.installed) {
-          return {
-            installed: false,
-            authenticated: false,
-            message: `codex transport not on PATH (npm i -g @openai/codex): ${codexAuth.message}`
-          };
-        }
-        const hasKey = Boolean(String(process.env[OAI_API_KEY_ENV] || "").trim());
         return {
-          installed: true,
-          authenticated: hasKey,
-          message: hasKey ? `ready \u2192 ${baseUrl}` : `set ${OAI_API_KEY_ENV} (or store it in the keychain) for ${baseUrl}`
+          installed: false,
+          authenticated: false,
+          message: "OpenAI-compatible coding is disabled; sanitized Model Firewall task capsules only"
         };
       }
     };
@@ -4046,7 +4111,7 @@ var init_rate_limit_detector_core = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/rate-limit-resume.mjs
-import { appendFileSync, mkdirSync as mkdirSync2 } from "node:fs";
+import { appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2, dirname as dirname2 } from "node:path";
 function resumeQueuePath() {
@@ -4069,7 +4134,7 @@ function buildResumeEntry({ task = {}, resumeAfter = null, summary = "", at } =
 function recordRateLimited({ task = {}, resumeAfter = null, summary = "", queuePath = resumeQueuePath(), at = (/* @__PURE__ */ new Date()).toISOString() } = {}) {
   const entry = buildResumeEntry({ task, resumeAfter, summary, at });
   try {
-    mkdirSync2(dirname2(queuePath), { recursive: true });
+    mkdirSync3(dirname2(queuePath), { recursive: true });
     appendFileSync(queuePath, `${JSON.stringify(entry)}
 `, "utf-8");
     return { ok: true, entry };
@@ -4161,8 +4226,8 @@ var init_auto_merge = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/pr-overlap-gate.mjs
-import { spawnSync as spawnSync7 } from "node:child_process";
-import path10 from "node:path";
+import { spawnSync as spawnSync8 } from "node:child_process";
+import path11 from "node:path";
 var init_pr_overlap_gate = __esm({
   "../../scripts/virtual-office/code-runner/pr-overlap-gate.mjs"() {
     "use strict";
@@ -4202,21 +4267,21 @@ var init_existing_pr_publication = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/publish.mjs
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 function parsePorcelainZ(out) {
   const tokens = String(out).split("\0");
   const files = [];
   for (let i = 0; i < tokens.length; i += 1) {
     const tok = tokens[i];
     if (!tok) continue;
-    const path17 = tok.slice(3);
-    if (path17) files.push(path17);
+    const path18 = tok.slice(3);
+    if (path18) files.push(path18);
     if (tok[0] === "R" || tok[0] === "C") i += 1;
   }
   return files;
 }
-function isAgentScratch(path17) {
-  const p = String(path17 || "");
+function isAgentScratch(path18) {
+  const p = String(path18 || "");
   return SCRATCH_PATTERNS.some((re) => re.test(p));
 }
 function isMaxTurnsResult(summary) {
@@ -4423,7 +4488,7 @@ var init_partial_pr_continuation = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/publish-async.mjs
-import path11 from "node:path";
+import path12 from "node:path";
 function compactTitle(value, max = 100) {
   return String(value || "").replace(/\s+/g, " ").trim().slice(0, max) || "code-task";
 }
@@ -4465,7 +4530,7 @@ async function resolveOrCreateBranchAsync(worktreeDir, branchPrefix, runCommand
   return branch;
 }
 async function runLocalPrOverlapGateAsync(worktreeDir, files, { branch = "", env: env2 = process.env, excludePrNumber = null } = {}) {
-  const scriptPath = path11.join(worktreeDir, "scripts", "ci", "check-local-pr-overlap.mjs");
+  const scriptPath = path12.join(worktreeDir, "scripts", "ci", "check-local-pr-overlap.mjs");
   try {
     const output = await runProcess2("node", [
       scriptPath,
@@ -5060,8 +5125,8 @@ var init_task_prompt = __esm({
 // ../../scripts/virtual-office/code-runner/task-attachments.mjs
 import { createHash as createHash3, randomUUID } from "node:crypto";
 import { chmod, mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path12 from "node:path";
+import os2 from "node:os";
+import path13 from "node:path";
 function safeTaskToken(taskId) {
   return String(taskId || "task").replace(/[^0-9A-Za-z_-]/gu, "_").slice(0, 48) || "task";
 }
@@ -5071,25 +5136,25 @@ function sanitizeTaskAttachmentName(name, index = 0) {
   return `${String(index + 1).padStart(2, "0")}-${normalized}`;
 }
 function assertGeneratedDirectory(directory, tempRoot) {
-  const resolvedDirectory = path12.resolve(directory);
-  const resolvedRoot = path12.resolve(tempRoot);
-  if (path12.dirname(resolvedDirectory) !== resolvedRoot || !path12.basename(resolvedDirectory).startsWith(DIRECTORY_PREFIX)) {
+  const resolvedDirectory = path13.resolve(directory);
+  const resolvedRoot = path13.resolve(tempRoot);
+  if (path13.dirname(resolvedDirectory) !== resolvedRoot || !path13.basename(resolvedDirectory).startsWith(DIRECTORY_PREFIX)) {
     throw new Error("refusing to clean an unverified task-attachment directory");
   }
   return resolvedDirectory;
 }
 async function createAttachmentDirectory(taskId, tempRoot) {
-  const root = path12.resolve(tempRoot);
+  const root = path13.resolve(tempRoot);
   await mkdir(root, { recursive: true });
-  const directory = await mkdtemp(path12.join(root, `${DIRECTORY_PREFIX}${safeTaskToken(taskId)}-`));
-  const marker = JSON.stringify({ owner: MARKER_OWNER, token: randomUUID(), directory: path12.basename(directory), created_at: (/* @__PURE__ */ new Date()).toISOString() });
-  await writeFile(path12.join(directory, MARKER_FILE), marker, { encoding: "utf8", mode: 384 });
+  const directory = await mkdtemp(path13.join(root, `${DIRECTORY_PREFIX}${safeTaskToken(taskId)}-`));
+  const marker = JSON.stringify({ owner: MARKER_OWNER, token: randomUUID(), directory: path13.basename(directory), created_at: (/* @__PURE__ */ new Date()).toISOString() });
+  await writeFile(path13.join(directory, MARKER_FILE), marker, { encoding: "utf8", mode: 384 });
   return { directory, marker, tempRoot: root };
 }
 async function cleanupGeneratedDirectory(state) {
   if (!state || state.cleaned) return;
   const directory = assertGeneratedDirectory(state.directory, state.tempRoot);
-  const marker = await readFile(path12.join(directory, MARKER_FILE), "utf8").catch(() => "");
+  const marker = await readFile(path13.join(directory, MARKER_FILE), "utf8").catch(() => "");
   if (marker !== state.marker) throw new Error("refusing to clean a task-attachment directory without its exact marker");
   await rm(directory, { recursive: true, force: true });
   state.cleaned = true;
@@ -5104,11 +5169,11 @@ function parseOwnedMarker(raw, directoryName) {
   }
 }
 async function sweepStaleTaskAttachmentDirectories({
-  tempRoot = os.tmpdir(),
+  tempRoot = os2.tmpdir(),
   now = Date.now(),
   maxAgeMs = DEFAULT_STALE_AGE_MS
 } = {}) {
-  const root = path12.resolve(tempRoot);
+  const root = path13.resolve(tempRoot);
   if (!Number.isFinite(maxAgeMs) || maxAgeMs <= 0) throw new Error("stale attachment age must be positive");
   const entries = await readdir(root, { withFileTypes: true }).catch((error) => {
     if (error?.code === "ENOENT") return [];
@@ -5117,8 +5182,8 @@ async function sweepStaleTaskAttachmentDirectories({
   let removed = 0;
   for (const entry of entries) {
     if (!entry.isDirectory() || !entry.name.startsWith(DIRECTORY_PREFIX)) continue;
-    const directory = assertGeneratedDirectory(path12.join(root, entry.name), root);
-    const markerRaw = await readFile(path12.join(directory, MARKER_FILE), "utf8").catch(() => "");
+    const directory = assertGeneratedDirectory(path13.join(root, entry.name), root);
+    const markerRaw = await readFile(path13.join(directory, MARKER_FILE), "utf8").catch(() => "");
     const marker = parseOwnedMarker(markerRaw, entry.name);
     if (!marker) continue;
     const directoryStat = await stat(directory);
@@ -5145,7 +5210,7 @@ function buildManifest(files) {
     "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 END UNTRUSTED TASK ATTACHMENTS \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"
   ].join("\n");
 }
-async function materializeTaskAttachments(client, task, { tempRoot = os.tmpdir() } = {}) {
+async function materializeTaskAttachments(client, task, { tempRoot = os2.tmpdir() } = {}) {
   const refs = Array.isArray(task?.attachments) ? task.attachments : [];
   if (refs.length === 0) return { directory: null, files: [], manifestMarkdown: "", cleanup: async () => {
   } };
@@ -5161,10 +5226,10 @@ async function materializeTaskAttachments(client, task, { tempRoot = os.tmpdir()
       const sha256 = createHash3("sha256").update(content).digest("hex");
       if (sha256 !== ref.sha256) throw new Error(`attachment ${ref.attachment_id} sha256 mismatch`);
       const name = sanitizeTaskAttachmentName(ref.name, index);
-      const filePath = path12.join(state.directory, name);
+      const filePath = path13.join(state.directory, name);
       await writeFile(filePath, content, { flag: "wx", mode: 384 });
       await chmod(filePath, 384);
-      files.push({ attachmentId: ref.attachment_id, name, mime: ref.mime, sizeBytes: ref.size_bytes, sha256, path: path12.resolve(filePath) });
+      files.push({ attachmentId: ref.attachment_id, name, mime: ref.mime, sizeBytes: ref.size_bytes, sha256, path: path13.resolve(filePath) });
     }
     return { directory: state.directory, files, manifestMarkdown: buildManifest(files), cleanup: () => cleanupGeneratedDirectory(state) };
   } catch (error) {
@@ -5228,9 +5293,9 @@ async function readSpool(spoolDir = SPOOL_DIR) {
   }
   return out;
 }
-async function readCloudMap(path17) {
+async function readCloudMap(path18) {
   try {
-    return JSON.parse(await readFile2(path17, "utf8"));
+    return JSON.parse(await readFile2(path18, "utf8"));
   } catch {
     return {};
   }
@@ -5373,14 +5438,14 @@ var init_rate_limit_resume_scheduler_core = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/rate-limit-resume-scheduler.mjs
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "node:fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync4 } from "node:fs";
 import { dirname as dirname3, join as join4, resolve } from "node:path";
 function log(msg) {
   console.log(`[rate-limit-scheduler ${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}`);
 }
 function readQueue(queuePath) {
-  if (!existsSync4(queuePath)) return [];
-  const content = readFileSync2(queuePath, "utf-8");
+  if (!existsSync5(queuePath)) return [];
+  const content = readFileSync3(queuePath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
   const entries = [];
   for (const line of lines) {
@@ -5393,18 +5458,18 @@ function readQueue(queuePath) {
   return entries;
 }
 function writeQueue(queuePath, entries) {
-  mkdirSync3(dirname3(queuePath), { recursive: true });
+  mkdirSync4(dirname3(queuePath), { recursive: true });
   const lines = entries.map((e) => JSON.stringify(e)).join("\n");
-  writeFileSync2(queuePath, lines + (entries.length > 0 ? "\n" : ""), "utf-8");
+  writeFileSync3(queuePath, lines + (entries.length > 0 ? "\n" : ""), "utf-8");
 }
 function attemptsStorePath() {
   return join4(dirname3(resumeQueuePath()), "resume-attempts.json");
 }
 function readAttemptsStore() {
   const p = attemptsStorePath();
-  if (!existsSync4(p)) return {};
+  if (!existsSync5(p)) return {};
   try {
-    const parsed = JSON.parse(readFileSync2(p, "utf-8"));
+    const parsed = JSON.parse(readFileSync3(p, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -5412,8 +5477,8 @@ function readAttemptsStore() {
 }
 function writeAttemptsStore(store) {
   const p = attemptsStorePath();
-  mkdirSync3(dirname3(p), { recursive: true });
-  writeFileSync2(p, JSON.stringify(store, null, 2), "utf-8");
+  mkdirSync4(dirname3(p), { recursive: true });
+  writeFileSync3(p, JSON.stringify(store, null, 2), "utf-8");
 }
 function countsFromStore(store) {
   const counts = {};
@@ -5797,9 +5862,9 @@ var init_agent_availability = __esm({
 // ../../scripts/virtual-office/code-runner/account-usage.mjs
 import { spawn as spawn4 } from "node:child_process";
 import fs6 from "node:fs";
-import os2 from "node:os";
-import path13 from "node:path";
-function readClaudeUsage({ homeDir = os2.homedir(), read: rawRead = readJson } = {}) {
+import os3 from "node:os";
+import path14 from "node:path";
+function readClaudeUsage({ homeDir = os3.homedir(), read: rawRead = readJson } = {}) {
   const read = (p) => {
     try {
       return rawRead(p);
@@ -5807,7 +5872,7 @@ function readClaudeUsage({ homeDir = os2.homedir(), read: rawRead = readJson } =
       return null;
     }
   };
-  const status = read(path13.join(homeDir, ".claude", "claude-usage.json"));
+  const status = read(path14.join(homeDir, ".claude", "claude-usage.json"));
   if (status && (status.seven_day || status.five_hour)) {
     const entry = {
       agent: "claude",
@@ -5816,7 +5881,7 @@ function readClaudeUsage({ homeDir = os2.homedir(), read: rawRead = readJson } =
     };
     if (entry.seven_day_used_pct !== null || entry.five_hour_used_pct !== null) return entry;
   }
-  const weekly = read(path13.join(homeDir, ".claude", "claude-weekly-usage.json"));
+  const weekly = read(path14.join(homeDir, ".claude", "claude-weekly-usage.json"));
   if (weekly) {
     const entry = {
       agent: "claude",
@@ -5973,9 +6038,9 @@ var init_account_usage = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/ci-repair-evidence.mjs
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 function runGh(args) {
-  const result = spawnSync9("gh", args, { encoding: "utf8", timeout: 6e4, windowsHide: true });
+  const result = spawnSync10("gh", args, { encoding: "utf8", timeout: 6e4, windowsHide: true });
   if (result.error) throw result.error;
   if (result.status !== 0) throw new Error((result.stderr || `gh ${args[0]} failed`).slice(-500));
   return result.stdout || "";
@@ -6140,9 +6205,9 @@ var init_superseded_pr_source = __esm({
 import { homedir as homedir4 } from "node:os";
 import { join as join5 } from "node:path";
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "node:fs/promises";
-import { spawnSync as spawnSync10 } from "node:child_process";
+import { spawnSync as spawnSync11 } from "node:child_process";
 function ghViewPr(prNumber, repo) {
-  const r = spawnSync10(
+  const r = spawnSync11(
     "gh",
     ["pr", "view", String(prNumber), "-R", repo, "--json", "state,statusCheckRollup,headRefName,headRefOid,url,isDraft,mergeStateStatus"],
     { encoding: "utf8", timeout: 3e4 }
@@ -6554,9 +6619,9 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
       res.end();
       return;
     }
-    const path17 = String(req.url || "").split("?")[0];
+    const path18 = String(req.url || "").split("?")[0];
     res.setHeader("content-type", "application/json");
-    if (req.method === "GET" && path17 === "/status") {
+    if (req.method === "GET" && path18 === "/status") {
       let status;
       try {
         status = getStatus();
@@ -6567,7 +6632,7 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
       res.end(JSON.stringify({ ok: true, ...status }));
       return;
     }
-    if (req.method === "POST" && path17 === "/stop") {
+    if (req.method === "POST" && path18 === "/stop") {
       if (!isControlOriginAllowed(req.headers.origin, allowedOrigin) || !req.headers["x-vo-control"]) {
         res.statusCode = 403;
         res.end(JSON.stringify({ ok: false, error: "forbidden" }));
@@ -6725,7 +6790,7 @@ var init_effort_mode_config = __esm({
 
 // ../../scripts/virtual-office/model-registry.mjs
 import fs7 from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 import { fileURLToPath } from "node:url";
 function uniqueModels(models = []) {
   return [...new Set(models.map((model) => String(model || "").trim()).filter(Boolean))];
@@ -6848,7 +6913,7 @@ function readCache(cacheFile = DEFAULT_CACHE_FILE, nowMs = Date.now(), ttlMs = D
   }
 }
 function writeCache(cacheFile = DEFAULT_CACHE_FILE, payload) {
-  fs7.mkdirSync(path14.dirname(cacheFile), { recursive: true });
+  fs7.mkdirSync(path15.dirname(cacheFile), { recursive: true });
   fs7.writeFileSync(cacheFile, JSON.stringify(payload, null, 2));
 }
 async function fetchRegistryCatalog({
@@ -6906,10 +6971,10 @@ var __dirname, ROOT, DEFAULT_CACHE_DIR, DEFAULT_CACHE_FILE, DEFAULT_TTL_MS3, ANT
 var init_model_registry = __esm({
   "../../scripts/virtual-office/model-registry.mjs"() {
     "use strict";
-    __dirname = path14.dirname(fileURLToPath(import.meta.url));
-    ROOT = path14.resolve(__dirname, "..", "..");
-    DEFAULT_CACHE_DIR = path14.join(ROOT, ".virtual-office-cache", "model-registry");
-    DEFAULT_CACHE_FILE = path14.join(DEFAULT_CACHE_DIR, "catalog.json");
+    __dirname = path15.dirname(fileURLToPath(import.meta.url));
+    ROOT = path15.resolve(__dirname, "..", "..");
+    DEFAULT_CACHE_DIR = path15.join(ROOT, ".virtual-office-cache", "model-registry");
+    DEFAULT_CACHE_FILE = path15.join(DEFAULT_CACHE_DIR, "catalog.json");
     DEFAULT_TTL_MS3 = 60 * 60 * 1e3;
     ANTHROPIC_API_VERSION = "2023-06-01";
     FAMILY_DEFINITIONS = {
@@ -6969,6 +7034,42 @@ var init_model_registry = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/meta-model-catalog.mjs
+function normalizeMetaEffort(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (["low", "medium", "high", "xhigh"].includes(normalized)) return normalized;
+  if (normalized === "max") return "xhigh";
+  return null;
+}
+function resolveMetaModelForTier() {
+  return META_DEFAULT_MODEL;
+}
+function resolveMetaEffortForTier(tier = "mid") {
+  return TIER_EFFORT[tier] || TIER_EFFORT.mid;
+}
+function resolveMetaEffortForRung(rung = "R3") {
+  return RUNG_EFFORT[rung] || RUNG_EFFORT.R3;
+}
+var META_DEFAULT_MODEL, TIER_EFFORT, RUNG_EFFORT;
+var init_meta_model_catalog = __esm({
+  "../../scripts/virtual-office/code-runner/meta-model-catalog.mjs"() {
+    "use strict";
+    META_DEFAULT_MODEL = "muse-spark-1.1";
+    TIER_EFFORT = Object.freeze({
+      cheap: "low",
+      mid: "medium",
+      best: "xhigh"
+    });
+    RUNG_EFFORT = Object.freeze({
+      R1: "low",
+      R2: "medium",
+      R3: "medium",
+      R4: "high",
+      R5: "xhigh"
+    });
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/model-router.mjs
 function normalizeAgent(agent = DEFAULT_AGENT2) {
   const normalized = String(agent || DEFAULT_AGENT2).trim().toLowerCase();
@@ -7450,7 +7551,7 @@ var init_classify_task = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/auto-router/effort-policy.mjs
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { join as join6 } from "node:path";
 function difficultyToRung(difficulty, thresholds) {
@@ -7477,9 +7578,9 @@ function operatorTierToRung(tier, difficulty, thresholds) {
   if (tier === "best" && difficulty >= thresholds.rungBounds.R5) return "R5";
   return base;
 }
-function readCodexModelsCache({ path: path17 = DEFAULT_CODEX_MODELS_CACHE, read = readFileSync3 } = {}) {
+function readCodexModelsCache({ path: path18 = DEFAULT_CODEX_MODELS_CACHE, read = readFileSync4 } = {}) {
   try {
-    const parsed = JSON.parse(read(path17, "utf8"));
+    const parsed = JSON.parse(read(path18, "utf8"));
     return Array.isArray(parsed?.models) ? parsed : null;
   } catch {
     return null;
@@ -7534,7 +7635,7 @@ var init_effort_policy = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/auto-router/auto-router.mjs
-import { readFileSync as readFileSync4, appendFileSync as appendFileSync2, mkdirSync as mkdirSync4 } from "node:fs";
+import { readFileSync as readFileSync5, appendFileSync as appendFileSync2, mkdirSync as mkdirSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { join as join7, dirname as dirname4 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -7545,7 +7646,7 @@ function getAutoRouterMode(env2 = process.env) {
 function loadThresholds() {
   if (!cachedThresholds) {
     const here = dirname4(fileURLToPath2(import.meta.url));
-    cachedThresholds = JSON.parse(readFileSync4(join7(here, "thresholds.json"), "utf8"));
+    cachedThresholds = JSON.parse(readFileSync5(join7(here, "thresholds.json"), "utf8"));
   }
   return cachedThresholds;
 }
@@ -7865,26 +7966,66 @@ function safeIdentityPart(value, fallback) {
   const normalized = String(value || "").trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized || fallback;
 }
+function safeBaseEnv(env2 = {}) {
+  const result = {};
+  for (const [key, value] of Object.entries(env2)) {
+    if (value !== void 0 && SAFE_ENV_NAMES.has(key.toUpperCase())) result[key] = value;
+  }
+  return result;
+}
 function buildAgentProcessEnv(env2, { agent = "agent", runnerId = "vo-runner", taskId = "task" } = {}) {
-  if (String(env2?.AGENT_ID || "").trim()) return env2;
+  const base = safeBaseEnv(env2);
+  if (String(env2?.AGENT_ID || "").trim()) return { ...base, AGENT_ID: env2.AGENT_ID };
   const generated = [
     "vo",
     safeIdentityPart(agent, "agent"),
     safeIdentityPart(runnerId, "runner"),
     safeIdentityPart(taskId, "task").slice(0, 12)
   ].join("-");
-  return { ...env2, AGENT_ID: generated };
+  return { ...base, AGENT_ID: generated };
 }
+var SAFE_ENV_NAMES;
 var init_agent_process_env = __esm({
   "../../scripts/virtual-office/code-runner/agent-process-env.mjs"() {
     "use strict";
+    SAFE_ENV_NAMES = /* @__PURE__ */ new Set([
+      "AGENT_ID",
+      "APPDATA",
+      "CI",
+      "COLORTERM",
+      "COMSPEC",
+      "FORCE_COLOR",
+      "HOME",
+      "HOMEDRIVE",
+      "HOMEPATH",
+      "LANG",
+      "LOCALAPPDATA",
+      "LOGONSERVER",
+      "NO_COLOR",
+      "NUMBER_OF_PROCESSORS",
+      "OS",
+      "PATH",
+      "PATHEXT",
+      "PROCESSOR_ARCHITECTURE",
+      "PROGRAMDATA",
+      "SYSTEMDRIVE",
+      "SYSTEMROOT",
+      "TEMP",
+      "TERM",
+      "TMP",
+      "TMPDIR",
+      "USERDOMAIN",
+      "USERNAME",
+      "USERPROFILE",
+      "WINDIR"
+    ]);
   }
 });
 
 // ../../scripts/virtual-office/code-runner/isolation-audit.mjs
 import fs8 from "node:fs";
 import fsp9 from "node:fs/promises";
-import path15 from "node:path";
+import path16 from "node:path";
 async function defaultRun(command, args, cwd, options = {}) {
   return runProcess2(command, args, { cwd, timeout: 6e4, ...options });
 }
@@ -7897,7 +8038,7 @@ async function canonicalRootForWorktree(worktreeDir, run) {
     "--path-format=absolute",
     "--git-common-dir"
   ])).trim();
-  const root = path15.dirname(commonDir);
+  const root = path16.dirname(commonDir);
   return samePath2(root, worktreeDir) ? null : root;
 }
 async function snapshot(root, run) {
@@ -7939,21 +8080,21 @@ async function changedPaths(root, run) {
 }
 async function quarantineCanonicalWrites({ baseline, worktreeDir, taskId, run, now }) {
   const paths = await changedPaths(baseline.root, run);
-  const quarantineDir = path15.join(
-    path15.dirname(worktreeDir),
+  const quarantineDir = path16.join(
+    path16.dirname(worktreeDir),
     ".canonical-recovery",
     `${String(taskId || "unknown").replace(/[^a-z0-9-]/gi, "-")}-${now().toISOString().replace(/[:.]/g, "-")}`
   );
   await fsp9.mkdir(quarantineDir, { recursive: true });
   const patch = await git2(run, baseline.root, ["diff", "--binary", "HEAD"], { raw: true });
-  await fsp9.writeFile(path15.join(quarantineDir, "tracked.patch"), patch, "utf8");
+  await fsp9.writeFile(path16.join(quarantineDir, "tracked.patch"), patch, "utf8");
   for (const relative of paths.untracked) {
-    const source = path15.join(baseline.root, relative);
-    const target = path15.join(quarantineDir, "untracked", relative);
-    await fsp9.mkdir(path15.dirname(target), { recursive: true });
+    const source = path16.join(baseline.root, relative);
+    const target = path16.join(quarantineDir, "untracked", relative);
+    await fsp9.mkdir(path16.dirname(target), { recursive: true });
     await fsp9.copyFile(source, target);
   }
-  await fsp9.writeFile(path15.join(quarantineDir, "manifest.json"), `${JSON.stringify({
+  await fsp9.writeFile(path16.join(quarantineDir, "manifest.json"), `${JSON.stringify({
     taskId,
     canonicalRoot: baseline.root,
     canonicalHead: baseline.head,
@@ -7975,8 +8116,8 @@ async function restoreExactCanonicalPaths(baseline, evidence, run) {
     ]);
   }
   for (const relative of evidence.untracked) {
-    const target = path15.resolve(baseline.root, relative);
-    const prefix = `${path15.resolve(baseline.root)}${path15.sep}`;
+    const target = path16.resolve(baseline.root, relative);
+    const prefix = `${path16.resolve(baseline.root)}${path16.sep}`;
     if (!target.startsWith(prefix) || !fs8.existsSync(target)) continue;
     await fsp9.rm(target, { force: true });
   }
@@ -8013,7 +8154,7 @@ var init_isolation_audit = __esm({
     init_process_runner2();
     splitZ2 = (value) => String(value || "").split("\0").map((item) => item.trim()).filter(Boolean);
     samePath2 = (left, right) => {
-      const [a, b] = [left, right].map((value) => path15.resolve(value));
+      const [a, b] = [left, right].map((value) => path16.resolve(value));
       return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
     };
   }
@@ -8022,7 +8163,7 @@ var init_isolation_audit = __esm({
 // ../../scripts/virtual-office/code-runner/recovery-ledger.mjs
 import fs9 from "node:fs";
 import fsp10 from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 function recoveryTaskId(prompt) {
   const match = String(prompt || "").match(/VO_RECOVERY_FROM_CODE_TASK:\s*([0-9a-f-]{36})/i);
   return match ? match[1].toLowerCase() : null;
@@ -8036,10 +8177,10 @@ function cloneLeaf(repo) {
 function recoveryLedgerCandidates(repo, clonesRoot2) {
   const leaf = cloneLeaf(repo);
   if (!leaf || !clonesRoot2) return [];
-  const canonical = path16.join(clonesRoot2, leaf);
+  const canonical = path17.join(clonesRoot2, leaf);
   return [
-    path16.join(clonesRoot2, ".agent-worktrees", leaf, "recovery-ledger.jsonl"),
-    path16.join(canonical, ".agent-worktrees", "recovery-ledger.jsonl")
+    path17.join(clonesRoot2, ".agent-worktrees", leaf, "recovery-ledger.jsonl"),
+    path17.join(canonical, ".agent-worktrees", "recovery-ledger.jsonl")
   ];
 }
 async function readLedger(file, readFile4) {
@@ -8217,7 +8358,7 @@ var code_runner_daemon_exports = {};
 __export(code_runner_daemon_exports, {
   main: () => main
 });
-import os3 from "node:os";
+import os4 from "node:os";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function log2(msg) {
@@ -8227,7 +8368,7 @@ function loadConfig(env2 = process.env) {
   const servedOperators = parseList(env2.VO_CODE_RUNNER_OPERATOR_IDS);
   const allowAmbientGithub = env2.VO_CODE_RUNNER_ALLOW_AMBIENT_GH === "1";
   return {
-    runnerId: env2.VO_CODE_RUNNER_ID || `vo-code-runner-${os3.hostname()}`,
+    runnerId: env2.VO_CODE_RUNNER_ID || `vo-code-runner-${os4.hostname()}`,
     // BYO multi-agent: {agent, runner, runnerBin} — VO_CODE_RUNNER_AGENT selects the provider.
     ...resolveRunner(env2, { warn: (m) => log2(`agent-select: ${m}`) }),
     permissionMode: env2.VO_CODE_RUNNER_PERMISSION_MODE || "acceptEdits",
@@ -8240,7 +8381,7 @@ function loadConfig(env2 = process.env) {
     // 'Sees ALL agents': how often to forward the local session spool to the
     // cloud (best-effort). Default 30s. Set 0 to disable forwarding.
     sessionForwardSec: Math.max(0, Number(env2.VO_SESSION_FORWARD_SEC ?? 30) || 0),
-    operatorSeed: env2.VO_LOCAL_OPERATOR_SEED || env2.VO_CODE_RUNNER_ID || `local-${os3.hostname()}`,
+    operatorSeed: env2.VO_LOCAL_OPERATOR_SEED || env2.VO_CODE_RUNNER_ID || `local-${os4.hostname()}`,
     cancelPollMs: Math.max(1e3, Number(env2.VO_CODE_RUNNER_CANCEL_POLL_MS || 2500) || 2500),
     // 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)),
@@ -8438,6 +8579,7 @@ async function main({ env: env2 = process.env, once: once2 = false } = {}) {
   await sweepStaleTaskAttachmentDirectories().catch((error) => log2(`stale attachment cleanup failed: ${error.message}`));
   const client = createControlPlaneClient({ env: env2 });
   const runnerInstanceId = randomUUID2();
+  bootstrapOrphanReaper({ instanceId: runnerInstanceId, log: log2 });
   let reconcileStale = true;
   let stopping = false;
   let active = 0;
@@ -8550,6 +8692,7 @@ var init_code_runner_daemon = __esm({
     init_resolve_runner();
     init_rate_limit_resume();
     init_publish();
+    init_orphan_agent_reaper();
     init_publish_async();
     init_resume_branch();
     init_task_prompt();