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

package/dist/runner-supervisor.js

@@ -0,0 +1,3780 @@
+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 randomUUID4 } 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/installation-token.mjs
+var READ_TOKEN_TIMEOUT_MS = 15e3;
+async function fetchInstallationToken({ req, required = false, readOnly = false, repo = null }) {
+  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",
+      readOnly ? { scope: "read", ...repo ? { repo } : {} } : {},
+      readOnly ? { timeoutMs: READ_TOKEN_TIMEOUT_MS } : {}
+    );
+    if (!res.ok) return fail(`HTTP ${res.status}`);
+    const json = await res.json();
+    if (!json || !json.token) return fail("missing token");
+    if (readOnly && json.scope !== "read") return fail("control plane did not confirm a read-only grant");
+    return { token: json.token, expiresAt: json.expires_at || null, ...typeof json.ci_readable === "boolean" ? { ciReadable: json.ci_readable } : {} };
+  } catch (err) {
+    if (required) throw err;
+    return null;
+  }
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-heartbeat-body.mjs
+function buildRunnerHeartbeatBody({
+  runnerId: runnerId2,
+  runnerInstanceId,
+  operatorId,
+  uptimeSec,
+  activeTasks,
+  maxConcurrency,
+  effectiveConcurrency,
+  measuredTaskSlots,
+  measuredCpuSlots,
+  measuredMemorySlots,
+  version,
+  daemonVersion,
+  nodeVersion,
+  defaultAgent,
+  supervisorInstanceId: supervisorInstanceId2,
+  supervisorVersion: supervisorVersion2,
+  supervisorCapabilities,
+  servedRepos,
+  servedOperators,
+  availableAgents,
+  accountUsage,
+  availableLocalModels,
+  supportedTaskKinds,
+  prepared_job_shadow: preparedJobShadow
+} = {}) {
+  const body = { runner_id: runnerId2, ...preparedJobShadow ? { prepared_job_shadow: preparedJobShadow } : {} };
+  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 (nodeVersion) body.node_version = nodeVersion;
+  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;
+  }
+  if (Array.isArray(supportedTaskKinds) && supportedTaskKinds.length > 0) {
+    body.supported_task_kinds = supportedTaskKinds;
+  }
+  return body;
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-promote.mjs
+async function promoteDraftPrRequest(req, prNumber, automationContext, onUnauthorized = () => {
+}) {
+  const res = await req("POST", "/api/v1/admin/pr/promote-draft", { prNumber, automationContext }, { timeoutMs: 6e4 });
+  if (res.status === 401) {
+    onUnauthorized();
+    throw new Error("promote-draft unauthorized (401)");
+  }
+  const json = await res.json().catch(() => ({}));
+  if (res.ok && json?.ok === true) {
+    return {
+      status: json.promoted === true ? json.auto_merge_disarmed === true ? "promoted (auto-merge disarmed)" : "promoted" : json.already_ready === true ? "already_ready" : "unchanged",
+      headSha: typeof json.head_sha === "string" ? json.head_sha : null,
+      reason: typeof json.blocked_reason === "string" ? json.blocked_reason : null
+    };
+  }
+  const code = typeof json?.error === "string" ? json.error : null;
+  const err = new Error(`promote-draft failed: HTTP ${res.status}${code ? ` (${code})` : ""}${json?.reason ? ` \u2014 ${json.reason}` : ""}`);
+  err.status = res.status;
+  err.code = code;
+  throw err;
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-task-list.mjs
+var PAGE_SIZE = 500;
+async function listAllPrOpenedTasks(request) {
+  const tasks = [];
+  let beforeCreatedAt = "";
+  let beforeId = "";
+  for (; ; ) {
+    const params = new URLSearchParams({
+      status: "pr_opened",
+      limit: String(PAGE_SIZE),
+      runner_adoption: "1"
+    });
+    if (beforeCreatedAt) {
+      params.set("before_created_at", beforeCreatedAt);
+      params.set("before_id", beforeId);
+    }
+    const res = await request("GET", `/api/v1/code-task?${params}`);
+    if (!res.ok) throw new Error(`listPrOpenedTasks failed: HTTP ${res.status}`);
+    const json = await res.json();
+    const page = Array.isArray(json?.tasks) ? json.tasks : [];
+    tasks.push(...page);
+    if (page.length < PAGE_SIZE) return tasks;
+    const last = page.at(-1);
+    if (!last?.created_at || !last?.code_task_id) {
+      throw new Error("listPrOpenedTasks pagination cursor missing");
+    }
+    beforeCreatedAt = last.created_at;
+    beforeId = last.code_task_id;
+  }
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-resume.mjs
+async function resumeCodeTaskRequest(req, taskId, { automaticRateLimit = false, automaticContinuation = false } = {}, onUnauthorized = () => {
+}) {
+  const res = await req(
+    "POST",
+    `/api/v1/code-task/${encodeURIComponent(taskId)}/resume`,
+    automaticRateLimit ? { automatic_rate_limit: true } : automaticContinuation ? { automatic_continuation: true } : {}
+  );
+  if (res.status === 401) {
+    onUnauthorized();
+    throw new Error("resume unauthorized (401)");
+  }
+  if (!res.ok) {
+    let code = null;
+    try {
+      const body = await res.json();
+      code = typeof body?.error === "string" ? body.error : null;
+    } catch {
+    }
+    const err = new Error(`resume failed: HTTP ${res.status}${code ? ` (${code})` : ""}`);
+    err.status = res.status;
+    err.code = code;
+    throw err;
+  }
+  const json = await res.json();
+  const task = json && json.task ? json.task : null;
+  if (task && typeof json.deduplicated === "boolean") Object.defineProperty(task, "deduplicated", { value: json.deduplicated, enumerable: false });
+  return task;
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-autonomous-admission.mjs
+function makeAutonomousDispatchAdmissionClient(req, timeoutMs, onUnauthorized = () => {
+}) {
+  return {
+    async reserveAutonomousDispatchBudget({ requestedBudgetUsd, reservationId, occurrenceKey }) {
+      const res = await req("POST", "/api/v1/autonomous-dispatch/admission", {
+        requested_budget_usd: requestedBudgetUsd,
+        reservation_id: reservationId,
+        dispatch_occurrence_key: occurrenceKey
+      }, { timeoutMs });
+      if (res.status === 401) {
+        onUnauthorized();
+        throw new Error("autonomous dispatch admission unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`autonomous dispatch admission failed: HTTP ${res.status}`);
+      const body = await res.json();
+      return {
+        allowed: body?.allowed === true,
+        reason: typeof body?.reason === "string" ? body.reason : ""
+      };
+    },
+    async releaseAutonomousDispatchBudget(reservationId) {
+      const res = await req("POST", "/api/v1/autonomous-dispatch/reservation/release", {
+        reservation_id: reservationId
+      }, { timeoutMs });
+      if (res.status === 401) {
+        onUnauthorized();
+        throw new Error("autonomous dispatch release unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`autonomous dispatch release failed: HTTP ${res.status}`);
+      return true;
+    }
+  };
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-merge.mjs
+async function mergeVerifiedPrRequest(req, prNumber, automationContext, onUnauthorized) {
+  const res = await req(
+    "POST",
+    "/api/v1/admin/pr/merge",
+    { prNumber, automationContext },
+    { timeoutMs: 12e4 }
+  );
+  if (res.status === 401) {
+    onUnauthorized();
+    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
+    };
+  }
+  const captureStoreRetry = json?.action_status === "not_attempted" && (json?.error === "capture_preflight_unavailable" || json?.error === "decision_outcome_intent_failed");
+  if (res.status === 503 && (json?.error === "verify_unavailable" || json?.error === "merge_unavailable" || captureStoreRetry)) {
+    return { status: "retry", reason: json.reason || json.message || json.error || "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
+  };
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-weekly-tokens.mjs
+async function postWeeklyTokensRequest(taskReq, { operatorId, runnerId: runnerId2, tokens, claudeWeeklyPct, claudeWeeklyResetsAt }, onUnauthorized = () => {
+}) {
+  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 taskReq("POST", "/api/v1/weekly-tokens", body);
+  if (res.status === 401) {
+    onUnauthorized();
+    throw new Error("weekly-tokens unauthorized (401)");
+  }
+  if (!res.ok) throw new Error(`weekly-tokens failed: HTTP ${res.status}`);
+  return true;
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-telemetry-relay.mjs
+var TELEMETRY_RELAY_TIMEOUT_MS = 3e4;
+async function relayTelemetryEventsRequest(req, { events, source }, onUnauthorized = () => {
+}) {
+  const res = await req("POST", "/api/v1/telemetry/relay", { events, ...source ? { source } : {} }, {
+    timeoutMs: TELEMETRY_RELAY_TIMEOUT_MS
+  });
+  if (res.status === 401) onUnauthorized();
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+    body = null;
+  }
+  return { status: res.status, body };
+}
+
+// ../../scripts/virtual-office/code-runner/claim-gate-notice.mjs
+var REASON_HELP = {
+  daemon_version_below_floor: "this daemon is older than the approved release target \u2014 it idles until the governed updater brings it current (operator override: VO_RUNNER_CLAIM_MIN_DAEMON_VERSION / VO_RUNNER_CLAIM_VERSION_GATE=off on the control plane)",
+  daemon_version_unreported: "this daemon reports no parseable version in its heartbeat \u2014 too old for the updater to manage, so it may not claim work",
+  no_fresh_heartbeat: "the control plane has no fresh heartbeat from this runner \u2014 claims resume once heartbeats land",
+  runner_denylisted: "this runner id is on the operator quarantine list (VO_RUNNER_CLAIM_DENYLIST)"
+};
+function describeClaimGate(gate) {
+  if (!gate || gate.allowed !== false) return null;
+  const reason = String(gate.reason || "denied");
+  const floor = gate.floor_version ? ` (floor ${gate.floor_version})` : "";
+  return `claim gate: DENIED \u2014 ${reason}${floor}: ${(Object.hasOwn(REASON_HELP, reason) ? REASON_HELP[reason] : null) ?? "the control plane refused this runner's claims"}`;
+}
+function makeClaimGateNotice({ log = () => {
+} } = {}) {
+  let last = null;
+  let current = null;
+  return {
+    current: () => current,
+    observe(json) {
+      const gate = json && typeof json === "object" ? json.claim_gate : null;
+      const denied = gate && gate.allowed === false ? gate : null;
+      current = denied ? { ...denied, observed_at: (/* @__PURE__ */ new Date()).toISOString() } : null;
+      const signature = denied ? `${denied.reason}|${denied.floor_version ?? ""}` : null;
+      if (signature === last) return;
+      if (denied) log(describeClaimGate(denied));
+      else if (last !== null) log("claim gate: allowed again \u2014 this runner may claim work");
+      last = signature;
+    }
+  };
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-knowledge-context.mjs
+var MIN_KNOWLEDGE_CONTEXT_TIMEOUT_MS = 15e3;
+var KNOWLEDGE_CONTEXT_QUERY_MAX_CHARS = 2e3;
+var RETRY_DELAYS_MS = [2e3, 6e3];
+var MAX_ATTEMPTS = RETRY_DELAYS_MS.length + 1;
+function canonicalizeKnowledgeContextQuery(value) {
+  return typeof value === "string" ? value.trimStart().slice(0, KNOWLEDGE_CONTEXT_QUERY_MAX_CHARS) : "";
+}
+function isRetryableStatus(status) {
+  return status >= 500 && status <= 599;
+}
+function defaultSleep(ms) {
+  return new Promise((resolve5) => {
+    setTimeout(resolve5, ms);
+  });
+}
+async function getTaskKnowledgeContextRequest(req, taskId, { query, knowledgeRequestId } = {}, {
+  taskRequestTimeoutMs,
+  invalidateToken = () => {
+  },
+  sleep: sleep2 = defaultSleep,
+  log = () => {
+  }
+} = {}) {
+  const body = {};
+  const canonicalQuery = canonicalizeKnowledgeContextQuery(query);
+  if (canonicalQuery.trim()) body.query = canonicalQuery;
+  if (typeof knowledgeRequestId === "string" && knowledgeRequestId) body.knowledge_request_id = knowledgeRequestId;
+  const path2 = `/api/v1/code-task/${encodeURIComponent(taskId)}/knowledge-context`;
+  const timeoutMs = Math.max(Number(taskRequestTimeoutMs) || 0, MIN_KNOWLEDGE_CONTEXT_TIMEOUT_MS);
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+    let res;
+    let cause;
+    try {
+      res = await req("POST", path2, body, { timeoutMs });
+    } catch (err) {
+      cause = err;
+    }
+    if (!cause) {
+      if (res.status === 401) {
+        invalidateToken();
+        throw new Error("knowledge-context unauthorized (401)");
+      }
+      if (res.status === 404) return null;
+      if (res.ok) return res.json();
+      if (!isRetryableStatus(res.status)) {
+        throw new Error(`knowledge-context failed: HTTP ${res.status}`);
+      }
+      cause = new Error(`knowledge-context failed: HTTP ${res.status}`);
+    }
+    if (attempt === MAX_ATTEMPTS) throw cause;
+    const delayMs = RETRY_DELAYS_MS[attempt - 1];
+    log(`knowledge-context attempt ${attempt}/${MAX_ATTEMPTS} failed (${cause.message}); retrying in ${delayMs}ms`);
+    await sleep2(delayMs);
+  }
+  throw new Error("knowledge-context retry loop exited unexpectedly");
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-prepared-job.mjs
+var PREPARED_JOB_ENV_QUERY_KEYS = [
+  "VO_CODE_RUNNER_NO_WEB",
+  "VO_CODE_RUNNER_NO_WORKFLOW",
+  "VO_CODE_RUNNER_NO_CONSENSUS",
+  "VO_CODE_RUNNER_PERMISSION_MODE",
+  "VO_CODE_RUNNER_DEFAULT_BUDGET_USD",
+  "VO_CODE_RUNNER_META_REASONING_EFFORT",
+  "VO_CODE_RUNNER_ALLOW_MISSING_KNOWLEDGE_CONTEXT",
+  "VO_ENABLE_CONTEXT7"
+];
+var PREPARED_JOB_ENV_VALUE_MAX = 64;
+function preparedJobQuery({ agent = "claude", env = {} } = {}) {
+  const params = new URLSearchParams();
+  params.set("agent", String(agent));
+  const sent = [];
+  const dropped = [];
+  for (const key of PREPARED_JOB_ENV_QUERY_KEYS) {
+    const raw = env?.[key];
+    if (typeof raw !== "string" || raw.length === 0) continue;
+    if (raw.length > PREPARED_JOB_ENV_VALUE_MAX) {
+      dropped.push(key);
+      continue;
+    }
+    params.set(key, raw);
+    sent.push(key);
+  }
+  return { query: params.toString(), sent, dropped };
+}
+async function refusalCode(res) {
+  try {
+    const body = await res.json();
+    return typeof body?.error === "string" && body.error ? body.error : null;
+  } catch {
+    return null;
+  }
+}
+async function getPreparedJobRequest(req, taskId, options = {}, invalidateToken = () => {
+}) {
+  const { agent = "claude", env = {}, timeoutMs = 15e3 } = options;
+  const { query, sent, dropped } = preparedJobQuery({ agent, env });
+  const envMeta = { envSent: sent, envDropped: dropped };
+  if (typeof taskId !== "string" || taskId.length === 0) {
+    return { ok: false, reason: "missing_task_id", status: 0, ...envMeta };
+  }
+  const path2 = `/api/v1/code-task/${encodeURIComponent(taskId)}/prepared-job?${query}`;
+  let res;
+  try {
+    res = await req("GET", path2, void 0, { timeoutMs });
+  } catch (err) {
+    return { ok: false, reason: `transport: ${err?.message || String(err)}`, status: 0, ...envMeta };
+  }
+  if (res?.status === 401) {
+    try {
+      invalidateToken();
+    } catch {
+    }
+    return { ok: false, reason: "unauthorized", status: 401, ...envMeta };
+  }
+  if (!res?.ok) {
+    const code = await refusalCode(res);
+    return { ok: false, reason: code || `http_${res?.status ?? "unknown"}`, status: res?.status ?? 0, ...envMeta };
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch (err) {
+    return { ok: false, reason: `unreadable_body: ${err?.message || String(err)}`, status: res.status, ...envMeta };
+  }
+  const job = body?.prepared_job;
+  if (!job || typeof job !== "object") {
+    return { ok: false, reason: "no_prepared_job_in_body", status: res.status, ...envMeta };
+  }
+  return {
+    ok: true,
+    job,
+    composition: body?.composition && typeof body.composition === "object" ? body.composition : {},
+    ...envMeta
+  };
+}
+
+// ../../scripts/virtual-office/code-runner/control-plane-client.mjs
+var cachedFirebaseToken = null;
+var ClaimAuthorityChangedError = class extends Error {
+  constructor() {
+    super("code-task claim authority changed");
+    this.name = "ClaimAuthorityChangedError";
+    this.code = "code_task_claim_authority_changed";
+  }
+};
+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
+  ),
+  taskRequestTimeoutMs = Math.min(
+    Math.max(Number(env.VO_CODE_RUNNER_TASK_REQUEST_TIMEOUT_MS) || 5e3, 100),
+    6e4
+  ),
+  runnerId: runnerId2,
+  runnerInstanceId,
+  sleep: sleep2
+} = {}) {
+  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(/\/+$/, "");
+  const claimOccurrences = /* @__PURE__ */ new Map();
+  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);
+    }
+  }
+  const taskReq = (method, path2, body, options = {}) => req(method, path2, body, { timeoutMs: taskRequestTimeoutMs, ...options });
+  const claimGate = makeClaimGateNotice({ log: (m) => console.warn(`[code-runner ${(/* @__PURE__ */ new Date()).toISOString()}] ${m}`) });
+  return {
+    getClaimGate: () => claimGate.current(),
+    // last DENIED claim-gate verdict (null when allowed) — for /status + tests
+    ...makeAutonomousDispatchAdmissionClient(
+      req,
+      taskRequestTimeoutMs,
+      () => {
+        cachedFirebaseToken = null;
+      }
+    ),
+    /**
+     * 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(runnerId3, repos, operatorIds, session = {}) {
+      const body = { runner_id: runnerId3 };
+      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;
+        body.runner_progress_protocol_version = 2;
+      }
+      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 taskReq("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();
+      claimGate.observe(json);
+      const task = json && json.task ? json.task : null;
+      if (task?.claim_occurrence_id) claimOccurrences.set(task.code_task_id, task.claim_occurrence_id);
+      return task;
+    },
+    /**
+     * 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, dispatch_mode, tier, agent, model, dispatch_occurrence_key, autonomous_reservation_id, on_behalf_of_operator_id, repair_pr_number, repair_kind, repair_head_sha, repair_chain }) {
+      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;
+      for (const [key, value] of Object.entries({ dispatch_mode, tier, agent, model, repair_kind, repair_head_sha })) {
+        if (value) body[key] = value;
+      }
+      if (dispatch_occurrence_key) body.dispatch_occurrence_key = dispatch_occurrence_key;
+      if (autonomous_reservation_id) body.autonomous_reservation_id = autonomous_reservation_id;
+      if (on_behalf_of_operator_id) body.on_behalf_of_operator_id = on_behalf_of_operator_id;
+      if (Number.isInteger(repair_pr_number) && repair_pr_number > 0) body.repair_pr_number = repair_pr_number;
+      if (repair_chain) body.repair_chain = repair_chain;
+      const res = await taskReq("POST", "/api/v1/code-task", body);
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("enqueue unauthorized (401)");
+      }
+      if (!res.ok) {
+        let code = null;
+        try {
+          const errBody = await res.json();
+          code = typeof errBody?.error === "string" ? errBody.error : null;
+        } catch {
+        }
+        const err = new Error(`enqueue failed: HTTP ${res.status}${code ? ` (${code})` : ""}`);
+        err.status = res.status;
+        err.code = code;
+        throw err;
+      }
+      const json = await res.json();
+      const task = json && json.task ? json.task : null;
+      if (task && typeof json.deduplicated === "boolean") Object.defineProperty(task, "deduplicated", { value: json.deduplicated, enumerable: false });
+      return task;
+    },
+    /**
+     * 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, { automaticRateLimit = false, automaticContinuation = false } = {}) {
+      return resumeCodeTaskRequest(taskReq, taskId, { automaticRateLimit, automaticContinuation }, () => {
+        cachedFirebaseToken = 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.
+     */
+    /** F35: promote a PARTIAL draft to READY via the plane (admin-only; server re-checks; never merges). */
+    promoteDraftPr: (prNumber, automationContext) => promoteDraftPrRequest(req, prNumber, automationContext, () => {
+      cachedFirebaseToken = null;
+    }),
+    async mergeVerifiedPr(prNumber, automationContext) {
+      return mergeVerifiedPrRequest(
+        req,
+        prNumber,
+        automationContext,
+        () => {
+          cachedFirebaseToken = null;
+        }
+      );
+    },
+    async postProgress(taskId, patch) {
+      const progress = {
+        ...patch,
+        ...patch.runner_id ? {} : runnerId2 ? { runner_id: runnerId2 } : {},
+        ...patch.runner_instance_id ? {} : runnerInstanceId ? { runner_instance_id: runnerInstanceId } : {},
+        ...patch.claim_occurrence_id ? {} : claimOccurrences.has(taskId) ? { claim_occurrence_id: claimOccurrences.get(taskId) } : {}
+      };
+      const res = await taskReq("PATCH", `/api/v1/code-task/${taskId}/progress`, progress);
+      if (res.status === 409) {
+        const conflict = await res.json().catch(() => ({}));
+        if (conflict?.error === "code_task_claim_authority_changed") {
+          throw new ClaimAuthorityChangedError();
+        }
+        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 taskReq("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 getAssignedSkill(task) {
+      const name = task?.skill_invocation?.skill;
+      if (!runnerId2 || !runnerInstanceId || task?.claimed_by !== runnerId2 || task?.runner_instance_id !== runnerInstanceId || !task?.claim_occurrence_id || !name) {
+        throw new ClaimAuthorityChangedError();
+      }
+      const res = await taskReq("POST", `/api/v1/code-task/${encodeURIComponent(task.code_task_id)}/assigned-skill`, {
+        runner_id: runnerId2,
+        runner_instance_id: runnerInstanceId,
+        claim_occurrence_id: task.claim_occurrence_id,
+        skill: name
+      });
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("skill corpus unauthorized (401)");
+      }
+      if (res.status === 409) {
+        const conflict = await res.json().catch(() => ({}));
+        if (conflict?.error === "code_task_claim_authority_changed") {
+          throw new ClaimAuthorityChangedError();
+        }
+      }
+      if (res.status === 404) throw new Error(`skill not found: ${name}`);
+      if (!res.ok) throw new Error(`skill corpus failed: HTTP ${res.status}`);
+      const json = await res.json();
+      if (json?.corpus_available !== true || !json.skill) {
+        throw new Error(`skill corpus unavailable: ${String(json?.reason || "unknown")}`);
+      }
+      return json.skill;
+    },
+    async listPrOpenedTasks() {
+      return listAllPrOpenedTasks(taskReq);
+    },
+    async downloadTaskAttachment(taskId, attachmentId) {
+      const path2 = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
+      const res = await taskReq("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());
+    },
+    // Raised per-attempt timeout (>=15s) + bounded retry — see control-plane-knowledge-context.mjs.
+    async getTaskKnowledgeContext(taskId, { query, knowledgeRequestId } = {}) {
+      return getTaskKnowledgeContextRequest(req, taskId, { query, knowledgeRequestId }, {
+        taskRequestTimeoutMs,
+        invalidateToken: () => {
+          cachedFirebaseToken = null;
+        },
+        sleep: sleep2,
+        log: (m) => console.warn(`[code-runner ${(/* @__PURE__ */ new Date()).toISOString()}] ${m}`)
+      });
+    },
+    /** ADR-004 § 11.1b: the plane's prepared job, for SHADOW comparison. Never throws. */
+    getPreparedJob: (taskId, options) => getPreparedJobRequest(req, taskId, options, () => {
+      cachedFirebaseToken = null;
+    }),
+    /** Weekly Claude token usage report — see control-plane-weekly-tokens.mjs. */
+    async postWeeklyTokens(report) {
+      return postWeeklyTokensRequest(taskReq, report, () => {
+        cachedFirebaseToken = null;
+      });
+    },
+    /**
+     * Relay a batch of this machine's local vo-mcp events to vo-telemetry via
+     * the control plane (telemetry-forwarder.mjs). Returns { status, body };
+     * the forwarder owns backoff/disable policy. See control-plane-telemetry-relay.mjs.
+     */
+    async relayTelemetryEvents(batch) {
+      return relayTelemetryEventsRequest(req, batch, () => {
+        cachedFirebaseToken = null;
+      });
+    },
+    /**
+     * 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(heartbeat) {
+      const body = buildRunnerHeartbeatBody(heartbeat);
+      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) {
+        let detail = "";
+        try {
+          const body2 = await res.json();
+          if (Array.isArray(body2?.issue_paths) && body2.issue_paths.length > 0) {
+            detail = ` (rejected fields: ${body2.issue_paths.join(", ")})`;
+          }
+        } catch {
+        }
+        throw new Error(`heartbeat failed: HTTP ${res.status}${detail}`);
+      }
+      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: runnerId3, operatorId, supervisorInstanceId: supervisorInstanceId2, supervisorVersion: supervisorVersion2, capabilities }) {
+      const body = { runner_id: runnerId3 };
+      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 taskReq("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: runnerId3, operatorId, supervisorInstanceId: supervisorInstanceId2, supervisorVersion: supervisorVersion2, capabilities, status, detail }) {
+      const body = { runner_id: runnerId3, 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 taskReq("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 GitHub App installation token — see installation-token.mjs. */
+    async getInstallationToken({ required = false, readOnly = false, repo = null } = {}) {
+      return fetchInstallationToken({ req: taskReq, required, readOnly, repo });
+    },
+    /**
+     * Read the operator's dispatch-mode config (Fast→Ultracode effort setting).
+     * Returns the mode string ('fast'|'standard'|'deep'|'ultra'|'marathon'; 'ultracode' legacy),
+     * defaulting to 'standard' on any error. Never throws — best-effort.
+     */
+    async getDispatchMode() {
+      try {
+        const res = await taskReq("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));
+      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,
+  isReadinessDeferred = () => false,
+  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)) {
+      if (isReadinessDeferred(child)) return false;
+      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-entry.mjs
+var VERSION_RE2 = /^(?:[\w.-]+\/)?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u;
+function parseRuntimeVersion(value) {
+  if (typeof value !== "string") return null;
+  const match = VERSION_RE2.exec(value.trim());
+  if (!match) return null;
+  const prerelease = match[4] ? match[4].split(".").map((part) => /^\d+$/u.test(part) ? Number(part) : part) : null;
+  return { release: [Number(match[1]), Number(match[2]), Number(match[3])], prerelease };
+}
+function compareRuntimeVersions(a, b) {
+  for (let i = 0; i < 3; i += 1) {
+    const av = a.release[i] ?? 0;
+    const bv = b.release[i] ?? 0;
+    if (av !== bv) return av < bv ? -1 : 1;
+  }
+  if (!a.prerelease && !b.prerelease) return 0;
+  if (!a.prerelease) return 1;
+  if (!b.prerelease) return -1;
+  const len = Math.max(a.prerelease.length, b.prerelease.length);
+  for (let i = 0; i < len; i += 1) {
+    const av = a.prerelease[i];
+    const bv = b.prerelease[i];
+    if (av === void 0) return -1;
+    if (bv === void 0) return 1;
+    if (av === bv) continue;
+    const aNum = typeof av === "number";
+    const bNum = typeof bv === "number";
+    if (aNum && bNum) return av < bv ? -1 : 1;
+    if (aNum !== bNum) return aNum ? -1 : 1;
+    return String(av) < String(bv) ? -1 : 1;
+  }
+  return 0;
+}
+function resolveSupervisorChildEntry({
+  runtimeRoot,
+  bundledEntry,
+  bundledVersion,
+  readPointer = readActivation,
+  validate = validateSlot
+}) {
+  const bundled = (detail) => ({
+    // The bundled entry is `dist/runner-cli.js`, which IS the daemon and takes
+    // no subcommand. The slot entry is `bin/vo-mcp`, the multiplexed CLI, which
+    // needs the `runner` subcommand — the same argv the proven rollback path
+    // (`launchPreviousChild`) uses.
+    args: [bundledEntry],
+    entry: bundledEntry,
+    source: "bundled",
+    version: String(bundledVersion || "unknown"),
+    descriptor: `bundled ${bundledVersion || "unknown"} ${bundledEntry}`,
+    detail
+  });
+  if (!runtimeRoot) return bundled("no runtime root");
+  let pointer;
+  try {
+    pointer = readPointer(runtimeRoot);
+  } catch (error) {
+    return bundled(`activation pointer unreadable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!pointer?.active) return bundled("no activated runtime slot");
+  if (pointer.pending) return bundled("runtime activation still pending");
+  const activeVersion = parseRuntimeVersion(pointer.active.version);
+  const currentVersion = parseRuntimeVersion(bundledVersion);
+  if (!activeVersion) return bundled(`active slot version unparseable: ${String(pointer.active.version)}`);
+  if (!currentVersion) return bundled(`bundled version unparseable: ${String(bundledVersion)}`);
+  if (compareRuntimeVersions(activeVersion, currentVersion) <= 0) {
+    return bundled(`active slot ${pointer.active.version} is not newer than bundled ${bundledVersion}`);
+  }
+  let validated;
+  try {
+    validated = validate(runtimeRoot, pointer.active);
+  } catch (error) {
+    return bundled(`slot validation threw: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!validated?.ok) return bundled(`active slot invalid: ${validated?.detail || "unknown"}`);
+  const entry = validated.paths.entry;
+  return {
+    args: [entry, "runner"],
+    entry,
+    source: "active-slot",
+    version: pointer.active.version,
+    descriptor: `active-slot ${pointer.active.version} ${entry}`,
+    detail: `activated slot ${pointer.active.slot_id}`
+  };
+}
+
+// src/runner/update-drain-gate.mjs
+var DEFAULT_DRAIN_CAP_MS = 45 * 60 * 1e3;
+var DEFAULT_DRAIN_CHECK_MS = 3e4;
+var MAX_DRAIN_CAP_MS = 6 * 60 * 60 * 1e3;
+var MIN_DRAIN_CHECK_MS = 1e3;
+var MAX_DRAIN_CHECK_MS = 5 * 60 * 1e3;
+var sleepMs = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+function positiveNumber(raw) {
+  if (raw === void 0 || raw === null || String(raw).trim() === "") return null;
+  const value = Number(raw);
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function resolveDrainCapMs(env = {}) {
+  const ms = positiveNumber(env.VO_RUNNER_UPDATE_DRAIN_CAP_MS);
+  if (ms !== null) return Math.min(ms, MAX_DRAIN_CAP_MS);
+  const minutes = positiveNumber(env.VO_RUNNER_UPDATE_DRAIN_CAP_MIN);
+  if (minutes !== null) return Math.min(minutes * 6e4, MAX_DRAIN_CAP_MS);
+  return DEFAULT_DRAIN_CAP_MS;
+}
+function resolveDrainCheckMs(env = {}) {
+  const ms = positiveNumber(env.VO_RUNNER_UPDATE_DRAIN_CHECK_MS);
+  if (ms === null) return DEFAULT_DRAIN_CHECK_MS;
+  return Math.min(Math.max(ms, MIN_DRAIN_CHECK_MS), MAX_DRAIN_CHECK_MS);
+}
+function readActiveTasks(status, { childRunning = true } = {}) {
+  if (!childRunning) {
+    return { count: 0, ids: [], known: true, runnerId: null, runnerInstanceId: null };
+  }
+  if (!status || status.ok === false) {
+    return { count: 0, ids: [], known: false, runnerId: null, runnerInstanceId: null };
+  }
+  const ids = Array.isArray(status.activeTaskIds) ? status.activeTaskIds.map((id) => String(id)).filter(Boolean) : [];
+  const reported = Number(status.activeTasks);
+  const count = Number.isFinite(reported) && reported >= 0 ? reported : ids.length;
+  return {
+    count: Math.max(count, ids.length),
+    ids,
+    known: true,
+    runnerId: status.runnerId ? String(status.runnerId) : null,
+    runnerInstanceId: status.runnerInstanceId ? String(status.runnerInstanceId) : null
+  };
+}
+function decideDrainStep({ active, elapsedMs, capMs }) {
+  const busy = active.known ? active.count : "unknown";
+  if (active.known && active.count === 0) return { action: "proceed", busy };
+  if (elapsedMs >= capMs) return { action: "cap", busy };
+  return { action: "wait", busy };
+}
+function describeBusy(active) {
+  if (!active.known) return "status unreadable from a running child (assumed busy)";
+  const ids = active.ids.length > 0 ? ` [${active.ids.join(", ")}]` : " [ids unavailable]";
+  return `${active.count} active task(s)${ids}`;
+}
+function describeDeferral(active) {
+  if (!active.known) return "status unreadable from a running child (assumed busy)";
+  return `${active.count} active task(s)`;
+}
+async function awaitRunnerUpdateDrain({
+  readStatus,
+  isChildRunning = () => true,
+  drainable = false,
+  env = {},
+  now = Date.now,
+  sleep: sleep2 = sleepMs,
+  log = () => {
+  }
+} = {}) {
+  const capMs = resolveDrainCapMs(env);
+  const checkMs = resolveDrainCheckMs(env);
+  const startedAt = now();
+  let checks = 0;
+  let lastReported = null;
+  const snapshot = async () => {
+    checks += 1;
+    const childRunning = Boolean(isChildRunning());
+    let status;
+    try {
+      status = await readStatus();
+    } catch {
+      status = null;
+    }
+    return readActiveTasks(status, { childRunning });
+  };
+  if (!drainable) {
+    const active = await snapshot();
+    if (active.known && active.count > 0) {
+      return {
+        proceed: false,
+        detail: `deferred safely: ${active.count} active task(s); retry when the runner is idle`,
+        capped: false,
+        waitedMs: 0,
+        checks,
+        markedTaskIds: []
+      };
+    }
+    return { proceed: true, detail: "runner idle", capped: false, waitedMs: 0, checks, markedTaskIds: [] };
+  }
+  for (; ; ) {
+    const active = await snapshot();
+    const elapsedMs = now() - startedAt;
+    const step = decideDrainStep({ active, elapsedMs, capMs });
+    if (step.action === "proceed") {
+      if (lastReported !== null) {
+        log(`update drain complete after ${Math.round(elapsedMs / 1e3)}s \u2014 runner idle, applying staged update restart`);
+      }
+      return { proceed: true, detail: "runner idle", capped: false, waitedMs: elapsedMs, checks, markedTaskIds: [] };
+    }
+    if (step.action === "cap") {
+      log(`update drain cap reached after ${Math.round(elapsedMs / 1e3)}s (cap ${Math.round(capMs / 1e3)}s) \u2014 ${describeBusy(active)}; deferring update until idle`);
+      return {
+        proceed: false,
+        capped: true,
+        // This reaches the runner-control `detail` field; keep it bounded and
+        // reserve task IDs for the local log above.
+        detail: `deferred safely: update drain cap reached with ${describeDeferral(active)}; retry when the runner is idle`,
+        waitedMs: elapsedMs,
+        checks,
+        // Kept for result-shape compatibility; a safe deferral never writes
+        // a terminal task outcome or stops the child.
+        markedTaskIds: []
+      };
+    }
+    const fingerprint = `${step.busy}:${active.ids.join(",")}`;
+    if (fingerprint !== lastReported) {
+      lastReported = fingerprint;
+      log(`deferring staged update restart \u2014 ${describeBusy(active)}; re-checking every ${Math.round(checkMs / 1e3)}s until idle (cap ${Math.round(capMs / 1e3)}s)`);
+    }
+    await sleep2(Math.max(1, Math.min(checkMs, capMs - elapsedMs)));
+  }
+}
+
+// src/runner/supervisor-child-env.mjs
+import { hostname as systemHostname } from "node:os";
+
+// src/runner-readiness.mjs
+import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
+var RUNNER_GITHUB_READINESS_TIMEOUT_MS = 5e4;
+var RUNNER_IDENTITY_READINESS_TIMEOUT_MS = 1e4;
+var RUNNER_READINESS_MAX_REPOSITORIES = 4;
+var RUNNER_READINESS_TRANSIENT_MAX_RETRY_AFTER_MS = 3e5;
+var RUNNER_READINESS_DEFERRAL_MESSAGE_TYPE = "vo-runner-readiness-deferred-v1";
+var RUNNER_READINESS_DEFERRAL_ACK_TYPE = "vo-runner-readiness-deferred-ack-v1";
+var RUNNER_REPOSITORY = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u;
+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;
+function runnerRepositoryScopeFromEnv(env = {}) {
+  return String(env.VO_CODE_RUNNER_REPOS || "").split(/[\s,]+/u).map((repo) => repo.trim()).filter(Boolean);
+}
+function normalizeRunnerRepositoryScope(repositories) {
+  if (!Array.isArray(repositories) || repositories.length < 1) {
+    throw new Error("VO_CODE_RUNNER_REPOS must name at least one owner/name repository");
+  }
+  if (repositories.length > RUNNER_READINESS_MAX_REPOSITORIES) {
+    throw new Error(`VO_CODE_RUNNER_REPOS supports at most ${RUNNER_READINESS_MAX_REPOSITORIES} repositories`);
+  }
+  const normalized = repositories.map((repo) => {
+    const [owner, name] = typeof repo === "string" ? repo.split("/") : [];
+    if (typeof repo !== "string" || repo.length > 140 || !RUNNER_REPOSITORY.test(repo) || owner === "." || owner === ".." || name === "." || name === "..") {
+      throw new Error("VO_CODE_RUNNER_REPOS entries must be canonical owner/name repositories");
+    }
+    return repo.toLowerCase();
+  });
+  if (new Set(normalized).size !== normalized.length) {
+    throw new Error("VO_CODE_RUNNER_REPOS entries must be unique");
+  }
+  const owners = new Set(normalized.map((repo) => repo.split("/")[0]));
+  if (owners.size !== 1) {
+    throw new Error("VO_CODE_RUNNER_REPOS entries must share one owner");
+  }
+  return Object.freeze(normalized.sort());
+}
+function runnerRepositoryScopeDigest(repositories) {
+  const scope = normalizeRunnerRepositoryScope(repositories);
+  return createHash5("sha256").update(JSON.stringify({
+    version: 1,
+    repositories: scope
+  }), "utf8").digest("hex");
+}
+function runnerReadinessRetryDelayMs(readiness) {
+  if (readiness?.paired !== true || readiness?.githubReady !== false) return null;
+  if (Number.isFinite(readiness.retryAfterMs) && readiness.retryAfterMs > 0) {
+    return Math.ceil(readiness.retryAfterMs);
+  }
+  return null;
+}
+function parseRunnerReadinessDeferralRequest(message) {
+  if (message?.type !== RUNNER_READINESS_DEFERRAL_MESSAGE_TYPE || !UUID_RE2.test(String(message.nonce || "")) || !Number.isFinite(message.retryAfterMs) || message.retryAfterMs <= 0) return null;
+  return Object.freeze({
+    nonce: message.nonce,
+    retryAfterMs: Math.ceil(message.retryAfterMs),
+    error: typeof message.error === "string" ? message.error : null
+  });
+}
+function failed({
+  paired = false,
+  operatorId = null,
+  tenantId = null,
+  githubReady = null,
+  retryAfterMs = null,
+  error,
+  message
+}) {
+  return {
+    ok: false,
+    paired,
+    operatorId,
+    tenantId,
+    githubReady,
+    ...Number.isFinite(retryAfterMs) && retryAfterMs > 0 ? { retryAfterMs } : {},
+    error,
+    message
+  };
+}
+function responseRetryAfterMs(response, body) {
+  const transientReadinessFailure = response.status === 503 && body?.error === "github_installation_readiness_retryable";
+  if (response.status !== 429 && !transientReadinessFailure) return null;
+  const bound = (retryAfterMs) => transientReadinessFailure ? Math.min(RUNNER_READINESS_TRANSIENT_MAX_RETRY_AFTER_MS, retryAfterMs) : retryAfterMs;
+  const value = response.headers?.get?.("retry-after")?.trim() ?? "";
+  const seconds = Number(value);
+  if (value && Number.isFinite(seconds) && seconds >= 0) {
+    return bound(Math.max(1e3, Math.ceil(seconds * 1e3)));
+  }
+  const at = value ? Date.parse(value) : Number.NaN;
+  if (Number.isFinite(at)) {
+    return bound(Math.max(1e3, Math.ceil(at - Date.now())));
+  }
+  return bound(6e4);
+}
+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 fetchJsonWithTimeout(fetchImpl, url, init, timeoutMs) {
+  const controller = new AbortController();
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`request aborted after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+  try {
+    const requestAndBody = (async () => {
+      const response = await fetchImpl(url, { ...init, signal: controller.signal });
+      return { response, body: await responseBody(response) };
+    })();
+    return await Promise.race([requestAndBody, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function probeRunnerReadiness({
+  controlPlaneUrl,
+  token,
+  fetchImpl = fetch,
+  requireGithub = false,
+  repositories = [],
+  timeoutMs = RUNNER_IDENTITY_READINESS_TIMEOUT_MS,
+  // The server performs at most five sequential App-JWT GETs (installation plus
+  // every one of at most four configured repositories), each bounded at 8s.
+  // Keep a transport margin while preventing a stuck proof from hanging startup.
+  githubTimeoutMs = RUNNER_GITHUB_READINESS_TIMEOUT_MS
+}) {
+  const base = controlPlaneUrl.replace(/\/+$/u, "");
+  const headers = { authorization: `Bearer ${token}` };
+  let identityResponse;
+  let identity;
+  try {
+    ({ response: identityResponse, body: identity } = await fetchJsonWithTimeout(
+      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}`
+    });
+  }
+  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 repositoryScope = null;
+  try {
+    if (!Array.isArray(repositories)) {
+      throw new Error("VO_CODE_RUNNER_REPOS must be a repository array");
+    }
+    if (repositories.length > 0) repositoryScope = normalizeRunnerRepositoryScope(repositories);
+  } catch (error) {
+    return failed({
+      paired: true,
+      operatorId,
+      tenantId,
+      githubReady: false,
+      error: "github_repository_scope_invalid",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+  let githubResponse;
+  let github;
+  try {
+    const readinessUrl = new URL(`${base}/api/v1/github/installation-readiness`);
+    for (const repo of repositoryScope ?? []) readinessUrl.searchParams.append("repo", repo);
+    ({ response: githubResponse, body: github } = await fetchJsonWithTimeout(
+      fetchImpl,
+      readinessUrl.toString(),
+      { headers },
+      githubTimeoutMs
+    ));
+  } 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 repositorySelection = github.repository_selection;
+  const repositoriesVerified = github.repositories_verified;
+  const returnedScope = github.repository_scope;
+  let normalizedReturnedScope = null;
+  try {
+    normalizedReturnedScope = normalizeRunnerRepositoryScope(returnedScope);
+  } catch {
+  }
+  const effectiveScope = repositoryScope ?? normalizedReturnedScope;
+  const sourceVerified = repositoryScope === null ? github.repository_scope_source === "persisted_installation_singleton" && normalizedReturnedScope?.length === 1 : github.repository_scope_source === "runner_config";
+  const repositoryScopeVerified = effectiveScope !== null && normalizedReturnedScope !== null && Array.isArray(returnedScope) && returnedScope.length === normalizedReturnedScope.length && returnedScope.every((repo, index) => repo === normalizedReturnedScope[index]) && normalizedReturnedScope.length === effectiveScope.length && normalizedReturnedScope.every((repo, index) => repo === effectiveScope[index]) && github.repository_scope_sha256 === runnerRepositoryScopeDigest(effectiveScope) && repositoriesVerified === effectiveScope.length && sourceVerified && (repositorySelection === "all" || repositorySelection === "selected");
+  if (!githubResponse.ok || github.configured !== true || github.verified !== true || github.publication_ready !== true || !repositoryScopeVerified) {
+    const error = typeof github.error === "string" && github.error ? github.error : "github_not_ready";
+    return failed({
+      paired: true,
+      operatorId,
+      tenantId,
+      githubReady: false,
+      retryAfterMs: responseRetryAfterMs(githubResponse, github),
+      error,
+      message: serverMessage(github, `GitHub publication preflight failed (HTTP ${githubResponse.status}).`)
+    });
+  }
+  return {
+    ok: true,
+    paired: true,
+    operatorId,
+    tenantId,
+    githubReady: true,
+    repositoryScope: effectiveScope,
+    repositoryScopeSource: github.repository_scope_source,
+    error: null,
+    message: `Paired with a verified Algosuite GitHub App installation (${repositoriesVerified} repos).`
+  };
+}
+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;
+  let repositoryScope = runnerRepositoryScopeFromEnv(baseEnv);
+  let startupRetryAfterMs = null;
+  let githubReady = null;
+  let readinessError = null;
+  if (!explicitAdminToken) {
+    const readiness = await probeReadiness({
+      controlPlaneUrl,
+      token,
+      requireGithub: true,
+      repositories: repositoryScope
+    });
+    const pairedScope = pairedOperatorScope(readiness) || (readiness?.paired === true && typeof readiness.operatorId === "string" ? readiness.operatorId.trim() : "");
+    operatorId = pairedScope || void 0;
+    if (!operatorId) throw new Error("runner readiness failed: paired operator scope is missing");
+    if (readiness.ok && Array.isArray(readiness.repositoryScope)) {
+      repositoryScope = [...readiness.repositoryScope];
+      githubReady = true;
+    } else {
+      githubReady = false;
+      readinessError = typeof readiness?.error === "string" ? readiness.error : "github_not_ready";
+      startupRetryAfterMs = runnerReadinessRetryDelayMs(readiness);
+    }
+  }
+  const effectiveBaseEnv = repositoryScope.length > 0 ? { ...baseEnv, VO_CODE_RUNNER_REPOS: repositoryScope.join(",") } : baseEnv;
+  const childEnv = buildSupervisorChildEnv({
+    baseEnv: effectiveBaseEnv,
+    controlPlaneUrl,
+    explicitAdminToken,
+    pairedOperatorId: explicitAdminToken ? null : operatorId
+  });
+  const clientEnv = {
+    ...effectiveBaseEnv,
+    VO_CONTROL_PLANE_ADMIN_TOKEN: token,
+    VO_CONTROL_PLANE_URL: controlPlaneUrl,
+    ...operatorId ? { VO_CODE_RUNNER_OPERATOR_IDS: operatorId } : {}
+  };
+  return {
+    childEnv,
+    clientEnv,
+    operatorId,
+    repositoryScope,
+    githubReady,
+    readinessError,
+    startupRetryAfterMs
+  };
+}
+
+// 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/respawn-circuit.mjs
+var DEFAULT_RESPAWN_CIRCUIT = Object.freeze({
+  baseDelayMs: 2e3,
+  maxDelayMs: 3e4,
+  healthyResetMs: 6e4,
+  maxRapidExits: 5
+});
+function createRespawnCircuit(options = {}) {
+  const config = { ...DEFAULT_RESPAWN_CIRCUIT, ...options };
+  for (const [key, value] of Object.entries(config)) {
+    if (!Number.isInteger(value) || value < 1) throw new Error(`${key} must be a positive integer`);
+  }
+  let rapidExits = 0;
+  return Object.freeze({
+    recordExit(startedAt, exitedAt) {
+      if (!Number.isFinite(startedAt) || !Number.isFinite(exitedAt) || exitedAt < startedAt) {
+        throw new Error("respawn circuit timestamps are invalid");
+      }
+      const uptimeMs = exitedAt - startedAt;
+      rapidExits = uptimeMs >= config.healthyResetMs ? 0 : rapidExits + 1;
+      const tripped = rapidExits >= config.maxRapidExits;
+      const delayMs = Math.min(
+        config.maxDelayMs,
+        config.baseDelayMs * 2 ** Math.max(0, rapidExits - 1)
+      );
+      return Object.freeze({ rapidExits, uptimeMs, delayMs, tripped });
+    },
+    snapshot() {
+      return Object.freeze({ rapidExits, tripped: rapidExits >= config.maxRapidExits });
+    }
+  });
+}
+
+// src/runner/supervisor-child-health.mjs
+var terminatedChildren = /* @__PURE__ */ new WeakSet();
+function attachSupervisorChildTerminationCustody(target, onTerminated, onObservedError = () => {
+}) {
+  let accounted = false;
+  const account = (kind, { error = null, code = null, signal = null } = {}) => {
+    terminatedChildren.add(target);
+    if (accounted) return false;
+    accounted = true;
+    onTerminated(Object.freeze({ target, kind, error, code, signal }));
+    return true;
+  };
+  target.on("error", (error) => {
+    onObservedError(error);
+    if (target.pid === void 0 || target.pid === null) account("error", { error });
+  });
+  target.on("exit", (code, signal) => {
+    account("exit", { code: code ?? null, signal: signal ?? null });
+  });
+  return Object.freeze({ accounted: () => accounted });
+}
+function describeChildTermination(record, runtime = process.version) {
+  if (!record || typeof record !== "object") return `unknown termination on Node ${runtime}`;
+  if (record.kind === "error") {
+    const detail = record.error instanceof Error ? record.error.message : String(record.error ?? "no detail");
+    return `spawn error on Node ${runtime}: ${detail}`;
+  }
+  if (record.signal) return `killed by ${record.signal} on Node ${runtime}`;
+  if (record.code === 0) return `exited cleanly (code 0) on Node ${runtime}`;
+  if (record.code === null) return `exited with no reported code or signal on Node ${runtime}`;
+  return `exited with code ${record.code} on Node ${runtime}`;
+}
+function supervisorChildHasExited(target) {
+  return terminatedChildren.has(target) || target.exitCode !== null || (target.signalCode ?? null) !== null;
+}
+function supervisorChildIsRunning(target) {
+  return !supervisorChildHasExited(target);
+}
+function shouldRespawnSupervisorChild({ stopping, degraded, handling, child }) {
+  return !stopping && !degraded && !handling && (!child || supervisorChildHasExited(child));
+}
+function shouldDeferSupervisorReadinessExit({
+  target,
+  currentChild,
+  retryAfterMs
+}) {
+  return target === currentChild && target?.exitCode === 75 && Number.isFinite(retryAfterMs) && retryAfterMs > 0;
+}
+function createSupervisorReadinessDeferralTracker({
+  currentChild,
+  releaseCurrentChild,
+  onCaptured
+}) {
+  const pending = /* @__PURE__ */ new WeakMap();
+  const terminal = /* @__PURE__ */ new WeakSet();
+  const recoveryGenerations = /* @__PURE__ */ new WeakMap();
+  return Object.freeze({
+    recordPending(target, request) {
+      if (!target || target !== currentChild() || terminal.has(target) || pending.has(target) || typeof request?.nonce !== "string" || !request.nonce || !Number.isFinite(request.retryAfterMs) || request.retryAfterMs <= 0) return false;
+      pending.set(target, Object.freeze({
+        nonce: request.nonce,
+        retryAfterMs: Math.ceil(request.retryAfterMs)
+      }));
+      return true;
+    },
+    recordRecoveryGeneration(target, generation) {
+      if (!target || !Number.isInteger(generation)) return false;
+      recoveryGenerations.set(target, generation);
+      return true;
+    },
+    isDeferred(target) {
+      const request = target ? pending.get(target) : null;
+      return Boolean(target) && (terminal.has(target) || shouldDeferSupervisorReadinessExit({
+        target,
+        currentChild: currentChild(),
+        retryAfterMs: request?.retryAfterMs
+      }));
+    },
+    capture(target) {
+      if (!target) return false;
+      if (terminal.has(target)) return true;
+      const request = pending.get(target);
+      if (!shouldDeferSupervisorReadinessExit({
+        target,
+        currentChild: currentChild(),
+        retryAfterMs: request?.retryAfterMs
+      })) return false;
+      const recoveryGeneration = recoveryGenerations.get(target);
+      terminal.add(target);
+      pending.delete(target);
+      recoveryGenerations.delete(target);
+      releaseCurrentChild(target);
+      onCaptured(Object.freeze({
+        target,
+        retryAfterMs: request.retryAfterMs,
+        recoveryGeneration: Number.isInteger(recoveryGeneration) ? recoveryGeneration : null
+      }));
+      return true;
+    },
+    forget(target) {
+      if (!target) return;
+      pending.delete(target);
+      recoveryGenerations.delete(target);
+    }
+  });
+}
+function resolveSupervisorChildStartAuthority({
+  degradationState,
+  deferredRecoveryGeneration
+}) {
+  const snapshot = degradationState.snapshot();
+  const exactRecovery = Number.isInteger(deferredRecoveryGeneration) && deferredRecoveryGeneration === snapshot.generation;
+  return Object.freeze({
+    allowed: !snapshot.degraded || exactRecovery,
+    recoveryGeneration: exactRecovery ? deferredRecoveryGeneration : null
+  });
+}
+function createSupervisorStartupDeferral({
+  retryAfterMs = null,
+  nowMs = () => Date.now()
+} = {}) {
+  let started = false;
+  let notBefore = null;
+  const defer = (delayMs) => {
+    if (started || !Number.isFinite(delayMs) || delayMs <= 0) return false;
+    const candidate = nowMs() + Math.ceil(delayMs);
+    notBefore = notBefore === null ? candidate : Math.max(notBefore, candidate);
+    return true;
+  };
+  defer(retryAfterMs);
+  return Object.freeze({
+    defer,
+    reopen(delayMs) {
+      if (!Number.isFinite(delayMs) || delayMs <= 0) return false;
+      started = false;
+      notBefore = null;
+      return defer(delayMs);
+    },
+    isPending() {
+      return !started && notBefore !== null && nowMs() < notBefore;
+    },
+    remainingMs() {
+      return started || notBefore === null ? 0 : Math.max(0, notBefore - nowMs());
+    },
+    consumeIfReady() {
+      if (started || notBefore !== null && nowMs() < notBefore) return false;
+      started = true;
+      notBefore = null;
+      return true;
+    },
+    hasStarted() {
+      return started;
+    }
+  });
+}
+function createSupervisorDegradationState() {
+  let degraded = false;
+  let generation = 0;
+  return {
+    isDegraded() {
+      return degraded;
+    },
+    markDegraded() {
+      degraded = true;
+      generation += 1;
+    },
+    beginHealthProof({ target, currentChild, allowRecovery, onRecovery }) {
+      const observedGeneration = generation;
+      return () => {
+        if (currentChild() !== target || generation !== observedGeneration) return false;
+        if (degraded && !allowRecovery) return false;
+        const recovered = degraded;
+        degraded = false;
+        if (recovered) onRecovery?.();
+        return true;
+      };
+    },
+    beginDegradationProof({ target, currentChild, onDegraded }) {
+      const observedGeneration = generation;
+      return (message) => {
+        if (currentChild() !== target || generation !== observedGeneration) return false;
+        onDegraded(message);
+        return true;
+      };
+    },
+    snapshot() {
+      return { degraded, generation };
+    }
+  };
+}
+function beginSupervisorHealthyStateCommit({
+  degradationState,
+  target,
+  currentChild,
+  allowRecovery,
+  clearStaleExitCode
+}) {
+  return degradationState.beginHealthProof({
+    target,
+    currentChild,
+    allowRecovery,
+    onRecovery: clearStaleExitCode
+  });
+}
+var RUNNER_RECOVERY_ACTIONS = /* @__PURE__ */ new Set(["update", "reinstall", "reconnect"]);
+function shouldRecoverSupervisorChildAfterAction({
+  stoppedChild,
+  actionKind,
+  actionSucceeded
+}) {
+  return Boolean(stoppedChild) || actionSucceeded === true && RUNNER_RECOVERY_ACTIONS.has(actionKind);
+}
+function createSupervisorControlRecoveryFence() {
+  let targetStoppedForControl = null;
+  const consume = () => {
+    const target = targetStoppedForControl;
+    targetStoppedForControl = null;
+    return target;
+  };
+  return {
+    markBeforeStop(target) {
+      targetStoppedForControl = target && supervisorChildIsRunning(target) ? target : null;
+      return targetStoppedForControl !== null;
+    },
+    consume,
+    async recoverOnce(recover) {
+      const target = consume();
+      if (!target) return false;
+      await recover(target);
+      return true;
+    }
+  };
+}
+async function verifySupervisorChildHealth({
+  target,
+  degradeOnExit,
+  context,
+  waitBeforeProbe,
+  waitForLocalRunner: waitForLocalRunner2,
+  stopExpectedly,
+  markHealthy,
+  markDegraded,
+  isReadinessDeferredExit = () => false,
+  isExpectedStop = () => false
+}) {
+  try {
+    await waitBeforeProbe();
+    const healthy = supervisorChildIsRunning(target) && await waitForLocalRunner2(target);
+    const exited = supervisorChildHasExited(target);
+    if (isExpectedStop(target)) return false;
+    if (exited && isReadinessDeferredExit(target)) return false;
+    if (healthy && !exited) {
+      if (markHealthy() !== false) return true;
+      if (supervisorChildIsRunning(target)) await stopExpectedly(target);
+      return false;
+    }
+    if (!exited || degradeOnExit) {
+      const committed = markDegraded(`${context} did not become healthy; entering degraded mode`) !== false;
+      if (!committed) return false;
+      if (supervisorChildIsRunning(target)) await stopExpectedly(target);
+    }
+    return false;
+  } catch (error) {
+    if (isExpectedStop(target)) return false;
+    const committed = markDegraded(
+      `${context} health proof failed; entering degraded mode: ${error instanceof Error ? error.message : String(error)}`
+    ) !== false;
+    if (!committed) return false;
+    if (supervisorChildIsRunning(target)) await stopExpectedly(target).catch(() => {
+    });
+    return false;
+  }
+}
+
+// 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 CHILD_READINESS_TIMEOUT_MS = RUNNER_IDENTITY_READINESS_TIMEOUT_MS + RUNNER_GITHUB_READINESS_TIMEOUT_MS + 1e4;
+var SUPERVISOR_CAPABILITIES = [
+  "bundled-runtime-slots-v1",
+  "legacy-orphan-purge-v1",
+  "exact-source-sha-v1"
+];
+var UUID_RE3 = /^[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 bundledChildEntry = join5(dirname4(selfPath), "runner-cli.js");
+var supervisorRuntimeRoot = runtimeRootFromEnv(process.env);
+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_RE3.test(String(process.env.VO_RUNNER_SUPERVISOR_INSTANCE_ID || "")) ? process.env.VO_RUNNER_SUPERVISOR_INSTANCE_ID : randomUUID4();
+var supervisorInstanceId = activationSupervisorInstanceId(
+  runtimeRootFromEnv(process.env),
+  requestedSupervisorInstanceId
+);
+var supervisorVersion = packageVersion();
+var supervisorControlIdentity = {
+  supervisorInstanceId,
+  supervisorVersion,
+  capabilities: SUPERVISOR_CAPABILITIES
+};
+var lastResolvedChildDescriptor = null;
+function spawnChild(childEnv) {
+  const resolved = resolveSupervisorChildEntry({
+    runtimeRoot: supervisorRuntimeRoot,
+    bundledEntry: bundledChildEntry,
+    bundledVersion: supervisorVersion
+  });
+  if (resolved.descriptor !== lastResolvedChildDescriptor) {
+    console.error(`[vo-runner supervisor] child entry -> ${resolved.descriptor} (${resolved.detail})`);
+    lastResolvedChildDescriptor = resolved.descriptor;
+  }
+  return spawn(process.execPath, resolved.args, {
+    env: childEnv,
+    stdio: ["inherit", "inherit", "inherit", "ipc"],
+    windowsHide: true
+  });
+}
+function spawnPreviousChild(entry, childEnv) {
+  const previous = spawn(process.execPath, [entry, "runner"], {
+    env: childEnv,
+    stdio: ["inherit", "inherit", "inherit", "ipc"],
+    windowsHide: true
+  });
+  attachSupervisorChildTerminationCustody(
+    previous,
+    () => {
+    },
+    (error) => {
+      console.error(
+        `[vo-runner supervisor] rollback child process error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  );
+  return previous;
+}
+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() + CHILD_READINESS_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (supervisorChildHasExited(child)) 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 waitForChildExit(child, timeoutMs) {
+  if (!child || supervisorChildHasExited(child)) return true;
+  return new Promise((resolve5) => {
+    let settled = false;
+    const finish = (exited) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.off("exit", onExit);
+      resolve5(exited);
+    };
+    const onExit = () => finish(true);
+    const timer = setTimeout(() => finish(false), timeoutMs);
+    child.once("exit", onExit);
+    if (supervisorChildHasExited(child)) finish(true);
+  });
+}
+async function stopChild(child) {
+  if (!child || supervisorChildHasExited(child)) return;
+  child.kill(process.platform === "win32" ? void 0 : "SIGTERM");
+  if (await waitForChildExit(child, 15e3)) return;
+  if (supervisorChildIsRunning(child)) child.kill("SIGKILL");
+  await waitForChildExit(child, 5e3);
+}
+async function main() {
+  const stored = readStoredCredentialIsolated();
+  const controlPlaneUrl = process.env.VO_CONTROL_PLANE_URL || DEFAULT_CONTROL_PLANE_URL;
+  const pairedSupervisor = !String(process.env.VO_CONTROL_PLANE_ADMIN_TOKEN || "").trim();
+  const supervisorAuthInput = {
+    baseEnv: process.env,
+    storedCredential: stored,
+    controlPlaneUrl
+  };
+  const {
+    childEnv,
+    clientEnv,
+    operatorId,
+    startupRetryAfterMs
+  } = await prepareSupervisorAuth(supervisorAuthInput);
+  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 expectedChildStops = /* @__PURE__ */ new WeakSet();
+  const healthNeutralizedChildren = /* @__PURE__ */ new WeakSet();
+  const degradationState = createSupervisorDegradationState();
+  const markSupervisorDegraded = () => {
+    degradationState.markDegraded();
+    process.exitCode = 1;
+  };
+  const respawnCircuit = createRespawnCircuit();
+  const controlRecoveryFence = createSupervisorControlRecoveryFence();
+  const startupDeferral = createSupervisorStartupDeferral({
+    retryAfterMs: startupRetryAfterMs
+  });
+  let startupNeedsReadinessRefresh = startupRetryAfterMs !== null;
+  let deferredControlRecoveryGeneration = null;
+  const stopChildExpectedly = async (target) => {
+    if (!target) return;
+    expectedChildStops.add(target);
+    healthNeutralizedChildren.add(target);
+    try {
+      await stopChild(target);
+    } finally {
+      if (supervisorChildHasExited(target)) expectedChildStops.delete(target);
+    }
+  };
+  const readinessDeferrals = createSupervisorReadinessDeferralTracker({
+    currentChild: () => child,
+    releaseCurrentChild: (target) => {
+      if (child === target) child = null;
+    },
+    onCaptured: ({ retryAfterMs, recoveryGeneration }) => {
+      startupNeedsReadinessRefresh = true;
+      if (Number.isInteger(recoveryGeneration) && degradationState.snapshot().generation === recoveryGeneration) {
+        deferredControlRecoveryGeneration = recoveryGeneration;
+      }
+      startupDeferral.reopen(retryAfterMs);
+      console.warn(
+        `[vo-runner supervisor] child deferred by GitHub readiness for ${retryAfterMs}ms; preserving control polling without consuming rapid-exit breaker budget`
+      );
+    }
+  });
+  const isChildReadinessDeferred = (target) => readinessDeferrals.isDeferred(target);
+  const captureChildReadinessDeferral = (target) => readinessDeferrals.capture(target);
+  const respawn = () => {
+    if (!startupDeferral.hasStarted()) return;
+    if (!shouldRespawnSupervisorChild({
+      stopping,
+      degraded: degradationState.isDegraded(),
+      handling,
+      child
+    })) return;
+    try {
+      child = launchChild();
+      void verifyChildHealth(child, false, "automatic relaunch");
+    } catch (error) {
+      markSupervisorDegraded();
+      console.error(
+        `[vo-runner supervisor] child relaunch failed; entering degraded mode: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+  const launchChild = () => {
+    const next = spawnChild(childEnv);
+    const startedAt = Date.now();
+    next.on("message", (message) => {
+      const request = parseRunnerReadinessDeferralRequest(message);
+      if (!request || !readinessDeferrals.recordPending(next, request)) return;
+      try {
+        next.send({
+          type: RUNNER_READINESS_DEFERRAL_ACK_TYPE,
+          nonce: request.nonce
+        }, (error) => {
+          if (error) console.warn(`[vo-runner supervisor] readiness deferral ACK failed: ${error.message}`);
+        });
+      } catch (error) {
+        console.warn(
+          `[vo-runner supervisor] readiness deferral ACK failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    });
+    attachSupervisorChildTerminationCustody(
+      next,
+      (record) => {
+        if (stopping || expectedChildStops.delete(next)) {
+          readinessDeferrals.forget(next);
+          return;
+        }
+        if (captureChildReadinessDeferral(next)) return;
+        readinessDeferrals.forget(next);
+        console.error(`[vo-runner supervisor] child ${describeChildTermination(record)}`);
+        const decision = respawnCircuit.recordExit(startedAt, Date.now());
+        if (decision.tripped) {
+          markSupervisorDegraded();
+          console.error(
+            `[vo-runner supervisor] child exited rapidly ${decision.rapidExits} times; entering degraded mode to stop startup/token churn while remote repair remains available`
+          );
+          return;
+        }
+        setTimeout(respawn, decision.delayMs);
+      },
+      (error) => {
+        console.error(
+          `[vo-runner supervisor] child process error: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    );
+    return next;
+  };
+  const verifyChildHealth = async (target, degradeOnExit, context) => {
+    const commitSupervisorHealthyState = beginSupervisorHealthyStateCommit({
+      degradationState,
+      target,
+      currentChild: () => child,
+      allowRecovery: degradeOnExit,
+      clearStaleExitCode: () => {
+        process.exitCode = void 0;
+      }
+    });
+    const commitSupervisorDegradedState = degradationState.beginDegradationProof({
+      target,
+      currentChild: () => child,
+      onDegraded: (message) => {
+        markSupervisorDegraded();
+        console.error(`[vo-runner supervisor] ${message}`);
+      }
+    });
+    return verifySupervisorChildHealth({
+      target,
+      degradeOnExit,
+      context,
+      waitBeforeProbe: () => sleep(CHILD_START_MS),
+      waitForLocalRunner,
+      stopExpectedly: stopChildExpectedly,
+      isReadinessDeferredExit: isChildReadinessDeferred,
+      isExpectedStop: (candidate) => healthNeutralizedChildren.has(candidate),
+      markHealthy: commitSupervisorHealthyState,
+      markDegraded: commitSupervisorDegradedState
+    });
+  };
+  const deferChildAdmission = (retryAfterMs) => {
+    startupNeedsReadinessRefresh = true;
+    if (startupDeferral.hasStarted()) startupDeferral.reopen(retryAfterMs);
+    else startupDeferral.defer(retryAfterMs);
+    console.warn(
+      `[vo-runner supervisor] GitHub readiness embargoed child startup for ${retryAfterMs}ms; control polling remains active`
+    );
+  };
+  const refreshSupervisorChildAdmission = async () => {
+    if (!pairedSupervisor) return true;
+    const refreshed = await prepareSupervisorAuth({
+      ...supervisorAuthInput,
+      baseEnv: childEnv
+    });
+    if (refreshed.operatorId !== operatorId) {
+      throw new Error("runner readiness operator identity changed during supervisor admission");
+    }
+    if (refreshed.startupRetryAfterMs !== null) {
+      deferChildAdmission(refreshed.startupRetryAfterMs);
+      return false;
+    }
+    if (refreshed.repositoryScope.length > 0) {
+      const repositoryScope = refreshed.repositoryScope.join(",");
+      childEnv.VO_CODE_RUNNER_REPOS = repositoryScope;
+      clientEnv.VO_CODE_RUNNER_REPOS = repositoryScope;
+    }
+    startupNeedsReadinessRefresh = false;
+    return true;
+  };
+  const ensureHealthyChildAfterControl = async () => {
+    if (!child || supervisorChildHasExited(child)) {
+      const recoveryGeneration = degradationState.snapshot().generation;
+      if (!startupDeferral.hasStarted() && startupDeferral.isPending()) {
+        deferredControlRecoveryGeneration = recoveryGeneration;
+        return false;
+      }
+      try {
+        if (!await refreshSupervisorChildAdmission()) {
+          deferredControlRecoveryGeneration = recoveryGeneration;
+          return false;
+        }
+        if (!startupDeferral.hasStarted() && !startupDeferral.consumeIfReady()) return false;
+        child = launchChild();
+        readinessDeferrals.recordRecoveryGeneration(child, recoveryGeneration);
+      } catch (error) {
+        markSupervisorDegraded();
+        console.error(
+          `[vo-runner supervisor] control recovery relaunch failed; entering degraded mode: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return false;
+      }
+    }
+    return verifyChildHealth(child, true, "control recovery relaunch");
+  };
+  const startInitialChild = async (recoveryGeneration = null) => {
+    const activationChild = launchChild();
+    child = activationChild;
+    if (Number.isInteger(recoveryGeneration)) {
+      readinessDeferrals.recordRecoveryGeneration(activationChild, recoveryGeneration);
+    }
+    void verifyChildHealth(
+      activationChild,
+      Number.isInteger(recoveryGeneration),
+      Number.isInteger(recoveryGeneration) ? "deferred control recovery" : "initial child"
+    );
+    if (!await finishPendingActivation({
+      client,
+      child: activationChild,
+      runtimeRoot,
+      operatorId,
+      runnerId,
+      selfPath,
+      packageVersion: supervisorVersion,
+      supervisorIdentity: supervisorControlIdentity,
+      waitForLocalRunner,
+      isReadinessDeferred: isChildReadinessDeferred,
+      localStatus,
+      stopChild: stopChildExpectedly,
+      launchPreviousChild: (entry) => spawnPreviousChild(entry, childEnv),
+      log: (message) => console.error(`[vo-runner supervisor] ${message}`)
+    })) {
+      if (captureChildReadinessDeferral(activationChild)) {
+        console.warn("[vo-runner supervisor] activation attestation deferred with GitHub readiness; pending slot remains durable");
+        return false;
+      }
+      markSupervisorDegraded();
+      await stopChildExpectedly(activationChild);
+      if (child === activationChild) child = null;
+      console.error("[vo-runner supervisor] activation FAILED \u2014 entering degraded mode: not serving tasks, still polling for remote control actions");
+      return false;
+    }
+    return true;
+  };
+  const attemptInitialChildStart = async () => {
+    if (startupDeferral.hasStarted() || startupDeferral.isPending()) return false;
+    const beforeRefresh = resolveSupervisorChildStartAuthority({
+      degradationState,
+      deferredRecoveryGeneration: deferredControlRecoveryGeneration
+    });
+    if (!beforeRefresh.allowed) return false;
+    if (startupNeedsReadinessRefresh) {
+      try {
+        if (!await refreshSupervisorChildAdmission()) return false;
+      } catch (error) {
+        markSupervisorDegraded();
+        deferredControlRecoveryGeneration = null;
+        startupDeferral.consumeIfReady();
+        console.error(
+          `[vo-runner supervisor] deferred readiness refresh failed; entering degraded mode: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return false;
+      }
+    }
+    const afterRefresh = resolveSupervisorChildStartAuthority({
+      degradationState,
+      deferredRecoveryGeneration: deferredControlRecoveryGeneration
+    });
+    if (!afterRefresh.allowed) return false;
+    if (!startupDeferral.consumeIfReady()) return false;
+    deferredControlRecoveryGeneration = null;
+    return startInitialChild(afterRefresh.recoveryGeneration);
+  };
+  await attemptInitialChildStart();
+  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 {
+      await attemptInitialChildStart();
+      const action = await client.pollRunnerControl({
+        runnerId,
+        ...operatorId ? { operatorId } : {},
+        ...supervisorControlIdentity
+      });
+      if (!action) {
+        await sleep(POLL_MS);
+        continue;
+      }
+      deferredControlRecoveryGeneration = null;
+      handling = true;
+      const controlIdentity = { runnerId, ...operatorId ? { operatorId } : {}, ...supervisorControlIdentity };
+      const bundledAction = action.kind === "update" || action.kind === "reinstall";
+      const drain = await awaitRunnerUpdateDrain({
+        readStatus: localStatus,
+        drainable: bundledAction,
+        env: process.env,
+        isChildRunning: () => supervisorChildIsRunning(child),
+        log: (message) => console.warn(`[vo-runner supervisor] ${message}`)
+      });
+      if (!drain.proceed) {
+        await client.completeRunnerControl(action.actionId, { ...controlIdentity, status: "failed", detail: drain.detail });
+        handling = false;
+        respawn();
+        continue;
+      }
+      controlRecoveryFence.markBeforeStop(child);
+      await stopChildExpectedly(child);
+      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) {
+        if (drain.capped) console.warn(`[vo-runner supervisor] ${drain.detail}`);
+        console.warn(`[vo-runner supervisor] activated ${result.active.version}; exiting for new-process attestation`);
+        return;
+      }
+      const recoveryAuthorized = shouldRecoverSupervisorChildAfterAction({
+        stoppedChild: controlRecoveryFence.consume(),
+        actionKind: action.kind,
+        actionSucceeded: result.ok
+      });
+      const relaunchedHealthy = recoveryAuthorized ? await ensureHealthyChildAfterControl() : false;
+      if (!relaunchedHealthy) result.ok = false;
+      await client.completeRunnerControl(action.actionId, {
+        ...controlIdentity,
+        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}` : ""}${relaunchedHealthy ? "" : "; runner relaunch did not become healthy"}`
+      });
+      handling = false;
+      respawn();
+    } catch (error) {
+      console.error(`[vo-runner supervisor] ${error instanceof Error ? error.message : String(error)}`);
+      await controlRecoveryFence.recoverOnce(() => ensureHealthyChildAfterControl());
+      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