@algosuite/vo-mcp 0.2.0-beta.22 → 0.2.0-beta.24

package/dist/agent-auth-probe-cli.mjs

@@ -0,0 +1,1386 @@
+import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
+
+// ../../scripts/virtual-office/code-runner/claude-runner.mjs
+import { spawn } from "node:child_process";
+
+// ../../scripts/virtual-office/code-runner/anthropic-key-store.mjs
+import { createRequire } from "node:module";
+import { spawnSync as spawnSync2 } from "node:child_process";
+
+// ../../scripts/virtual-office/code-runner/windows-claude-launch.mjs
+import { existsSync, realpathSync } from "node:fs";
+import { win32 as path } from "node:path";
+import { spawnSync } from "node:child_process";
+var NATIVE_CLAUDE_PARTS = [
+  "node_modules",
+  "@anthropic-ai",
+  "claude-code",
+  "bin",
+  "claude.exe"
+];
+function pathValue(env) {
+  for (const key of ["Path", "PATH", "path"]) {
+    if (typeof env?.[key] === "string") return env[key];
+  }
+  return "";
+}
+function cleanPathSegment(value) {
+  const trimmed = String(value || "").trim();
+  return trimmed.startsWith('"') && trimmed.endsWith('"') ? trimmed.slice(1, -1) : trimmed;
+}
+function envValue(env, name) {
+  const exact = env?.[name];
+  if (typeof exact === "string") return exact.trim();
+  const key = Object.keys(env || {}).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return typeof env?.[key] === "string" ? env[key].trim() : "";
+}
+function userClaudeCandidates(bin, env) {
+  if (!/^claude(?:\.(?:exe|cmd|ps1))?$/iu.test(bin)) return [];
+  const userProfile = envValue(env, "USERPROFILE");
+  const appData = envValue(env, "APPDATA") || (userProfile ? path.join(userProfile, "AppData", "Roaming") : "");
+  const localAppData = envValue(env, "LOCALAPPDATA") || (userProfile ? path.join(userProfile, "AppData", "Local") : "");
+  const candidates = [];
+  if (appData) {
+    const npmBin = path.join(appData, "npm");
+    candidates.push(
+      path.join(npmBin, "claude.exe"),
+      path.join(npmBin, "claude.cmd"),
+      path.join(npmBin, "claude.ps1"),
+      path.join(npmBin, "claude"),
+      path.join(npmBin, ...NATIVE_CLAUDE_PARTS)
+    );
+  }
+  if (userProfile) candidates.push(path.join(userProfile, ".local", "bin", "claude.exe"));
+  if (localAppData) {
+    candidates.push(
+      path.join(localAppData, "Microsoft", "WinGet", "Links", "claude.exe"),
+      path.join(localAppData, "Microsoft", "WindowsApps", "claude.exe")
+    );
+  }
+  return candidates;
+}
+function pathCandidates(bin, env) {
+  if (path.isAbsolute(bin) || /[\\/]/u.test(bin)) {
+    return [path.resolve(bin)];
+  }
+  const extension = path.extname(bin);
+  const fromPath = pathValue(env).split(";").map(cleanPathSegment).filter(Boolean).flatMap((directory) => extension ? [path.join(directory, bin)] : [
+    path.join(directory, `${bin}.exe`),
+    path.join(directory, `${bin}.cmd`),
+    path.join(directory, `${bin}.ps1`),
+    path.join(directory, bin)
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  return [...fromPath, ...userClaudeCandidates(bin, env)].filter((candidate) => {
+    const key = candidate.toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function canonicalExistingPath(candidate, exists, canonicalize) {
+  if (!exists(candidate)) return null;
+  try {
+    return canonicalize(candidate);
+  } catch {
+    return null;
+  }
+}
+function resolveWindowsClaudeExecutable({
+  bin = "claude",
+  env = process.env,
+  exists = existsSync,
+  canonicalize = realpathSync
+} = {}) {
+  const requested = String(bin || "").trim();
+  if (!requested || requested.includes("\0")) {
+    throw new TypeError("Claude executable must be a non-empty path without NUL bytes");
+  }
+  for (const candidate of pathCandidates(requested, env)) {
+    const found = canonicalExistingPath(candidate, exists, canonicalize);
+    if (!found) continue;
+    if (path.extname(found).toLowerCase() === ".exe") return found;
+    const native = path.join(path.dirname(found), ...NATIVE_CLAUDE_PARTS);
+    const resolvedNative = canonicalExistingPath(native, exists, canonicalize);
+    if (resolvedNative) return resolvedNative;
+  }
+  const error = new Error(
+    `Could not resolve a native claude.exe for "${requested}". Install or update Claude Code with the native Windows installer (recommended) or npm install -g @anthropic-ai/claude-code; the HQ runner will not execute a shell-only .cmd/.ps1 shim.`
+  );
+  error.code = "ENOENT";
+  throw error;
+}
+function buildWindowsClaudeLaunch({
+  bin = "claude",
+  args = [],
+  env = process.env
+} = {}) {
+  return {
+    bin: resolveWindowsClaudeExecutable({ bin, env }),
+    args: Array.from(args, (value) => String(value)),
+    spawnOptions: {
+      shell: false,
+      windowsHide: true,
+      windowsVerbatimArguments: false
+    }
+  };
+}
+function spawnClaudeSync(args = [], options = {}) {
+  if (process.platform !== "win32") {
+    return spawnSync("claude", args, { windowsHide: true, ...options });
+  }
+  try {
+    const launch = buildWindowsClaudeLaunch({
+      bin: "claude",
+      args,
+      env: options.env || process.env
+    });
+    return spawnSync(launch.bin, launch.args, {
+      ...options,
+      ...launch.spawnOptions
+    });
+  } catch (error) {
+    return {
+      error,
+      status: null,
+      signal: null,
+      output: null,
+      stdout: null,
+      stderr: null
+    };
+  }
+}
+
+// ../../scripts/virtual-office/code-runner/anthropic-key-store.mjs
+var require2 = createRequire(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";
+var CLAUDE_PREFER_LOGIN_ENV = "VO_RUNNER_CLAUDE_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[CLAUDE_PREFER_LOGIN_ENV]) || 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[CLAUDE_PREFER_LOGIN_ENV]) || 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)";
+}
+function probeClaudeLoginState({
+  spawn: spawn2 = spawnSync2,
+  buildWindowsLaunch = buildWindowsClaudeLaunch,
+  platform = process.platform
+} = {}) {
+  try {
+    const launch = platform === "win32" ? buildWindowsLaunch({ bin: "claude", args: ["auth", "status"] }) : { bin: "claude", args: ["auth", "status"], spawnOptions: { windowsHide: true } };
+    const st = spawn2(launch.bin, launch.args, { ...launch.spawnOptions, 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";
+
+// ../../scripts/virtual-office/code-runner/context7-mcp.mjs
+var CONTEXT7_URL = "https://mcp.context7.com/mcp";
+function context7McpConfig(env = process.env) {
+  if (env.VO_ENABLE_CONTEXT7 !== "1") return null;
+  const url = env.VO_CONTEXT7_URL && env.VO_CONTEXT7_URL.trim() || CONTEXT7_URL;
+  const server = { type: "http", url };
+  if (env.CONTEXT7_API_KEY && env.CONTEXT7_API_KEY.trim()) {
+    server.headers = { CONTEXT7_API_KEY: env.CONTEXT7_API_KEY.trim() };
+  }
+  return { mcpServers: { context7: server } };
+}
+function context7McpArgs(env = process.env) {
+  const cfg = context7McpConfig(env);
+  return cfg ? ["--mcp-config", JSON.stringify(cfg)] : [];
+}
+
+// ../../scripts/virtual-office/code-runner/claude-args.mjs
+var DEFAULT_PERMISSION_MODE = "acceptEdits";
+var VO_SESSION_STATE_TOOL = "mcp__vo-mcp__vo_report_session_state";
+var VO_HEADLESS_PNPM_TOOL = "Bash(pnpm *)";
+var VO_HEADLESS_PNPM_FROM_DIR_TOOL = "Bash(pnpm --dir *)";
+var SAFE_PERMISSION_MODES = /* @__PURE__ */ new Set(["acceptEdits", "plan", "default", "dontAsk", "delegate"]);
+function normalizeClaudePermissionMode(value) {
+  const normalized = String(value ?? "").trim() || DEFAULT_PERMISSION_MODE;
+  if (!SAFE_PERMISSION_MODES.has(normalized)) {
+    throw new Error(`unsafe Claude permission mode "${normalized}"`);
+  }
+  return normalized;
+}
+function buildClaudeArgs({ permissionMode = DEFAULT_PERMISSION_MODE, maxTurns, model, effort, maxBudgetUsd, env = process.env } = {}) {
+  const effectivePermissionMode = normalizeClaudePermissionMode(permissionMode);
+  const allowedTools = effectivePermissionMode === DEFAULT_PERMISSION_MODE ? `${VO_SESSION_STATE_TOOL},${VO_HEADLESS_PNPM_TOOL},${VO_HEADLESS_PNPM_FROM_DIR_TOOL}` : VO_SESSION_STATE_TOOL;
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--permission-mode",
+    effectivePermissionMode,
+    "--allowedTools",
+    allowedTools
+  ];
+  if (Number.isInteger(maxTurns) && maxTurns > 0) {
+    args.push("--max-turns", String(maxTurns));
+  }
+  if (model) {
+    args.push("--model", String(model));
+  }
+  if (effort) {
+    args.push("--effort", String(effort));
+  }
+  if (typeof maxBudgetUsd === "number" && maxBudgetUsd > 0) {
+    args.push("--max-budget-usd", String(maxBudgetUsd));
+  }
+  args.push(...context7McpArgs(env));
+  return args;
+}
+
+// ../../scripts/virtual-office/code-runner/terminal-process-cleanup.mjs
+import { spawnSync as spawnSync4 } from "node:child_process";
+
+// ../../scripts/virtual-office/code-runner/orphan-agent-reaper.mjs
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+
+// ../../scripts/virtual-office/code-runner/agent-token-usage.mjs
+var MAX_TOKEN_COUNT = 1e9;
+var MAX_COST_USD = 1e4;
+function count(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null;
+  return Math.min(MAX_TOKEN_COUNT, Math.round(value));
+}
+function money(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null;
+  return Math.min(MAX_COST_USD, value);
+}
+function extractTokenUsage(evt) {
+  const models = extractModelUsage(evt);
+  if (models) {
+    const out2 = models.reduce((sum, row) => ({
+      input_tokens: Math.min(MAX_TOKEN_COUNT, sum.input_tokens + row.input_tokens),
+      output_tokens: Math.min(MAX_TOKEN_COUNT, sum.output_tokens + row.output_tokens),
+      cache_creation_tokens: Math.min(MAX_TOKEN_COUNT, sum.cache_creation_tokens + row.cache_creation_tokens),
+      cache_read_tokens: Math.min(MAX_TOKEN_COUNT, sum.cache_read_tokens + row.cache_read_tokens)
+    }), { input_tokens: 0, output_tokens: 0, cache_creation_tokens: 0, cache_read_tokens: 0 });
+    return Object.values(out2).some((value) => value > 0) ? out2 : null;
+  }
+  const u = evt?.usage;
+  if (!u || typeof u !== "object") return null;
+  const out = {
+    input_tokens: count(u.input_tokens) ?? 0,
+    output_tokens: count(u.output_tokens) ?? 0,
+    cache_creation_tokens: count(u.cache_creation_input_tokens) ?? 0,
+    cache_read_tokens: count(u.cache_read_input_tokens) ?? 0
+  };
+  const total = out.input_tokens + out.output_tokens + out.cache_creation_tokens + out.cache_read_tokens;
+  return total > 0 ? out : null;
+}
+var MAX_MODELS = 20;
+function extractModelUsage(evt) {
+  const m = evt?.modelUsage;
+  if (!m || typeof m !== "object" || Array.isArray(m)) return null;
+  const rows = [];
+  for (const [model, raw] of Object.entries(m)) {
+    if (rows.length >= MAX_MODELS) break;
+    if (!model || typeof raw !== "object" || raw === null) continue;
+    rows.push({
+      model: String(model).slice(0, 120),
+      input_tokens: count(raw.inputTokens) ?? 0,
+      output_tokens: count(raw.outputTokens) ?? 0,
+      cache_read_tokens: count(raw.cacheReadInputTokens) ?? 0,
+      cache_creation_tokens: count(raw.cacheCreationInputTokens) ?? 0,
+      cost_usd: money(raw.costUSD) ?? 0
+    });
+  }
+  return rows.length > 0 ? rows : null;
+}
+
+// ../../scripts/virtual-office/code-runner/claude-result-event.mjs
+function buildResultEvent(evt) {
+  const isError = Boolean(evt.is_error) || evt.subtype === "error_max_turns" || evt.subtype === "error_during_execution";
+  return {
+    kind: "result",
+    isError,
+    costUsd: typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : null,
+    summary: typeof evt.result === "string" && evt.result.length > 0 ? evt.result : evt.subtype || (isError ? "error" : "completed"),
+    numTurns: typeof evt.num_turns === "number" ? evt.num_turns : null,
+    tokenUsage: extractTokenUsage(evt),
+    modelUsage: extractModelUsage(evt)
+  };
+}
+
+// ../../scripts/virtual-office/code-runner/claude-stream-event.mjs
+function extractText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => block && block.type === "text" && typeof block.text === "string").map((block) => block.text).join("").trim();
+}
+function parseClaudeStreamEvent(line) {
+  const trimmed = String(line || "").trim();
+  if (!trimmed) return null;
+  let event;
+  try {
+    event = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (!event || typeof event !== "object") return null;
+  if (event.type === "assistant" && event.message?.content) {
+    const text = extractText(event.message.content);
+    const tokenUsage = extractTokenUsage({ usage: event.message.usage });
+    return text || tokenUsage ? { kind: "progress", text, ...tokenUsage ? { tokenUsage } : {} } : null;
+  }
+  return event.type === "result" ? buildResultEvent(event) : null;
+}
+
+// ../../scripts/virtual-office/code-runner/cli-version-floor.mjs
+var MIN_CLAUDE_CLI_VERSION = "2.1.218";
+var SECURITY_RATIONALE = "Claude Code 2.1.211/2.1.213 fixed a PreToolUse-hook bypass on unsandboxed Bash (our destructive-fs/git/cloud tripwires DO NOT FIRE on older CLIs) and worktree-subagents mutating the main checkout. 2.1.218 fixed Windows paths with a lowercase-\\u segment (e.g. ...\\utils\\, ...\\ui\\) being corrupted into CJK in tool inputs, making those files silently inaccessible \u2014 the fleet is Windows and 1,376 tracked files sit under utils/ alone. Update: npm install -g @anthropic-ai/claude-code (or the native installer).";
+function parseCliVersion(output) {
+  const match = /\b(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?\b/.exec(String(output ?? ""));
+  return match ? `${match[1]}.${match[2]}.${match[3]}` : null;
+}
+function compareSemver(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i += 1) {
+    if (pa[i] !== pb[i]) return pa[i] < pb[i] ? -1 : 1;
+  }
+  return 0;
+}
+function checkCliVersionFloor(versionOutput, { floor = MIN_CLAUDE_CLI_VERSION } = {}) {
+  const version = parseCliVersion(versionOutput);
+  if (!version) {
+    const seen = String(versionOutput ?? "").trim().slice(0, 120) || "<empty>";
+    return {
+      ok: false,
+      version: null,
+      floor,
+      message: `could not parse a semver from \`claude --version\` output ("${seen}") \u2014 cannot prove the CLI meets the ${floor} security floor. ${SECURITY_RATIONALE}`
+    };
+  }
+  if (compareSemver(version, floor) < 0) {
+    return {
+      ok: false,
+      version,
+      floor,
+      message: `claude CLI ${version} is BELOW the minimum security floor ${floor}. ` + SECURITY_RATIONALE
+    };
+  }
+  return {
+    ok: true,
+    version,
+    floor,
+    message: `claude CLI ${version} meets the minimum security floor ${floor}`
+  };
+}
+function applyCliVersionFloor({ versionOutput, env = process.env, log = console.error } = {}) {
+  const check = checkCliVersionFloor(versionOutput);
+  if (check.ok) return { refused: false, check, message: check.message };
+  const allowUnsafe = String(env?.VO_CLI_FLOOR_ALLOW_UNSAFE ?? "") === "1";
+  const message = `[cli-version-floor] ${allowUnsafe ? "WARNING (unsafe emergency override)" : "REFUSING"}: ` + check.message;
+  try {
+    log(message);
+  } catch {
+  }
+  return { refused: !allowUnsafe, check, message };
+}
+
+// ../../scripts/virtual-office/code-runner/claude-auth-check.mjs
+var FIRST_VERSION_TIMEOUT_MS = 4500;
+var RETRY_VERSION_TIMEOUT_MS = 2e3;
+function errorCode(error) {
+  return String(error?.code || "").toUpperCase();
+}
+function isTimeout(probe) {
+  return errorCode(probe?.error) === "ETIMEDOUT" || String(probe?.signal || "").toUpperCase() === "SIGTERM";
+}
+function notFound(probe) {
+  return errorCode(probe?.error) === "ENOENT";
+}
+async function checkClaudeAuth({
+  spawnVersion = spawnClaudeSync,
+  probeLogin = probeClaudeLoginState,
+  env = process.env
+} = {}) {
+  try {
+    let probe = spawnVersion(["--version"], {
+      timeout: FIRST_VERSION_TIMEOUT_MS,
+      encoding: "utf8",
+      env
+    });
+    let retriedAfterTimeout = false;
+    if (isTimeout(probe)) {
+      retriedAfterTimeout = true;
+      probe = spawnVersion(["--version"], {
+        timeout: RETRY_VERSION_TIMEOUT_MS,
+        encoding: "utf8",
+        env
+      });
+    }
+    if (probe.error) {
+      if (notFound(probe)) {
+        return {
+          installed: false,
+          authenticated: false,
+          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."
+        };
+      }
+      return {
+        installed: true,
+        authenticated: false,
+        message: isTimeout(probe) ? "claude CLI executable was found, but its cold-start version probe timed out twice; availability will be retried without misreporting it as uninstalled." : `claude CLI executable was found, but its version probe failed: ${probe.error.message}`
+      };
+    }
+    if (probe.status !== 0) {
+      return { installed: true, authenticated: false, message: "claude binary exists but --version failed (auth unclear)" };
+    }
+    const floorGate = applyCliVersionFloor({ versionOutput: probe.stdout, env });
+    if (floorGate.refused) {
+      return { installed: true, authenticated: false, message: floorGate.message };
+    }
+    const loggedIn = retriedAfterTimeout ? null : probeLogin();
+    if (loggedIn === false) {
+      return {
+        installed: true,
+        authenticated: false,
+        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: loggedIn === true ? "claude CLI installed and logged in (claude auth status)" : "claude binary found (login state unknown \u2014 auth check is best-effort)"
+    };
+  } catch (error) {
+    return {
+      installed: false,
+      authenticated: false,
+      message: `checkAuth probe failed: ${error.message}`
+    };
+  }
+}
+
+// ../../scripts/virtual-office/code-runner/claude-runner.mjs
+function parseStreamEvent(line) {
+  return parseClaudeStreamEvent(line);
+}
+var ClaudeRunner = class {
+  get enforcesBudgetCap() {
+    return true;
+  }
+  get binary() {
+    return "claude";
+  }
+  buildArgs({ permissionMode, maxTurns, model, effort, maxBudgetUsd } = {}) {
+    return buildClaudeArgs({ permissionMode, maxTurns, model, effort, maxBudgetUsd });
+  }
+  parseEvent(line) {
+    return parseStreamEvent(line);
+  }
+  getSpawnOptions() {
+    return { shell: false, windowsHide: true };
+  }
+  prepareSpawn({ bin, args, spawnOptions, env = process.env } = {}) {
+    if (process.platform !== "win32") return { bin, args, spawnOptions: spawnOptions ?? this.getSpawnOptions() };
+    return buildWindowsClaudeLaunch({ bin, args, env });
+  }
+  /**
+   * 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(env = process.env) {
+    return withAnthropicKey(env);
+  }
+  costBasis(env = process.env) {
+    return String(env.ANTHROPIC_API_KEY || "").trim() ? "vendor_billed" : "subscription_api_equivalent";
+  }
+  /** Describe which Anthropic auth source the spawn will use (for runner logs). */
+  describeAuth(env = process.env) {
+    return describeAnthropicAuthSource(env);
+  }
+  /**
+   * 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
+   * and let the real spawn fail with a clearer error from the CLI itself.
+   */
+  async checkAuth() {
+    return checkClaudeAuth();
+  }
+};
+var claudeRunner = new ClaudeRunner();
+
+// ../../scripts/virtual-office/code-runner/codex-runner.mjs
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import { win32 } from "node:path";
+
+// ../../scripts/virtual-office/code-runner/agent-key-store.mjs
+import { createRequire as createRequire2 } from "node:module";
+var require3 = createRequire2(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"],
+  meta: ["MODEL_API_KEY"],
+  // Generic OpenAI-compatible runner (bring-your-own model + endpoint): its key
+  // is a dedicated var so it never collides with a real OpenAI/Codex key.
+  "oai-compat": ["VO_CODE_RUNNER_OAI_API_KEY"],
+  // Sovereign local inference (Ollama / LM Studio). The key is OPTIONAL — most
+  // local servers need none — and exists for locally secured endpoints only.
+  local: ["VO_CODE_RUNNER_LOCAL_API_KEY"]
+};
+var PROVIDER_ALIAS = {
+  claude: "anthropic",
+  anthropic: "anthropic",
+  codex: "openai",
+  openai: "openai",
+  cursor: "cursor",
+  meta: "meta",
+  muse: "meta",
+  spark: "meta",
+  "muse-spark": "meta",
+  oai: "oai-compat",
+  "oai-compat": "oai-compat",
+  local: "local",
+  ollama: "local",
+  lmstudio: "local"
+};
+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/flat-token-usage.mjs
+var MAX_TOKEN_COUNT2 = 1e9;
+function count2(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return 0;
+  return Math.min(MAX_TOKEN_COUNT2, Math.round(value));
+}
+function extractFlatTokenUsage(usage) {
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return null;
+  const rawInput = count2(usage.input_tokens ?? usage.prompt_tokens);
+  const cached = count2(
+    usage.cached_input_tokens ?? usage.cache_read_input_tokens ?? usage.cache_read_tokens
+  );
+  const hasInclusiveCache = usage.cached_input_tokens !== void 0;
+  const out = {
+    input_tokens: hasInclusiveCache ? Math.max(0, rawInput - cached) : rawInput,
+    output_tokens: count2(usage.output_tokens ?? usage.completion_tokens),
+    cache_creation_tokens: count2(
+      usage.cache_creation_input_tokens ?? usage.cache_creation_tokens
+    ),
+    cache_read_tokens: cached
+  };
+  return Object.values(out).some((value) => value > 0) ? out : null;
+}
+
+// ../../scripts/virtual-office/code-runner/codex-runner.mjs
+var CODEX_PREFER_LOGIN_ENV = "VO_RUNNER_CODEX_PREFER_LOGIN";
+var LEGACY_PREFER_LOGIN_ENV = "VO_RUNNER_PREFER_LOGIN";
+function isTruthyFlag2(value) {
+  return ["1", "true", "yes", "on"].includes(String(value ?? "").trim().toLowerCase());
+}
+function resolveCodexBinary({
+  env = process.env,
+  platform = process.platform,
+  exists = existsSync3
+} = {}) {
+  if (platform !== "win32") return "codex";
+  const appData = String(env.APPDATA || "").trim();
+  const userProfile = String(env.USERPROFILE || "").trim();
+  const localAppData = String(env.LOCALAPPDATA || "").trim();
+  const candidates = [];
+  if (appData) {
+    candidates.push(win32.join(
+      appData,
+      "npm",
+      "node_modules",
+      "@openai",
+      "codex",
+      "node_modules",
+      "@openai",
+      "codex-win32-x64",
+      "vendor",
+      "x86_64-pc-windows-msvc",
+      "bin",
+      "codex.exe"
+    ));
+  }
+  if (userProfile) {
+    candidates.push(win32.join(userProfile, ".local", "bin", "codex.exe"));
+    candidates.push(win32.join(userProfile, ".codex", "bin", "codex.exe"));
+  }
+  if (localAppData) {
+    candidates.push(win32.join(localAppData, "Microsoft", "WindowsApps", "codex.exe"));
+  }
+  const absolute = candidates.find((candidate) => exists(candidate));
+  if (absolute) return absolute;
+  return "codex";
+}
+function buildCodexArgs({ model, effort } = {}) {
+  const args = ["exec", "--json", "-c", 'approval_policy="never"', "--sandbox", "workspace-write", "--skip-git-repo-check"];
+  if (model) {
+    args.push("--model", String(model));
+  }
+  if (effort) {
+    args.push("-c", `model_reasoning_effort="${String(effort)}"`);
+  }
+  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 parseCodexVersion(stdout) {
+  if (typeof stdout !== "string") return null;
+  const match = stdout.match(/\b(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b/u);
+  return match ? match[1] : null;
+}
+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,
+      tokenUsage: extractFlatTokenUsage(evt.usage)
+    };
+  }
+  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 {
+  constructor({ spawn: spawn2 = spawnSync6, resolveBinary = resolveCodexBinary, env = process.env } = {}) {
+    this.spawn = spawn2;
+    this.resolveBinary = resolveBinary;
+    this.env = env;
+  }
+  get binary() {
+    return this.resolveBinary();
+  }
+  buildArgs(opts = {}) {
+    return buildCodexArgs(opts);
+  }
+  parseEvent(line) {
+    return parseCodexEvent(line);
+  }
+  /**
+   * SECURITY: never `shell: true` — same RCE class as cursor-runner. The old
+   * `shell: win32 && !/\.exe$/` fell back to shell mode whenever
+   * resolveCodexBinary() could not find one of its hardcoded absolute paths and
+   * returned the bare string 'codex'. Node's shell mode joins argv into
+   * `cmd /d /s /c` with windowsVerbatimArguments, and buildCodexArgs() puts the
+   * control-plane-controlled `model` into argv, so a payload of
+   * `{ agent: 'codex', model: 'gpt-5 & <cmd>' }` executed arbitrary code —
+   * including on hosts where codex is NOT installed, because cmd runs the first
+   * command, it fails, and `&` runs the rest anyway.
+   *
+   * With shell:false a `.cmd`/`.ps1` shim no longer resolves and the spawn fails
+   * closed with ENOENT, matching resolveWindowsClaudeExecutable()'s policy.
+   */
+  getSpawnOptions() {
+    return {
+      shell: false,
+      windowsHide: true,
+      windowsVerbatimArguments: false
+    };
+  }
+  /**
+   * 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(env = process.env) {
+    if (isTruthyFlag2(env[CODEX_PREFER_LOGIN_ENV]) || isTruthyFlag2(env[LEGACY_PREFER_LOGIN_ENV])) {
+      const out = { ...env };
+      delete out.OPENAI_API_KEY;
+      delete out.CODEX_API_KEY;
+      return out;
+    }
+    return withAgentKey("openai", env);
+  }
+  costBasis(env = process.env) {
+    return String(env.OPENAI_API_KEY || env.CODEX_API_KEY || "").trim() ? "vendor_billed" : "subscription_api_equivalent";
+  }
+  /** Best-effort binary + persisted-login probe. Never throws or spends tokens. */
+  async checkAuth() {
+    try {
+      const bin = this.binary;
+      const version = this.spawn(bin, ["--version"], {
+        ...this.getSpawnOptions({ bin }),
+        windowsHide: true,
+        timeout: 3e3,
+        encoding: "utf8"
+      });
+      if (version.error) {
+        return { installed: false, authenticated: false, message: `codex not found on PATH: ${version.error.message}` };
+      }
+      if (version.status !== 0) {
+        return { installed: true, authenticated: false, message: "codex exists but --version failed (auth unclear)" };
+      }
+      const cliVersion = parseCodexVersion(version.stdout);
+      const versionField = cliVersion ? { version: cliVersion } : {};
+      const login = this.spawn(bin, ["login", "status"], {
+        ...this.getSpawnOptions({ bin }),
+        windowsHide: true,
+        timeout: 5e3,
+        encoding: "utf8"
+      });
+      const output = `${login.stdout || ""}
+${login.stderr || ""}`.trim();
+      if (login.error || login.status !== 0) {
+        const authEnv = this.applyAuthEnv(this.env);
+        if (authEnv.OPENAI_API_KEY || authEnv.CODEX_API_KEY) {
+          return {
+            installed: true,
+            authenticated: true,
+            ...versionField,
+            message: "codex API key available (no persisted ChatGPT login)"
+          };
+        }
+        return {
+          installed: true,
+          authenticated: false,
+          ...versionField,
+          message: output || login.error?.message || "codex is installed but not logged in"
+        };
+      }
+      return {
+        installed: true,
+        authenticated: true,
+        ...versionField,
+        message: output || "codex login status succeeded"
+      };
+    } 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 spawnSync7 } 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";
+    const tokenUsage = extractFlatTokenUsage(evt.usage);
+    return {
+      kind: "result",
+      isError,
+      costUsd: null,
+      ...tokenUsage ? { tokenUsage } : {},
+      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);
+  }
+  /**
+   * SECURITY: never `shell: true`. Node's shell mode on Windows joins argv and
+   * hands it to `cmd /d /s /c` with windowsVerbatimArguments, so every cmd
+   * metacharacter (& | > ^) in an argument is interpreted by the shell. This
+   * runner puts two control-plane-controlled strings into argv — `task.model`
+   * and the composed prompt (buildCursorArgs) — so shell mode turned a task
+   * payload into arbitrary host code execution. It fired even without
+   * cursor-agent installed: cmd runs the first command, it fails, and `&` runs
+   * the rest anyway. With shell:false argv goes straight to CreateProcess and
+   * metacharacters are inert.
+   *
+   * Consequence on Windows: a `.cmd`/`.ps1` shim no longer resolves, so the
+   * runner fails closed with ENOENT rather than executing through a shell —
+   * the same policy resolveWindowsClaudeExecutable() enforces for Claude.
+   */
+  getSpawnOptions() {
+    return {
+      shell: false,
+      windowsHide: true,
+      windowsVerbatimArguments: false
+    };
+  }
+  /**
+   * 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(env = process.env) {
+    return withAgentKey("cursor", env);
+  }
+  costBasis(env = process.env) {
+    return env.CURSOR_API_KEY ? "vendor_billed" : "unknown";
+  }
+  /** Best-effort: is `cursor-agent` on PATH? Never throws. */
+  async checkAuth() {
+    try {
+      const { status, error } = spawnSync7("cursor-agent", ["--version"], {
+        shell: false,
+        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)" };
+      }
+      if (process.env.VO_CODE_RUNNER_ALLOW_UNMETERED_CURSOR !== "1") {
+        return {
+          installed: true,
+          authenticated: false,
+          message: "cursor-agent disabled: its documented stream-JSON result has no token/cost fields; set VO_CODE_RUNNER_ALLOW_UNMETERED_CURSOR=1 only for an explicit unmeasured experiment"
+        };
+      }
+      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/local-model-runner.mjs
+var LOCAL_API_KEY_ENV = "VO_CODE_RUNNER_LOCAL_API_KEY";
+var LOCAL_PROVIDERS = ["ollama", "lmstudio"];
+var DEFAULT_LOCAL_PROVIDER = "ollama";
+var LOCAL_PROBE_URLS = {
+  ollama: "http://127.0.0.1:11434/api/version",
+  lmstudio: "http://127.0.0.1:1234/v1/models"
+};
+function resolveLocalProvider(env = process.env) {
+  return String(env.VO_CODE_RUNNER_LOCAL_PROVIDER || "").trim().toLowerCase() || DEFAULT_LOCAL_PROVIDER;
+}
+var remoteDesiredLocalModel = "";
+function resolveLocalModel(env = process.env) {
+  return String(env.VO_CODE_RUNNER_LOCAL_MODEL || "").trim() || remoteDesiredLocalModel;
+}
+function resolveLocalBaseUrl(env = process.env) {
+  return String(env.VO_CODE_RUNNER_LOCAL_BASE_URL || "").trim();
+}
+var LOCAL_MODEL_RE = new RegExp("^[A-Za-z0-9][A-Za-z0-9._/:-]{0,127}$");
+function isValidLocalModel(model) {
+  return LOCAL_MODEL_RE.test(String(model || ""));
+}
+function isLoopbackBaseUrl(url) {
+  const raw = String(url || "").trim();
+  if (!/^https?:\/\/[^\s"'`\\]+$/.test(raw)) return false;
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return false;
+  }
+  const host = parsed.hostname.toLowerCase();
+  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+}
+function buildLocalArgs(opts = {}, env = process.env) {
+  const provider = resolveLocalProvider(env);
+  if (!LOCAL_PROVIDERS.includes(provider)) {
+    throw new Error(
+      `local-model runner: unknown VO_CODE_RUNNER_LOCAL_PROVIDER "${provider}" (supported: ${LOCAL_PROVIDERS.join(", ")}).`
+    );
+  }
+  const model = resolveLocalModel(env);
+  if (!model) {
+    throw new Error(
+      "local-model runner: set VO_CODE_RUNNER_LOCAL_MODEL to a model your local server already has (recommended: gpt-oss:20b \u2014 codex drives its tool loop reliably; generic chat models often cannot edit files agentically), or pick an already-pulled model from the web runner settings. Refusing to run with no explicit model (fail-closed)."
+    );
+  }
+  if (!isValidLocalModel(model)) {
+    throw new Error(`local-model runner: "${model}" is not a valid local model id.`);
+  }
+  const baseUrl = resolveLocalBaseUrl(env);
+  if (baseUrl && !isLoopbackBaseUrl(baseUrl)) {
+    throw new Error(
+      "local-model runner: VO_CODE_RUNNER_LOCAL_BASE_URL must be a loopback http(s) URL (localhost / 127.0.0.1 / [::1]). Remote endpoints are refused \u2014 use the Model Firewall lanes for hosted providers."
+    );
+  }
+  const args = [
+    "exec",
+    "--json",
+    "-c",
+    'approval_policy="never"',
+    "--sandbox",
+    "workspace-write",
+    "--skip-git-repo-check",
+    "--oss",
+    "--local-provider",
+    provider,
+    "--model",
+    model
+  ];
+  if (opts.effort) {
+    args.push("-c", `model_reasoning_effort="${String(opts.effort)}"`);
+  }
+  args.push("-");
+  return args;
+}
+function applyLocalAuthEnv(baseEnv = process.env, configEnv = process.env) {
+  const out = withAgentKey("local", baseEnv);
+  const baseUrl = resolveLocalBaseUrl(configEnv);
+  if (baseUrl && isLoopbackBaseUrl(baseUrl) && resolveLocalProvider(configEnv) === "ollama" && !String(out.OLLAMA_HOST || "").trim()) {
+    out.OLLAMA_HOST = baseUrl.replace(/\/+$/, "");
+  }
+  return out;
+}
+var LocalModelRunner = class {
+  constructor({
+    spawn: spawn2 = null,
+    resolveBinary = resolveCodexBinary,
+    env = process.env,
+    fetchImpl = globalThis.fetch
+  } = {}) {
+    this.spawn = spawn2;
+    this.resolveBinary = resolveBinary;
+    this.env = env;
+    this.fetchImpl = fetchImpl;
+  }
+  /** Codex is the transport binary; the model/endpoint are the user's. */
+  get binary() {
+    return this.resolveBinary();
+  }
+  buildArgs(opts = {}) {
+    return buildLocalArgs(opts, this.env);
+  }
+  /**
+   * Codex JSONL events map identically, except a sovereign local model has no
+   * vendor bill. Codex omits total_cost_usd for OSS runs; turn that known fact
+   * into a measured zero at the producer so readers never have to guess.
+   */
+  parseEvent(line) {
+    const event = parseCodexEvent(line);
+    return event?.kind === "result" ? { ...event, costUsd: 0 } : event;
+  }
+  // SECURITY: never shell — see no-shell-spawn.test.mjs. The model id is
+  // control-plane-influenced and validated, but shell:false is the hard floor.
+  getSpawnOptions() {
+    return {
+      shell: false,
+      windowsHide: true,
+      windowsVerbatimArguments: false
+    };
+  }
+  applyAuthEnv(env = process.env) {
+    return applyLocalAuthEnv(env, this.env);
+  }
+  costBasis() {
+    return "local_zero";
+  }
+  describeAuth(env = process.env) {
+    const authEnv = this.applyAuthEnv(env);
+    const provider = resolveLocalProvider(this.env);
+    const model = resolveLocalModel(this.env) || "<unset>";
+    const hasKey = Boolean(String(authEnv[LOCAL_API_KEY_ENV] || "").trim());
+    return `local provider=${provider} model=${model} key=${hasKey ? "set" : "none (optional)"}`;
+  }
+  /**
+   * Best-effort: codex transport present AND the local inference endpoint
+   * answers. Never throws, never spends tokens; the endpoint probe is bounded
+   * to 1.5s so a stopped Ollama can't hang availability checks.
+   */
+  async checkAuth() {
+    const provider = resolveLocalProvider(this.env);
+    if (!LOCAL_PROVIDERS.includes(provider)) {
+      return {
+        installed: false,
+        authenticated: false,
+        message: `unknown local provider "${provider}" (supported: ${LOCAL_PROVIDERS.join(", ")})`
+      };
+    }
+    const model = resolveLocalModel(this.env);
+    const override = resolveLocalBaseUrl(this.env);
+    if (override && !isLoopbackBaseUrl(override)) {
+      return {
+        installed: true,
+        authenticated: false,
+        message: "VO_CODE_RUNNER_LOCAL_BASE_URL is not loopback \u2014 refused (fail-closed)"
+      };
+    }
+    const probeUrl = provider === "ollama" && override ? `${override.replace(/\/+$/, "")}/api/version` : LOCAL_PROBE_URLS[provider];
+    let endpointUp = false;
+    let probeNote = "";
+    try {
+      const res = await this.fetchImpl(probeUrl, { signal: AbortSignal.timeout(1500) });
+      endpointUp = Boolean(res?.ok);
+      if (!endpointUp) probeNote = `endpoint ${probeUrl} answered HTTP ${res?.status}`;
+    } catch {
+      probeNote = `no local inference server answering at ${probeUrl}`;
+    }
+    if (!endpointUp) {
+      return {
+        installed: true,
+        authenticated: false,
+        message: `${probeNote} \u2014 start ${provider === "ollama" ? "Ollama" : "LM Studio"} first`
+      };
+    }
+    if (!model) {
+      return {
+        installed: true,
+        authenticated: false,
+        message: `${provider} is running but VO_CODE_RUNNER_LOCAL_MODEL is not set`
+      };
+    }
+    return {
+      installed: true,
+      authenticated: true,
+      message: `${provider} reachable; model "${model}" configured (local-only, no cloud spend)`
+    };
+  }
+};
+var localModelRunner = new LocalModelRunner();
+
+// ../../scripts/virtual-office/code-runner/meta-runner.mjs
+var META_API_KEY_ENV = "MODEL_API_KEY";
+var META_API_KEY_ALIAS = "META_API";
+function applyMetaAuthEnv(baseEnv = process.env) {
+  const out = withAgentKey("meta", baseEnv);
+  if (!String(out[META_API_KEY_ENV] || "").trim() && String(out[META_API_KEY_ALIAS] || "").trim()) {
+    out[META_API_KEY_ENV] = out[META_API_KEY_ALIAS];
+  }
+  return out;
+}
+function buildMetaArgs(opts = {}) {
+  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 MetaRunner = class {
+  get binary() {
+    return resolveCodexBinary();
+  }
+  buildArgs(opts = {}) {
+    return buildMetaArgs(opts);
+  }
+  parseEvent(line) {
+    return parseCodexEvent(line);
+  }
+  // SECURITY: never shell — see no-shell-spawn.test.mjs. Inert today (buildArgs
+  // throws) but this goes hot the moment the transport is enabled.
+  getSpawnOptions() {
+    return {
+      shell: false,
+      windowsHide: true,
+      windowsVerbatimArguments: false
+    };
+  }
+  applyAuthEnv(env = process.env) {
+    return applyMetaAuthEnv(env);
+  }
+  describeAuth(env = process.env) {
+    const authEnv = applyMetaAuthEnv(env);
+    const hasKey = Boolean(String(authEnv[META_API_KEY_ENV] || "").trim());
+    return `meta muse-spark key=${hasKey ? "set" : "MISSING"} transport=codex`;
+  }
+  async checkAuth() {
+    return {
+      installed: false,
+      authenticated: false,
+      message: "Muse Spark coding is disabled; sanitized Model Firewall review only"
+    };
+  }
+};
+var metaRunner = new MetaRunner();
+
+// ../../scripts/virtual-office/code-runner/openai-compatible-runner.mjs
+var OAI_API_KEY_ENV = "VO_CODE_RUNNER_OAI_API_KEY";
+function resolveOaiBaseUrl(env = process.env) {
+  return String(env.VO_CODE_RUNNER_OAI_BASE_URL || "").trim();
+}
+var OpenAICompatibleRunner = class {
+  /** Codex is the transport binary. */
+  get binary() {
+    return resolveCodexBinary();
+  }
+  buildArgs(opts = {}) {
+    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) {
+    return parseCodexEvent(line);
+  }
+  // SECURITY: never shell — see no-shell-spawn.test.mjs. Inert today (buildArgs
+  // throws) but this goes hot the moment the transport is enabled.
+  getSpawnOptions() {
+    return {
+      shell: false,
+      windowsHide: true,
+      windowsVerbatimArguments: false
+    };
+  }
+  /** Fill the BYO key env var from the OS keychain when not already set. */
+  applyAuthEnv(env = process.env) {
+    return withAgentKey("oai-compat", env);
+  }
+  describeAuth(env = process.env) {
+    const hasKey = Boolean(String(env[OAI_API_KEY_ENV] || "").trim());
+    const baseUrl = resolveOaiBaseUrl(env);
+    return `oai-compat endpoint=${baseUrl || "<unset>"} key=${hasKey ? "set" : "MISSING"}`;
+  }
+  /** Best-effort: base URL chosen AND the codex transport is installed. */
+  async checkAuth() {
+    return {
+      installed: false,
+      authenticated: false,
+      message: "OpenAI-compatible coding is disabled; sanitized Model Firewall task capsules only"
+    };
+  }
+};
+var openaiCompatibleRunner = new OpenAICompatibleRunner();
+
+// ../../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,
+  // `local` = sovereign local inference (Ollama / LM Studio; Mistral/Llama-class
+  // models) — free tier of the pricing pivot; nothing leaves the user's machine.
+  local: localModelRunner,
+  meta: metaRunner,
+  oai: openaiCompatibleRunner
+};
+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(env) {
+  for (const bin of [
+    env.VO_CODE_RUNNER_BIN,
+    env.VO_CODE_RUNNER_CLAUDE_BIN
+  ]) {
+    const agent2 = inferAgentFromBin(bin);
+    if (agent2) return { agent: agent2, bin };
+  }
+  return null;
+}
+function resolveRunner(env = process.env, { warn = () => {
+} } = {}) {
+  const explicitAgent = String(env.VO_CODE_RUNNER_AGENT || env.VO_AGENT || "").trim();
+  const inferred = explicitAgent ? null : inferAgentFromEnvBin(env);
+  const raw = String(explicitAgent || inferred?.agent || DEFAULT_AGENT).trim().toLowerCase();
+  let agent2 = raw;
+  let fellBack = false;
+  let runner = RUNNERS[agent2];
+  if (inferred && runner) {
+    try {
+      warn(`VO_CODE_RUNNER_AGENT not set; inferred "${agent2}" 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 {
+    }
+    agent2 = DEFAULT_AGENT;
+    runner = RUNNERS[DEFAULT_AGENT];
+    fellBack = true;
+  }
+  validateAgentRunner(runner);
+  const runnerBin = env.VO_CODE_RUNNER_BIN || (inferred && inferred.agent === agent2 ? inferred.bin : "") || (agent2 === "claude" ? env.VO_CODE_RUNNER_CLAUDE_BIN : "") || runner.binary;
+  return { agent: agent2, runner, runnerBin, fellBack };
+}
+
+// ../../scripts/virtual-office/code-runner/agent-auth-probe-cli.mjs
+var agent = String(process.argv[2] || "");
+try {
+  const result = await resolveRunner({ ...process.env, VO_CODE_RUNNER_AGENT: agent }).runner.checkAuth();
+  process.stdout.write(`${JSON.stringify(result)}
+`);
+} catch (error) {
+  process.stdout.write(`${JSON.stringify({
+    installed: false,
+    authenticated: false,
+    message: String(error?.message || error)
+  })}
+`);
+}