@algosuite/vo-mcp 0.2.0-beta.7 → 0.2.0-beta.70

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

@@ -0,0 +1,1731 @@
+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/claude-credential-choice.mjs
+var PREFER_LOGIN_ENV = "VO_RUNNER_PREFER_LOGIN";
+var CLAUDE_PREFER_LOGIN_ENV = "VO_RUNNER_CLAUDE_PREFER_LOGIN";
+var PREFER_KEY_ENV = "VO_RUNNER_PREFER_KEY";
+var CLAUDE_PREFER_KEY_ENV = "VO_RUNNER_CLAUDE_PREFER_KEY";
+var CLAUDE_CREDENTIAL_SOURCE = Object.freeze({
+  /** PREFER_LOGIN set (and not overridden): any API key is ignored. */
+  PREFER_LOGIN: "prefer_login",
+  /** An explicit ANTHROPIC_API_KEY in the environment — the manual override. */
+  ENV_KEY: "env_key",
+  /** No key anywhere; the spawn falls through to the login session. */
+  NO_KEY: "no_key",
+  /** A stored key, used because the operator explicitly opted out of tier 1. */
+  KEYCHAIN_PREFER_KEY: "keychain_prefer_key",
+  /** A stored key exists but a proven live subscription outranks it. */
+  SUBSCRIPTION_WINS: "subscription_wins",
+  /** A stored key, used because no live subscription was proven. */
+  KEYCHAIN: "keychain"
+});
+function isTruthyFlag(v) {
+  const s = String(v ?? "").trim().toLowerCase();
+  return s === "1" || s === "true" || s === "yes" || s === "on";
+}
+function wantsLogin(env) {
+  return isTruthyFlag(env[CLAUDE_PREFER_LOGIN_ENV]) || isTruthyFlag(env[PREFER_LOGIN_ENV]);
+}
+function wantsKey(env) {
+  return isTruthyFlag(env[CLAUDE_PREFER_KEY_ENV]) || isTruthyFlag(env[PREFER_KEY_ENV]);
+}
+function classifyClaudeCredential(baseEnv = {}, { getKey, probeLogin } = {}) {
+  const preferKey = wantsKey(baseEnv);
+  if (!preferKey && wantsLogin(baseEnv)) {
+    return { source: CLAUDE_CREDENTIAL_SOURCE.PREFER_LOGIN, key: null };
+  }
+  if (baseEnv.ANTHROPIC_API_KEY) {
+    return { source: CLAUDE_CREDENTIAL_SOURCE.ENV_KEY, key: null };
+  }
+  const key = getKey();
+  if (!key) {
+    return { source: CLAUDE_CREDENTIAL_SOURCE.NO_KEY, key: null };
+  }
+  if (preferKey) {
+    return { source: CLAUDE_CREDENTIAL_SOURCE.KEYCHAIN_PREFER_KEY, key };
+  }
+  if (probeLogin() === true) {
+    return { source: CLAUDE_CREDENTIAL_SOURCE.SUBSCRIPTION_WINS, key: null };
+  }
+  return { source: CLAUDE_CREDENTIAL_SOURCE.KEYCHAIN, key };
+}
+
+// ../../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;
+  }
+}
+function withAnthropicKey(baseEnv = {}, { getKey = getAnthropicKey, probeLogin = probeClaudeLoginState } = {}) {
+  const { source, key } = classifyClaudeCredential(baseEnv, { getKey, probeLogin });
+  const next = { ...baseEnv };
+  if (source === CLAUDE_CREDENTIAL_SOURCE.PREFER_LOGIN) {
+    delete next.ANTHROPIC_API_KEY;
+    return next;
+  }
+  if (key !== null) next.ANTHROPIC_API_KEY = key;
+  return next;
+}
+function claudeCostBasis(env = process.env) {
+  return String(env.ANTHROPIC_API_KEY || "").trim() ? "vendor_billed" : "subscription_api_equivalent";
+}
+var AUTH_SOURCE_DESCRIPTION = Object.freeze({
+  [CLAUDE_CREDENTIAL_SOURCE.PREFER_LOGIN]: "claude auth login (VO_RUNNER_PREFER_LOGIN set \u2014 any API key ignored)",
+  [CLAUDE_CREDENTIAL_SOURCE.ENV_KEY]: "ANTHROPIC_API_KEY from environment",
+  [CLAUDE_CREDENTIAL_SOURCE.NO_KEY]: "claude auth login session (no API key set)",
+  [CLAUDE_CREDENTIAL_SOURCE.KEYCHAIN_PREFER_KEY]: "ANTHROPIC_API_KEY from OS keychain (VO_RUNNER_PREFER_KEY set \u2014 subscription ignored)",
+  [CLAUDE_CREDENTIAL_SOURCE.SUBSCRIPTION_WINS]: "claude auth login session (subscription beats the stored keychain key)",
+  [CLAUDE_CREDENTIAL_SOURCE.KEYCHAIN]: "ANTHROPIC_API_KEY from OS keychain"
+});
+function describeAnthropicAuthSource(baseEnv = {}, { getKey = getAnthropicKey, probeLogin = probeClaudeLoginState } = {}) {
+  const { source } = classifyClaudeCredential(baseEnv, { getKey, probeLogin });
+  return AUTH_SOURCE_DESCRIPTION[source];
+}
+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 VO_RESEARCH_TOOLS = ["WebFetch", "WebSearch"];
+var VO_WORKFLOW_TOOLS = ["Workflow"];
+var VO_CONSENSUS_TOOLS = ["mcp__vo-mcp__vo_consensus_judgment", "mcp__vo-mcp__vo_verify_answer"];
+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, researchHarness = false, env = process.env } = {}) {
+  const effectivePermissionMode = normalizeClaudePermissionMode(permissionMode);
+  const noWeb = String(env?.VO_CODE_RUNNER_NO_WEB ?? "").trim() === "1";
+  const research = noWeb ? [] : VO_RESEARCH_TOOLS;
+  const noWorkflow = noWeb || String(env?.VO_CODE_RUNNER_NO_WORKFLOW ?? "").trim() === "1";
+  const workflow = researchHarness === true && !noWorkflow ? VO_WORKFLOW_TOOLS : [];
+  const noConsensus = String(env?.VO_CODE_RUNNER_NO_CONSENSUS ?? "").trim() === "1";
+  const consensus = noConsensus ? [] : VO_CONSENSUS_TOOLS;
+  const baseTools = effectivePermissionMode === DEFAULT_PERMISSION_MODE ? [VO_SESSION_STATE_TOOL, VO_HEADLESS_PNPM_TOOL, VO_HEADLESS_PNPM_FROM_DIR_TOOL] : [VO_SESSION_STATE_TOOL];
+  const allowedTools = [...baseTools, ...consensus, ...research, ...workflow].join(",");
+  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;
+var NO_AGENT_SPAWNED_ECONOMICS = Object.freeze({ cost_usd: 0, cost_basis: "no_agent_spawned" });
+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
+var CAPPED_RESULT_SUBTYPES = Object.freeze(["error_max_budget_usd", "error_max_turns"]);
+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/agent-auth-tier.mjs
+var AUTH_TIER_SUBSCRIPTION = "subscription";
+var AUTH_TIER_API_KEY = "api_key";
+var AUTH_TIER_LOCAL = "local";
+var AUTH_TIER_UNKNOWN = "unknown";
+var AUTH_TIERS = Object.freeze([
+  AUTH_TIER_SUBSCRIPTION,
+  AUTH_TIER_API_KEY,
+  AUTH_TIER_LOCAL,
+  AUTH_TIER_UNKNOWN
+]);
+var COST_BASIS_TO_TIER = Object.freeze({
+  subscription_api_equivalent: AUTH_TIER_SUBSCRIPTION,
+  vendor_billed: AUTH_TIER_API_KEY,
+  local_zero: AUTH_TIER_LOCAL
+});
+function authTierFromCostBasis(costBasis) {
+  return COST_BASIS_TO_TIER[String(costBasis ?? "")] ?? AUTH_TIER_UNKNOWN;
+}
+function safeAuthTier(compute) {
+  try {
+    return normalizeAuthTier(compute());
+  } catch {
+    return AUTH_TIER_UNKNOWN;
+  }
+}
+function normalizeAuthTier(value) {
+  return AUTH_TIERS.includes(value) ? value : AUTH_TIER_UNKNOWN;
+}
+
+// ../../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";
+}
+function resolveClaudeAuthTier({
+  env = process.env,
+  loggedIn = null,
+  getStoredKey = getAnthropicKey
+} = {}) {
+  return safeAuthTier(() => {
+    const spawnEnv = withAnthropicKey(env, { getKey: getStoredKey, probeLogin: () => loggedIn });
+    const tier = authTierFromCostBasis(claudeCostBasis(spawnEnv));
+    if (tier === AUTH_TIER_SUBSCRIPTION && loggedIn !== true) return AUTH_TIER_UNKNOWN;
+    return tier;
+  });
+}
+async function checkClaudeAuth({
+  spawnVersion = spawnClaudeSync,
+  probeLogin = probeClaudeLoginState,
+  getStoredKey = getAnthropicKey,
+  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,
+      // Dispatch-time billing signal, carried on the same probe that already
+      // paid for the login read. Never sent for a non-authenticated result:
+      // there is no tier without a working credential.
+      authTier: resolveClaudeAuthTier({ env, loggedIn, getStoredKey }),
+      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, researchHarness } = {}) {
+    return buildClaudeArgs({ permissionMode, maxTurns, model, effort, maxBudgetUsd, researchHarness });
+  }
+  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 });
+  }
+  applyAuthEnv(env = process.env) {
+    return withAnthropicKey(env);
+  }
+  costBasis(env = process.env) {
+    return claudeCostBasis(env);
+  }
+  describeAuth(env = process.env) {
+    return describeAnthropicAuthSource(env);
+  }
+  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"],
+  // AlgoHQ cloud consensus (ADR-002 moat plane) entitlement token. Not a model
+  // key: it authorises the runner's `vo_consensus_judgment` / `vo_verify_answer`
+  // tools against the moat. On an npm-installed runner the local consensus
+  // engine is never present (it is a workspace-only package), so WITHOUT this
+  // token every consensus call answers `unimplemented /
+  // consensus-engine-package-not-installed` (2026-08-16 finding, task fbd8659b).
+  moat: ["VO_ENTITLEMENT_TOKEN"]
+};
+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",
+  moat: "moat",
+  entitlement: "moat",
+  consensus: "moat"
+};
+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/error-message.mjs
+var FAILURE_SCHEMA = "vo.runner_failure.v1";
+var FAILURE_DEFINITIONS = {
+  model_unsupported_for_account: {
+    source: "terminal_event",
+    operator_next_action: "Create a new owner-reviewed task with an account-supported Codex model; keep the preserved draft PR for review rather than resuming this task."
+  },
+  codex_runtime_launch_logon_session: {
+    source: "stderr",
+    win32_error: 1312,
+    operator_next_action: "Repair the Codex Windows logon/session configuration on the serving host, then rerun the runner."
+  }
+};
+function codexFailure(code, fields = {}) {
+  const definition = FAILURE_DEFINITIONS[code];
+  return {
+    schema: FAILURE_SCHEMA,
+    agent: "codex",
+    source: definition.source,
+    code,
+    ...fields,
+    operator_next_action: definition.operator_next_action
+  };
+}
+function classifyCodexTerminalFailure(evt = {}) {
+  const error = evt && typeof evt.error === "object" && evt.error !== null ? evt.error : null;
+  if (!/^The ['"][^'"]+['"] model is not supported when using Codex with a ChatGPT account\.$/u.test(
+    typeof error?.message === "string" ? error.message : ""
+  )) return null;
+  const status = Number(evt.status ?? error.status);
+  return codexFailure("model_unsupported_for_account", Number.isInteger(status) ? { provider_status: status } : {});
+}
+function classifyCodexStderr(stderr = "") {
+  if (!/(?:^|\n)\s*windows sandbox(?: failed)?: runner error:.*\bCreateProcessAsUserW failed:\s*1312\b/imu.test(String(stderr))) return null;
+  return codexFailure("codex_runtime_launch_logon_session", { win32_error: 1312 });
+}
+
+// ../../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";
+    const failure = classifyCodexTerminalFailure(evt);
+    return { kind: "result", isError: true, costUsd: null, summary: String(msg), numTurns: null, ...failure ? { failure } : {} };
+  }
+  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);
+  }
+  classifyStderr(stderr) {
+    return classifyCodexStderr(stderr);
+  }
+  /**
+   * 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
+    };
+  }
+  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";
+  }
+  authTier(env = this.env) {
+    return safeAuthTier(() => authTierFromCostBasis(this.costBasis(this.applyAuthEnv(env))));
+  }
+  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,
+            authTier: this.authTier(),
+            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,
+        authTier: this.authTier(),
+        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";
+  }
+  /**
+   * Dispatch-time billing tier. Inherits costBasis()'s deliberate refusal to
+   * guess: a prior interactive `cursor-agent login` has undocumented
+   * subscription semantics, so it reports 'unknown' rather than claiming a
+   * flat-cost seat the runner cannot actually prove. Keychain read only — the
+   * heartbeat never pays for a subprocess to answer this.
+   */
+  authTier(env = process.env) {
+    return safeAuthTier(() => authTierFromCostBasis(this.costBasis(this.applyAuthEnv(env))));
+  }
+  /** 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,
+        authTier: this.authTier(),
+        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/ollama-agent-tools.mjs
+var MAX_READ_BYTES = 64 * 1024;
+var MAX_WRITE_BYTES = 512 * 1024;
+var TOOL_DEFS = [
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read a UTF-8 text file inside the working directory. Returns up to 64 KiB.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path relative to the working directory." }
+        },
+        required: ["path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_files",
+      description: "List entries in a directory inside the working directory (files and subdirs).",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: 'Directory path relative to the working directory. Default ".".' }
+        }
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "write_file",
+      description: "Create or overwrite a UTF-8 text file inside the working directory. Parent dirs are created.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path relative to the working directory." },
+          content: { type: "string", description: "Full new file contents." }
+        },
+        required: ["path", "content"]
+      }
+    }
+  }
+];
+var TOOL_NAMES = TOOL_DEFS.map((t) => t.function.name);
+var READ_ONLY_TOOL_NAMES = Object.freeze(["read_file", "list_files"]);
+var READ_ONLY_TOOL_DEFS = Object.freeze(
+  TOOL_DEFS.filter((tool) => READ_ONLY_TOOL_NAMES.includes(tool.function.name))
+);
+
+// ../../scripts/virtual-office/code-runner/ollama-agent-core.mjs
+var MAX_TURNS_DEFAULT = 20;
+var NUM_CTX_DEFAULT = 16384;
+function parseOllamaAgentEvent(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 === "progress") {
+    const text = String(evt.text || "").trim();
+    return text ? { kind: "progress", text } : null;
+  }
+  if (evt.type === "tool") {
+    const via = evt.recovered ? " (recovered from text)" : "";
+    const label = `${evt.ok === false ? "tool failed" : "tool"}: ${evt.name}${evt.path ? ` ${evt.path}` : ""}${via}`;
+    return { kind: "progress", text: label };
+  }
+  if (evt.type === "result") {
+    const usage = evt.usage || null;
+    const tokenUsage = usage ? { inputTokens: usage.inputTokens ?? null, outputTokens: usage.outputTokens ?? null, totalTokens: usage.totalTokens ?? null } : void 0;
+    return {
+      kind: "result",
+      isError: Boolean(evt.isError),
+      costUsd: 0,
+      // sovereign local inference is free — no meter.
+      summary: String(evt.summary || (evt.isError ? "local run failed" : "completed")),
+      numTurns: Number.isInteger(evt.numTurns) ? evt.numTurns : null,
+      ...tokenUsage ? { tokenUsage } : {},
+      // Pass the sovereign receipt through to the daemon. Omitted entirely when
+      // absent so the event shape is unchanged for every other transport.
+      ...evt.receipt ? { receipt: evt.receipt } : {}
+    };
+  }
+  return null;
+}
+
+// ../../scripts/virtual-office/code-runner/ollama-native-transport.mjs
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+var DEFAULT_LOCAL_TRANSPORT = "codex";
+var LOCAL_NATIVE_PROFILES = Object.freeze(["coding", "verification"]);
+var DEFAULT_LOCAL_NATIVE_PROFILE = "coding";
+function resolveLocalNativeProfile(env = process.env) {
+  const profile = String(env.VO_CODE_RUNNER_LOCAL_PROFILE || "").trim().toLowerCase() || DEFAULT_LOCAL_NATIVE_PROFILE;
+  if (!LOCAL_NATIVE_PROFILES.includes(profile)) {
+    throw new Error(`local-model runner (native): unknown profile "${profile}" (coding|verification).`);
+  }
+  return profile;
+}
+function resolveLocalTransport(env = process.env) {
+  return String(env.VO_CODE_RUNNER_LOCAL_TRANSPORT || "").trim().toLowerCase() === "native" ? "native" : DEFAULT_LOCAL_TRANSPORT;
+}
+function ollamaAgentScriptPath() {
+  return join(dirname(fileURLToPath(import.meta.url)), "ollama-agent.mjs");
+}
+function posIntOr(raw, fallback) {
+  const n = Number(String(raw ?? "").trim());
+  return Number.isInteger(n) && n > 0 ? n : fallback;
+}
+function buildOllamaAgentArgs({ model, numCtx, maxTurns, profile = DEFAULT_LOCAL_NATIVE_PROFILE } = {}) {
+  return [
+    ollamaAgentScriptPath(),
+    "--model",
+    String(model),
+    "--profile",
+    String(profile),
+    "--num-ctx",
+    String(posIntOr(numCtx, NUM_CTX_DEFAULT)),
+    "--max-turns",
+    String(posIntOr(maxTurns, MAX_TURNS_DEFAULT))
+  ];
+}
+function buildLocalNativeArgs(opts = {}, env = process.env) {
+  const provider = resolveLocalProvider(env);
+  if (provider !== "ollama") {
+    throw new Error(
+      `local-model runner (native): the native tool-loop executor speaks Ollama's /api/chat; provider "${provider}" is not supported on native transport. Set VO_CODE_RUNNER_LOCAL_PROVIDER=ollama, or use VO_CODE_RUNNER_LOCAL_TRANSPORT=codex for LM Studio.`
+    );
+  }
+  const model = resolveLocalModel(env);
+  if (!model) {
+    throw new Error(
+      "local-model runner (native): set VO_CODE_RUNNER_LOCAL_MODEL to a coding model your Ollama server already has (e.g. qwen2.5-coder:7b). Refusing to run with no explicit model (fail-closed)."
+    );
+  }
+  if (!isValidLocalModel(model)) {
+    throw new Error(`local-model runner (native): "${model}" is not a valid local model id.`);
+  }
+  const baseUrl = resolveLocalBaseUrl(env);
+  if (baseUrl && !isLoopbackBaseUrl(baseUrl)) {
+    throw new Error(
+      "local-model runner (native): 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."
+    );
+  }
+  return buildOllamaAgentArgs({
+    model,
+    profile: resolveLocalNativeProfile(env),
+    numCtx: env.VO_CODE_RUNNER_LOCAL_NUM_CTX,
+    maxTurns: env.VO_CODE_RUNNER_LOCAL_MAX_TURNS
+  });
+}
+
+// ../../scripts/virtual-office/code-runner/local-model-runner.mjs
+var LOCAL_API_KEY_ENV = "VO_CODE_RUNNER_LOCAL_API_KEY";
+var FORBIDDEN_LOCAL_CHILD_CREDENTIALS = /* @__PURE__ */ new Set([
+  "ANTHROPIC_API_KEY",
+  "AWS_ACCESS_KEY_ID",
+  "AWS_SECRET_ACCESS_KEY",
+  "AWS_SESSION_TOKEN",
+  "FIREBASE_TOKEN",
+  "GH_TOKEN",
+  "GITHUB_TOKEN",
+  "GOOGLE_API_KEY",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "OPENAI_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);
+  for (const key of Object.keys(out)) {
+    if (FORBIDDEN_LOCAL_CHILD_CREDENTIALS.has(key.toUpperCase())) delete out[key];
+  }
+  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;
+  }
+  /**
+   * Transport binary. codex transport → the codex CLI. native transport →
+   * this daemon's own node (process.execPath), which runs ollama-agent.mjs; no
+   * external CLI is involved on the native path.
+   */
+  get binary() {
+    return resolveLocalTransport(this.env) === "native" ? process.execPath : this.resolveBinary();
+  }
+  buildArgs(opts = {}) {
+    return resolveLocalTransport(this.env) === "native" ? buildLocalNativeArgs(opts, this.env) : buildLocalArgs(opts, this.env);
+  }
+  /**
+   * native transport → parse the executor's own JSONL contract. codex transport
+   * → codex JSONL maps identically, except a sovereign local model has no vendor
+   * bill: codex omits total_cost_usd for OSS runs, so turn that known fact into a
+   * measured zero at the producer. (The native parser already stamps costUsd:0.)
+   */
+  parseEvent(line) {
+    if (resolveLocalTransport(this.env) === "native") return parseOllamaAgentEvent(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";
+  }
+  /** Dispatch-time billing tier: local inference is never billed by a vendor. */
+  authTier() {
+    return safeAuthTier(() => authTierFromCostBasis(this.costBasis()));
+  }
+  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,
+      authTier: this.authTier(),
+      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. The `oai` runner lane is RETIRED (PR #8742) and executes nothing. Set VO_CODE_RUNNER_AGENT to claude, codex, cursor, local, or meta. 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 RETIRED endpoint=${baseUrl || "<unset>"} key=${hasKey ? "set" : "MISSING"}`;
+  }
+  /** Always unavailable: the lane is retired, so nothing can authenticate it. */
+  async checkAuth() {
+    return {
+      installed: false,
+      authenticated: false,
+      message: "the `oai` lane is RETIRED (PR #8742); OpenAI-compatible coding is disabled \u2014 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)
+  })}
+`);
+}