@algosuite/vo-mcp 0.2.0-beta.2 → 0.2.0-beta.21

package/dist/runner-supervisor.js

@@ -0,0 +1,2333 @@
+import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/runner/control-plane-auth-stub.mjs
+var control_plane_auth_stub_exports = {};
+__export(control_plane_auth_stub_exports, {
+  getFirebaseAuth: () => getFirebaseAuth
+});
+async function getFirebaseAuth() {
+  throw new Error(
+    "vo-mcp runner: no control-plane credential. Run `vo-mcp login` first \u2014 the runner authenticates with your stored vo_credential (or set VO_CONTROL_PLANE_ADMIN_TOKEN)."
+  );
+}
+var init_control_plane_auth_stub = __esm({
+  "src/runner/control-plane-auth-stub.mjs"() {
+  }
+});
+
+// src/runner-supervisor.mjs
+import { spawn } from "node:child_process";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { createRequire } from "node:module";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as dirname4, join as join5 } from "node:path";
+
+// ../../scripts/virtual-office/code-runner/control-plane-client.mjs
+var cachedFirebaseToken = null;
+async function resolveBearer(env) {
+  const adminToken = env.VO_CONTROL_PLANE_ADMIN_TOKEN;
+  if (adminToken) return adminToken;
+  if (cachedFirebaseToken) return cachedFirebaseToken;
+  const { getFirebaseAuth: getFirebaseAuth2 } = await Promise.resolve().then(() => (init_control_plane_auth_stub(), control_plane_auth_stub_exports));
+  const auth = await getFirebaseAuth2({ env });
+  if (!auth || !auth.idToken) {
+    throw new Error(
+      "no control-plane credential: set VO_CONTROL_PLANE_ADMIN_TOKEN, or SMOKE_EMAIL/SMOKE_PASSWORD/SMOKE_API_KEY"
+    );
+  }
+  cachedFirebaseToken = auth.idToken;
+  return cachedFirebaseToken;
+}
+function createControlPlaneClient({
+  baseUrl,
+  env = process.env,
+  fetchImpl = fetch,
+  heartbeatTimeoutMs = Math.min(
+    Math.max(Number(env.VO_CODE_RUNNER_HEARTBEAT_TIMEOUT_MS) || 15e3, 1e3),
+    6e4
+  )
+} = {}) {
+  const resolvedBaseUrl = baseUrl ?? env.VO_CONTROL_PLANE_URL ?? "";
+  if (!resolvedBaseUrl) {
+    throw new Error("VO_CONTROL_PLANE_URL is required for the code-runner daemon");
+  }
+  const root = resolvedBaseUrl.replace(/\/+$/, "");
+  async function req(method, path2, body, { timeoutMs } = {}) {
+    const bearer = await resolveBearer(env);
+    const controller = timeoutMs ? new AbortController() : null;
+    let timeoutId;
+    const request = Promise.resolve(fetchImpl(`${root}${path2}`, {
+      method,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${bearer}`
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      ...controller ? { signal: controller.signal } : {}
+    }));
+    if (!timeoutMs) return request;
+    const timeout = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        controller.abort();
+        reject(new Error(`control-plane ${path2} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+    });
+    try {
+      return await Promise.race([request, timeout]);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  return {
+    /**
+     * Claim the next pending task. Returns the task or null (empty queue).
+     * `repos` (optional `owner/name` list) and `operatorIds` (optional
+     * `operator_id` list) scope the claim so this daemon only picks up tasks it
+     * serves — the control-plane filters by both (logical AND), so another
+     * operator's task never lands on (or bills) this machine.
+     */
+    async claim(runnerId2, repos, operatorIds, session = {}) {
+      const body = { runner_id: runnerId2 };
+      if (Array.isArray(repos) && repos.length > 0) body.repos = repos;
+      if (Array.isArray(operatorIds) && operatorIds.length > 0) body.operator_ids = operatorIds;
+      if (session.runnerInstanceId) body.runner_instance_id = session.runnerInstanceId;
+      if (session.runnerInstanceId && session.reconcileStale) body.reconcile_stale = true;
+      if (session.defaultAgent) body.default_agent = session.defaultAgent;
+      if (Array.isArray(session.availableAgents)) {
+        body.available_agents = session.availableAgents.filter((entry) => entry?.installed === true && entry?.authenticated === true).map((entry) => entry.agent);
+      }
+      const res = await req("POST", "/api/v1/code-task/claim", body);
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("claim unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`claim failed: HTTP ${res.status}`);
+      const json = await res.json();
+      return json && json.task ? json.task : null;
+    },
+    /**
+     * Enqueue a new code-task (used by the PR watcher to auto-dispatch a CI fix).
+     * Server derives operator/tenant from the daemon's authenticated principal.
+     * Returns the created task, or throws on a non-2xx response.
+     */
+    async enqueueCodeTask({ repo, prompt, max_budget_usd, max_turns }) {
+      const body = { repo, prompt };
+      if (typeof max_budget_usd === "number") body.max_budget_usd = max_budget_usd;
+      if (typeof max_turns === "number") body.max_turns = max_turns;
+      const res = await req("POST", "/api/v1/code-task", body);
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("enqueue unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`enqueue failed: HTTP ${res.status}`);
+      const json = await res.json();
+      return json && json.task ? json.task : null;
+    },
+    /**
+     * Resume a failed/cancelled/max-turn partial code-task. The PR watcher uses
+     * this after the runner opens a partial draft PR and CI is no longer pending.
+     */
+    async resumeCodeTask(taskId) {
+      const res = await req("POST", `/api/v1/code-task/${encodeURIComponent(taskId)}/resume`, {});
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("resume unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`resume failed: HTTP ${res.status}`);
+      const json = await res.json();
+      return json && json.task ? json.task : null;
+    },
+    /**
+     * Send a CI-green PR through the production verify-before-act merge route.
+     * The server inspects the current diff, applies deterministic blockers, runs
+     * consensus, records a receipt, and direct-merges only the inspected SHA.
+     */
+    async mergeVerifiedPr(prNumber, automationContext) {
+      const res = await req("POST", "/api/v1/admin/pr/merge", { prNumber, automationContext });
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("gated merge unauthorized (401)");
+      }
+      const json = await res.json().catch(() => ({}));
+      if (res.ok && json?.ok === true) {
+        const result = json?.result && typeof json.result === "object" ? json.result : {};
+        const status = result.merged === true || result.status === "merged" ? "merged" : result.status === "auto-merge-enabled" || String(result.action || "").includes("auto-merge") ? "queued" : "accepted";
+        return {
+          status,
+          detail: typeof result.detail === "string" ? result.detail : null,
+          actionReceiptId: typeof json.action_receipt_id === "string" ? json.action_receipt_id : null
+        };
+      }
+      if (res.status === 503 && json?.error === "verify_unavailable") {
+        return { status: "retry", reason: json.reason || "verification unavailable" };
+      }
+      return {
+        status: "blocked",
+        reason: json?.reason || json?.message || json?.error || `HTTP ${res.status}`,
+        actionReceiptId: typeof json?.action_receipt_id === "string" ? json.action_receipt_id : null
+      };
+    },
+    /**
+     * Append progress / set terminal status. Returns
+     *   { task }            — applied
+     *   { terminal: true }  — task already terminal (operator cancelled): STOP
+     */
+    async postProgress(taskId, patch) {
+      const res = await req("PATCH", `/api/v1/code-task/${taskId}/progress`, patch);
+      if (res.status === 409) return { terminal: true };
+      if (res.status === 404) return { terminal: true, missing: true };
+      if (!res.ok) throw new Error(`progress failed: HTTP ${res.status}`);
+      const json = await res.json();
+      return { task: json && json.task };
+    },
+    async getTask(taskId) {
+      const res = await req("GET", `/api/v1/code-task/${taskId}`);
+      if (res.status === 404) return null;
+      if (!res.ok) throw new Error(`getTask failed: HTTP ${res.status}`);
+      const json = await res.json();
+      return json ? json.task : null;
+    },
+    async downloadTaskAttachment(taskId, attachmentId) {
+      const path2 = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
+      const res = await req("GET", path2);
+      if (res.status === 401) cachedFirebaseToken = null;
+      if (!res.ok) throw new Error(`attachment download failed: HTTP ${res.status}`);
+      return Buffer.from(await res.arrayBuffer());
+    },
+    async getTaskKnowledgeContext(taskId, { query } = {}) {
+      const body = {};
+      if (typeof query === "string" && query.trim()) body.query = query;
+      const res = await req("POST", `/api/v1/code-task/${encodeURIComponent(taskId)}/knowledge-context`, body);
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("knowledge-context unauthorized (401)");
+      }
+      if (res.status === 404) return null;
+      if (!res.ok) throw new Error(`knowledge-context failed: HTTP ${res.status}`);
+      return res.json();
+    },
+    /**
+     * Report this machine's rolling-7-day Claude Code token usage (the real
+     * weekly-capacity gauge) PLUS the operator's real Claude weekly % (when
+     * available). The daemon authenticates as admin, so the target `operatorId`
+     * is named explicitly. Best-effort; throws on a non-2xx so the caller can
+     * log + move on.
+     *
+     * `tokens` = { input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens }.
+     * Optional: `claudeWeeklyPct` (number) + `claudeWeeklyResetsAt` (ISO string | null).
+     */
+    async postWeeklyTokens({ operatorId, runnerId: runnerId2, tokens, claudeWeeklyPct, claudeWeeklyResetsAt }) {
+      const body = {
+        operator_id: operatorId,
+        runner_id: runnerId2,
+        input_tokens: tokens.input_tokens,
+        output_tokens: tokens.output_tokens,
+        cache_creation_tokens: tokens.cache_creation_tokens,
+        cache_read_tokens: tokens.cache_read_tokens
+      };
+      if (typeof claudeWeeklyPct === "number") {
+        body.claude_weekly_pct = claudeWeeklyPct;
+      }
+      if (claudeWeeklyResetsAt !== void 0) {
+        body.claude_weekly_resets_at = claudeWeeklyResetsAt;
+      }
+      const res = await req("POST", "/api/v1/weekly-tokens", body);
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("weekly-tokens unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`weekly-tokens failed: HTTP ${res.status}`);
+      return true;
+    },
+    /**
+     * Send a liveness heartbeat (M2). The control-plane upserts it under the
+     * authenticated operator so the web shows a TRUE "runner online" signal.
+     * Best-effort caller; throws on 401/non-ok so the daemon can log + retry.
+     */
+    async postHeartbeat({ runnerId: runnerId2, runnerInstanceId, operatorId, uptimeSec, activeTasks, maxConcurrency, effectiveConcurrency, measuredTaskSlots, measuredCpuSlots, measuredMemorySlots, version, daemonVersion, defaultAgent, supervisorInstanceId: supervisorInstanceId2, supervisorVersion: supervisorVersion2, supervisorCapabilities, servedRepos, servedOperators, availableAgents, accountUsage, availableLocalModels }) {
+      const body = { runner_id: runnerId2 };
+      if (runnerInstanceId) body.runner_instance_id = runnerInstanceId;
+      if (operatorId) body.operator_id = operatorId;
+      if (typeof uptimeSec === "number") body.uptime_sec = uptimeSec;
+      if (typeof activeTasks === "number") body.active_tasks = activeTasks;
+      if (typeof maxConcurrency === "number") body.max_concurrency = maxConcurrency;
+      if (typeof effectiveConcurrency === "number") body.effective_concurrency = effectiveConcurrency;
+      if (typeof measuredTaskSlots === "number") body.measured_task_slots = measuredTaskSlots;
+      if (typeof measuredCpuSlots === "number") body.measured_cpu_slots = measuredCpuSlots;
+      if (typeof measuredMemorySlots === "number") body.measured_memory_slots = measuredMemorySlots;
+      if (version) body.version = version;
+      if (daemonVersion) body.daemon_version = daemonVersion;
+      if (defaultAgent) body.default_agent = defaultAgent;
+      if (supervisorInstanceId2) body.supervisor_instance_id = supervisorInstanceId2;
+      if (supervisorVersion2) body.supervisor_version = supervisorVersion2;
+      if (Array.isArray(supervisorCapabilities) && supervisorCapabilities.length > 0) {
+        body.supervisor_capabilities = supervisorCapabilities;
+      }
+      if (Array.isArray(servedRepos) && servedRepos.length > 0) body.served_repos = servedRepos;
+      if (Array.isArray(servedOperators) && servedOperators.length > 0) {
+        body.served_operator_ids = servedOperators;
+      }
+      if (Array.isArray(availableAgents) && availableAgents.length > 0) {
+        body.available_agents = availableAgents;
+      }
+      if (Array.isArray(accountUsage) && accountUsage.length > 0) {
+        body.account_usage = accountUsage;
+      }
+      if (Array.isArray(availableLocalModels) && availableLocalModels.length > 0) {
+        body.available_local_models = availableLocalModels;
+      }
+      const res = await req("POST", "/api/v1/runner/heartbeat", body, {
+        timeoutMs: heartbeatTimeoutMs
+      });
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("heartbeat unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`heartbeat failed: HTTP ${res.status}`);
+      return res.json();
+    },
+    async getRunnerStatus({ operatorId } = {}) {
+      const query = operatorId ? `?operator_id=${encodeURIComponent(operatorId)}` : "";
+      const res = await req("GET", `/api/v1/runner/status${query}`, void 0, {
+        timeoutMs: heartbeatTimeoutMs
+      });
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("runner status unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`runner status failed: HTTP ${res.status}`);
+      const body = await res.json();
+      return Array.isArray(body?.runners) ? body.runners : [];
+    },
+    async pollRunnerControl({ runnerId: runnerId2, operatorId, supervisorInstanceId: supervisorInstanceId2, supervisorVersion: supervisorVersion2, capabilities }) {
+      const body = { runner_id: runnerId2 };
+      if (operatorId) body.operator_id = operatorId;
+      if (supervisorInstanceId2) body.supervisor_instance_id = supervisorInstanceId2;
+      if (supervisorVersion2) body.supervisor_version = supervisorVersion2;
+      if (Array.isArray(capabilities) && capabilities.length > 0) body.capabilities = capabilities;
+      const res = await req("POST", "/api/v1/runner/control/poll", body);
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("runner control poll unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`runner control poll failed: HTTP ${res.status}`);
+      const json = await res.json();
+      const action = json?.action;
+      return action && typeof action.action_id === "string" && action.action_id ? { ...action, actionId: action.action_id } : null;
+    },
+    async completeRunnerControl(actionId, { runnerId: runnerId2, operatorId, supervisorInstanceId: supervisorInstanceId2, supervisorVersion: supervisorVersion2, capabilities, status, detail }) {
+      const body = { runner_id: runnerId2, status };
+      if (operatorId) body.operator_id = operatorId;
+      if (supervisorInstanceId2) body.supervisor_instance_id = supervisorInstanceId2;
+      if (supervisorVersion2) body.supervisor_version = supervisorVersion2;
+      if (Array.isArray(capabilities) && capabilities.length > 0) body.capabilities = capabilities;
+      if (detail) body.detail = detail;
+      const res = await req("POST", `/api/v1/runner/control/${encodeURIComponent(actionId)}/complete`, body);
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("runner control completion unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`runner control completion failed: HTTP ${res.status}`);
+      const json = await res.json();
+      return json?.action || null;
+    },
+    /**
+     * Mint a short-lived (~1h), repo-scoped GitHub App installation token for
+     * THIS runner's operator (M3). The control-plane keys the mint on the
+     * authenticated operator (ctx.operator_id), so the token covers only that
+     * operator's installation.
+     *
+     * Returns { token, expiresAt } on success. In legacy/admin mode it returns
+     * null on a miss so the caller may use ambient `gh`. In scoped-operator mode
+     * callers pass `{ required: true }`, which fails closed instead of letting a
+     * missing/mis-scoped installation fall through to the runner machine's `gh`.
+     *
+     * The minted token is only usable for push + PR if the GitHub App grants
+     * BOTH `Contents: write` (git push) AND `Pull requests: write` (gh pr
+     * create) — see docs/vo/github-app-setup-2026-06-18.md. A token missing
+     * either scope fails at push (→ ambient fallback) or at `gh pr create`.
+     */
+    async getInstallationToken({ required = false } = {}) {
+      const fail = (reason) => {
+        if (required) throw new Error(`installation-token required: ${reason}`);
+        return null;
+      };
+      try {
+        const res = await req("POST", "/api/v1/github/installation-token", {});
+        if (!res.ok) return fail(`HTTP ${res.status}`);
+        const json = await res.json();
+        if (!json || !json.token) return fail("missing token");
+        return { token: json.token, expiresAt: json.expires_at || null };
+      } catch (err) {
+        if (required) throw err;
+        return null;
+      }
+    },
+    /**
+     * Read the operator's dispatch-mode config (Fast→Ultracode effort setting).
+     * Returns the mode string ('fast'|'standard'|'deep'|'ultra'|'ultracode'),
+     * defaulting to 'standard' on any error. Never throws — best-effort.
+     */
+    async getDispatchMode() {
+      try {
+        const res = await req("GET", "/api/v1/dispatch-mode-config");
+        if (!res.ok) return "standard";
+        const json = await res.json();
+        return json?.dispatchMode || "standard";
+      } catch {
+        return "standard";
+      }
+    }
+  };
+}
+
+// ../../scripts/virtual-office/code-runner/runner-host-maintenance.mjs
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { win32 } from "node:path";
+var DEFAULT_RUNNER_PACKAGE = "@algosuite/vo-mcp@beta";
+var PACKAGE_SPEC_RE = /^@algosuite\/vo-mcp@(beta|latest|\d+(?:\.\d+){0,2}(?:-[\w.-]+)?)$/u;
+var MAX_DIAGNOSTIC_CHARS = 800;
+var NPM_CLI_SUFFIX = `\\${win32.join("node_modules", "npm", "bin", "npm-cli.js").toLowerCase()}`;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function sanitizeMaintenanceDiagnostic(raw, env = {}) {
+  let value = String(raw || "").replace(/\b(?:vocred|npm|gh[oprsu])_[A-Za-z0-9._-]+\b/gu, "[REDACTED]").replace(/\bBearer\s+\S+/giu, "Bearer [REDACTED]").replace(/\b(_?authToken|token|password|secret|credential)(\s*[=:]\s*)\S+/giu, "$1$2[REDACTED]");
+  for (const [name, secret] of Object.entries(env)) {
+    if (!/(?:TOKEN|KEY|SECRET|PASSWORD|CREDENTIAL)/iu.test(name)) continue;
+    const text = String(secret || "");
+    if (text.length < 4) continue;
+    value = value.replace(new RegExp(escapeRegExp(text), "gu"), "[REDACTED]");
+  }
+  value = value.replace(/\s+/gu, " ").trim();
+  if (value.length <= MAX_DIAGNOSTIC_CHARS) return value;
+  return `${value.slice(0, MAX_DIAGNOSTIC_CHARS - 1)}\u2026`;
+}
+function isNpmCliPath(value) {
+  return typeof value === "string" && win32.isAbsolute(value) && win32.normalize(value).toLowerCase().endsWith(NPM_CLI_SUFFIX);
+}
+function resolveNpmCli({
+  env = process.env,
+  execPath = process.execPath,
+  fileExists = existsSync
+} = {}) {
+  const candidates = [];
+  if (isNpmCliPath(env.npm_execpath)) candidates.push(env.npm_execpath);
+  candidates.push(win32.join(win32.dirname(execPath), "node_modules", "npm", "bin", "npm-cli.js"));
+  const pathValue = env.PATH ?? env.Path ?? env.path ?? "";
+  for (const entry of pathValue.split(";")) {
+    const trimmed = entry.trim();
+    if (!win32.isAbsolute(trimmed)) continue;
+    candidates.push(win32.join(trimmed, "node_modules", "npm", "bin", "npm-cli.js"));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const normalized = win32.normalize(candidate);
+    const key = normalized.toLowerCase();
+    if (seen.has(key) || !isNpmCliPath(normalized)) continue;
+    seen.add(key);
+    if (fileExists(normalized)) return normalized;
+  }
+  return null;
+}
+function buildMaintenanceCommand(kind, {
+  platform = process.platform,
+  packageSpec = DEFAULT_RUNNER_PACKAGE,
+  env = process.env,
+  execPath = process.execPath,
+  fileExists = existsSync
+} = {}) {
+  if (!["update", "reinstall"].includes(kind)) return null;
+  if (!PACKAGE_SPEC_RE.test(packageSpec)) throw new Error("unsafe runner package spec");
+  const npmCli = platform === "win32" ? resolveNpmCli({ env, execPath, fileExists }) : null;
+  if (platform === "win32" && !npmCli) throw new Error("trusted npm CLI not found");
+  const command = platform === "win32" ? execPath : "npm";
+  const args = [...npmCli ? [npmCli] : [], "install", "-g", packageSpec];
+  if (kind === "reinstall") args.push("--force");
+  return { command, args };
+}
+function runHostMaintenance(kind, {
+  platform = process.platform,
+  packageSpec = DEFAULT_RUNNER_PACKAGE,
+  env = process.env,
+  execPath = process.execPath,
+  fileExists = existsSync,
+  spawn: spawn2 = spawnSync,
+  log = () => {
+  }
+} = {}) {
+  if (kind === "reconnect") return { ok: true, status: 0, command: null, args: [] };
+  let command;
+  try {
+    command = buildMaintenanceCommand(kind, { platform, packageSpec, env, execPath, fileExists });
+  } catch (error) {
+    return {
+      ok: false,
+      status: 2,
+      command: null,
+      args: [],
+      detail: sanitizeMaintenanceDiagnostic(error instanceof Error ? error.message : String(error), env)
+    };
+  }
+  if (!command) return { ok: false, status: 2, command: null, args: [] };
+  log(`runner maintenance: ${command.command} ${command.args.join(" ")}`);
+  const result = spawn2(command.command, command.args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8",
+    env,
+    shell: false,
+    windowsHide: true
+  });
+  const status = typeof result.status === "number" ? result.status : 1;
+  const detail = sanitizeMaintenanceDiagnostic(
+    [result.stderr, result.stdout, result.error?.message].filter(Boolean).join("\n"),
+    env
+  );
+  if (detail) log(`runner maintenance result: ${detail}`);
+  return { ok: status === 0, status, command: command.command, args: command.args, detail };
+}
+
+// src/runner/bundled-runtime-updater.mjs
+import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
+import {
+  existsSync as existsSync4,
+  lstatSync as lstatSync3,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync3,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { basename, isAbsolute as isAbsolute3, join as join3, relative as relative3, resolve as resolve4, sep as sep2 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+
+// ../../scripts/virtual-office/runner-bootstrap/runtime-authorization.mjs
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { dirname, posix, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../../scripts/virtual-office/runner-bootstrap/runtime-staged-tree.mjs
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  existsSync as existsSync2,
+  lstatSync,
+  readFileSync,
+  readdirSync
+} from "node:fs";
+import { isAbsolute, join, relative, resolve, sep, win32 as win322 } from "node:path";
+var WINDOWS_REPARSE_ATTRIBUTE = 1024;
+var RUNNER_LOCK_KEY = "node_modules/@algosuite/vo-mcp";
+var INSTALLED_TREE_ALGORITHM = "algohq-node-modules-manifest-sha256-v1";
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
+  }
+  return value;
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonical(value));
+}
+function hasFileAttribute(value, bit) {
+  if (typeof value === "bigint") return (value & BigInt(bit)) !== 0n;
+  return Number.isSafeInteger(value) && (value & bit) !== 0;
+}
+function isReparseStat(stats) {
+  if (!stats || typeof stats !== "object") return false;
+  if (typeof stats.isSymbolicLink === "function" && stats.isSymbolicLink()) return true;
+  if (stats.reparseTag !== void 0 && stats.reparseTag !== null && stats.reparseTag !== 0) return true;
+  return ["fileAttributes", "fileAttribute", "attributes"].some((key) => hasFileAttribute(stats[key], WINDOWS_REPARSE_ATTRIBUTE));
+}
+function platformConstraintAllows(values, target) {
+  if (!Array.isArray(values) || values.length === 0) return true;
+  if (values.some((value) => value === `!${target}`)) return false;
+  const positive = values.filter((value) => typeof value === "string" && !value.startsWith("!"));
+  return positive.length === 0 || positive.includes(target);
+}
+function isOmittedOptionalPackage(entry, platform = { os: "win32", arch: "x64" }) {
+  return entry?.optional === true && (!platformConstraintAllows(entry.os, platform.os) || !platformConstraintAllows(entry.cpu, platform.arch));
+}
+function assertContained(root, candidate, label) {
+  const rel = relative(root, candidate);
+  if (rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel)) return;
+  throw new Error(`staged runtime ${label} escapes the payload root`);
+}
+function normalizeReportedPath(root, candidate) {
+  const absolute = resolve(String(candidate || ""));
+  assertContained(root, absolute, "reparse point");
+  return absolute;
+}
+function listWindowsReparsePoints(root, {
+  execFile = execFileSync,
+  env = process.env,
+  platform = process.platform
+} = {}) {
+  if (platform !== "win32") return [];
+  const systemRoot = String(env.SystemRoot || env.SYSTEMROOT || "");
+  if (!win322.isAbsolute(systemRoot) || win322.normalize(systemRoot) !== systemRoot) {
+    throw new Error("staged runtime trusted PowerShell root unavailable");
+  }
+  const system32 = win322.join(systemRoot, "System32");
+  const powershell = win322.join(system32, "WindowsPowerShell", "v1.0", "powershell.exe");
+  const script = [
+    '$ErrorActionPreference = "Stop"',
+    "$root = [IO.Path]::GetFullPath($env:ALGOHQ_REPARSE_ROOT)",
+    "$items = @((Get-Item -LiteralPath $root -Force)) + @(Get-ChildItem -LiteralPath $root -Force -Recurse)",
+    "foreach ($item in $items) {",
+    "  if (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) {",
+    "    [Console]::Out.WriteLine($item.FullName)",
+    "  }",
+    "}"
+  ].join("; ");
+  const output = execFile(powershell, [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    script
+  ], {
+    cwd: system32,
+    encoding: "utf8",
+    env: { SystemRoot: systemRoot, ALGOHQ_REPARSE_ROOT: win322.resolve(root) },
+    windowsHide: true
+  });
+  return String(output || "").split(/\r?\n/u).filter(Boolean).map((item) => normalizeReportedPath(root, item));
+}
+function normalizedRunnerRecord(actual, expected) {
+  const normalized = structuredClone(actual);
+  if (normalized?.resolved === expected?.resolved) return normalized;
+  if (typeof normalized?.resolved !== "string" || !normalized.resolved.startsWith("file:")) {
+    return normalized;
+  }
+  const fileName = normalized.resolved.slice("file:".length).replaceAll("\\", "/").split("/").at(-1);
+  const expectedFileNames = /* @__PURE__ */ new Set([
+    String(expected.resolved || "").split("/").at(-1),
+    `algosuite-vo-mcp-${expected.version}.tgz`
+  ]);
+  if (expectedFileNames.has(fileName)) normalized.resolved = expected.resolved;
+  return normalized;
+}
+function validateLock(lock, authorization) {
+  if (!lock || typeof lock !== "object" || Array.isArray(lock)) {
+    throw new Error("staged runtime package-lock must be an object");
+  }
+  if (lock.lockfileVersion !== authorization.dependency_lock.source_lockfile_version) {
+    throw new Error("staged runtime package-lock version mismatch");
+  }
+  if (!lock.packages || typeof lock.packages !== "object" || Array.isArray(lock.packages)) {
+    throw new Error("staged runtime package-lock package map missing");
+  }
+  const expected = authorization.dependency_lock.packages;
+  const actual = Object.fromEntries(Object.entries(lock.packages).filter(([key]) => key !== ""));
+  const expectedKeys = Object.keys(expected).sort();
+  const actualKeys = Object.keys(actual).sort();
+  if (canonicalJson(actualKeys) !== canonicalJson(expectedKeys)) {
+    throw new Error("staged runtime package-lock package set mismatch");
+  }
+  for (const key of expectedKeys) {
+    const record = key === RUNNER_LOCK_KEY ? normalizedRunnerRecord(actual[key], expected[key]) : actual[key];
+    if (canonicalJson(record) !== canonicalJson(expected[key])) {
+      throw new Error(`staged runtime package-lock record mismatch: ${key}`);
+    }
+  }
+  return { actual, expected };
+}
+function checkPathKind(path2, expectedKind, fsOps, label) {
+  if (!fsOps.exists(path2)) throw new Error(`staged runtime ${label} missing`);
+  const stats = fsOps.lstat(path2);
+  if (isReparseStat(stats) || fsOps.isReparsePoint(path2, stats)) {
+    throw new Error(`staged runtime ${label} is a reparse point`);
+  }
+  if (expectedKind === "directory" && !stats.isDirectory()) {
+    throw new Error(`staged runtime ${label} is not a directory`);
+  }
+  if (expectedKind === "file" && !stats.isFile()) {
+    throw new Error(`staged runtime ${label} is not a regular file`);
+  }
+  if (expectedKind === "file" && Number(stats.nlink) > 1) {
+    throw new Error(`staged runtime ${label} is hardlinked`);
+  }
+  return stats;
+}
+function verifyInstalledPackages(payloadRoot, packageRecords, platform, fsOps) {
+  const omitted = [];
+  let installed = 0;
+  for (const [key, entry] of Object.entries(packageRecords)) {
+    const path2 = resolve(payloadRoot, key);
+    assertContained(payloadRoot, path2, "package path");
+    const shouldOmit = isOmittedOptionalPackage(entry, platform);
+    if (shouldOmit) {
+      omitted.push(key);
+      if (fsOps.exists(path2)) throw new Error(`staged runtime optional package should be omitted: ${key}`);
+      continue;
+    }
+    checkPathKind(path2, "directory", fsOps, `installed package ${key}`);
+    installed += 1;
+  }
+  return { installed, omitted: omitted.sort() };
+}
+function treeRecord(kind, path2, stats, fileHash = "") {
+  if (kind === "d") return `d	${path2}\r
+`;
+  return `f	${path2}	${stats.size}	${fileHash}\r
+`;
+}
+function computeInstalledTree(nodeModulesRoot, fsOps = {}) {
+  const ops = {
+    exists: existsSync2,
+    lstat: lstatSync,
+    readdir: (path2) => readdirSync(path2, { withFileTypes: true }),
+    readFile: readFileSync,
+    isReparsePoint: () => false,
+    listReparsePoints: listWindowsReparsePoints,
+    ...fsOps
+  };
+  const root = resolve(nodeModulesRoot);
+  checkPathKind(root, "directory", ops, "node_modules root");
+  const reported = ops.listReparsePoints(root);
+  if (!Array.isArray(reported)) throw new Error("staged runtime reparse probe returned an invalid result");
+  if (reported.length > 0) throw new Error("staged runtime tree contains a Windows reparse point");
+  let fileCount = 0;
+  let directoryCount = 1;
+  let byteCount = 0;
+  const entries = [];
+  function walk(absolute, relativePath) {
+    for (const entry of ops.readdir(absolute)) {
+      const childRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+      if (childRelative === ".package-lock.json") continue;
+      const child = resolve(absolute, entry.name);
+      assertContained(root, child, "tree entry");
+      const stats = ops.lstat(child);
+      if (isReparseStat(stats) || ops.isReparsePoint(child, stats)) {
+        throw new Error(`staged runtime tree contains a reparse point: ${childRelative}`);
+      }
+      if (stats.isDirectory()) {
+        directoryCount += 1;
+        entries.push({ kind: "d", path: childRelative, stats });
+        walk(child, childRelative);
+      } else if (stats.isFile()) {
+        if (Number(stats.nlink) > 1) {
+          throw new Error(`staged runtime tree contains a hardlinked file: ${childRelative}`);
+        }
+        fileCount += 1;
+        byteCount += Number(stats.size);
+        const digest = createHash("sha256").update(ops.readFile(child)).digest("hex");
+        entries.push({ kind: "f", path: childRelative, stats, digest });
+      } else {
+        throw new Error(`staged runtime tree contains a non-file entry: ${childRelative}`);
+      }
+    }
+  }
+  walk(root, "");
+  entries.sort((left, right) => Buffer.compare(Buffer.from(left.path), Buffer.from(right.path)));
+  const manifest = treeRecord("d", "", { size: 0 }) + entries.map((entry) => treeRecord(entry.kind, entry.path, entry.stats, entry.digest)).join("");
+  return {
+    algorithm: INSTALLED_TREE_ALGORITHM,
+    sha256: createHash("sha256").update(manifest, "utf8").digest("hex"),
+    file_count: fileCount,
+    directory_count: directoryCount,
+    byte_count: byteCount,
+    canonical_manifest_byte_count: Buffer.byteLength(manifest),
+    reparse_point_count: 0,
+    hardlinked_file_count: 0
+  };
+}
+function compareStagedRuntime({
+  payloadRoot,
+  nodeModulesRoot = join(payloadRoot, "node_modules"),
+  packageLockFile = join(payloadRoot, "package-lock.json"),
+  authorization,
+  fsOps = {}
+}) {
+  const payload = resolve(payloadRoot);
+  const modules = resolve(nodeModulesRoot);
+  const lockFile = resolve(packageLockFile);
+  if (modules !== resolve(payload, "node_modules") || lockFile !== resolve(payload, "package-lock.json")) {
+    throw new Error("staged runtime paths do not identify one canonical payload");
+  }
+  const ops = {
+    exists: existsSync2,
+    lstat: lstatSync,
+    readFile: readFileSync,
+    isReparsePoint: () => false,
+    ...fsOps
+  };
+  checkPathKind(lockFile, "file", ops, "package-lock");
+  const lock = JSON.parse(ops.readFile(lockFile, "utf8"));
+  const { expected } = validateLock(lock, authorization);
+  const platform = { os: authorization.platform.os, arch: authorization.platform.arch };
+  const packages = verifyInstalledPackages(payload, expected, platform, ops);
+  const declaredOmitted = [...authorization.dependency_lock.windows_x64_omitted_optional_entries].sort();
+  if (canonicalJson(packages.omitted) !== canonicalJson(declaredOmitted)) {
+    throw new Error("staged runtime optional omission list mismatch");
+  }
+  if (packages.installed !== Object.keys(expected).length - packages.omitted.length) {
+    throw new Error("staged runtime installed package count mismatch");
+  }
+  const tree = computeInstalledTree(modules, fsOps);
+  if (canonicalJson(tree) !== canonicalJson(authorization.installed_tree)) {
+    throw new Error("staged runtime installed tree mismatch");
+  }
+  return { ok: true, packageCount: Object.keys(expected).length, ...packages, tree };
+}
+
+// ../../scripts/virtual-office/runner-bootstrap/runtime-authorization.mjs
+var HERE = dirname(fileURLToPath(import.meta.url));
+var BETA13_WINDOWS_X64_AUTHORIZATION = resolve2(
+  HERE,
+  "authorizations",
+  "vo-mcp-0.2.0-beta.13-win32-x64.json"
+);
+var EXPECTED = Object.freeze({
+  authorizationId: "vo-mcp-0.2.0-beta.13-win32-x64-v1",
+  packageName: "@algosuite/vo-mcp",
+  version: "0.2.0-beta.13",
+  registry: "https://registry.npmjs.org/",
+  tarballUrl: "https://registry.npmjs.org/@algosuite/vo-mcp/-/vo-mcp-0.2.0-beta.13.tgz",
+  integrity: "sha512-TQa5VaEFsaleHbAZZp+zS4u5U/0zQBIGOiPDGn9IqfZfdMltH2dY81nTftvu5EUABthE1xTCrdSzJjO9mzkNag==",
+  tarballSha256: "c1e39e8bb2df7f53f48e46e77ffb617452a01849469ff4757b4384a478c1cbff",
+  npmShasumSha1: "f076649b31294aa38deb7852f38a889e0d0fbe44",
+  gitHead: "ba00db90720416fa7474581eb823c6255221880f",
+  sourceLockSha256: "f8bbb5e81a0057ee2d60145580ec07f7e7055d999bdd038515c6c4e88af6cc92",
+  canonicalEntriesSha256: "7f6b2f93ccb93ad625ed244dc59ac556792e478178fc690ad2ca2c6f3a2325d2",
+  entryCount: 107,
+  optionalEntryCount: 13,
+  installedEntryCount: 96,
+  treeAlgorithm: "algohq-node-modules-manifest-sha256-v1",
+  treeSha256: "9c8b0749d7ae1e2c132ef08c5b5655673ae88432859c561806276c9eb18f4874",
+  treeFileCount: 3538,
+  treeDirectoryCount: 553,
+  treeByteCount: 20566445,
+  treeManifestByteCount: 412062
+});
+var SRI_RE = /^sha512-[A-Za-z0-9+/]{86}==$/u;
+var SHA256_RE = /^[a-f0-9]{64}$/u;
+function canonical2(value) {
+  if (Array.isArray(value)) return value.map(canonical2);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical2(value[key])]));
+  }
+  return value;
+}
+function sha256Canonical(value) {
+  return createHash2("sha256").update(`${JSON.stringify(canonical2(value))}
+`, "utf8").digest("hex");
+}
+function assertEqual(actual, expected, label) {
+  if (actual !== expected) throw new Error(`runtime authorization ${label} mismatch`);
+}
+function isOmittedOnWindowsX64(entry) {
+  return isOmittedOptionalPackage(entry, { os: "win32", arch: "x64" });
+}
+function validateRuntimeAuthorization(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("runtime authorization must be an object");
+  }
+  assertEqual(value.schema_version, 1, "schema version");
+  assertEqual(value.authorization_id, EXPECTED.authorizationId, "id");
+  assertEqual(value.package?.name, EXPECTED.packageName, "package name");
+  assertEqual(value.package?.version, EXPECTED.version, "package version");
+  assertEqual(value.package?.registry, EXPECTED.registry, "registry");
+  assertEqual(value.package?.tarball_url, EXPECTED.tarballUrl, "tarball URL");
+  assertEqual(value.package?.sri_sha512, EXPECTED.integrity, "package integrity");
+  assertEqual(value.package?.tarball_sha256, EXPECTED.tarballSha256, "tarball sha256");
+  assertEqual(value.package?.npm_shasum_sha1, EXPECTED.npmShasumSha1, "npm shasum");
+  assertEqual(value.package?.git_head, EXPECTED.gitHead, "git head");
+  assertEqual(value.package?.packed_file_count, 25, "packed file count");
+  assertEqual(value.package?.packed_bytes, 846151, "packed byte count");
+  assertEqual(value.package?.unpacked_bytes, 3350387, "unpacked byte count");
+  assertEqual(value.platform?.os, "win32", "operating system");
+  assertEqual(value.platform?.arch, "x64", "architecture");
+  assertEqual(value.platform?.package_node_engine, ">=22.5.0", "package node engine");
+  if (!/^24\.15\.0$/u.test(String(value.platform?.authorization_builder_node || "")) || value.platform?.authorization_builder_npm !== "11.12.1") {
+    throw new Error("runtime authorization builder toolchain mismatch");
+  }
+  for (const [key, expected] of Object.entries({
+    ignore_scripts: true,
+    bin_links: false,
+    include_optional: true,
+    omit_dev: true,
+    audit: false,
+    fund: false,
+    reject_links_reparse_points: true,
+    reject_hardlinks: true,
+    remove_generated_node_modules_package_lock_before_tree_validation: true
+  })) assertEqual(value.install_contract?.[key], expected, `install contract ${key}`);
+  assertEqual(value.install_contract?.allowed_registry_prefix, EXPECTED.registry, "registry prefix");
+  const lock = value.dependency_lock;
+  if (!lock?.packages || typeof lock.packages !== "object" || Array.isArray(lock.packages)) {
+    throw new Error("runtime authorization dependency set missing");
+  }
+  assertEqual(lock.source_lockfile_version, 3, "lockfile version");
+  assertEqual(lock.source_lock_sha256, EXPECTED.sourceLockSha256, "source lock sha256");
+  assertEqual(lock.canonical_entries_sha256, EXPECTED.canonicalEntriesSha256, "entry-set sha256");
+  assertEqual(lock.entry_count, EXPECTED.entryCount, "entry count");
+  assertEqual(lock.integrity_entry_count, EXPECTED.entryCount, "integrity count");
+  assertEqual(lock.optional_entry_count, EXPECTED.optionalEntryCount, "optional count");
+  assertEqual(lock.windows_x64_installed_entry_count, EXPECTED.installedEntryCount, "installed count");
+  const entries = Object.entries(lock.packages);
+  assertEqual(entries.length, EXPECTED.entryCount, "package map count");
+  for (const [key, entry] of entries) {
+    if (!key.startsWith("node_modules/") || key.includes("\\") || posix.normalize(key) !== key || key.split("/").includes("..")) {
+      throw new Error(`runtime authorization has unsafe package path: ${key}`);
+    }
+    if (!entry || typeof entry !== "object" || entry.link === true) {
+      throw new Error(`runtime authorization contains a linked package: ${key}`);
+    }
+    if (!SRI_RE.test(String(entry.integrity || ""))) {
+      throw new Error(`runtime authorization package lacks sha512 integrity: ${key}`);
+    }
+    if (!String(entry.resolved || "").startsWith(EXPECTED.registry)) {
+      throw new Error(`runtime authorization package is outside the public registry: ${key}`);
+    }
+    if (entry.hasInstallScript === true) {
+      throw new Error(`runtime authorization package declares an install script: ${key}`);
+    }
+  }
+  const runner = lock.packages["node_modules/@algosuite/vo-mcp"];
+  assertEqual(runner?.version, EXPECTED.version, "runner dependency version");
+  assertEqual(runner?.integrity, EXPECTED.integrity, "runner dependency integrity");
+  assertEqual(sha256Canonical(lock.packages), EXPECTED.canonicalEntriesSha256, "computed entry-set sha256");
+  const omitted = entries.filter(([, entry]) => isOmittedOnWindowsX64(entry)).map(([key]) => key).sort();
+  const declaredOmitted = [...lock.windows_x64_omitted_optional_entries || []].sort();
+  assertEqual(JSON.stringify(declaredOmitted), JSON.stringify(omitted), "omitted optional entries");
+  assertEqual(entries.length - omitted.length, EXPECTED.installedEntryCount, "derived installed count");
+  const tree = value.installed_tree;
+  assertEqual(tree?.algorithm, EXPECTED.treeAlgorithm, "tree algorithm");
+  if (!SHA256_RE.test(String(tree?.sha256 || ""))) throw new Error("runtime authorization tree hash invalid");
+  assertEqual(tree.sha256, EXPECTED.treeSha256, "tree sha256");
+  assertEqual(tree.file_count, EXPECTED.treeFileCount, "tree file count");
+  assertEqual(tree.directory_count, EXPECTED.treeDirectoryCount, "tree directory count");
+  assertEqual(tree.byte_count, EXPECTED.treeByteCount, "tree byte count");
+  assertEqual(tree.canonical_manifest_byte_count, EXPECTED.treeManifestByteCount, "tree manifest byte count");
+  assertEqual(tree.reparse_point_count, 0, "tree reparse count");
+  assertEqual(tree.hardlinked_file_count, 0, "tree hardlink count");
+  return value;
+}
+function readRuntimeAuthorization(file = BETA13_WINDOWS_X64_AUTHORIZATION) {
+  return validateRuntimeAuthorization(JSON.parse(readFileSync2(file, "utf8")));
+}
+function validateStagedRuntimeAuthorization(options) {
+  const authorization = validateRuntimeAuthorization(options?.authorization || readRuntimeAuthorization());
+  return compareStagedRuntime({ ...options, authorization });
+}
+if (process.argv[1] && resolve2(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  readRuntimeAuthorization(process.argv[2] ? resolve2(process.argv[2]) : void 0);
+  process.stdout.write("AlgoHQ runtime authorization valid\n");
+}
+
+// src/runner/bundled-runtime-store.mjs
+import { createHash as createHash3, randomUUID } from "node:crypto";
+import {
+  closeSync,
+  existsSync as existsSync3,
+  fsyncSync,
+  lstatSync as lstatSync2,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve3 } from "node:path";
+var SLOT_ID_RE = /^vo-mcp-[0-9A-Za-z._-]{1,96}$/u;
+var ACTION_ID_RE = /^[0-9A-Za-z._-]{1,128}$/u;
+var INTEGRITY_RE = /^sha512-[A-Za-z0-9+/]{86}==$/u;
+var VERSION_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+var ENTRY_REL = join2("node_modules", "@algosuite", "vo-mcp", "bin", "vo-mcp");
+var SUPERVISOR_REL = join2("node_modules", "@algosuite", "vo-mcp", "dist", "runner-supervisor.js");
+var PACKAGE_REL = join2("node_modules", "@algosuite", "vo-mcp", "package.json");
+var CREDENTIAL_HELPER_REL = join2("node_modules", "@algosuite", "vo-mcp", "dist", "supervisor-credential-helper.js");
+var MANIFEST_FILE = "runtime-manifest.json";
+function within(parent, candidate) {
+  const rel = relative2(resolve3(parent), resolve3(candidate));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+}
+var APP_IDENTIFIER = "ai.algosuite.vo-runner";
+var RUNNER_RUNTIME_DIR = "runner-runtime";
+function defaultRuntimeRoot({ platform = process.platform, env = process.env, home = homedir() } = {}) {
+  if (platform === "win32") {
+    const appData = String(env.APPDATA || "").trim();
+    return appData && isAbsolute2(appData) ? join2(appData, APP_IDENTIFIER, RUNNER_RUNTIME_DIR) : null;
+  }
+  if (!home) return null;
+  if (platform === "darwin") {
+    return join2(home, "Library", "Application Support", APP_IDENTIFIER, RUNNER_RUNTIME_DIR);
+  }
+  const xdg = String(env.XDG_CONFIG_HOME || "").trim();
+  const base = xdg && isAbsolute2(xdg) ? xdg : join2(home, ".config");
+  return join2(base, APP_IDENTIFIER, RUNNER_RUNTIME_DIR);
+}
+function runtimeRootFromEnv(env = process.env, { platform, home } = {}) {
+  const value = String(env.VO_RUNNER_RUNTIME_ROOT || "").trim();
+  if (value) return isAbsolute2(value) ? resolve3(value) : null;
+  const derived = defaultRuntimeRoot({ platform, env, home });
+  return derived ? resolve3(derived) : null;
+}
+function hashFileSha512(file) {
+  return `sha512-${createHash3("sha512").update(readFileSync3(file)).digest("base64")}`;
+}
+function hashRuntimeTree(root) {
+  const hasher = createHash3("sha512");
+  const files = [];
+  const visit = (directory, prefix = "") => {
+    const rootStat = lstatSync2(directory);
+    if (rootStat.isSymbolicLink()) throw new Error("runtime tree contains a link/reparse point");
+    if (!rootStat.isDirectory()) throw new Error("runtime tree root is not a directory");
+    for (const name of readdirSync2(directory).sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)))) {
+      const absolute = join2(directory, name);
+      const relativePath = prefix ? `${prefix}/${name}` : name;
+      const stat = lstatSync2(absolute);
+      if (stat.isSymbolicLink()) throw new Error("runtime tree contains a link/reparse point");
+      if (stat.isDirectory()) visit(absolute, relativePath);
+      else if (stat.isFile() && relativePath !== MANIFEST_FILE) files.push({ absolute, relativePath, size: stat.size });
+      else if (!stat.isFile()) throw new Error("runtime tree contains a non-regular file");
+    }
+  };
+  visit(root);
+  files.sort((a, b) => Buffer.compare(Buffer.from(a.relativePath), Buffer.from(b.relativePath)));
+  for (const file of files) {
+    const pathBytes = Buffer.from(file.relativePath, "utf8");
+    hasher.update(`${pathBytes.length}:`);
+    hasher.update(pathBytes);
+    hasher.update(`:${file.size}:`);
+    hasher.update(readFileSync3(file.absolute));
+    hasher.update("\n");
+  }
+  return `sha512-${hasher.digest("base64")}`;
+}
+function atomicWriteJson(file, value) {
+  mkdirSync(dirname2(file), { recursive: true });
+  const temp = join2(dirname2(file), `.${randomUUID()}.tmp`);
+  const fd = openSync(temp, "wx", 384);
+  try {
+    writeFileSync(fd, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  try {
+    renameSync(temp, file);
+    if (process.platform !== "win32") {
+      try {
+        const parentFd = openSync(dirname2(file), "r");
+        try {
+          fsyncSync(parentFd);
+        } finally {
+          closeSync(parentFd);
+        }
+      } catch {
+      }
+    }
+  } finally {
+    rmSync(temp, { force: true });
+  }
+}
+function readActivation(runtimeRoot) {
+  const file = join2(runtimeRoot, "current.json");
+  if (!existsSync3(file)) return null;
+  try {
+    const value = JSON.parse(readFileSync3(file, "utf8"));
+    return value?.schema_version === 1 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function slotPaths(runtimeRoot, slotId) {
+  if (!SLOT_ID_RE.test(slotId)) throw new Error("invalid runtime slot id");
+  const slotRoot = join2(runtimeRoot, "slots", slotId);
+  return {
+    slotRoot,
+    entry: join2(slotRoot, ENTRY_REL),
+    supervisor: join2(slotRoot, SUPERVISOR_REL),
+    packageJson: join2(slotRoot, PACKAGE_REL),
+    credentialHelper: join2(slotRoot, CREDENTIAL_HELPER_REL),
+    manifest: join2(slotRoot, MANIFEST_FILE)
+  };
+}
+function validActive(active) {
+  return active && SLOT_ID_RE.test(active.slot_id) && VERSION_RE.test(active.version) && INTEGRITY_RE.test(active.integrity) && INTEGRITY_RE.test(active.entry_sha512) && INTEGRITY_RE.test(active.supervisor_sha512) && INTEGRITY_RE.test(active.tree_sha512);
+}
+function validateSlot(runtimeRoot, active) {
+  if (!validActive(active)) return { ok: false, detail: "invalid activation metadata" };
+  const paths = slotPaths(runtimeRoot, active.slot_id);
+  try {
+    const manifest = JSON.parse(readFileSync3(paths.manifest, "utf8"));
+    const pkg = JSON.parse(readFileSync3(paths.packageJson, "utf8"));
+    const expected = {
+      slot_id: active.slot_id,
+      version: active.version,
+      integrity: active.integrity,
+      entry_sha512: active.entry_sha512,
+      supervisor_sha512: active.supervisor_sha512,
+      tree_sha512: active.tree_sha512
+    };
+    for (const [key, value] of Object.entries(expected)) {
+      if (manifest?.[key] !== value) return { ok: false, detail: `manifest ${key} mismatch` };
+    }
+    if (manifest?.schema_version !== 1 || pkg?.name !== "@algosuite/vo-mcp" || pkg?.version !== active.version) {
+      return { ok: false, detail: "package identity mismatch" };
+    }
+    if (lstatSync2(paths.entry).isSymbolicLink() || lstatSync2(paths.supervisor).isSymbolicLink() || lstatSync2(paths.credentialHelper).isSymbolicLink()) {
+      return { ok: false, detail: "runtime entry cannot be a link" };
+    }
+    if (!within(paths.slotRoot, realpathSync(paths.entry)) || !within(paths.slotRoot, realpathSync(paths.supervisor)) || !within(paths.slotRoot, realpathSync(paths.credentialHelper))) {
+      return { ok: false, detail: "runtime entry escaped its slot" };
+    }
+    if (hashFileSha512(paths.entry) !== active.entry_sha512) return { ok: false, detail: "entry hash mismatch" };
+    if (hashFileSha512(paths.supervisor) !== active.supervisor_sha512) return { ok: false, detail: "supervisor hash mismatch" };
+    if (hashRuntimeTree(paths.slotRoot) !== active.tree_sha512) return { ok: false, detail: "runtime tree hash mismatch" };
+    return { ok: true, paths, manifest };
+  } catch (error) {
+    return { ok: false, detail: error instanceof Error ? error.message : String(error) };
+  }
+}
+function journalActivation(runtimeRoot, actionId, state, detail = "") {
+  if (!ACTION_ID_RE.test(actionId)) throw new Error("invalid runner action id");
+  atomicWriteJson(join2(runtimeRoot, "transactions", `${actionId}.json`), {
+    schema_version: 1,
+    action_id: actionId,
+    state,
+    detail: String(detail).slice(0, 400),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function activateSlot(runtimeRoot, active, action) {
+  if (!validActive(active)) throw new Error("cannot activate invalid runtime metadata");
+  if (!ACTION_ID_RE.test(action.actionId)) throw new Error("invalid runner action id");
+  if (!UUID_RE.test(String(action.supervisorInstanceId || ""))) throw new Error("invalid claiming supervisor instance id");
+  const validated = validateSlot(runtimeRoot, active);
+  if (!validated.ok) throw new Error(`cannot activate invalid runtime slot: ${validated.detail}`);
+  const current = readActivation(runtimeRoot);
+  if (current?.pending) throw new Error("another runtime activation is still pending");
+  const pointer = {
+    schema_version: 1,
+    generation: randomUUID(),
+    active,
+    previous: validActive(current?.active) ? current.active : null,
+    pending: {
+      action_id: action.actionId,
+      runner_id: String(action.runnerId || ""),
+      operator_id: String(action.operatorId || ""),
+      supervisor_instance_id: action.supervisorInstanceId,
+      activated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ack_attempts: 0
+    }
+  };
+  journalActivation(runtimeRoot, action.actionId, "prepared", `${active.version} ${active.integrity}`);
+  atomicWriteJson(join2(runtimeRoot, "current.json"), pointer);
+  return pointer;
+}
+function activationSupervisorInstanceId(runtimeRoot, fallback) {
+  const current = runtimeRoot ? readActivation(runtimeRoot) : null;
+  const pending = String(current?.pending?.supervisor_instance_id || "");
+  if (UUID_RE.test(pending)) return pending;
+  return UUID_RE.test(String(fallback || "")) ? fallback : null;
+}
+function recordActivationRetry(runtimeRoot, pointer, detail) {
+  const current = readActivation(runtimeRoot);
+  if (current?.generation !== pointer?.generation || current?.pending?.action_id !== pointer?.pending?.action_id) {
+    throw new Error("runtime activation generation changed before retry");
+  }
+  const attempts = Math.max(0, Number(current.pending.ack_attempts || 0)) + 1;
+  const updated = {
+    ...current,
+    pending: { ...current.pending, ack_attempts: attempts, last_error: String(detail).slice(0, 240) }
+  };
+  atomicWriteJson(join2(runtimeRoot, "current.json"), updated);
+  journalActivation(runtimeRoot, current.pending.action_id, "ack-retry", `attempt ${attempts}: ${detail}`);
+  return updated;
+}
+function attestCurrentSupervisor({ runtimeRoot, selfPath: selfPath2, version }) {
+  const pointer = readActivation(runtimeRoot);
+  if (!pointer?.pending || !validActive(pointer.active)) return { ok: false, detail: "no pending activation" };
+  const validated = validateSlot(runtimeRoot, pointer.active);
+  if (!validated.ok) return validated;
+  try {
+    if (realpathSync(selfPath2) !== realpathSync(validated.paths.supervisor)) {
+      return { ok: false, detail: "running supervisor is not the activated supervisor" };
+    }
+  } catch {
+    return { ok: false, detail: "could not resolve running supervisor path" };
+  }
+  if (version !== pointer.active.version) return { ok: false, detail: "running supervisor version mismatch" };
+  return { ok: true, pointer, active: pointer.active, paths: validated.paths };
+}
+function finalizeActivation(runtimeRoot, pointer) {
+  const current = readActivation(runtimeRoot);
+  if (current?.generation !== pointer?.generation || current?.pending?.action_id !== pointer?.pending?.action_id) {
+    throw new Error("runtime activation generation changed before finalization");
+  }
+  journalActivation(runtimeRoot, pointer.pending.action_id, "attesting", `${pointer.active.version} verified`);
+  atomicWriteJson(join2(runtimeRoot, "current.json"), {
+    schema_version: 1,
+    generation: pointer.generation,
+    active: pointer.active,
+    previous: pointer.previous || null,
+    pending: null
+  });
+  try {
+    journalActivation(runtimeRoot, pointer.pending.action_id, "attested", `${pointer.active.version} active`);
+  } catch {
+  }
+}
+function rollbackActivation(runtimeRoot, pointer, detail) {
+  const current = readActivation(runtimeRoot);
+  if (current?.generation !== pointer?.generation || current?.pending?.action_id !== pointer?.pending?.action_id) {
+    throw new Error("runtime activation generation changed before rollback");
+  }
+  journalActivation(runtimeRoot, pointer.pending.action_id, "rolling-back", detail);
+  const rolledBack = {
+    schema_version: 1,
+    generation: randomUUID(),
+    active: validActive(pointer?.previous) ? pointer.previous : null,
+    previous: null,
+    pending: {
+      ...pointer.pending,
+      terminal_status: "failed",
+      terminal_detail: String(detail).slice(0, 400),
+      rolled_back_at: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  atomicWriteJson(join2(runtimeRoot, "current.json"), rolledBack);
+  try {
+    journalActivation(runtimeRoot, pointer.pending.action_id, "rolled-back", detail);
+  } catch {
+  }
+  return rolledBack;
+}
+function acknowledgeActivationFailure(runtimeRoot, pointer) {
+  const current = readActivation(runtimeRoot);
+  if (current?.generation !== pointer?.generation || current?.pending?.action_id !== pointer?.pending?.action_id || current?.pending?.terminal_status !== "failed") {
+    throw new Error("runtime rollback acknowledgement obligation changed");
+  }
+  atomicWriteJson(join2(runtimeRoot, "current.json"), { ...current, pending: null });
+  try {
+    journalActivation(runtimeRoot, pointer.pending.action_id, "failure-acknowledged", pointer.pending.terminal_detail);
+  } catch {
+  }
+}
+
+// src/runner/bundled-runtime-updater.mjs
+var PACKAGE_NAME = "@algosuite/vo-mcp";
+var PACKAGE_SPEC_RE2 = /^@algosuite\/vo-mcp@\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u;
+var INTEGRITY_RE2 = /^sha512-[A-Za-z0-9+/]{86}==$/u;
+var MAX_TARBALL_BYTES = 100 * 1024 * 1024;
+var PUBLIC_REGISTRY = "https://registry.npmjs.org/";
+function buildMinimalMaintenanceEnv(env = process.env, runtimeRoot = "") {
+  const allowed = /* @__PURE__ */ new Set([
+    "PATH",
+    "Path",
+    "path",
+    "PATHEXT",
+    "SystemRoot",
+    "SYSTEMROOT",
+    "WINDIR",
+    "COMSPEC",
+    "TEMP",
+    "TMP",
+    "TMPDIR",
+    "HOME",
+    "USERPROFILE",
+    "APPDATA",
+    "LOCALAPPDATA",
+    "ProgramFiles",
+    "ProgramFiles(x86)",
+    "ProgramW6432",
+    "LANG",
+    "LC_ALL"
+  ]);
+  const clean = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (allowed.has(key) && typeof value === "string") clean[key] = value;
+  }
+  return {
+    ...clean,
+    npm_config_ignore_scripts: "true",
+    npm_config_bin_links: "false",
+    npm_config_audit: "false",
+    npm_config_fund: "false",
+    npm_config_update_notifier: "false",
+    npm_config_registry: PUBLIC_REGISTRY,
+    ...runtimeRoot ? {
+      npm_config_userconfig: join3(runtimeRoot, "maintenance", "user.npmrc"),
+      npm_config_globalconfig: join3(runtimeRoot, "maintenance", "global.npmrc"),
+      npm_config_cache: join3(runtimeRoot, "maintenance", "npm-cache")
+    } : {}
+  };
+}
+function defaultRun(command, args, options) {
+  return spawnSync2(command, args, {
+    cwd: options.cwd,
+    encoding: "utf8",
+    env: options.env,
+    shell: false,
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: options.timeout ?? 12e4
+  });
+}
+function commandRunner({ platform, execPath, env, fileExists, run }) {
+  const npmCli = platform === "win32" ? resolveNpmCli({ env, execPath, fileExists }) : null;
+  if (platform === "win32" && !npmCli) throw new Error("trusted npm CLI not found");
+  const npmCommand = platform === "win32" ? execPath : "npm";
+  const prefix = npmCli ? [npmCli] : [];
+  return {
+    npm(args, options) {
+      return run(npmCommand, [...prefix, ...args], options);
+    },
+    node(args, options) {
+      return run(execPath, args, options);
+    }
+  };
+}
+function parseJsonOutput(result, operation) {
+  if (result?.status !== 0) {
+    throw new Error(`${operation} failed: ${String(result?.stderr || result?.error?.message || `exit ${result?.status ?? 1}`)}`);
+  }
+  try {
+    return JSON.parse(String(result.stdout || ""));
+  } catch {
+    throw new Error(`${operation} returned invalid JSON`);
+  }
+}
+function tarballIntegrity(file) {
+  return `sha512-${createHash4("sha512").update(readFileSync4(file)).digest("base64")}`;
+}
+function assertNoLinks(root) {
+  const pending = [root];
+  while (pending.length) {
+    const current = pending.pop();
+    const stat = lstatSync3(current);
+    if (stat.isSymbolicLink()) throw new Error("installed runtime contains a link/reparse point");
+    if (!stat.isDirectory()) continue;
+    for (const entry of readdirSync3(current)) pending.push(join3(current, entry));
+  }
+}
+function validateDependencyLock(payloadRoot, expected) {
+  const lock = JSON.parse(readFileSync4(join3(payloadRoot, "package-lock.json"), "utf8"));
+  if (Number(lock.lockfileVersion) < 3 || !lock.packages || typeof lock.packages !== "object") {
+    throw new Error("runtime dependency lock is missing or unsupported");
+  }
+  let foundPackage = false;
+  for (const [key, item] of Object.entries(lock.packages)) {
+    if (!key) continue;
+    if (item?.link === true) throw new Error(`runtime dependency lock contains link: ${key}`);
+    const isRunner = key.replaceAll("\\", "/").endsWith("node_modules/@algosuite/vo-mcp");
+    if (isRunner) {
+      foundPackage = item.version === expected.version && item.integrity === expected.integrity;
+      continue;
+    }
+    if (!INTEGRITY_RE2.test(String(item?.integrity || ""))) throw new Error(`dependency lacks sha512 integrity: ${key}`);
+    if (!String(item?.resolved || "").startsWith("https://registry.npmjs.org/")) {
+      throw new Error(`dependency is not registry-pinned: ${key}`);
+    }
+  }
+  if (!foundPackage) throw new Error("installed runner package does not match registry integrity");
+}
+function writeAuthorizedInstallSeed(payloadRoot, tarball, runtimeAuthorization) {
+  const authorization = validateRuntimeAuthorization(runtimeAuthorization);
+  const stagingRoot = resolve4(payloadRoot, "..", "..");
+  const tarballFromStaging = relative3(stagingRoot, resolve4(tarball));
+  if (!tarballFromStaging || tarballFromStaging === ".." || tarballFromStaging.startsWith(`..${sep2}`) || isAbsolute3(tarballFromStaging)) {
+    throw new Error("authorized runtime tarball escaped staging root");
+  }
+  const relativeTarball = relative3(payloadRoot, resolve4(tarball)).replaceAll("\\", "/");
+  if (!relativeTarball || isAbsolute3(relativeTarball) || relativeTarball.includes("\n") || relativeTarball.includes("\r")) {
+    throw new Error("authorized runtime tarball path invalid");
+  }
+  const fileSpec = `file:${relativeTarball}`;
+  const packageRecord = {
+    name: "algohq-runner-runtime",
+    version: "0.0.0",
+    private: true,
+    dependencies: { [PACKAGE_NAME]: fileSpec }
+  };
+  const packages = structuredClone(authorization.dependency_lock.packages);
+  packages[`node_modules/${PACKAGE_NAME}`].resolved = fileSpec;
+  const lock = {
+    name: packageRecord.name,
+    version: packageRecord.version,
+    lockfileVersion: authorization.dependency_lock.source_lockfile_version,
+    requires: true,
+    packages: { "": packageRecord, ...packages }
+  };
+  writeFileSync2(join3(payloadRoot, "package.json"), `${JSON.stringify(packageRecord)}
+`, { mode: 384 });
+  writeFileSync2(join3(payloadRoot, "package-lock.json"), `${JSON.stringify(lock)}
+`, { mode: 384 });
+  return { fileSpec, lock };
+}
+function buildActive(slotId, metadata, paths) {
+  return {
+    slot_id: slotId,
+    version: metadata.version,
+    integrity: metadata.integrity,
+    entry_sha512: hashFileSha512(paths.entry),
+    supervisor_sha512: hashFileSha512(paths.supervisor),
+    tree_sha512: hashRuntimeTree(paths.slotRoot ?? paths.payloadRoot)
+  };
+}
+function installSlot({
+  runtimeRoot,
+  metadata,
+  tarball,
+  runner,
+  npmEnv,
+  runOptions,
+  force,
+  runtimeAuthorization
+}) {
+  const digest = createHash4("sha256").update(metadata.integrity).digest("hex").slice(0, 16);
+  const suffix = force ? `${digest}-${randomUUID2().slice(0, 8)}` : digest;
+  const slotId = `vo-mcp-${metadata.version}-${suffix}`;
+  const finalPaths = slotPaths(runtimeRoot, slotId);
+  if (!force && existsSync4(finalPaths.slotRoot)) {
+    const manifest = JSON.parse(readFileSync4(finalPaths.manifest, "utf8"));
+    const active = buildActive(slotId, metadata, finalPaths);
+    const validated = validateSlot(runtimeRoot, active);
+    if (validated.ok && manifest.integrity === metadata.integrity) {
+      if (runtimeAuthorization) {
+        validateStagedRuntimeAuthorization({
+          payloadRoot: finalPaths.slotRoot,
+          authorization: runtimeAuthorization
+        });
+      }
+      return { active, created: false };
+    }
+  }
+  const staging = join3(runtimeRoot, "staging", randomUUID2());
+  const payload = join3(staging, "payload");
+  let installedSlot = false;
+  try {
+    mkdirSync2(payload, { recursive: true });
+    let installArgs;
+    if (runtimeAuthorization) {
+      writeAuthorizedInstallSeed(payload, tarball, runtimeAuthorization);
+      installArgs = [
+        "ci",
+        "--ignore-scripts",
+        "--no-bin-links",
+        "--no-audit",
+        "--no-fund",
+        `--registry=${PUBLIC_REGISTRY}`
+      ];
+    } else {
+      writeFileSync2(join3(payload, "package.json"), `${JSON.stringify({
+        name: "algohq-runner-runtime",
+        version: "0.0.0",
+        private: true
+      })}
+`);
+      installArgs = [
+        "install",
+        "--ignore-scripts",
+        "--no-bin-links",
+        "--no-audit",
+        "--no-fund",
+        "--package-lock=true",
+        "--save-exact",
+        `--registry=${PUBLIC_REGISTRY}`,
+        tarball
+      ];
+    }
+    const install = runner.npm(
+      installArgs,
+      { ...runOptions, cwd: payload, env: npmEnv, timeout: 18e4 }
+    );
+    if (install.status !== 0) throw new Error(`npm install failed: ${install.stderr || install.error?.message || install.status}`);
+    assertNoLinks(payload);
+    validateDependencyLock(payload, metadata);
+    if (runtimeAuthorization) {
+      validateStagedRuntimeAuthorization({ payloadRoot: payload, authorization: runtimeAuthorization });
+    }
+    const stagedPaths = {
+      entry: join3(payload, "node_modules", "@algosuite", "vo-mcp", "bin", "vo-mcp"),
+      supervisor: join3(payload, "node_modules", "@algosuite", "vo-mcp", "dist", "runner-supervisor.js"),
+      packageJson: join3(payload, "node_modules", "@algosuite", "vo-mcp", "package.json"),
+      credentialHelper: join3(payload, "node_modules", "@algosuite", "vo-mcp", "dist", "supervisor-credential-helper.js"),
+      slotRoot: payload
+    };
+    const pkg = JSON.parse(readFileSync4(stagedPaths.packageJson, "utf8"));
+    if (pkg.name !== PACKAGE_NAME || pkg.version !== metadata.version) throw new Error("installed package identity mismatch");
+    if (!lstatSync3(stagedPaths.credentialHelper).isFile()) throw new Error("installed credential helper is missing");
+    const smoke = runner.node([stagedPaths.entry, "runner", "--version"], { ...runOptions, cwd: payload, env: npmEnv, timeout: 3e4 });
+    if (smoke.status !== 0 || String(smoke.stdout || "").trim() !== `vo-mcp runner ${metadata.version}`) {
+      throw new Error("bundled runtime smoke check failed");
+    }
+    const active = buildActive(slotId, metadata, stagedPaths);
+    atomicWriteJson(join3(payload, "runtime-manifest.json"), { schema_version: 1, ...active });
+    mkdirSync2(join3(runtimeRoot, "slots"), { recursive: true });
+    if (existsSync4(finalPaths.slotRoot)) throw new Error("immutable runtime slot already exists");
+    renameSync2(payload, finalPaths.slotRoot);
+    installedSlot = true;
+    const validated = validateSlot(runtimeRoot, active);
+    if (!validated.ok) throw new Error(`staged runtime validation failed: ${validated.detail}`);
+    return { active, created: true };
+  } catch (error) {
+    if (installedSlot) rmSync2(finalPaths.slotRoot, { recursive: true, force: true });
+    throw error;
+  } finally {
+    rmSync2(staging, { recursive: true, force: true });
+  }
+}
+function stageBundledRuntimeSlot(options) {
+  const {
+    runtimeRoot,
+    packageSpec,
+    expectedVersion,
+    expectedIntegrity,
+    platform = process.platform,
+    execPath = process.execPath,
+    env = process.env,
+    fileExists = existsSync4,
+    run = defaultRun,
+    force = false,
+    runtimeAuthorization = null
+  } = options;
+  if (!runtimeRoot || !isAbsolute3(runtimeRoot)) return { ok: false, status: 2, detail: "bundled runtime root unavailable" };
+  if (!expectedVersion || !PACKAGE_SPEC_RE2.test(`${PACKAGE_NAME}@${expectedVersion}`)) {
+    return { ok: false, status: 2, detail: "invalid expected runner version" };
+  }
+  if (!expectedIntegrity || !INTEGRITY_RE2.test(expectedIntegrity)) {
+    return { ok: false, status: 2, detail: "invalid expected runner integrity" };
+  }
+  const exactSpec = `${PACKAGE_NAME}@${expectedVersion}`;
+  if (packageSpec !== exactSpec) return { ok: false, status: 2, detail: "runner package spec does not match authorized version" };
+  const resolvedRoot = resolve4(runtimeRoot);
+  const npmEnv = buildMinimalMaintenanceEnv(env, resolvedRoot);
+  const runOptions = { env: npmEnv, cwd: resolvedRoot };
+  let tarDir = null;
+  try {
+    mkdirSync2(resolvedRoot, { recursive: true });
+    mkdirSync2(join3(resolvedRoot, "maintenance"), { recursive: true });
+    writeFileSync2(npmEnv.npm_config_userconfig, "", { mode: 384 });
+    writeFileSync2(npmEnv.npm_config_globalconfig, "", { mode: 384 });
+    const runner = commandRunner({ platform, execPath, env: npmEnv, fileExists, run });
+    const metadata = { version: expectedVersion, integrity: expectedIntegrity };
+    tarDir = join3(resolvedRoot, "staging", randomUUID2());
+    mkdirSync2(tarDir, { recursive: true });
+    const packed = parseJsonOutput(runner.npm([
+      "pack",
+      exactSpec,
+      "--ignore-scripts",
+      "--json",
+      "--pack-destination",
+      tarDir,
+      `--registry=${PUBLIC_REGISTRY}`
+    ], runOptions), "npm pack");
+    const record = Array.isArray(packed) ? packed[0] : packed;
+    const tarball = join3(tarDir, basename(String(record?.filename || "")));
+    if (!existsSync4(tarball) || !basename(tarball).endsWith(".tgz")) throw new Error("npm pack returned no tarball");
+    if (lstatSync3(tarball).size > MAX_TARBALL_BYTES) throw new Error("runner package tarball exceeds size limit");
+    if (record.integrity !== metadata.integrity || tarballIntegrity(tarball) !== metadata.integrity) {
+      throw new Error("runner package sha512 integrity mismatch");
+    }
+    const installed = installSlot({
+      runtimeRoot: resolvedRoot,
+      metadata,
+      tarball,
+      runner,
+      npmEnv,
+      runOptions,
+      force,
+      runtimeAuthorization
+    });
+    return { ok: true, status: 0, ...installed };
+  } catch (error) {
+    return { ok: false, status: 1, detail: sanitizeMaintenanceDiagnostic(error instanceof Error ? error.message : String(error), env) };
+  } finally {
+    if (tarDir) rmSync2(tarDir, { recursive: true, force: true });
+  }
+}
+function stageAndActivateBundledUpdate(options) {
+  const staged = stageBundledRuntimeSlot(options);
+  if (!staged.ok) return staged;
+  try {
+    activateSlot(resolve4(options.runtimeRoot), staged.active, options.action);
+    return { ...staged, handoff: true };
+  } catch (error) {
+    return {
+      ok: false,
+      status: 1,
+      detail: sanitizeMaintenanceDiagnostic(error instanceof Error ? error.message : String(error), options.env ?? process.env)
+    };
+  }
+}
+
+// ../../scripts/virtual-office/code-runner/legacy-orphan-sweep.mjs
+import { spawnSync as spawnSync4 } from "node:child_process";
+
+// ../../scripts/virtual-office/code-runner/orphan-agent-reaper.mjs
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function windowsSystemRoot(env = process.env) {
+  return env.SystemRoot || env.WINDIR || "C:\\Windows";
+}
+function windowsPowershellExe(env = process.env) {
+  return path.join(windowsSystemRoot(env), "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+}
+function killProcessTree(pid, { platform = process.platform, spawn: spawn2 = spawnSync3, env = process.env } = {}) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  if (platform === "win32") {
+    const taskkill = path.join(windowsSystemRoot(env), "System32", "taskkill.exe");
+    const r = spawn2(taskkill, ["/PID", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore", timeout: 15e3 });
+    return !r.error && r.status === 0;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+    return true;
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// ../../scripts/virtual-office/code-runner/legacy-orphan-sweep.mjs
+var MAX_LEGACY_KILLS = 50;
+var SWEEP_RECENCY_BUFFER_MS = 5e3;
+var SIGNATURES = [
+  {
+    signature: "claude-headless",
+    // claude-args.mjs always emits `-p --output-format stream-json --verbose`.
+    test: (cl) => /(?:^|[\\/"\s])claude(?:\.exe|\.cmd|\.ps1)?(?:"|\s)/iu.test(cl) && /--output-format[\s"=]+stream-json/iu.test(cl)
+  },
+  {
+    signature: "codex-headless",
+    // openai-compatible-runner always emits `exec --json`.
+    test: (cl) => /(?:^|[\\/"\s])codex(?:\.exe|\.cmd|\.ps1)?(?:"|\s)/iu.test(cl) && /\bexec\b/u.test(cl) && /--json\b/u.test(cl)
+  }
+];
+function matchAgentSignature(commandLine) {
+  if (typeof commandLine !== "string" || !commandLine) return null;
+  for (const { signature, test } of SIGNATURES) {
+    if (test(commandLine)) return signature;
+  }
+  return null;
+}
+function selectLegacyOrphans({ processes, cutoffMs, protectedPids = /* @__PURE__ */ new Set() }) {
+  const byPid = /* @__PURE__ */ new Map();
+  for (const proc of processes) {
+    if (Number.isInteger(proc?.pid) && proc.pid > 0) byPid.set(proc.pid, proc);
+  }
+  const kills = [];
+  for (const proc of byPid.values()) {
+    if (protectedPids.has(proc.pid)) continue;
+    if (!(Number.isFinite(proc.creationMs) && proc.creationMs < cutoffMs)) continue;
+    const signature = matchAgentSignature(proc.commandLine);
+    if (!signature) continue;
+    const parent = Number.isInteger(proc.ppid) && proc.ppid > 0 ? byPid.get(proc.ppid) : void 0;
+    const parentDead = !parent || Number.isFinite(parent.creationMs) && parent.creationMs > proc.creationMs;
+    if (!parentDead) continue;
+    kills.push({ pid: proc.pid, creationMs: proc.creationMs, signature, commandLine: proc.commandLine });
+  }
+  kills.sort((a, b) => a.creationMs - b.creationMs);
+  return { kills: kills.slice(0, MAX_LEGACY_KILLS) };
+}
+function parsePosixSweepLine(line, nowMs) {
+  const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(.+)$/u.exec(line ?? "");
+  if (!match) return null;
+  const pid = Number(match[1]);
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  return {
+    pid,
+    ppid: Number(match[2]),
+    creationMs: nowMs - Number(match[3]) * 1e3,
+    commandLine: match[4]
+  };
+}
+function listProcessesForSweep({ platform = process.platform, spawn: spawn2 = spawnSync4, nowMs = Date.now(), env = process.env, warn = console.warn } = {}) {
+  const rows = [];
+  if (platform === "win32") {
+    const ps = "Get-CimInstance Win32_Process | Where-Object { $_.CreationDate } | ForEach-Object { @{ p = $_.ProcessId; pp = $_.ParentProcessId; c = (([DateTimeOffset]$_.CreationDate.ToUniversalTime()).ToUnixTimeMilliseconds()); cl = [string]$_.CommandLine } | ConvertTo-Json -Compress }";
+    const result2 = spawn2(windowsPowershellExe(env), ["-NoProfile", "-NonInteractive", "-Command", ps], {
+      windowsHide: true,
+      encoding: "utf8",
+      timeout: 3e4,
+      maxBuffer: 64 * 1024 * 1024
+    });
+    if (result2.error || result2.status !== 0) {
+      const cause = result2.error ? result2.error.message : `powershell exit ${result2.status}`;
+      warn(`[orphan-sweep] process enumeration failed (${cause}); sweeping nothing this cycle`);
+      throw new Error(`process enumeration failed (${cause}); swept nothing`);
+    }
+    for (const line of String(result2.stdout ?? "").split(/\r?\n/u)) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        const pid = Number(parsed?.p);
+        if (!Number.isInteger(pid) || pid <= 0) continue;
+        rows.push({
+          pid,
+          ppid: Number(parsed.pp),
+          creationMs: Number(parsed.c),
+          commandLine: typeof parsed.cl === "string" ? parsed.cl : ""
+        });
+      } catch {
+      }
+    }
+    return rows;
+  }
+  const result = spawn2("ps", ["-eo", "pid=,ppid=,etimes=,args="], { encoding: "utf8", timeout: 3e4, maxBuffer: 64 * 1024 * 1024 });
+  if (result.error || result.status !== 0) {
+    const cause = result.error ? result.error.message : `ps exit ${result.status}`;
+    warn(`[orphan-sweep] process enumeration failed (${cause}); sweeping nothing this cycle`);
+    throw new Error(`process enumeration failed (${cause}); swept nothing`);
+  }
+  for (const line of String(result.stdout ?? "").split("\n")) {
+    const row = parsePosixSweepLine(line, nowMs);
+    if (row) rows.push(row);
+  }
+  return rows;
+}
+function runLegacyOrphanSweep({
+  nowMs = Date.now(),
+  protectedPids = [process.pid],
+  listProcesses = listProcessesForSweep,
+  killTree = killProcessTree,
+  log = () => {
+  }
+} = {}) {
+  try {
+    const processes = listProcesses({ nowMs });
+    const { kills } = selectLegacyOrphans({
+      processes,
+      cutoffMs: nowMs - SWEEP_RECENCY_BUFFER_MS,
+      protectedPids: new Set(protectedPids)
+    });
+    const killed = [];
+    for (const kill of kills) {
+      const done = killTree(kill.pid);
+      log(`legacy-orphan-sweep ${done ? "killed" : "FAILED to kill"} pid=${kill.pid} sig=${kill.signature} cmd=${String(kill.commandLine).slice(0, 200)}`);
+      if (done) killed.push({ pid: kill.pid, signature: kill.signature });
+    }
+    const failed2 = kills.length - killed.length;
+    const detail = kills.length === 0 ? `no orphaned agent processes matched the sweep criteria (${processes.length} scanned)` : `purged ${killed.length} of ${kills.length} orphaned agent process tree(s)${failed2 > 0 ? ` (${failed2} kill(s) failed)` : ""}: ${killed.map((k) => `${k.pid}:${k.signature}`).join(", ").slice(0, 700)}`;
+    return { ok: true, status: 0, detail, killed };
+  } catch (error) {
+    return { ok: false, status: 1, detail: `legacy sweep error: ${error instanceof Error ? error.message : String(error)}`.slice(0, 500), killed: [] };
+  }
+}
+
+// src/runner/supervisor-activation.mjs
+var MAX_ACK_ATTEMPTS = 3;
+var delay = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+async function waitForAuthoritativeRunnerHeartbeat({
+  client,
+  runnerId: runnerId2,
+  operatorId,
+  runnerInstanceId,
+  excludeRunnerInstanceId,
+  daemonVersion,
+  supervisorIdentity,
+  timeoutMs = 6e4,
+  pollMs = 1e3
+}) {
+  if (!runnerInstanceId && !excludeRunnerInstanceId) throw new Error("runner instance identity proof unavailable");
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const runners = await client.getRunnerStatus({ ...operatorId ? { operatorId } : {} });
+      const runner = runners.find((item) => item?.runner_id === runnerId2 && item.status === "online" && (runnerInstanceId ? item.runner_meta?.runner_instance_id === runnerInstanceId : Boolean(item.runner_meta?.runner_instance_id) && item.runner_meta.runner_instance_id !== excludeRunnerInstanceId) && item.runner_meta?.daemon_version === daemonVersion && item.runner_meta?.supervisor_instance_id === supervisorIdentity.supervisorInstanceId && item.runner_meta?.supervisor_version === supervisorIdentity.supervisorVersion && supervisorIdentity.capabilities.every((value) => item.runner_meta?.supervisor_capabilities?.includes(value)) && Array.isArray(item.runner_meta?.available_agents) && item.runner_meta.available_agents.some((agent) => agent.agent === item.runner_meta.default_agent && agent.installed === true && agent.authenticated === true));
+      if (runner) return runner;
+    } catch {
+    }
+    await delay(pollMs);
+  }
+  throw new Error("authoritative child heartbeat attestation timed out");
+}
+async function finishPendingActivation({
+  client,
+  child,
+  runtimeRoot,
+  operatorId,
+  runnerId: runnerId2,
+  selfPath: selfPath2,
+  packageVersion: packageVersion2,
+  supervisorIdentity,
+  waitForLocalRunner: waitForLocalRunner2,
+  localStatus: localStatus2,
+  waitForCloudRunner = waitForAuthoritativeRunnerHeartbeat,
+  cloudTimeoutMs,
+  cloudPollMs,
+  stopChild: stopChild2,
+  launchPreviousChild,
+  log = () => {
+  }
+}) {
+  const pointer = runtimeRoot ? readActivation(runtimeRoot) : null;
+  if (!pointer?.pending) return true;
+  const runnerIdForAction = pointer.pending.runner_id || runnerId2;
+  const operatorIdForAction = pointer.pending.operator_id || operatorId;
+  if (pointer.pending.terminal_status === "failed") {
+    try {
+      await client.completeRunnerControl(pointer.pending.action_id, {
+        runnerId: runnerIdForAction,
+        ...operatorIdForAction ? { operatorId: operatorIdForAction } : {},
+        ...supervisorIdentity,
+        status: "failed",
+        detail: pointer.pending.terminal_detail
+      });
+      acknowledgeActivationFailure(runtimeRoot, pointer);
+      return true;
+    } catch (error) {
+      log(`activation failure acknowledgement remains pending: ${error instanceof Error ? error.message : String(error)}`);
+      await stopChild2(child);
+      return false;
+    }
+  }
+  let attestation;
+  try {
+    attestation = attestCurrentSupervisor({ runtimeRoot, selfPath: selfPath2, version: packageVersion2 });
+    if (!attestation.ok) throw new Error(attestation.detail);
+    if (!await waitForLocalRunner2(child)) throw new Error("activated runner did not become locally ready");
+  } catch (error) {
+    let detail = `activation attestation failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 400);
+    let rolledBack = null;
+    try {
+      rolledBack = rollbackActivation(runtimeRoot, pointer, detail);
+    } catch (rollbackError) {
+      detail = `${detail}; rollback pending: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`.slice(0, 400);
+    }
+    try {
+      await client.completeRunnerControl(pointer.pending.action_id, {
+        runnerId: runnerIdForAction,
+        ...operatorIdForAction ? { operatorId: operatorIdForAction } : {},
+        ...supervisorIdentity,
+        status: "failed",
+        detail
+      });
+      if (rolledBack) acknowledgeActivationFailure(runtimeRoot, rolledBack);
+    } catch {
+    } finally {
+      await stopChild2(child);
+    }
+    return false;
+  }
+  let activatedRunnerInstanceId = null;
+  try {
+    const status = await localStatus2();
+    activatedRunnerInstanceId = status?.runnerInstanceId || null;
+    await waitForCloudRunner({
+      client,
+      runnerId: runnerIdForAction,
+      operatorId: operatorIdForAction,
+      runnerInstanceId: status?.runnerInstanceId,
+      daemonVersion: `vo-mcp/${attestation.active.version}`,
+      supervisorIdentity,
+      timeoutMs: cloudTimeoutMs,
+      pollMs: cloudPollMs
+    });
+    await client.completeRunnerControl(pointer.pending.action_id, {
+      runnerId: runnerIdForAction,
+      ...operatorIdForAction ? { operatorId: operatorIdForAction } : {},
+      ...supervisorIdentity,
+      status: "succeeded",
+      detail: `attested new supervisor ${attestation.active.version} ${attestation.active.integrity}`
+    });
+    finalizeActivation(runtimeRoot, attestation.pointer);
+    return true;
+  } catch (error) {
+    const failure = `activation acknowledgement failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 400);
+    let retry;
+    try {
+      retry = recordActivationRetry(runtimeRoot, attestation.pointer, failure);
+    } catch (retryError) {
+      log(`activation retry could not be recorded: ${retryError instanceof Error ? retryError.message : String(retryError)}`);
+      await stopChild2(child);
+      return false;
+    }
+    if (retry.pending.ack_attempts < MAX_ACK_ATTEMPTS) {
+      log(`activation acknowledgement pending (${retry.pending.ack_attempts}/${MAX_ACK_ATTEMPTS})`);
+      await stopChild2(child);
+      return false;
+    }
+    const previous = validateSlot(runtimeRoot, retry.previous);
+    let detail = `${failure}; retry limit reached; previous runtime restored`.slice(0, 400);
+    let rollbackChild = null;
+    let rolledBack = null;
+    try {
+      if (!previous.ok) throw new Error(`previous runtime invalid: ${previous.detail}`, { cause: error });
+      rolledBack = rollbackActivation(runtimeRoot, retry, detail);
+      await stopChild2(child);
+      rollbackChild = launchPreviousChild(previous.paths.entry);
+      if (!await waitForLocalRunner2(rollbackChild)) throw new Error("previous runner did not become locally ready", { cause: error });
+      const status = await localStatus2();
+      await waitForCloudRunner({
+        client,
+        runnerId: runnerIdForAction,
+        operatorId: operatorIdForAction,
+        runnerInstanceId: status?.runnerInstanceId,
+        excludeRunnerInstanceId: status?.runnerInstanceId ? void 0 : activatedRunnerInstanceId,
+        daemonVersion: `vo-mcp/${retry.previous.version}`,
+        supervisorIdentity,
+        timeoutMs: cloudTimeoutMs,
+        pollMs: cloudPollMs
+      });
+    } catch (rollbackError) {
+      detail = `${detail}; rollback proof failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`.slice(0, 400);
+    }
+    try {
+      await client.completeRunnerControl(retry.pending.action_id, {
+        runnerId: runnerIdForAction,
+        ...operatorIdForAction ? { operatorId: operatorIdForAction } : {},
+        ...supervisorIdentity,
+        status: "failed",
+        detail
+      });
+      if (rolledBack) acknowledgeActivationFailure(runtimeRoot, rolledBack);
+    } catch {
+    }
+    if (rollbackChild) await stopChild2(rollbackChild);
+    else await stopChild2(child);
+    return false;
+  }
+}
+
+// src/runner/supervisor-child-env.mjs
+import { hostname as systemHostname } from "node:os";
+
+// src/runner-readiness.mjs
+function failed({ paired = false, operatorId = null, tenantId = null, githubReady = null, error, message }) {
+  return { ok: false, paired, operatorId, tenantId, githubReady, error, message };
+}
+async function responseBody(response) {
+  try {
+    const value = await response.json();
+    return value && typeof value === "object" ? value : {};
+  } catch {
+    return {};
+  }
+}
+function serverMessage(body, fallback) {
+  return typeof body.message === "string" && body.message.trim() ? body.message.trim() : fallback;
+}
+async function fetchWithTimeout(fetchImpl, url, init, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetchImpl(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function probeRunnerReadiness({
+  controlPlaneUrl,
+  token,
+  fetchImpl = fetch,
+  requireGithub = false,
+  timeoutMs = 1e4
+}) {
+  const base = controlPlaneUrl.replace(/\/+$/u, "");
+  const headers = { authorization: `Bearer ${token}` };
+  let identityResponse;
+  try {
+    identityResponse = await fetchWithTimeout(
+      fetchImpl,
+      `${base}/api/v1/auth/me`,
+      { headers },
+      timeoutMs
+    );
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return failed({
+      error: "control_plane_unreachable",
+      message: `AlgoHQ could not be reached: ${detail}`
+    });
+  }
+  const identity = await responseBody(identityResponse);
+  if (!identityResponse.ok) {
+    return failed({
+      error: "credential_rejected",
+      message: "The saved pairing is expired or revoked. Pair this computer again."
+    });
+  }
+  if (identity.provisioned !== true || identity.role !== "operator" || typeof identity.operator_id !== "string" || !identity.operator_id.trim() || typeof identity.tenant_id !== "string" || !identity.tenant_id.trim()) {
+    return failed({
+      error: "operator_identity_missing",
+      message: "The pairing credential is valid but has no operator identity. Pair this computer again."
+    });
+  }
+  const operatorId = identity.operator_id.trim();
+  const tenantId = identity.tenant_id.trim();
+  if (!requireGithub) {
+    return {
+      ok: true,
+      paired: true,
+      operatorId,
+      tenantId,
+      githubReady: null,
+      error: null,
+      message: "Paired to AlgoHQ."
+    };
+  }
+  let githubResponse;
+  try {
+    githubResponse = await fetchWithTimeout(
+      fetchImpl,
+      `${base}/api/v1/github/installation-token`,
+      {
+        method: "POST",
+        headers: { ...headers, "content-type": "application/json" },
+        body: "{}"
+      },
+      timeoutMs
+    );
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return failed({
+      paired: true,
+      operatorId,
+      tenantId,
+      githubReady: false,
+      error: "github_preflight_unreachable",
+      message: `GitHub publication readiness could not be checked: ${detail}`
+    });
+  }
+  const github = await responseBody(githubResponse);
+  if (!githubResponse.ok || typeof github.token !== "string" || !github.token) {
+    const error = typeof github.error === "string" && github.error ? github.error : "github_not_ready";
+    return failed({
+      paired: true,
+      operatorId,
+      tenantId,
+      githubReady: false,
+      error,
+      message: serverMessage(github, `GitHub publication preflight failed (HTTP ${githubResponse.status}).`)
+    });
+  }
+  return {
+    ok: true,
+    paired: true,
+    operatorId,
+    tenantId,
+    githubReady: true,
+    error: null,
+    message: "Paired and ready to publish through the Algosuite GitHub App."
+  };
+}
+function pairedOperatorScope(readiness) {
+  return readiness?.ok === true && readiness?.paired === true && typeof readiness.operatorId === "string" && readiness.operatorId.trim() ? readiness.operatorId.trim() : null;
+}
+
+// src/runner/supervisor-child-env.mjs
+function resolveSupervisorRunnerId(env = {}, hostname = systemHostname) {
+  const explicit = String(env.VO_CODE_RUNNER_ID || "").trim();
+  return explicit || `vo-code-runner-${hostname()}`;
+}
+function buildSupervisorChildEnv({
+  baseEnv = {},
+  controlPlaneUrl,
+  explicitAdminToken = null,
+  pairedOperatorId = null
+} = {}) {
+  const childEnv = {
+    ...baseEnv,
+    VO_CONTROL_PLANE_URL: controlPlaneUrl
+  };
+  const adminToken = typeof explicitAdminToken === "string" ? explicitAdminToken.trim() : "";
+  const operatorId = typeof pairedOperatorId === "string" ? pairedOperatorId.trim() : "";
+  if (adminToken) childEnv.VO_CONTROL_PLANE_ADMIN_TOKEN = adminToken;
+  else delete childEnv.VO_CONTROL_PLANE_ADMIN_TOKEN;
+  if (operatorId) childEnv.VO_CODE_RUNNER_OPERATOR_IDS = operatorId;
+  return childEnv;
+}
+async function prepareSupervisorAuth({
+  baseEnv = {},
+  storedCredential = null,
+  controlPlaneUrl,
+  probeReadiness = probeRunnerReadiness
+} = {}) {
+  const explicitAdminToken = baseEnv.VO_CONTROL_PLANE_ADMIN_TOKEN?.trim();
+  const token = explicitAdminToken || storedCredential?.vo_credential;
+  if (!token) throw new Error("runner is not paired; run `vo-mcp pair` once on this host");
+  let operatorId = String(baseEnv.VO_CODE_RUNNER_OPERATOR_IDS || "").split(/[\s,]+/u).filter(Boolean)[0] || void 0;
+  if (!explicitAdminToken) {
+    const readiness = await probeReadiness({ controlPlaneUrl, token, requireGithub: true });
+    if (!readiness.ok) throw new Error(`runner readiness failed: ${readiness.message}`);
+    operatorId = pairedOperatorScope(readiness) || void 0;
+    if (!operatorId) throw new Error("runner readiness failed: paired operator scope is missing");
+  }
+  const childEnv = buildSupervisorChildEnv({
+    baseEnv,
+    controlPlaneUrl,
+    explicitAdminToken,
+    pairedOperatorId: explicitAdminToken ? null : operatorId
+  });
+  const clientEnv = {
+    ...baseEnv,
+    VO_CONTROL_PLANE_ADMIN_TOKEN: token,
+    VO_CONTROL_PLANE_URL: controlPlaneUrl,
+    ...operatorId ? { VO_CODE_RUNNER_OPERATOR_IDS: operatorId } : {}
+  };
+  return { childEnv, clientEnv, operatorId };
+}
+
+// src/runner/supervisor-credential-reader.mjs
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+import { dirname as dirname3, join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function defaultCredentialHelperPath(metaUrl = import.meta.url) {
+  const moduleDir = dirname3(fileURLToPath2(metaUrl));
+  const bundled = join4(moduleDir, "supervisor-credential-helper.js");
+  const source = join4(moduleDir, "..", "supervisor-credential-helper.mjs");
+  return existsSync6(source) ? source : bundled;
+}
+function readStoredCredentialIsolated({
+  spawn: spawn2 = spawnSync5,
+  execPath = process.execPath,
+  helperPath = defaultCredentialHelperPath(),
+  helperArgs = [],
+  env = process.env
+} = {}) {
+  const result = spawn2(execPath, [helperPath, ...helperArgs], {
+    env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false,
+    windowsHide: true,
+    timeout: 1e4
+  });
+  if (result.status !== 0) {
+    throw new Error("runner credential helper could not read the paired credential");
+  }
+  try {
+    const parsed = JSON.parse(String(result.stdout || ""));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    throw new Error("runner credential helper returned an invalid credential");
+  }
+}
+
+// src/runner-supervisor.mjs
+var DEFAULT_CONTROL_PLANE_URL = "https://vo-control-plane-bzjphrajaq-uc.a.run.app";
+var POLL_MS = 5e3;
+var CHILD_START_MS = 1500;
+var SUPERVISOR_CAPABILITIES = ["bundled-runtime-slots-v1", "legacy-orphan-purge-v1"];
+var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+var selfPath = fileURLToPath3(import.meta.url);
+var childEntry = join5(dirname4(selfPath), "runner-cli.js");
+var sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+var runnerId = resolveSupervisorRunnerId(process.env);
+function packageVersion() {
+  try {
+    return createRequire(import.meta.url)("../package.json").version || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var requestedSupervisorInstanceId = UUID_RE2.test(String(process.env.VO_RUNNER_SUPERVISOR_INSTANCE_ID || "")) ? process.env.VO_RUNNER_SUPERVISOR_INSTANCE_ID : randomUUID3();
+var supervisorInstanceId = activationSupervisorInstanceId(
+  runtimeRootFromEnv(process.env),
+  requestedSupervisorInstanceId
+);
+var supervisorVersion = packageVersion();
+var supervisorControlIdentity = {
+  supervisorInstanceId,
+  supervisorVersion,
+  capabilities: SUPERVISOR_CAPABILITIES
+};
+function spawnChild(childEnv) {
+  return spawn(process.execPath, [childEntry], {
+    env: childEnv,
+    stdio: "inherit",
+    windowsHide: true
+  });
+}
+function spawnPreviousChild(entry, childEnv) {
+  return spawn(process.execPath, [entry, "runner"], {
+    env: childEnv,
+    stdio: "inherit",
+    windowsHide: true
+  });
+}
+async function localStatus() {
+  try {
+    const port = Number(process.env.VO_CODE_RUNNER_CONTROL_PORT || 7787);
+    const response = await fetch(`http://127.0.0.1:${port}/status`, { signal: AbortSignal.timeout(800) });
+    if (!response.ok) return null;
+    const body = await response.json();
+    return body?.ok === true ? body : null;
+  } catch {
+    return null;
+  }
+}
+async function waitForLocalRunner(child) {
+  const deadline = Date.now() + 15e3;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) return false;
+    const status = await localStatus();
+    if (status?.running === true && Number(status.pid) === Number(child.pid)) return true;
+    await sleep(500);
+  }
+  return false;
+}
+async function stopChild(child) {
+  if (!child || child.exitCode !== null) return;
+  child.kill(process.platform === "win32" ? void 0 : "SIGTERM");
+  await Promise.race([
+    new Promise((resolve5) => child.once("exit", resolve5)),
+    sleep(15e3)
+  ]);
+  if (child.exitCode === null) child.kill("SIGKILL");
+}
+async function main() {
+  const stored = readStoredCredentialIsolated();
+  const controlPlaneUrl = process.env.VO_CONTROL_PLANE_URL || DEFAULT_CONTROL_PLANE_URL;
+  const { childEnv, clientEnv, operatorId } = await prepareSupervisorAuth({
+    baseEnv: process.env,
+    storedCredential: stored,
+    controlPlaneUrl
+  });
+  Object.assign(childEnv, {
+    VO_RUNNER_SUPERVISOR_INSTANCE_ID: supervisorInstanceId,
+    VO_RUNNER_SUPERVISOR_VERSION: supervisorVersion,
+    VO_RUNNER_SUPERVISOR_CAPABILITIES: SUPERVISOR_CAPABILITIES.join(",")
+  });
+  const client = createControlPlaneClient({ baseUrl: controlPlaneUrl, env: clientEnv });
+  const runtimeRoot = runtimeRootFromEnv(process.env);
+  let child = null;
+  let stopping = false;
+  let handling = false;
+  const respawn = () => {
+    if (!stopping && !handling && (!child || child.exitCode !== null)) child = launchChild();
+  };
+  const launchChild = () => {
+    const next = spawnChild(childEnv);
+    next.on("exit", () => setTimeout(respawn, 2e3));
+    return next;
+  };
+  child = launchChild();
+  if (!await finishPendingActivation({
+    client,
+    child,
+    runtimeRoot,
+    operatorId,
+    runnerId,
+    selfPath,
+    packageVersion: supervisorVersion,
+    supervisorIdentity: supervisorControlIdentity,
+    waitForLocalRunner,
+    localStatus,
+    stopChild,
+    launchPreviousChild: (entry) => spawnPreviousChild(entry, childEnv),
+    log: (message) => console.error(`[vo-runner supervisor] ${message}`)
+  })) {
+    stopping = true;
+    return;
+  }
+  const shutdown = async () => {
+    if (stopping) return;
+    stopping = true;
+    await stopChild(child);
+  };
+  process.on("SIGINT", () => {
+    void shutdown().finally(() => process.exit(0));
+  });
+  process.on("SIGTERM", () => {
+    void shutdown().finally(() => process.exit(0));
+  });
+  while (!stopping) {
+    try {
+      const action = await client.pollRunnerControl({
+        runnerId,
+        ...operatorId ? { operatorId } : {},
+        ...supervisorControlIdentity
+      });
+      if (!action) {
+        await sleep(POLL_MS);
+        continue;
+      }
+      handling = true;
+      const beforeStop = await localStatus();
+      if (beforeStop && Number(beforeStop.activeTasks || 0) > 0) {
+        await client.completeRunnerControl(action.actionId, {
+          runnerId,
+          ...operatorId ? { operatorId } : {},
+          ...supervisorControlIdentity,
+          status: "failed",
+          detail: `deferred safely: ${beforeStop.activeTasks} active task(s); retry when the runner is idle`
+        });
+        handling = false;
+        continue;
+      }
+      await stopChild(child);
+      const bundledAction = action.kind === "update" || action.kind === "reinstall";
+      const result = bundledAction ? stageAndActivateBundledUpdate({
+        runtimeRoot,
+        packageSpec: `@algosuite/vo-mcp@${action.desired_package_version}`,
+        expectedVersion: action.desired_package_version,
+        expectedIntegrity: action.desired_package_integrity,
+        action: {
+          actionId: action.actionId,
+          runnerId,
+          operatorId: operatorId || "",
+          supervisorInstanceId
+        },
+        env: process.env,
+        force: action.kind === "reinstall"
+      }) : action.kind === "purge-orphans" ? runLegacyOrphanSweep({
+        protectedPids: [process.pid],
+        log: (message) => console.warn(`[vo-runner supervisor] ${message}`)
+      }) : runHostMaintenance(action.kind, {
+        env: clientEnv,
+        log: (message) => console.warn(`[vo-runner supervisor] ${message}`)
+      });
+      if (result.ok && result.handoff) {
+        console.warn(`[vo-runner supervisor] activated ${result.active.version}; exiting for new-process attestation`);
+        return;
+      }
+      child = launchChild();
+      await sleep(CHILD_START_MS);
+      if (child.exitCode !== null || !await waitForLocalRunner(child)) result.ok = false;
+      await client.completeRunnerControl(action.actionId, {
+        runnerId,
+        ...operatorId ? { operatorId } : {},
+        ...supervisorControlIdentity,
+        status: result.ok ? "succeeded" : "failed",
+        detail: result.ok ? result.detail ? `${result.detail}; runner ${packageVersion()} reconnected`.slice(0, 1e3) : `runner ${packageVersion()} reconnected` : `maintenance exited ${result.status}${result.detail ? `: ${result.detail}` : ""}`
+      });
+      handling = false;
+    } catch (error) {
+      console.error(`[vo-runner supervisor] ${error instanceof Error ? error.message : String(error)}`);
+      handling = false;
+      await sleep(POLL_MS);
+    }
+  }
+}
+main().catch((error) => {
+  console.error(`[vo-runner supervisor] fatal: ${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=runner-supervisor.js.map