@algosuite/vo-mcp 0.2.0-beta.13 → 0.2.0-beta.14

package/dist/runner-supervisor.js

@@ -33,8 +33,8 @@ var init_control_plane_auth_stub = __esm({
 import { spawn } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { createRequire } from "node:module";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as dirname4, join as join5 } from "node:path";
 
 // ../../scripts/virtual-office/code-runner/control-plane-client.mjs
 var cachedFirebaseToken = null;
@@ -193,7 +193,6 @@ function createControlPlaneClient({
       const json = await res.json();
       return { task: json && json.task };
     },
-    /** Read the current task (cancel detection). Null on 404. */
     async getTask(taskId) {
       const res = await req("GET", `/api/v1/code-task/${taskId}`);
       if (res.status === 404) return null;
@@ -201,7 +200,13 @@ function createControlPlaneClient({
       const json = await res.json();
       return json ? json.task : null;
     },
-    /** Fetch bounded, prompt-ready AlgoHQ knowledge snippets for this task. */
+    async downloadTaskAttachment(taskId, attachmentId) {
+      const path = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
+      const res = await req("GET", path);
+      if (res.status === 401) cachedFirebaseToken = null;
+      if (!res.ok) throw new Error(`attachment download failed: HTTP ${res.status}`);
+      return Buffer.from(await res.arrayBuffer());
+    },
     async getTaskKnowledgeContext(taskId, { query } = {}) {
       const body = {};
       if (typeof query === "string" && query.trim()) body.query = query;
@@ -252,12 +257,17 @@ function createControlPlaneClient({
      * authenticated operator so the web shows a TRUE "runner online" signal.
      * Best-effort caller; throws on 401/non-ok so the daemon can log + retry.
      */
-    async postHeartbeat({ runnerId: runnerId2, runnerInstanceId, operatorId, uptimeSec, activeTasks, version, daemonVersion, defaultAgent, supervisorInstanceId: supervisorInstanceId2, supervisorVersion: supervisorVersion2, supervisorCapabilities, servedRepos, servedOperators, availableAgents, accountUsage }) {
+    async postHeartbeat({ runnerId: runnerId2, runnerInstanceId, operatorId, uptimeSec, activeTasks, maxConcurrency, effectiveConcurrency, measuredTaskSlots, measuredCpuSlots, measuredMemorySlots, version, daemonVersion, defaultAgent, supervisorInstanceId: supervisorInstanceId2, supervisorVersion: supervisorVersion2, supervisorCapabilities, servedRepos, servedOperators, availableAgents, accountUsage }) {
       const body = { runner_id: runnerId2 };
       if (runnerInstanceId) body.runner_instance_id = runnerInstanceId;
       if (operatorId) body.operator_id = operatorId;
       if (typeof uptimeSec === "number") body.uptime_sec = uptimeSec;
       if (typeof activeTasks === "number") body.active_tasks = activeTasks;
+      if (typeof maxConcurrency === "number") body.max_concurrency = maxConcurrency;
+      if (typeof effectiveConcurrency === "number") body.effective_concurrency = effectiveConcurrency;
+      if (typeof measuredTaskSlots === "number") body.measured_task_slots = measuredTaskSlots;
+      if (typeof measuredCpuSlots === "number") body.measured_cpu_slots = measuredCpuSlots;
+      if (typeof measuredMemorySlots === "number") body.measured_memory_slots = measuredMemorySlots;
       if (version) body.version = version;
       if (daemonVersion) body.daemon_version = daemonVersion;
       if (defaultAgent) body.default_agent = defaultAgent;
@@ -284,9 +294,8 @@ function createControlPlaneClient({
         throw new Error("heartbeat unauthorized (401)");
       }
       if (!res.ok) throw new Error(`heartbeat failed: HTTP ${res.status}`);
-      return true;
+      return res.json();
     },
-    /** Read the server-authoritative heartbeat ledger without mutating it. */
     async getRunnerStatus({ operatorId } = {}) {
       const query = operatorId ? `?operator_id=${encodeURIComponent(operatorId)}` : "";
       const res = await req("GET", `/api/v1/runner/status${query}`, void 0, {
@@ -300,7 +309,6 @@ function createControlPlaneClient({
       const body = await res.json();
       return Array.isArray(body?.runners) ? body.runners : [];
     },
-    /** Poll one authenticated runner's durable Mission Control action queue. */
     async pollRunnerControl({ runnerId: runnerId2, operatorId, supervisorInstanceId: supervisorInstanceId2, supervisorVersion: supervisorVersion2, capabilities }) {
       const body = { runner_id: runnerId2 };
       if (operatorId) body.operator_id = operatorId;
@@ -317,7 +325,6 @@ function createControlPlaneClient({
       const action = json?.action;
       return action && typeof action.action_id === "string" && action.action_id ? { ...action, actionId: action.action_id } : null;
     },
-    /** Acknowledge a maintenance action after the host has restarted the child. */
     async completeRunnerControl(actionId, { runnerId: runnerId2, operatorId, supervisorInstanceId: supervisorInstanceId2, supervisorVersion: supervisorVersion2, capabilities, status, detail }) {
       const body = { runner_id: runnerId2, status };
       if (operatorId) body.operator_id = operatorId;
@@ -492,69 +499,486 @@ function runHostMaintenance(kind, {
 }
 
 // src/runner/bundled-runtime-updater.mjs
-import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
 import {
-  existsSync as existsSync3,
-  lstatSync as lstatSync2,
+  existsSync as existsSync4,
+  lstatSync as lstatSync3,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync2,
-  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync3,
   renameSync as renameSync2,
   rmSync as rmSync2,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { basename, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "node:path";
+import { basename, isAbsolute as isAbsolute3, join as join3, resolve as resolve4 } 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(path, expectedKind, fsOps, label) {
+  if (!fsOps.exists(path)) throw new Error(`staged runtime ${label} missing`);
+  const stats = fsOps.lstat(path);
+  if (isReparseStat(stats) || fsOps.isReparsePoint(path, 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 path = resolve(payloadRoot, key);
+    assertContained(payloadRoot, path, "package path");
+    const shouldOmit = isOmittedOptionalPackage(entry, platform);
+    if (shouldOmit) {
+      omitted.push(key);
+      if (fsOps.exists(path)) throw new Error(`staged runtime optional package should be omitted: ${key}`);
+      continue;
+    }
+    checkPathKind(path, "directory", fsOps, `installed package ${key}`);
+    installed += 1;
+  }
+  return { installed, omitted: omitted.sort() };
+}
+function treeRecord(kind, path, stats, fileHash = "") {
+  if (kind === "d") return `d	${path}\r
+`;
+  return `f	${path}	${stats.size}	${fileHash}\r
+`;
+}
+function computeInstalledTree(nodeModulesRoot, fsOps = {}) {
+  const ops = {
+    exists: existsSync2,
+    lstat: lstatSync,
+    readdir: (path) => readdirSync(path, { 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, randomUUID } from "node:crypto";
+import { createHash as createHash3, randomUUID } from "node:crypto";
 import {
   closeSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   fsyncSync,
-  lstatSync,
+  lstatSync as lstatSync2,
   mkdirSync,
   openSync,
-  readFileSync,
-  readdirSync,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
   realpathSync,
   renameSync,
   rmSync,
   writeFileSync
 } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+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 = join("node_modules", "@algosuite", "vo-mcp", "bin", "vo-mcp");
-var SUPERVISOR_REL = join("node_modules", "@algosuite", "vo-mcp", "dist", "runner-supervisor.js");
-var PACKAGE_REL = join("node_modules", "@algosuite", "vo-mcp", "package.json");
-var CREDENTIAL_HELPER_REL = join("node_modules", "@algosuite", "vo-mcp", "dist", "supervisor-credential-helper.js");
+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 = relative(resolve(parent), resolve(candidate));
-  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+  const rel = relative2(resolve3(parent), resolve3(candidate));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
 }
 function runtimeRootFromEnv(env = process.env) {
   const value = String(env.VO_RUNNER_RUNTIME_ROOT || "").trim();
-  return value && isAbsolute(value) ? resolve(value) : null;
+  return value && isAbsolute2(value) ? resolve3(value) : null;
 }
 function hashFileSha512(file) {
-  return `sha512-${createHash("sha512").update(readFileSync(file)).digest("base64")}`;
+  return `sha512-${createHash3("sha512").update(readFileSync3(file)).digest("base64")}`;
 }
 function hashRuntimeTree(root) {
-  const hasher = createHash("sha512");
+  const hasher = createHash3("sha512");
   const files = [];
   const visit = (directory, prefix = "") => {
-    const rootStat = lstatSync(directory);
+    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 readdirSync(directory).sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)))) {
-      const absolute = join(directory, name);
+    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 = lstatSync(absolute);
+      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 });
@@ -568,14 +992,14 @@ function hashRuntimeTree(root) {
     hasher.update(`${pathBytes.length}:`);
     hasher.update(pathBytes);
     hasher.update(`:${file.size}:`);
-    hasher.update(readFileSync(file.absolute));
+    hasher.update(readFileSync3(file.absolute));
     hasher.update("\n");
   }
   return `sha512-${hasher.digest("base64")}`;
 }
 function atomicWriteJson(file, value) {
-  mkdirSync(dirname(file), { recursive: true });
-  const temp = join(dirname(file), `.${randomUUID()}.tmp`);
+  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)}
@@ -588,7 +1012,7 @@ function atomicWriteJson(file, value) {
     renameSync(temp, file);
     if (process.platform !== "win32") {
       try {
-        const parentFd = openSync(dirname(file), "r");
+        const parentFd = openSync(dirname2(file), "r");
         try {
           fsyncSync(parentFd);
         } finally {
@@ -602,10 +1026,10 @@ function atomicWriteJson(file, value) {
   }
 }
 function readActivation(runtimeRoot) {
-  const file = join(runtimeRoot, "current.json");
-  if (!existsSync2(file)) return null;
+  const file = join2(runtimeRoot, "current.json");
+  if (!existsSync3(file)) return null;
   try {
-    const value = JSON.parse(readFileSync(file, "utf8"));
+    const value = JSON.parse(readFileSync3(file, "utf8"));
     return value?.schema_version === 1 ? value : null;
   } catch {
     return null;
@@ -613,14 +1037,14 @@ function readActivation(runtimeRoot) {
 }
 function slotPaths(runtimeRoot, slotId) {
   if (!SLOT_ID_RE.test(slotId)) throw new Error("invalid runtime slot id");
-  const slotRoot = join(runtimeRoot, "slots", slotId);
+  const slotRoot = join2(runtimeRoot, "slots", slotId);
   return {
     slotRoot,
-    entry: join(slotRoot, ENTRY_REL),
-    supervisor: join(slotRoot, SUPERVISOR_REL),
-    packageJson: join(slotRoot, PACKAGE_REL),
-    credentialHelper: join(slotRoot, CREDENTIAL_HELPER_REL),
-    manifest: join(slotRoot, MANIFEST_FILE)
+    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) {
@@ -630,8 +1054,8 @@ 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(readFileSync(paths.manifest, "utf8"));
-    const pkg = JSON.parse(readFileSync(paths.packageJson, "utf8"));
+    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,
@@ -646,7 +1070,7 @@ function validateSlot(runtimeRoot, active) {
     if (manifest?.schema_version !== 1 || pkg?.name !== "@algosuite/vo-mcp" || pkg?.version !== active.version) {
       return { ok: false, detail: "package identity mismatch" };
     }
-    if (lstatSync(paths.entry).isSymbolicLink() || lstatSync(paths.supervisor).isSymbolicLink() || lstatSync(paths.credentialHelper).isSymbolicLink()) {
+    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))) {
@@ -662,7 +1086,7 @@ function validateSlot(runtimeRoot, active) {
 }
 function journalActivation(runtimeRoot, actionId, state, detail = "") {
   if (!ACTION_ID_RE.test(actionId)) throw new Error("invalid runner action id");
-  atomicWriteJson(join(runtimeRoot, "transactions", `${actionId}.json`), {
+  atomicWriteJson(join2(runtimeRoot, "transactions", `${actionId}.json`), {
     schema_version: 1,
     action_id: actionId,
     state,
@@ -693,7 +1117,7 @@ function activateSlot(runtimeRoot, active, action) {
     }
   };
   journalActivation(runtimeRoot, action.actionId, "prepared", `${active.version} ${active.integrity}`);
-  atomicWriteJson(join(runtimeRoot, "current.json"), pointer);
+  atomicWriteJson(join2(runtimeRoot, "current.json"), pointer);
   return pointer;
 }
 function activationSupervisorInstanceId(runtimeRoot, fallback) {
@@ -712,7 +1136,7 @@ function recordActivationRetry(runtimeRoot, pointer, detail) {
     ...current,
     pending: { ...current.pending, ack_attempts: attempts, last_error: String(detail).slice(0, 240) }
   };
-  atomicWriteJson(join(runtimeRoot, "current.json"), updated);
+  atomicWriteJson(join2(runtimeRoot, "current.json"), updated);
   journalActivation(runtimeRoot, current.pending.action_id, "ack-retry", `attempt ${attempts}: ${detail}`);
   return updated;
 }
@@ -737,7 +1161,7 @@ function finalizeActivation(runtimeRoot, pointer) {
     throw new Error("runtime activation generation changed before finalization");
   }
   journalActivation(runtimeRoot, pointer.pending.action_id, "attesting", `${pointer.active.version} verified`);
-  atomicWriteJson(join(runtimeRoot, "current.json"), {
+  atomicWriteJson(join2(runtimeRoot, "current.json"), {
     schema_version: 1,
     generation: pointer.generation,
     active: pointer.active,
@@ -767,7 +1191,7 @@ function rollbackActivation(runtimeRoot, pointer, detail) {
       rolled_back_at: (/* @__PURE__ */ new Date()).toISOString()
     }
   };
-  atomicWriteJson(join(runtimeRoot, "current.json"), rolledBack);
+  atomicWriteJson(join2(runtimeRoot, "current.json"), rolledBack);
   try {
     journalActivation(runtimeRoot, pointer.pending.action_id, "rolled-back", detail);
   } catch {
@@ -779,7 +1203,7 @@ function acknowledgeActivationFailure(runtimeRoot, pointer) {
   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(join(runtimeRoot, "current.json"), { ...current, pending: null });
+  atomicWriteJson(join2(runtimeRoot, "current.json"), { ...current, pending: null });
   try {
     journalActivation(runtimeRoot, pointer.pending.action_id, "failure-acknowledged", pointer.pending.terminal_detail);
   } catch {
@@ -828,9 +1252,9 @@ function buildMinimalMaintenanceEnv(env = process.env, runtimeRoot = "") {
     npm_config_update_notifier: "false",
     npm_config_registry: PUBLIC_REGISTRY,
     ...runtimeRoot ? {
-      npm_config_userconfig: join2(runtimeRoot, "maintenance", "user.npmrc"),
-      npm_config_globalconfig: join2(runtimeRoot, "maintenance", "global.npmrc"),
-      npm_config_cache: join2(runtimeRoot, "maintenance", "npm-cache")
+      npm_config_userconfig: join3(runtimeRoot, "maintenance", "user.npmrc"),
+      npm_config_globalconfig: join3(runtimeRoot, "maintenance", "global.npmrc"),
+      npm_config_cache: join3(runtimeRoot, "maintenance", "npm-cache")
     } : {}
   };
 }
@@ -870,20 +1294,20 @@ function parseJsonOutput(result, operation) {
   }
 }
 function tarballIntegrity(file) {
-  return `sha512-${createHash2("sha512").update(readFileSync2(file)).digest("base64")}`;
+  return `sha512-${createHash4("sha512").update(readFileSync4(file)).digest("base64")}`;
 }
 function assertNoLinks(root) {
   const pending = [root];
   while (pending.length) {
     const current = pending.pop();
-    const stat = lstatSync2(current);
+    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 readdirSync2(current)) pending.push(join2(current, entry));
+    for (const entry of readdirSync3(current)) pending.push(join3(current, entry));
   }
 }
 function validateDependencyLock(payloadRoot, expected) {
-  const lock = JSON.parse(readFileSync2(join2(payloadRoot, "package-lock.json"), "utf8"));
+  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");
   }
@@ -913,23 +1337,40 @@ function buildActive(slotId, metadata, paths) {
     tree_sha512: hashRuntimeTree(paths.slotRoot ?? paths.payloadRoot)
   };
 }
-function installSlot({ runtimeRoot, metadata, tarball, runner, npmEnv, runOptions, force }) {
-  const digest = createHash2("sha256").update(metadata.integrity).digest("hex").slice(0, 16);
+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 && existsSync3(finalPaths.slotRoot)) {
-    const manifest = JSON.parse(readFileSync2(finalPaths.manifest, "utf8"));
+  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) return { active, created: false };
+    if (validated.ok && manifest.integrity === metadata.integrity) {
+      if (runtimeAuthorization) {
+        validateStagedRuntimeAuthorization({
+          payloadRoot: finalPaths.slotRoot,
+          authorization: runtimeAuthorization
+        });
+      }
+      return { active, created: false };
+    }
   }
-  const staging = join2(runtimeRoot, "staging", randomUUID2());
-  const payload = join2(staging, "payload");
+  const staging = join3(runtimeRoot, "staging", randomUUID2());
+  const payload = join3(staging, "payload");
   let installedSlot = false;
   try {
     mkdirSync2(payload, { recursive: true });
-    writeFileSync2(join2(payload, "package.json"), `${JSON.stringify({ name: "algohq-runner-runtime", version: "0.0.0", private: true })}
+    writeFileSync2(join3(payload, "package.json"), `${JSON.stringify({ name: "algohq-runner-runtime", version: "0.0.0", private: true })}
 `);
     const install = runner.npm([
       "install",
@@ -945,24 +1386,27 @@ function installSlot({ runtimeRoot, metadata, tarball, runner, npmEnv, runOption
     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: join2(payload, "node_modules", "@algosuite", "vo-mcp", "bin", "vo-mcp"),
-      supervisor: join2(payload, "node_modules", "@algosuite", "vo-mcp", "dist", "runner-supervisor.js"),
-      packageJson: join2(payload, "node_modules", "@algosuite", "vo-mcp", "package.json"),
-      credentialHelper: join2(payload, "node_modules", "@algosuite", "vo-mcp", "dist", "supervisor-credential-helper.js"),
+      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(readFileSync2(stagedPaths.packageJson, "utf8"));
+    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 (!lstatSync2(stagedPaths.credentialHelper).isFile()) throw new Error("installed credential helper is missing");
+    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(join2(payload, "runtime-manifest.json"), { schema_version: 1, ...active });
-    mkdirSync2(join2(runtimeRoot, "slots"), { recursive: true });
-    if (existsSync3(finalPaths.slotRoot)) throw new Error("immutable runtime slot already exists");
+    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);
@@ -984,11 +1428,12 @@ function stageBundledRuntimeSlot(options) {
     platform = process.platform,
     execPath = process.execPath,
     env = process.env,
-    fileExists = existsSync3,
+    fileExists = existsSync4,
     run = defaultRun,
-    force = false
+    force = false,
+    runtimeAuthorization = null
   } = options;
-  if (!runtimeRoot || !isAbsolute2(runtimeRoot)) return { ok: false, status: 2, detail: "bundled runtime root unavailable" };
+  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" };
   }
@@ -997,18 +1442,18 @@ function stageBundledRuntimeSlot(options) {
   }
   const exactSpec = `${PACKAGE_NAME}@${expectedVersion}`;
   if (packageSpec !== exactSpec) return { ok: false, status: 2, detail: "runner package spec does not match authorized version" };
-  const resolvedRoot = resolve2(runtimeRoot);
+  const resolvedRoot = resolve4(runtimeRoot);
   const npmEnv = buildMinimalMaintenanceEnv(env, resolvedRoot);
   const runOptions = { env: npmEnv, cwd: resolvedRoot };
   let tarDir = null;
   try {
     mkdirSync2(resolvedRoot, { recursive: true });
-    mkdirSync2(join2(resolvedRoot, "maintenance"), { 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 = join2(resolvedRoot, "staging", randomUUID2());
+    tarDir = join3(resolvedRoot, "staging", randomUUID2());
     mkdirSync2(tarDir, { recursive: true });
     const packed = parseJsonOutput(runner.npm([
       "pack",
@@ -1020,13 +1465,22 @@ function stageBundledRuntimeSlot(options) {
       `--registry=${PUBLIC_REGISTRY}`
     ], runOptions), "npm pack");
     const record = Array.isArray(packed) ? packed[0] : packed;
-    const tarball = join2(tarDir, basename(String(record?.filename || "")));
-    if (!existsSync3(tarball) || !basename(tarball).endsWith(".tgz")) throw new Error("npm pack returned no tarball");
-    if (lstatSync2(tarball).size > MAX_TARBALL_BYTES) throw new Error("runner package tarball exceeds size limit");
+    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 });
+    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) };
@@ -1038,7 +1492,7 @@ function stageAndActivateBundledUpdate(options) {
   const staged = stageBundledRuntimeSlot(options);
   if (!staged.ok) return staged;
   try {
-    activateSlot(resolve2(options.runtimeRoot), staged.active, options.action);
+    activateSlot(resolve4(options.runtimeRoot), staged.active, options.action);
     return { ...staged, handoff: true };
   } catch (error) {
     return {
@@ -1051,7 +1505,7 @@ function stageAndActivateBundledUpdate(options) {
 
 // src/runner/supervisor-activation.mjs
 var MAX_ACK_ATTEMPTS = 3;
-var delay = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+var delay = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 async function waitForAuthoritativeRunnerHeartbeat({
   client,
   runnerId: runnerId2,
@@ -1405,14 +1859,14 @@ async function prepareSupervisorAuth({
 
 // src/runner/supervisor-credential-reader.mjs
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync4 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync as existsSync5 } 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 = dirname2(fileURLToPath(metaUrl));
-  const bundled = join3(moduleDir, "supervisor-credential-helper.js");
-  const source = join3(moduleDir, "..", "supervisor-credential-helper.mjs");
-  return existsSync4(source) ? source : bundled;
+  const moduleDir = dirname3(fileURLToPath2(metaUrl));
+  const bundled = join4(moduleDir, "supervisor-credential-helper.js");
+  const source = join4(moduleDir, "..", "supervisor-credential-helper.mjs");
+  return existsSync5(source) ? source : bundled;
 }
 function readStoredCredentialIsolated({
   spawn: spawn2 = spawnSync3,
@@ -1446,9 +1900,9 @@ var POLL_MS = 5e3;
 var CHILD_START_MS = 1500;
 var SUPERVISOR_CAPABILITIES = ["bundled-runtime-slots-v1"];
 var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-var selfPath = fileURLToPath2(import.meta.url);
-var childEntry = join4(dirname3(selfPath), "runner-cli.js");
-var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+var selfPath = fileURLToPath3(import.meta.url);
+var childEntry = join5(dirname4(selfPath), "runner-cli.js");
+var sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 var runnerId = resolveSupervisorRunnerId(process.env);
 function packageVersion() {
   try {
@@ -1507,7 +1961,7 @@ async function stopChild(child) {
   if (!child || child.exitCode !== null) return;
   child.kill(process.platform === "win32" ? void 0 : "SIGTERM");
   await Promise.race([
-    new Promise((resolve3) => child.once("exit", resolve3)),
+    new Promise((resolve5) => child.once("exit", resolve5)),
     sleep(15e3)
   ]);
   if (child.exitCode === null) child.kill("SIGKILL");