sootsim 0.1.251 → 0.1.253

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.251 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.253 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;
@@ -10528,10 +10528,10 @@ function tcpPing(port, timeout = TCP_GATE_MS) {
     sock.connect(port, "localhost");
   });
 }
-function httpGet(port, path11, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(port, path12, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve5) => {
     const req = import_http.default.request(
-      { hostname: "localhost", port, path: path11, method, timeout, headers },
+      { hostname: "localhost", port, path: path12, method, timeout, headers },
       (res) => {
         let body = "";
         res.on("data", (c) => body += c.toString());
@@ -11088,34 +11088,6 @@ function writeActiveRuntime(version) {
   import_node_fs2.default.writeFileSync(activeRuntimeFile(), `${version}
 `, "utf8");
 }
-function listInstalledRuntimes() {
-  try {
-    return import_node_fs2.default.readdirSync(runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
-  } catch {
-    return [];
-  }
-}
-function compareSemver(a, b) {
-  const parse = (v) => {
-    const hyphen = v.indexOf("-");
-    const core = hyphen >= 0 ? v.slice(0, hyphen) : v;
-    const pre = hyphen >= 0 ? v.slice(hyphen + 1) : "";
-    const parts = core.split(".").map((n) => Number.parseInt(n, 10));
-    if (parts.some((n) => !Number.isFinite(n))) return [[Number.POSITIVE_INFINITY], v];
-    return [parts, pre];
-  };
-  const [an, ap] = parse(a);
-  const [bn, bp] = parse(b);
-  for (let i = 0; i < Math.max(an.length, bn.length); i++) {
-    const av = an[i] ?? 0;
-    const bv = bn[i] ?? 0;
-    if (av !== bv) return av - bv;
-  }
-  if (ap === bp) return 0;
-  if (!ap) return 1;
-  if (!bp) return -1;
-  return ap < bp ? -1 : 1;
-}
 function activeRuntimeDir() {
   const version = readActiveRuntime();
   if (!version) return null;
@@ -11271,139 +11243,241 @@ var init_runtime_assets = __esm({
   }
 });
 
-// src/runtime-delivery.ts
-function readConfig() {
+// ../contrast-runtime-delivery/src/product.ts
+function listInstalledRuntimes(product) {
   try {
-    const parsed = JSON.parse(import_fs2.default.readFileSync(configFilePath(), "utf8"));
-    return parsed && typeof parsed === "object" ? parsed : {};
+    return import_node_fs3.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
   } catch {
-    return {};
+    return [];
   }
 }
-function resolveRuntimeCdnOrigin(input) {
-  const config = readConfig();
-  const value = input || process.env[RUNTIME_CDN_ORIGIN_ENV] || config.cdnOrigin || DEFAULT_RUNTIME_CDN_ORIGIN;
-  return value.replace(/\/+$/, "");
-}
-function resolveRuntimeChannel(input) {
-  const config = readConfig();
-  return input || process.env[RUNTIME_CHANNEL_ENV] || config.runtimeChannel || "stable";
-}
-function resolveRuntimePin() {
-  const env = process.env[RUNTIME_PIN_ENV];
-  if (env && env.trim()) return env.trim();
-  const config = readConfig();
-  return typeof config.runtimeVersion === "string" && config.runtimeVersion.trim() ? config.runtimeVersion.trim() : null;
-}
-function runtimeManifestUrl(cdnOrigin) {
-  const url = new URL(`${resolveRuntimeCdnOrigin(cdnOrigin)}/runtimes/manifest.json`);
-  url.searchParams.set("t", String(Date.now()));
-  return url.toString();
-}
-function runtimeTarballUrl(version, cdnOrigin) {
-  return `${resolveRuntimeCdnOrigin(cdnOrigin)}/runtimes/sootsim-runtime-${version}.tar.gz`;
+function runtimeTarballCacheName(product, version) {
+  return import_node_path2.default.posix.basename(product.tarballPath(version));
 }
-async function fetchRuntimeManifest(cdnOrigin) {
-  const url = runtimeManifestUrl(cdnOrigin);
-  const res = await fetch(url, { headers: { Accept: "application/json" } });
-  if (!res.ok) {
-    throw new Error(`manifest fetch failed: ${res.status} ${res.statusText} (${url})`);
+function compareSemver(a, b) {
+  const parse = (v) => {
+    const hyphen = v.indexOf("-");
+    const core = hyphen >= 0 ? v.slice(0, hyphen) : v;
+    const pre = hyphen >= 0 ? v.slice(hyphen + 1) : "";
+    const parts = core.split(".").map((n) => Number.parseInt(n, 10));
+    if (parts.some((n) => !Number.isFinite(n))) return [[Number.POSITIVE_INFINITY], v];
+    return [parts, pre];
+  };
+  const [an, ap] = parse(a);
+  const [bn, bp] = parse(b);
+  for (let i = 0; i < Math.max(an.length, bn.length); i++) {
+    const av = an[i] ?? 0;
+    const bv = bn[i] ?? 0;
+    if (av !== bv) return av - bv;
   }
-  return await res.json();
+  if (ap === bp) return 0;
+  if (!ap) return 1;
+  if (!bp) return -1;
+  return ap < bp ? -1 : 1;
 }
-function resolveRuntimeVersion(manifest, opts = {}) {
-  const channel = resolveRuntimeChannel(opts.channel);
-  const version = opts.version || resolveRuntimePin() || manifest.channels[channel]?.latest;
-  if (!version) {
-    throw new Error(
-      `no version specified and channel '${channel}' has no latest entry in the manifest`
-    );
+var import_node_fs3, import_node_path2;
+var init_product = __esm({
+  "../contrast-runtime-delivery/src/product.ts"() {
+    "use strict";
+    import_node_fs3 = __toESM(require("node:fs"), 1);
+    import_node_path2 = __toESM(require("node:path"), 1);
   }
-  const entry = manifest.versions[version];
-  if (!entry) {
-    throw new Error(
-      `version ${version} not found in manifest; available: ${Object.keys(manifest.versions).slice(-10).join(", ") || "(none)"}`
-    );
+});
+
+// ../contrast-runtime-delivery/src/index.ts
+function createRuntimeDelivery(product) {
+  function readConfig() {
+    try {
+      const parsed = JSON.parse(
+        import_node_fs4.default.readFileSync(product.configFile(), "utf8")
+      );
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
   }
-  return { version, channel, entry };
-}
-async function installRuntime(opts = {}) {
-  ensureSootsimHome();
-  const cdnOrigin = resolveRuntimeCdnOrigin(opts.cdnOrigin);
-  const manifest = await fetchRuntimeManifest(cdnOrigin);
-  const { version, channel, entry } = resolveRuntimeVersion(manifest, opts);
-  const destDir = runtimeDir(version);
-  const setActive = opts.setActive !== false;
-  if (!opts.force && import_fs2.default.existsSync(import_path2.default.join(destDir, "index.html"))) {
-    if (setActive) writeActiveRuntime(version);
+  function resolveCdnOrigin(input) {
+    const config = readConfig();
+    const value = input || process.env[product.env.cdnOrigin] || config.cdnOrigin || product.defaultCdnOrigin;
+    return value.replace(/\/+$/, "");
+  }
+  function resolveChannel(input) {
+    const config = readConfig();
+    return input || process.env[product.env.channel] || config.runtimeChannel || "stable";
+  }
+  function resolvePin() {
+    const env = process.env[product.env.pin];
+    if (env && env.trim()) return env.trim();
+    const config = readConfig();
+    return typeof config.runtimeVersion === "string" && config.runtimeVersion.trim() ? config.runtimeVersion.trim() : null;
+  }
+  function manifestUrl(cdnOrigin) {
+    const url = new URL(`${resolveCdnOrigin(cdnOrigin)}${product.manifestPath}`);
+    url.searchParams.set("t", String(Date.now()));
+    return url.toString();
+  }
+  function tarballUrl(version, cdnOrigin) {
+    return `${resolveCdnOrigin(cdnOrigin)}${product.tarballPath(version)}`;
+  }
+  async function fetchManifest(cdnOrigin) {
+    const url = manifestUrl(cdnOrigin);
+    const res = await fetch(url, { headers: { Accept: "application/json" } });
+    if (!res.ok) {
+      throw new Error(`manifest fetch failed: ${res.status} ${res.statusText} (${url})`);
+    }
+    return await res.json();
+  }
+  function resolveVersion(manifest, opts = {}) {
+    const channel = resolveChannel(opts.channel);
+    const version = opts.version || resolvePin() || manifest.channels[channel]?.latest;
+    if (!version) {
+      throw new Error(
+        `no version specified and channel '${channel}' has no latest entry in the manifest`
+      );
+    }
+    const entry = manifest.versions[version];
+    if (!entry) {
+      throw new Error(
+        `version ${version} not found in manifest; available: ${Object.keys(manifest.versions).slice(-10).join(", ") || "(none)"}`
+      );
+    }
+    return { version, channel, entry };
+  }
+  async function install(opts = {}) {
+    product.ensureHome();
+    const cdnOrigin = resolveCdnOrigin(opts.cdnOrigin);
+    const manifest = await fetchManifest(cdnOrigin);
+    const { version, channel, entry } = resolveVersion(manifest, opts);
+    const destDir = product.runtimeDir(version);
+    const setActive = opts.setActive !== false;
+    if (!opts.force && import_node_fs4.default.existsSync(import_node_path3.default.join(destDir, product.installedMarker))) {
+      if (setActive) product.writeActiveRuntime(version);
+      return {
+        version,
+        channel,
+        cdnOrigin,
+        runtimeDir: destDir,
+        installed: false,
+        activated: setActive,
+        manifest
+      };
+    }
+    const tarUrl = entry.tarball || tarballUrl(version, cdnOrigin);
+    const tarCachePath = import_node_path3.default.join(
+      product.cacheDir(),
+      runtimeTarballCacheName(product, version)
+    );
+    process.stderr.write(`${product.id}: downloading runtime ${version}\u2026
+`);
+    await downloadToFile(tarUrl, tarCachePath);
+    process.stderr.write(`${product.id}: extracting runtime ${version}\u2026
+`);
+    const actualSha = await sha256File(tarCachePath);
+    if (actualSha !== entry.sha256) {
+      import_node_fs4.default.rmSync(tarCachePath, { force: true });
+      throw new Error(
+        `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
+      );
+    }
+    const tmpDir = import_node_path3.default.join(
+      import_node_path3.default.dirname(destDir),
+      `.installing-${version}-${process.pid}`
+    );
+    import_node_fs4.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_node_fs4.default.mkdirSync(tmpDir, { recursive: true });
+    try {
+      await extractTarball(tarCachePath, tmpDir);
+      if (!import_node_fs4.default.existsSync(import_node_path3.default.join(tmpDir, product.installedMarker))) {
+        throw new Error(
+          `extracted tarball for runtime ${version} is missing ${product.installedMarker}`
+        );
+      }
+      import_node_fs4.default.rmSync(destDir, { recursive: true, force: true });
+      import_node_fs4.default.renameSync(tmpDir, destDir);
+    } catch (err) {
+      import_node_fs4.default.rmSync(tmpDir, { recursive: true, force: true });
+      throw err;
+    }
+    if (setActive) product.writeActiveRuntime(version);
     return {
       version,
       channel,
       cdnOrigin,
       runtimeDir: destDir,
-      installed: false,
+      installed: true,
       activated: setActive,
       manifest
     };
   }
-  const tarUrl = entry.tarball || runtimeTarballUrl(version, cdnOrigin);
-  const tarCachePath = import_path2.default.join(cacheDir(), `sootsim-runtime-${version}.tar.gz`);
-  process.stderr.write(`sootsim: downloading runtime ${version}\u2026
-`);
-  await downloadToFile(tarUrl, tarCachePath);
-  process.stderr.write(`sootsim: extracting runtime ${version}\u2026
-`);
-  const actualSha = await sha256File(tarCachePath);
-  if (actualSha !== entry.sha256) {
-    import_fs2.default.rmSync(tarCachePath, { force: true });
-    throw new Error(
-      `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
-    );
-  }
-  const tmpDir = import_path2.default.join(import_path2.default.dirname(destDir), `.installing-${version}-${process.pid}`);
-  import_fs2.default.rmSync(tmpDir, { recursive: true, force: true });
-  import_fs2.default.mkdirSync(tmpDir, { recursive: true });
-  try {
-    await extractTarball(tarCachePath, tmpDir);
-    if (!import_fs2.default.existsSync(import_path2.default.join(tmpDir, "index.html"))) {
-      throw new Error(`extracted tarball for runtime ${version} is missing index.html`);
+  async function updateToLatest(opts = {}) {
+    product.ensureHome();
+    const cdnOrigin = resolveCdnOrigin(opts.cdnOrigin);
+    const channel = resolveChannel(opts.channel);
+    const pin = resolvePin();
+    if (pin) {
+      const activeVersion2 = product.readActiveRuntime();
+      const pinInstalled = import_node_fs4.default.existsSync(
+        import_node_path3.default.join(product.runtimeDir(pin), product.installedMarker)
+      );
+      if (activeVersion2 === pin && pinInstalled) {
+        return {
+          checked: true,
+          updated: false,
+          reason: `runtime is pinned to ${pin}`,
+          activeVersion: activeVersion2,
+          latestVersion: pin
+        };
+      }
+      const installed3 = await install({
+        version: pin,
+        channel,
+        cdnOrigin,
+        setActive: false
+      });
+      return {
+        checked: true,
+        updated: true,
+        reason: `runtime is pinned to ${pin}`,
+        activeVersion: pin,
+        latestVersion: pin,
+        install: installed3
+      };
     }
-    import_fs2.default.rmSync(destDir, { recursive: true, force: true });
-    import_fs2.default.renameSync(tmpDir, destDir);
-  } catch (err) {
-    import_fs2.default.rmSync(tmpDir, { recursive: true, force: true });
-    throw err;
-  }
-  if (setActive) writeActiveRuntime(version);
-  return {
-    version,
-    channel,
-    cdnOrigin,
-    runtimeDir: destDir,
-    installed: true,
-    activated: setActive,
-    manifest
-  };
-}
-async function updateRuntimeToLatest(opts = {}) {
-  ensureSootsimHome();
-  const cdnOrigin = resolveRuntimeCdnOrigin(opts.cdnOrigin);
-  const channel = resolveRuntimeChannel(opts.channel);
-  const pin = resolveRuntimePin();
-  if (pin) {
-    const activeVersion2 = readActiveRuntime();
-    const pinInstalled = import_fs2.default.existsSync(import_path2.default.join(runtimeDir(pin), "index.html"));
-    if (activeVersion2 === pin && pinInstalled) {
+    const manifest = await fetchManifest(cdnOrigin);
+    const latestVersion = manifest.channels[channel]?.latest;
+    if (!latestVersion) {
       return {
         checked: true,
         updated: false,
-        reason: `runtime is pinned to ${pin}`,
-        activeVersion: activeVersion2,
-        latestVersion: pin
+        reason: `channel '${channel}' has no latest runtime`,
+        activeVersion: product.readActiveRuntime()
+      };
+    }
+    const entry = manifest.versions[latestVersion];
+    if (!entry) {
+      return {
+        checked: true,
+        updated: false,
+        reason: `manifest is missing version ${latestVersion}`,
+        activeVersion: product.readActiveRuntime(),
+        latestVersion
+      };
+    }
+    const activeVersion = product.readActiveRuntime();
+    const activeDir = activeVersion ? product.runtimeDir(activeVersion) : null;
+    const activeInstalled = activeDir ? import_node_fs4.default.existsSync(import_node_path3.default.join(activeDir, product.installedMarker)) : false;
+    const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
+    if (!shouldInstall) {
+      return {
+        checked: true,
+        updated: false,
+        reason: "active runtime is current",
+        activeVersion,
+        latestVersion
       };
     }
-    const install2 = await installRuntime({
-      version: pin,
+    const installed2 = await install({
+      version: latestVersion,
       channel,
       cdnOrigin,
       setActive: false
@@ -11411,57 +11485,40 @@ async function updateRuntimeToLatest(opts = {}) {
     return {
       checked: true,
       updated: true,
-      reason: `runtime is pinned to ${pin}`,
-      activeVersion: pin,
-      latestVersion: pin,
-      install: install2
-    };
-  }
-  const manifest = await fetchRuntimeManifest(cdnOrigin);
-  const latestVersion = manifest.channels[channel]?.latest;
-  if (!latestVersion) {
-    return {
-      checked: true,
-      updated: false,
-      reason: `channel '${channel}' has no latest runtime`,
-      activeVersion: readActiveRuntime()
+      activeVersion: latestVersion,
+      latestVersion,
+      install: installed2
     };
   }
-  const entry = manifest.versions[latestVersion];
-  if (!entry) {
-    return {
-      checked: true,
-      updated: false,
-      reason: `manifest is missing version ${latestVersion}`,
-      activeVersion: readActiveRuntime(),
-      latestVersion
-    };
-  }
-  const activeVersion = readActiveRuntime();
-  const activeDir = activeVersion ? runtimeDir(activeVersion) : null;
-  const activeInstalled = activeDir ? import_fs2.default.existsSync(import_path2.default.join(activeDir, "index.html")) : false;
-  const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
-  if (!shouldInstall) {
-    return {
-      checked: true,
-      updated: false,
-      reason: "active runtime is current",
-      activeVersion,
-      latestVersion
-    };
+  async function checkUpToDate(opts = {}) {
+    const active = product.readActiveRuntime();
+    const pinned = resolvePin();
+    if (pinned) {
+      return { active, latest: pinned, pinned, outdated: active !== pinned };
+    }
+    try {
+      const manifest = await fetchManifest(resolveCdnOrigin(opts.cdnOrigin));
+      const channel = resolveChannel(opts.channel);
+      const latest = manifest.channels[channel]?.latest ?? null;
+      const outdated = !!(latest && (!active || compareSemver(latest, active) > 0));
+      return { active, latest, pinned: null, outdated };
+    } catch {
+      return { active, latest: null, pinned: null, outdated: false };
+    }
   }
-  const install = await installRuntime({
-    version: latestVersion,
-    channel,
-    cdnOrigin,
-    setActive: false
-  });
   return {
-    checked: true,
-    updated: true,
-    activeVersion: latestVersion,
-    latestVersion,
-    install
+    product,
+    resolveCdnOrigin,
+    resolveChannel,
+    resolvePin,
+    manifestUrl,
+    tarballUrl,
+    fetchManifest,
+    resolveVersion,
+    install,
+    updateToLatest,
+    checkUpToDate,
+    listInstalled: () => listInstalledRuntimes(product)
   };
 }
 async function downloadToFile(url, destPath) {
@@ -11469,17 +11526,17 @@ async function downloadToFile(url, destPath) {
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  import_fs2.default.mkdirSync(import_path2.default.dirname(destPath), { recursive: true });
+  import_node_fs4.default.mkdirSync(import_node_path3.default.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.partial`;
   try {
     await (0, import_promises.pipeline)(
-      import_stream.Readable.fromWeb(res.body),
-      import_fs2.default.createWriteStream(tmp)
+      import_node_stream.Readable.fromWeb(res.body),
+      import_node_fs4.default.createWriteStream(tmp)
     );
-    import_fs2.default.renameSync(tmp, destPath);
+    import_node_fs4.default.renameSync(tmp, destPath);
   } catch (err) {
     try {
-      import_fs2.default.unlinkSync(tmp);
+      import_node_fs4.default.unlinkSync(tmp);
     } catch {
     }
     throw err;
@@ -11487,8 +11544,8 @@ async function downloadToFile(url, destPath) {
 }
 function sha256File(filePath) {
   return new Promise((resolve5, reject) => {
-    const hash = import_crypto.default.createHash("sha256");
-    const stream = import_fs2.default.createReadStream(filePath);
+    const hash = import_node_crypto.default.createHash("sha256");
+    const stream = import_node_fs4.default.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve5(hash.digest("hex")));
@@ -11496,7 +11553,7 @@ function sha256File(filePath) {
 }
 function extractTarball(tarPath, destDir) {
   return new Promise((resolve5, reject) => {
-    const child = (0, import_child_process2.spawn)("tar", ["-xzf", tarPath, "-C", destDir], {
+    const child = (0, import_node_child_process2.spawn)("tar", ["-xzf", tarPath, "-C", destDir], {
       stdio: ["ignore", "inherit", "inherit"]
     });
     child.on("error", reject);
@@ -11506,21 +11563,52 @@ function extractTarball(tarPath, destDir) {
     });
   });
 }
-var import_child_process2, import_crypto, import_fs2, import_path2, import_stream, import_promises, DEFAULT_RUNTIME_CDN_ORIGIN, RUNTIME_CDN_ORIGIN_ENV, RUNTIME_CHANNEL_ENV, RUNTIME_PIN_ENV;
+var import_node_child_process2, import_node_crypto, import_node_fs4, import_node_path3, import_node_stream, import_promises;
+var init_src = __esm({
+  "../contrast-runtime-delivery/src/index.ts"() {
+    "use strict";
+    import_node_child_process2 = require("node:child_process");
+    import_node_crypto = __toESM(require("node:crypto"), 1);
+    import_node_fs4 = __toESM(require("node:fs"), 1);
+    import_node_path3 = __toESM(require("node:path"), 1);
+    import_node_stream = require("node:stream");
+    import_promises = require("node:stream/promises");
+    init_product();
+    init_product();
+  }
+});
+
+// src/runtime-delivery.ts
+var DEFAULT_RUNTIME_CDN_ORIGIN, SOOTSIM_RUNTIME_PRODUCT, sootsimRuntime;
 var init_runtime_delivery = __esm({
   "src/runtime-delivery.ts"() {
     "use strict";
-    import_child_process2 = require("child_process");
-    import_crypto = __toESM(require("crypto"), 1);
-    import_fs2 = __toESM(require("fs"), 1);
-    import_path2 = __toESM(require("path"), 1);
-    import_stream = require("stream");
-    import_promises = require("stream/promises");
+    init_src();
     init_home_paths();
     DEFAULT_RUNTIME_CDN_ORIGIN = "https://contrast.dev";
-    RUNTIME_CDN_ORIGIN_ENV = "SOOTSIM_CDN_ORIGIN";
-    RUNTIME_CHANNEL_ENV = "SOOTSIM_RUNTIME_CHANNEL";
-    RUNTIME_PIN_ENV = "SOOTSIM_RUNTIME_VERSION";
+    SOOTSIM_RUNTIME_PRODUCT = {
+      id: "sootsim",
+      defaultCdnOrigin: DEFAULT_RUNTIME_CDN_ORIGIN,
+      manifestPath: "/runtimes/manifest.json",
+      tarballPath: (version) => `/runtimes/sootsim-runtime-${version}.tar.gz`,
+      // the engine runtime is a static SPA: shell at the root, engine/ and
+      // engine-tenant/ beneath it. index.html is what the daemon and the
+      // vite/metro plugins serve, so its absence means the tarball is not one.
+      installedMarker: "index.html",
+      env: {
+        cdnOrigin: "SOOTSIM_CDN_ORIGIN",
+        channel: "SOOTSIM_RUNTIME_CHANNEL",
+        pin: "SOOTSIM_RUNTIME_VERSION"
+      },
+      ensureHome: ensureSootsimHome,
+      configFile: configFilePath,
+      runtimesDir,
+      runtimeDir,
+      cacheDir,
+      readActiveRuntime,
+      writeActiveRuntime
+    };
+    sootsimRuntime = createRuntimeDelivery(SOOTSIM_RUNTIME_PRODUCT);
   }
 });
 
@@ -11585,7 +11673,7 @@ function getUserDataDir() {
   return userDataDir();
 }
 function storeFile() {
-  return import_node_path2.default.join(userDataDir(), "attached-projects.json");
+  return import_node_path4.default.join(userDataDir(), "attached-projects.json");
 }
 function cloneEmpty() {
   return {
@@ -11599,7 +11687,7 @@ function loadStore() {
   const file = storeFile();
   let raw;
   try {
-    raw = import_node_fs3.default.readFileSync(file, "utf8");
+    raw = import_node_fs5.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return cloneEmpty();
     throw err;
@@ -11616,7 +11704,7 @@ function loadStore() {
   } catch (err) {
     const quarantine = `${file}.corrupt-${Date.now()}`;
     try {
-      import_node_fs3.default.renameSync(file, quarantine);
+      import_node_fs5.default.renameSync(file, quarantine);
       console.warn(
         `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
       );
@@ -11627,16 +11715,16 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs3.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
+  import_node_fs5.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const fd = import_node_fs3.default.openSync(tmp, "w", 384);
+  const fd = import_node_fs5.default.openSync(tmp, "w", 384);
   try {
-    import_node_fs3.default.writeFileSync(fd, JSON.stringify(store, null, 2));
-    import_node_fs3.default.fsyncSync(fd);
+    import_node_fs5.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs5.default.fsyncSync(fd);
   } finally {
-    import_node_fs3.default.closeSync(fd);
+    import_node_fs5.default.closeSync(fd);
   }
-  import_node_fs3.default.renameSync(tmp, file);
+  import_node_fs5.default.renameSync(tmp, file);
 }
 function mutateStore(fn) {
   const store = loadStore();
@@ -11645,13 +11733,13 @@ function mutateStore(fn) {
   return store;
 }
 function projectIdForCwd(cwd) {
-  return (0, import_node_crypto.createHash)("sha256").update(import_node_path2.default.resolve(cwd)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto2.createHash)("sha256").update(import_node_path4.default.resolve(cwd)).digest("hex").slice(0, 16);
 }
 function newSessionId() {
-  return `s_${(0, import_node_crypto.randomBytes)(10).toString("hex")}`;
+  return `s_${(0, import_node_crypto2.randomBytes)(10).toString("hex")}`;
 }
 function upsertProject(input) {
-  const cwd = import_node_path2.default.resolve(input.cwd);
+  const cwd = import_node_path4.default.resolve(input.cwd);
   const id = projectIdForCwd(cwd);
   let result;
   mutateStore((store) => {
@@ -11677,7 +11765,7 @@ function upsertProject(input) {
     const now = Date.now();
     const created = {
       id,
-      name: input.name ?? import_node_path2.default.basename(cwd),
+      name: input.name ?? import_node_path4.default.basename(cwd),
       cwd,
       repoRoot: input.repoRoot,
       sourceRoots: input.sourceRoots ?? [cwd],
@@ -11806,8 +11894,8 @@ async function seedFromDemoAppRegistry() {
   if (apps.length === 0) return;
   mutateStore((store) => {
     for (const app of apps) {
-      if (!import_node_fs3.default.existsSync(app.dir)) continue;
-      const cwd = import_node_path2.default.resolve(app.dir);
+      if (!import_node_fs5.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path4.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
       const now = Date.now();
@@ -11828,13 +11916,13 @@ async function seedFromDemoAppRegistry() {
     }
   });
 }
-var import_node_crypto, import_node_fs3, import_node_path2, overrideDir, COST_HISTORY_MAX_AGE_MS;
+var import_node_crypto2, import_node_fs5, import_node_path4, overrideDir, COST_HISTORY_MAX_AGE_MS;
 var init_attached_projects = __esm({
   "src/attached-projects.ts"() {
     "use strict";
-    import_node_crypto = require("node:crypto");
-    import_node_fs3 = __toESM(require("node:fs"), 1);
-    import_node_path2 = __toESM(require("node:path"), 1);
+    import_node_crypto2 = require("node:crypto");
+    import_node_fs5 = __toESM(require("node:fs"), 1);
+    import_node_path4 = __toESM(require("node:path"), 1);
     init_home_paths();
     overrideDir = null;
     COST_HISTORY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
@@ -11843,16 +11931,16 @@ var init_attached_projects = __esm({
 
 // src/agent-sessions.ts
 function sessionDir(sessionId) {
-  return import_node_path3.default.join(getUserDataDir(), "sessions", sessionId);
+  return import_node_path5.default.join(getUserDataDir(), "sessions", sessionId);
 }
 function promptFifoPath(sessionId) {
-  return import_node_path3.default.join(sessionDir(sessionId), "prompt.in");
+  return import_node_path5.default.join(sessionDir(sessionId), "prompt.in");
 }
 function eventsFifoPath(sessionId) {
-  return import_node_path3.default.join(sessionDir(sessionId), "events.out");
+  return import_node_path5.default.join(sessionDir(sessionId), "events.out");
 }
 function transcriptPath(sessionId) {
-  return import_node_path3.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+  return import_node_path5.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
 }
 function pidIsAlive(pid, sessionId) {
   if (!pid) return false;
@@ -11862,7 +11950,7 @@ function pidIsAlive(pid, sessionId) {
     return false;
   }
   if (sessionId) {
-    if (!import_node_fs4.default.existsSync(sessionDir(sessionId))) return false;
+    if (!import_node_fs6.default.existsSync(sessionDir(sessionId))) return false;
   }
   return true;
 }
@@ -11874,11 +11962,11 @@ function resolveSootsimInvocation() {
     const resourcesPath = process.resourcesPath;
     if (resourcesPath) {
       const candidates = [
-        import_node_path3.default.join(resourcesPath, "bin", "sootsim"),
-        import_node_path3.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+        import_node_path5.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path5.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
-        if (import_node_fs4.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
+        if (import_node_fs6.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
       }
     }
   }
@@ -11901,15 +11989,15 @@ function tryWorkspaceSootsim() {
     const sootsimDir = resolveSootsimPackageDir();
     if (!sootsimDir) return null;
     const binaryName = `sootsim-${process.platform}-${process.arch}`;
-    const distBinary = import_node_path3.default.join(sootsimDir, "dist-bin", binaryName);
-    if (import_node_fs4.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
-    const distBin = import_node_path3.default.join(sootsimDir, "dist-cli", "bin.js");
-    if (import_node_fs4.default.existsSync(distBin)) {
+    const distBinary = import_node_path5.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs6.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
+    const distBin = import_node_path5.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs6.default.existsSync(distBin)) {
       try {
-        const src = import_node_path3.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
-        if (import_node_fs4.default.existsSync(src)) {
-          const srcMtime = import_node_fs4.default.statSync(src).mtimeMs;
-          const buildMtime = import_node_fs4.default.statSync(distBin).mtimeMs;
+        const src = import_node_path5.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        if (import_node_fs6.default.existsSync(src)) {
+          const srcMtime = import_node_fs6.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs6.default.statSync(distBin).mtimeMs;
           if (buildMtime < srcMtime) {
             console.warn(
               `[sootsim] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/sootsim build:cli\`.`
@@ -11928,22 +12016,22 @@ function tryWorkspaceSootsim() {
 function resolveSootsimPackageDir() {
   try {
     const resolved = require.resolve("sootsim/package.json");
-    return import_node_path3.default.dirname(resolved);
+    return import_node_path5.default.dirname(resolved);
   } catch {
   }
   const here = fileFromImportMeta();
   if (!here) return null;
-  let cur = import_node_path3.default.dirname(here);
+  let cur = import_node_path5.default.dirname(here);
   for (let i = 0; i < 8; i++) {
-    const pkg = import_node_path3.default.join(cur, "package.json");
+    const pkg = import_node_path5.default.join(cur, "package.json");
     try {
-      if (import_node_fs4.default.existsSync(pkg)) {
-        const parsed = JSON.parse(import_node_fs4.default.readFileSync(pkg, "utf8"));
+      if (import_node_fs6.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs6.default.readFileSync(pkg, "utf8"));
         if (parsed.name === "sootsim") return cur;
       }
     } catch {
     }
-    const parent = import_node_path3.default.dirname(cur);
+    const parent = import_node_path5.default.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -11959,28 +12047,28 @@ function fileFromImportMeta() {
   }
 }
 async function withStartLock(projectId, provider, fn) {
-  const lockDir = import_node_path3.default.join(getUserDataDir(), "locks");
-  import_node_fs4.default.mkdirSync(lockDir, { recursive: true });
+  const lockDir = import_node_path5.default.join(getUserDataDir(), "locks");
+  import_node_fs6.default.mkdirSync(lockDir, { recursive: true });
   try {
-    import_node_fs4.default.chmodSync(lockDir, 448);
+    import_node_fs6.default.chmodSync(lockDir, 448);
   } catch {
   }
-  const lockPath = import_node_path3.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const lockPath = import_node_path5.default.join(lockDir, `start-${projectId}-${provider}.lock`);
   const deadline = Date.now() + 4e3;
   let fd = null;
   while (fd === null) {
     try {
-      fd = import_node_fs4.default.openSync(
+      fd = import_node_fs6.default.openSync(
         lockPath,
-        import_node_fs4.constants.O_WRONLY | import_node_fs4.constants.O_CREAT | import_node_fs4.constants.O_EXCL,
+        import_node_fs6.constants.O_WRONLY | import_node_fs6.constants.O_CREAT | import_node_fs6.constants.O_EXCL,
         384
       );
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stale = Number(import_node_fs4.default.readFileSync(lockPath, "utf8").trim());
+        const stale = Number(import_node_fs6.default.readFileSync(lockPath, "utf8").trim());
         if (stale && !isProcessAlive(stale)) {
-          import_node_fs4.default.unlinkSync(lockPath);
+          import_node_fs6.default.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -11994,15 +12082,15 @@ async function withStartLock(projectId, provider, fn) {
     }
   }
   try {
-    import_node_fs4.default.writeFileSync(fd, String(process.pid));
+    import_node_fs6.default.writeFileSync(fd, String(process.pid));
     return await fn();
   } finally {
     try {
-      import_node_fs4.default.closeSync(fd);
+      import_node_fs6.default.closeSync(fd);
     } catch {
     }
     try {
-      import_node_fs4.default.unlinkSync(lockPath);
+      import_node_fs6.default.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -12016,28 +12104,28 @@ function isProcessAlive(pid) {
   }
 }
 function mkfifoSync(p) {
-  const parent = import_node_path3.default.dirname(p);
-  import_node_fs4.default.mkdirSync(parent, { recursive: true });
+  const parent = import_node_path5.default.dirname(p);
+  import_node_fs6.default.mkdirSync(parent, { recursive: true });
   try {
-    import_node_fs4.default.chmodSync(parent, 448);
+    import_node_fs6.default.chmodSync(parent, 448);
   } catch {
   }
-  if (import_node_fs4.default.existsSync(p)) {
+  if (import_node_fs6.default.existsSync(p)) {
     try {
-      const stat = import_node_fs4.default.statSync(p);
+      const stat = import_node_fs6.default.statSync(p);
       if (stat.isFIFO()) {
         try {
-          import_node_fs4.default.chmodSync(p, 384);
+          import_node_fs6.default.chmodSync(p, 384);
         } catch {
         }
         return;
       }
-      import_node_fs4.default.unlinkSync(p);
+      import_node_fs6.default.unlinkSync(p);
     } catch {
-      import_node_fs4.default.unlinkSync(p);
+      import_node_fs6.default.unlinkSync(p);
     }
   }
-  const result = (0, import_node_child_process2.spawnSync)("mkfifo", ["-m", "600", p]);
+  const result = (0, import_node_child_process3.spawnSync)("mkfifo", ["-m", "600", p]);
   if (result.status !== 0) {
     throw new Error(
       `mkfifo(${p}) failed: ${result.stderr?.toString().trim() || "unknown error"}`
@@ -12060,7 +12148,7 @@ async function startSession(opts) {
         `session already running for project=${project.id} provider=${provider} (session ${existingLive.id}, pid ${existingLive.wrapperPid}). end it first with \`sootsim agent end <sessionId>\`.`
       );
     }
-    const claudeSessionUuid = provider === "claude" ? (0, import_node_crypto2.randomUUID)() : void 0;
+    const claudeSessionUuid = provider === "claude" ? (0, import_node_crypto3.randomUUID)() : void 0;
     const session = upsertSession({
       projectId: project.id,
       provider,
@@ -12074,10 +12162,10 @@ async function startSession(opts) {
     const transcript = transcriptPath(session.id);
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
-    const transcriptDir = import_node_path3.default.dirname(transcript);
-    import_node_fs4.default.mkdirSync(transcriptDir, { recursive: true });
+    const transcriptDir = import_node_path5.default.dirname(transcript);
+    import_node_fs6.default.mkdirSync(transcriptDir, { recursive: true });
     try {
-      import_node_fs4.default.chmodSync(transcriptDir, 448);
+      import_node_fs6.default.chmodSync(transcriptDir, 448);
     } catch {
     }
     const { cmd, prefixArgs } = resolveSootsimInvocation();
@@ -12105,7 +12193,7 @@ async function startSession(opts) {
     if (claudeSessionUuid) {
       wrapperArgs.push("--claude-session-uuid", claudeSessionUuid);
     }
-    const child = (0, import_node_child_process2.spawn)(cmd, wrapperArgs, {
+    const child = (0, import_node_child_process3.spawn)(cmd, wrapperArgs, {
       detached: true,
       stdio: "ignore",
       env: {
@@ -12128,7 +12216,7 @@ async function startSession(opts) {
         }
       }
       try {
-        import_node_fs4.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+        import_node_fs6.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
       } catch {
       }
       updateSessionStatus(session.id, { status: "ended" });
@@ -12156,18 +12244,18 @@ async function sendPrompt(sessionId, prompt) {
     );
   }
   const fifo = promptFifoPath(sessionId);
-  if (!import_node_fs4.default.existsSync(fifo)) {
+  if (!import_node_fs6.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs4.default.openSync(fifo, import_node_fs4.constants.O_WRONLY);
+  const fd = import_node_fs6.default.openSync(fifo, import_node_fs6.constants.O_WRONLY);
   try {
     const wireText = encodeAgentPromptEnvelope(prompt);
     if (!wireText) {
       throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
     }
-    import_node_fs4.default.writeSync(fd, wireText + "\n");
+    import_node_fs6.default.writeSync(fd, wireText + "\n");
   } finally {
-    import_node_fs4.default.closeSync(fd);
+    import_node_fs6.default.closeSync(fd);
   }
   updateSessionStatus(sessionId, {
     lastPrompt: prompt.displayText ?? prompt.text,
@@ -12189,7 +12277,7 @@ async function endSession(sessionId) {
   const base = getUserDataDir();
   if (dir.startsWith(base)) {
     try {
-      import_node_fs4.default.rmSync(dir, { recursive: true, force: true });
+      import_node_fs6.default.rmSync(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -12197,11 +12285,11 @@ async function endSession(sessionId) {
 }
 function subscribeEvents(sessionId, onEvent) {
   const fifo = eventsFifoPath(sessionId);
-  if (!import_node_fs4.default.existsSync(fifo)) {
+  if (!import_node_fs6.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs4.default.openSync(fifo, import_node_fs4.constants.O_RDWR);
-  const stream = import_node_fs4.default.createReadStream("", { fd, autoClose: true });
+  const fd = import_node_fs6.default.openSync(fifo, import_node_fs6.constants.O_RDWR);
+  const stream = import_node_fs6.default.createReadStream("", { fd, autoClose: true });
   const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const event = parseAgentEventLine(line);
@@ -12222,7 +12310,7 @@ function subscribeEvents(sessionId, onEvent) {
   };
 }
 async function waitForFirstEvent(fifo, predicate, timeoutMs) {
-  const fd = import_node_fs4.default.openSync(fifo, import_node_fs4.constants.O_RDWR | import_node_fs4.constants.O_NONBLOCK);
+  const fd = import_node_fs6.default.openSync(fifo, import_node_fs6.constants.O_RDWR | import_node_fs6.constants.O_NONBLOCK);
   const buf = Buffer.alloc(8192);
   let leftover = "";
   const deadline = Date.now() + timeoutMs;
@@ -12230,7 +12318,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     while (Date.now() < deadline) {
       let n = 0;
       try {
-        n = import_node_fs4.default.readSync(fd, buf, 0, buf.length, null);
+        n = import_node_fs6.default.readSync(fd, buf, 0, buf.length, null);
       } catch (err) {
         if (err.code !== "EAGAIN") throw err;
         n = 0;
@@ -12250,17 +12338,17 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs4.default.closeSync(fd);
+    import_node_fs6.default.closeSync(fd);
   }
 }
-var import_node_child_process2, import_node_crypto2, import_node_fs4, import_node_path3, import_node_readline, AgentSessionError;
+var import_node_child_process3, import_node_crypto3, import_node_fs6, import_node_path5, import_node_readline, AgentSessionError;
 var init_agent_sessions = __esm({
   "src/agent-sessions.ts"() {
     "use strict";
-    import_node_child_process2 = require("node:child_process");
-    import_node_crypto2 = require("node:crypto");
-    import_node_fs4 = __toESM(require("node:fs"), 1);
-    import_node_path3 = __toESM(require("node:path"), 1);
+    import_node_child_process3 = require("node:child_process");
+    import_node_crypto3 = require("node:crypto");
+    import_node_fs6 = __toESM(require("node:fs"), 1);
+    import_node_path5 = __toESM(require("node:path"), 1);
     import_node_readline = __toESM(require("node:readline"), 1);
     init_agent_events();
     init_agent_prompt();
@@ -12302,8 +12390,8 @@ function resolveAgentbusCommand(explicit) {
   if (fromArg) return fromArg;
   const fromEnv = process.env.AGENTBUS_COMMAND?.trim();
   if (fromEnv) return fromEnv;
-  const localBin = import_node_path4.default.join(import_node_os2.default.homedir(), ".local", "bin", "agentbus");
-  if (import_node_fs5.default.existsSync(localBin)) return localBin;
+  const localBin = import_node_path6.default.join(import_node_os2.default.homedir(), ".local", "bin", "agentbus");
+  if (import_node_fs7.default.existsSync(localBin)) return localBin;
   return "agentbus";
 }
 async function sendPromptToAgentbusSession(input) {
@@ -12318,7 +12406,7 @@ async function sendPromptToAgentbusSession(input) {
   const command = resolveAgentbusCommand(input.command);
   const timeoutMs = input.timeoutMs ?? 15e3;
   await new Promise((resolve5, reject) => {
-    const child = (0, import_node_child_process3.spawn)(command, ["send", sessionId, text], {
+    const child = (0, import_node_child_process4.spawn)(command, ["send", sessionId, text], {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
     });
@@ -12353,14 +12441,14 @@ async function sendPromptToAgentbusSession(input) {
     });
   });
 }
-var import_node_child_process3, import_node_fs5, import_node_os2, import_node_path4;
+var import_node_child_process4, import_node_fs7, import_node_os2, import_node_path6;
 var init_agentbus_prompt = __esm({
   "src/agentbus-prompt.ts"() {
     "use strict";
-    import_node_child_process3 = require("node:child_process");
-    import_node_fs5 = __toESM(require("node:fs"), 1);
+    import_node_child_process4 = require("node:child_process");
+    import_node_fs7 = __toESM(require("node:fs"), 1);
     import_node_os2 = __toESM(require("node:os"), 1);
-    import_node_path4 = __toESM(require("node:path"), 1);
+    import_node_path6 = __toESM(require("node:path"), 1);
     init_agent_identity();
     init_agent_identity();
   }
@@ -12379,12 +12467,12 @@ function mapFrameworkToProjectFramework(fw) {
   if (fw === "one" || fw === "vxrn") return "one";
   return "unknown";
 }
-var import_node_fs6, import_node_path5, WS_OPEN, AgentHost;
+var import_node_fs8, import_node_path7, WS_OPEN, AgentHost;
 var init_agent_host = __esm({
   "src/host/agent-host.ts"() {
     "use strict";
-    import_node_fs6 = __toESM(require("node:fs"), 1);
-    import_node_path5 = __toESM(require("node:path"), 1);
+    import_node_fs8 = __toESM(require("node:fs"), 1);
+    import_node_path7 = __toESM(require("node:path"), 1);
     init_dev_server_scanner();
     init_agent_sessions();
     init_agentbus_prompt();
@@ -12571,7 +12659,7 @@ var init_agent_host = __esm({
         );
         const project = upsertProject({
           cwd: match.cwd,
-          name: match.projectName ?? import_node_path5.default.basename(match.cwd),
+          name: match.projectName ?? import_node_path7.default.basename(match.cwd),
           preferredProvider: input.provider ?? existing?.preferredProvider,
           sourceRoots: existing?.sourceRoots ?? [match.cwd],
           knownBundleUrls,
@@ -12582,18 +12670,18 @@ var init_agent_host = __esm({
       }
       getTranscript(sessionId) {
         const p = transcriptPath(sessionId);
-        if (!import_node_fs6.default.existsSync(p)) {
+        if (!import_node_fs8.default.existsSync(p)) {
           return { error: "transcript not found", code: "NO_TRANSCRIPT" };
         }
-        return import_node_fs6.default.readFileSync(p, "utf8");
+        return import_node_fs8.default.readFileSync(p, "utf8");
       }
       getPaths() {
         const dir = getUserDataDir();
         return {
           userDataDir: dir,
-          storeFile: import_node_path5.default.join(dir, "attached-projects.json"),
-          sessionsDir: import_node_path5.default.join(dir, "sessions"),
-          transcriptsDir: import_node_path5.default.join(dir, "transcripts")
+          storeFile: import_node_path7.default.join(dir, "attached-projects.json"),
+          sessionsDir: import_node_path7.default.join(dir, "sessions"),
+          transcriptsDir: import_node_path7.default.join(dir, "transcripts")
         };
       }
       // --- subscription management ---
@@ -13193,19 +13281,19 @@ var init_fetch_proxy_handler = __esm({
 
 // src/host/open-url.ts
 function expandHome(candidate) {
-  return candidate.startsWith("~/") ? (0, import_path3.join)((0, import_os.homedir)(), candidate.slice(2)) : candidate;
+  return candidate.startsWith("~/") ? (0, import_path2.join)((0, import_os.homedir)(), candidate.slice(2)) : candidate;
 }
 function firstExisting(candidates) {
   for (const candidate of candidates) {
     const expanded = expandHome(candidate);
-    if ((0, import_fs3.existsSync)(expanded)) return expanded;
+    if ((0, import_fs2.existsSync)(expanded)) return expanded;
   }
   return null;
 }
 function lookupExecutable(command, platform) {
   try {
     const tool = platform === "win32" ? "where" : "which";
-    const out = (0, import_child_process3.execFileSync)(tool, [command], {
+    const out = (0, import_child_process2.execFileSync)(tool, [command], {
       encoding: "utf8",
       timeout: 1500,
       stdio: ["ignore", "pipe", "ignore"]
@@ -13217,7 +13305,7 @@ function lookupExecutable(command, platform) {
 }
 function resolveChromiumBinary(platform = process.platform) {
   const envCandidate = process.env.CHROME_PATH || process.env.CHROMIUM_PATH;
-  if (envCandidate && (0, import_fs3.existsSync)(envCandidate)) return envCandidate;
+  if (envCandidate && (0, import_fs2.existsSync)(envCandidate)) return envCandidate;
   const direct = platform === "darwin" ? firstExisting(MAC_CHROMIUM_CANDIDATES) : platform === "win32" ? firstExisting(WINDOWS_CHROMIUM_CANDIDATES) : firstExisting(LINUX_CHROMIUM_CANDIDATES);
   if (direct) return direct;
   const commands = platform === "win32" ? WINDOWS_CHROMIUM_COMMANDS : UNIX_CHROMIUM_COMMANDS;
@@ -13274,7 +13362,7 @@ function buildChromiumUrlCommand(url, options = {}) {
 }
 async function spawnLaunch(command, args, detached) {
   return new Promise((resolve5, reject) => {
-    const child = (0, import_child_process3.spawn)(command, args, {
+    const child = (0, import_child_process2.spawn)(command, args, {
       detached,
       stdio: "ignore"
     });
@@ -13297,14 +13385,14 @@ async function launchUrl(url, options = {}) {
 async function openUrl(url, options = {}) {
   await launchUrl(url, options);
 }
-var import_child_process3, import_fs3, import_os, import_path3, MAC_CHROMIUM_CANDIDATES, LINUX_CHROMIUM_CANDIDATES, WINDOWS_CHROMIUM_CANDIDATES, UNIX_CHROMIUM_COMMANDS, WINDOWS_CHROMIUM_COMMANDS;
+var import_child_process2, import_fs2, import_os, import_path2, MAC_CHROMIUM_CANDIDATES, LINUX_CHROMIUM_CANDIDATES, WINDOWS_CHROMIUM_CANDIDATES, UNIX_CHROMIUM_COMMANDS, WINDOWS_CHROMIUM_COMMANDS;
 var init_open_url = __esm({
   "src/host/open-url.ts"() {
     "use strict";
-    import_child_process3 = require("child_process");
-    import_fs3 = require("fs");
+    import_child_process2 = require("child_process");
+    import_fs2 = require("fs");
     import_os = require("os");
-    import_path3 = require("path");
+    import_path2 = require("path");
     MAC_CHROMIUM_CANDIDATES = [
       "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
       "~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
@@ -13566,14 +13654,14 @@ function unrefTimer(timer) {
     timer.unref();
   }
 }
-var import_child_process4, import_fs4, import_http3, import_path4, import_ws2, SOOTSIM_CROSS_ORIGIN_EMBEDDER_POLICY, WRITE_COMMAND_TYPES, FORCE_CLOSE_GRACE_MS, FORCE_CLOSE_TERMINATE_MS, DAEMON_HEARTBEAT_INTERVAL_MS, DEFAULT_RUNTIME_UPDATE_INTERVAL_MS, RUNTIME_UPDATE_INTERVAL_ENV, HTTP_MIME_TYPES, SootSimBridgeHost;
+var import_child_process3, import_fs3, import_http3, import_path3, import_ws2, SOOTSIM_CROSS_ORIGIN_EMBEDDER_POLICY, WRITE_COMMAND_TYPES, FORCE_CLOSE_GRACE_MS, FORCE_CLOSE_TERMINATE_MS, DAEMON_HEARTBEAT_INTERVAL_MS, DEFAULT_RUNTIME_UPDATE_INTERVAL_MS, RUNTIME_UPDATE_INTERVAL_ENV, HTTP_MIME_TYPES, SootSimBridgeHost;
 var init_bridge_host = __esm({
   "src/host/bridge-host.ts"() {
     "use strict";
-    import_child_process4 = require("child_process");
-    import_fs4 = __toESM(require("fs"), 1);
+    import_child_process3 = require("child_process");
+    import_fs3 = __toESM(require("fs"), 1);
     import_http3 = require("http");
-    import_path4 = __toESM(require("path"), 1);
+    import_path3 = __toESM(require("path"), 1);
     import_ws2 = require("ws");
     init_dev_server_scanner();
     init_bridge_constants();
@@ -13865,7 +13953,7 @@ var init_bridge_host = __esm({
               return;
             }
             if (msg.type === "runtime:list") {
-              const versions = listInstalledRuntimes();
+              const versions = sootsimRuntime.listInstalled();
               const active = this.getActiveRuntime();
               const reply = {
                 type: "runtime:list:ok",
@@ -13882,7 +13970,7 @@ var init_bridge_host = __esm({
             }
             if (msg.type === "runtime:use") {
               const version = typeof msg.version === "string" ? msg.version : "";
-              const installed2 = listInstalledRuntimes();
+              const installed2 = sootsimRuntime.listInstalled();
               if (!installed2.includes(version)) {
                 try {
                   ws.send(
@@ -14411,7 +14499,7 @@ var init_bridge_host = __esm({
             if (reason === "startup") {
               process.stderr.write("sootsim: checking for runtime updates\u2026\n");
             }
-            const result = await updateRuntimeToLatest();
+            const result = await sootsimRuntime.updateToLatest();
             if (!result.updated || !result.latestVersion) {
               if (reason === "startup") {
                 process.stderr.write(
@@ -14647,34 +14735,34 @@ var init_bridge_host = __esm({
             return;
           }
         }
-        const resolved = import_path4.default.resolve(baseDir, "." + rel);
-        const baseWithSep = baseDir.endsWith(import_path4.default.sep) ? baseDir : baseDir + import_path4.default.sep;
+        const resolved = import_path3.default.resolve(baseDir, "." + rel);
+        const baseWithSep = baseDir.endsWith(import_path3.default.sep) ? baseDir : baseDir + import_path3.default.sep;
         if (!resolved.startsWith(baseWithSep) && resolved !== baseDir) {
           res.writeHead(403);
           res.end("forbidden");
           return;
         }
-        import_fs4.default.realpath(resolved, (realErr, realResolved) => {
+        import_fs3.default.realpath(resolved, (realErr, realResolved) => {
           const servePath = realErr ? resolved : realResolved;
-          const servePathWithSep = servePath.endsWith(import_path4.default.sep) ? servePath : servePath + import_path4.default.sep;
+          const servePathWithSep = servePath.endsWith(import_path3.default.sep) ? servePath : servePath + import_path3.default.sep;
           if (!realErr) {
             const realBaseWithSep = (() => {
               try {
-                const rb = import_fs4.default.realpathSync(baseDir);
-                return rb.endsWith(import_path4.default.sep) ? rb : rb + import_path4.default.sep;
+                const rb = import_fs3.default.realpathSync(baseDir);
+                return rb.endsWith(import_path3.default.sep) ? rb : rb + import_path3.default.sep;
               } catch {
                 return baseWithSep;
               }
             })();
-            if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path4.default.sep !== realBaseWithSep) {
+            if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path3.default.sep !== realBaseWithSep) {
               res.writeHead(403);
               res.end("forbidden");
               return;
             }
           }
-          import_fs4.default.stat(servePath, (err, stats) => {
+          import_fs3.default.stat(servePath, (err, stats) => {
             if (err || !stats?.isFile()) {
-              const ext2 = import_path4.default.extname(rel).toLowerCase();
+              const ext2 = import_path3.default.extname(rel).toLowerCase();
               if (ext2 && ext2 !== ".html") {
                 res.writeHead(404);
                 res.end("not found");
@@ -14685,8 +14773,8 @@ var init_bridge_host = __esm({
                 res.end("not found");
                 return;
               }
-              const indexPath = import_path4.default.join(baseDir, "index.html");
-              import_fs4.default.readFile(indexPath, (err2, data) => {
+              const indexPath = import_path3.default.join(baseDir, "index.html");
+              import_fs3.default.readFile(indexPath, (err2, data) => {
                 if (err2) {
                   res.writeHead(404);
                   res.end("not found");
@@ -14706,7 +14794,7 @@ var init_bridge_host = __esm({
               });
               return;
             }
-            const ext = import_path4.default.extname(servePath).toLowerCase();
+            const ext = import_path3.default.extname(servePath).toLowerCase();
             const contentType = HTTP_MIME_TYPES[ext] || "application/octet-stream";
             res.writeHead(200, {
               "Content-Type": contentType,
@@ -14717,7 +14805,7 @@ var init_bridge_host = __esm({
               return;
             }
             if (ext === ".html") {
-              import_fs4.default.readFile(servePath, (readErr, data) => {
+              import_fs3.default.readFile(servePath, (readErr, data) => {
                 if (readErr) {
                   try {
                     res.end();
@@ -14731,7 +14819,7 @@ var init_bridge_host = __esm({
               });
               return;
             }
-            const stream = import_fs4.default.createReadStream(servePath);
+            const stream = import_fs3.default.createReadStream(servePath);
             stream.pipe(res);
             stream.on("error", () => {
               try {
@@ -14937,7 +15025,7 @@ var init_bridge_host = __esm({
         const target = `${filePath}${loc}`;
         const trySpawn = (cmd, args) => new Promise((resolve5) => {
           try {
-            const child = (0, import_child_process4.spawn)(cmd, args, { detached: true, stdio: "ignore" });
+            const child = (0, import_child_process3.spawn)(cmd, args, { detached: true, stdio: "ignore" });
             let settled = false;
             child.on("error", () => {
               if (settled) return;
@@ -15439,7 +15527,7 @@ function buildComm() {
   if (process.platform === "linux") {
     return (pid) => {
       try {
-        return (0, import_fs5.readFileSync)(`/proc/${pid}/comm`, "utf8").trim() || null;
+        return (0, import_fs4.readFileSync)(`/proc/${pid}/comm`, "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -15468,7 +15556,7 @@ function build() {
 function buildLinux() {
   return (pid) => {
     try {
-      const raw = (0, import_fs5.readFileSync)(`/proc/${pid}/stat`, "utf8");
+      const raw = (0, import_fs4.readFileSync)(`/proc/${pid}/stat`, "utf8");
       const end = raw.lastIndexOf(")");
       if (end < 0) return null;
       const rest = raw.slice(end + 1).trim().split(/\s+/);
@@ -15532,7 +15620,7 @@ function tryBuildDarwinCommFfi() {
 function buildDarwinLsofComm() {
   return (pid) => {
     try {
-      const out = (0, import_child_process5.execFileSync)("lsof", ["-R", "-p", String(pid), "-d", "cwd", "-a"], {
+      const out = (0, import_child_process4.execFileSync)("lsof", ["-R", "-p", String(pid), "-d", "cwd", "-a"], {
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["ignore", "pipe", "ignore"]
@@ -15549,7 +15637,7 @@ function buildDarwinLsofComm() {
 function buildDarwinLsof() {
   return (pid) => {
     try {
-      const out = (0, import_child_process5.execFileSync)("lsof", ["-R", "-p", String(pid), "-d", "cwd", "-a"], {
+      const out = (0, import_child_process4.execFileSync)("lsof", ["-R", "-p", String(pid), "-d", "cwd", "-a"], {
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["ignore", "pipe", "ignore"]
@@ -15564,12 +15652,12 @@ function buildDarwinLsof() {
     }
   };
 }
-var import_child_process5, import_fs5, import_module, cached3, cachedComm, PROC_PIDTBSDINFO, PROC_BSDINFO_SIZE, PBI_PPID_OFFSET, PBI_COMM_OFFSET, PBI_COMM_LEN;
+var import_child_process4, import_fs4, import_module, cached3, cachedComm, PROC_PIDTBSDINFO, PROC_BSDINFO_SIZE, PBI_PPID_OFFSET, PBI_COMM_OFFSET, PBI_COMM_LEN;
 var init_parent_pid = __esm({
   "cli/parent-pid.ts"() {
     "use strict";
-    import_child_process5 = require("child_process");
-    import_fs5 = require("fs");
+    import_child_process4 = require("child_process");
+    import_fs4 = require("fs");
     import_module = require("module");
     cached3 = null;
     cachedComm = null;
@@ -15614,18 +15702,18 @@ function getCliIdentityKey() {
 }
 function getCurrentSimPath() {
   if (process.env[CURRENT_SIM_PATH_ENV]) {
-    return (0, import_path5.resolve)(process.env[CURRENT_SIM_PATH_ENV]);
+    return (0, import_path4.resolve)(process.env[CURRENT_SIM_PATH_ENV]);
   }
   const key = getCliIdentityKey();
-  return (0, import_path5.join)((0, import_os2.tmpdir)(), `sootsim-current-sim-${key}.json`);
+  return (0, import_path4.join)((0, import_os2.tmpdir)(), `sootsim-current-sim-${key}.json`);
 }
 function readCurrentSim() {
   const filepath = getCurrentSimPath();
-  if (!(0, import_fs6.existsSync)(filepath)) return null;
+  if (!(0, import_fs5.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_fs6.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_fs5.readFileSync)(filepath, "utf8"));
     if (parsed.version !== CURRENT_SIM_VERSION || typeof parsed.simId !== "string" || !parsed.simId.trim() || typeof parsed.updatedAt !== "string") {
-      (0, import_fs6.rmSync)(filepath, { force: true });
+      (0, import_fs5.rmSync)(filepath, { force: true });
       return null;
     }
     return {
@@ -15634,7 +15722,7 @@ function readCurrentSim() {
       updatedAt: parsed.updatedAt
     };
   } catch {
-    (0, import_fs6.rmSync)(filepath, { force: true });
+    (0, import_fs5.rmSync)(filepath, { force: true });
     return null;
   }
 }
@@ -15642,15 +15730,15 @@ function readCurrentSimId() {
   return readCurrentSim()?.simId || null;
 }
 function clearCurrentSimId() {
-  (0, import_fs6.rmSync)(getCurrentSimPath(), { force: true });
+  (0, import_fs5.rmSync)(getCurrentSimPath(), { force: true });
 }
-var import_fs6, import_os2, import_path5, CURRENT_SIM_VERSION, CURRENT_SIM_PATH_ENV, IDENTITY_ENV_VARS, IMMORTAL_HOST_COMM_RE;
+var import_fs5, import_os2, import_path4, CURRENT_SIM_VERSION, CURRENT_SIM_PATH_ENV, IDENTITY_ENV_VARS, IMMORTAL_HOST_COMM_RE;
 var init_current_sim = __esm({
   "cli/current-sim.ts"() {
     "use strict";
-    import_fs6 = require("fs");
+    import_fs5 = require("fs");
     import_os2 = require("os");
-    import_path5 = require("path");
+    import_path4 = require("path");
     init_parent_pid();
     CURRENT_SIM_VERSION = 1;
     CURRENT_SIM_PATH_ENV = "SOOTSIM_CLI_CURRENT_SIM_PATH";
@@ -16091,11 +16179,11 @@ async function evalInBridge(bridge, code, opts = {}) {
   if (opts.acquireLock) payload.acquireLock = true;
   return bridge.send(payload);
 }
-async function callInBridge(bridge, path11, ...args) {
-  return bridge.send({ type: "call", path: path11, args });
+async function callInBridge(bridge, path12, ...args) {
+  return bridge.send({ type: "call", path: path12, args });
 }
-async function callInBridgeWrite(bridge, path11, ...args) {
-  return bridge.send({ type: "call", path: path11, args, acquireLock: true });
+async function callInBridgeWrite(bridge, path12, ...args) {
+  return bridge.send({ type: "call", path: path12, args, acquireLock: true });
 }
 var import_ws3, resolvedWorld, BridgeSimLockedError;
 var init_ws_bridge = __esm({
@@ -17091,7 +17179,7 @@ function executeSyncHttp(url, method, params) {
       delete childEnv[key];
     }
   }
-  const child = (0, import_child_process6.spawnSync)(process.execPath, ["-e", HTTP_CHILD_SRC], {
+  const child = (0, import_child_process5.spawnSync)(process.execPath, ["-e", HTTP_CHILD_SRC], {
     input: JSON.stringify({ url, method, headers: params?.headers, body: params?.body }),
     encoding: "utf8",
     timeout: HTTP_TIMEOUT_MS,
@@ -17138,11 +17226,11 @@ function scriptConditionIsTruthy(value) {
   if (!Number.isNaN(num) && num === 0) return false;
   return true;
 }
-var import_child_process6, vm, HTTP_TIMEOUT_MS, HTTP_CHILD_SRC, TEMPLATE_RE, ESCAPED_TEMPLATE_RE, BARE_IDENTIFIER_RE, MaestroJsContext;
+var import_child_process5, vm, HTTP_TIMEOUT_MS, HTTP_CHILD_SRC, TEMPLATE_RE, ESCAPED_TEMPLATE_RE, BARE_IDENTIFIER_RE, MaestroJsContext;
 var init_maestro_js = __esm({
   "cli/maestro-js.ts"() {
     "use strict";
-    import_child_process6 = require("child_process");
+    import_child_process5 = require("child_process");
     vm = __toESM(require("vm"), 1);
     HTTP_TIMEOUT_MS = 3e5;
     HTTP_CHILD_SRC = `
@@ -17322,14 +17410,14 @@ process.stdin.on('end', async () => {
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path6.dirname)((0, import_node_path6.resolve)(explicit));
+    return (0, import_node_path8.dirname)((0, import_node_path8.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path6.resolve)(explicit);
-  return (0, import_node_path6.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path8.resolve)(explicit);
+  return (0, import_node_path8.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -17375,26 +17463,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs7.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs9.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs7.rmSync)(filepath, { force: true });
+      (0, import_node_fs9.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs7.rmSync)(filepath, { force: true });
+    (0, import_node_fs9.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs7, import_node_path6, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs9, import_node_path8, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs7 = require("node:fs");
-    import_node_path6 = require("node:path");
+    import_node_fs9 = require("node:fs");
+    import_node_path8 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;
     SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
@@ -17670,16 +17758,16 @@ function resolveFlowScreenshotPath(screenshotDir, name) {
 }
 function resolveProjectRelativeFlowBase(flowDir) {
   if (!flowDir) return process.cwd();
-  return path9.basename(flowDir) === ".maestro" ? path9.dirname(flowDir) : flowDir;
+  return path10.basename(flowDir) === ".maestro" ? path10.dirname(flowDir) : flowDir;
 }
 function resolveFlowScreenshotPathWithMode(screenshotDir, name, opts) {
   const normalizedName = name.endsWith(".png") ? name : `${name}.png`;
-  if (path9.isAbsolute(normalizedName)) return normalizedName;
+  if (path10.isAbsolute(normalizedName)) return normalizedName;
   if (opts.mode === "flow" && /[\\/]/.test(normalizedName)) {
     const baseDir = normalizedName.startsWith("./") || normalizedName.startsWith("../") ? opts.flowDir ?? process.cwd() : resolveProjectRelativeFlowBase(opts.flowDir);
-    return path9.resolve(baseDir, normalizedName);
+    return path10.resolve(baseDir, normalizedName);
   }
-  return path9.join(screenshotDir, normalizedName);
+  return path10.join(screenshotDir, normalizedName);
 }
 function normalizeFlowScreenshotSpec(step) {
   if (typeof step === "string") {
@@ -17736,12 +17824,12 @@ function parseFlowSteps(content) {
   const parsed = import_yaml.default.parse(candidate);
   return Array.isArray(parsed) ? parsed : [];
 }
-var fs9, path9, import_settings2, import_yaml, DEFAULT_TIMEOUT, FLOW_TIMEOUT_SCALE, scaledTimeout, SCREEN_W, SCREEN_H, SootSimBridgeFlowRunner;
+var fs10, path10, import_settings2, import_yaml, DEFAULT_TIMEOUT, FLOW_TIMEOUT_SCALE, scaledTimeout, SCREEN_W, SCREEN_H, SootSimBridgeFlowRunner;
 var init_bridge_flow_runner = __esm({
   "cli/bridge-flow-runner.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs"), 1);
-    path9 = __toESM(require("path"), 1);
+    fs10 = __toESM(require("fs"), 1);
+    path10 = __toESM(require("path"), 1);
     import_settings2 = require("sootsim-engine/settings");
     import_yaml = __toESM(require("yaml"), 1);
     init_frame_compose();
@@ -18029,14 +18117,14 @@ var init_bridge_flow_runner = __esm({
         if (chunks.length === 0) {
           throw new Error("recording requested but no video buffer was produced");
         }
-        fs9.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
+        fs10.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
         const videoMime = stopped.mime || this.opts.recordingFormat || "video/webm";
         const extension = videoMime.includes("mp4") ? "mp4" : "webm";
-        const outputPath = path9.join(
+        const outputPath = path10.join(
           this.opts.recordingOutputDir,
           `sootsim-${Date.now()}.${extension}`
         );
-        fs9.writeFileSync(outputPath, Buffer.concat(chunks));
+        fs10.writeFileSync(outputPath, Buffer.concat(chunks));
         return outputPath;
       }
       async waitForRecordingTail(opts) {
@@ -18545,7 +18633,7 @@ var init_bridge_flow_runner = __esm({
             flowDir: this.opts.flowDir
           }
         );
-        fs9.mkdirSync(path9.dirname(outputPath), { recursive: true });
+        fs10.mkdirSync(path10.dirname(outputPath), { recursive: true });
         const layers = spec.layers ?? this.opts.screenshotLayers;
         const screenshotRequest = {
           type: "screenshot",
@@ -18561,11 +18649,11 @@ var init_bridge_flow_runner = __esm({
             throw new Error("could not read current device model for framed screenshot");
           }
           const framed = await composeFramedScreenshot(rawBuffer, model);
-          fs9.writeFileSync(outputPath, framed);
+          fs10.writeFileSync(outputPath, framed);
           console.log(`[flow] screenshot: ${outputPath} (frame: ${model})`);
           return outputPath;
         }
-        fs9.writeFileSync(outputPath, rawBuffer);
+        fs10.writeFileSync(outputPath, rawBuffer);
         console.log(`[flow] screenshot: ${outputPath}`);
         return outputPath;
       }
@@ -18581,22 +18669,22 @@ var init_bridge_flow_runner = __esm({
         return model;
       }
       async captureScreenshot(outputPath) {
-        fs9.mkdirSync(path9.dirname(outputPath), { recursive: true });
+        fs10.mkdirSync(path10.dirname(outputPath), { recursive: true });
         const dataUrl = await this.bridge.send({
           type: "screenshot",
           simId: this.opts.simId
         });
         const base64 = dataUrl.replace(/^data:image\/png;base64,/, "");
-        fs9.writeFileSync(outputPath, Buffer.from(base64, "base64"));
+        fs10.writeFileSync(outputPath, Buffer.from(base64, "base64"));
       }
       // writes a per-failure debug bundle: screenshot + structured describe
       // + a11y tree + console errors/warnings + failed network requests +
       // shell state, all under one directory so post-mortem is one grep away.
       async captureFailureBundle(outputDir, context) {
-        fs9.mkdirSync(outputDir, { recursive: true });
+        fs10.mkdirSync(outputDir, { recursive: true });
         const write = (name, content) => {
           try {
-            fs9.writeFileSync(path9.join(outputDir, name), content);
+            fs10.writeFileSync(path10.join(outputDir, name), content);
           } catch {
           }
         };
@@ -19138,8 +19226,8 @@ var init_bridge_flow_runner = __esm({
       runScript(target) {
         const spec = typeof target === "string" ? { file: target } : target;
         if (!spec.file) throw new Error("runScript requires a file");
-        const scriptPath = path9.resolve(this.opts.flowDir, spec.file);
-        const source = fs9.readFileSync(scriptPath, "utf8");
+        const scriptPath = path10.resolve(this.opts.flowDir, spec.file);
+        const source = fs10.readFileSync(scriptPath, "utf8");
         this.js.evaluate(source, { env: spec.env });
         console.log(`[flow]   runScript: ${spec.file} done`);
       }
@@ -19433,10 +19521,10 @@ var init_bridge_flow_runner = __esm({
               for (const [k, v] of Object.entries(env)) this.js.putEnv(k, v);
             }
             if (file) {
-              const flowPath = path9.resolve(this.opts.flowDir, file);
-              const flowContent = fs9.readFileSync(flowPath, "utf8");
+              const flowPath = path10.resolve(this.opts.flowDir, file);
+              const flowContent = fs10.readFileSync(flowPath, "utf8");
               const previousDir = this.opts.flowDir;
-              this.opts.flowDir = path9.dirname(flowPath);
+              this.opts.flowDir = path10.dirname(flowPath);
               try {
                 await this.runFlow(parseFlowSteps(flowContent));
               } finally {
@@ -19591,8 +19679,8 @@ __export(registry_exports, {
   skillRegistry: () => skillRegistry
 });
 module.exports = __toCommonJS(registry_exports);
-var fs10 = __toESM(require("fs"), 1);
-var path10 = __toESM(require("path"), 1);
+var fs11 = __toESM(require("fs"), 1);
+var path11 = __toESM(require("path"), 1);
 
 // src/skills/builtin/a11y-review.ts
 init_reap_browser();
@@ -19611,8 +19699,8 @@ var skill = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path11 = await import("path");
-        const fs11 = await import("fs");
+        const path12 = await import("path");
+        const fs12 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -19667,9 +19755,9 @@ var skill = {
             warnings: issues.filter((i) => i.severity === "warning").length,
             tree: typeof tree === "string" ? tree : JSON.stringify(tree)
           };
-          const reportPath = path11.join(context.outputDir, "a11y-report.json");
-          fs11.mkdirSync(path11.dirname(reportPath), { recursive: true });
-          fs11.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path12.join(context.outputDir, "a11y-report.json");
+          fs12.mkdirSync(path12.dirname(reportPath), { recursive: true });
+          fs12.writeFileSync(reportPath, JSON.stringify(report, null, 2));
           return {
             success: issues.filter((i) => i.severity === "error").length === 0,
             message: `${report.errors} errors, ${report.warnings} warnings across ${report.nodeCount} nodes`,
@@ -19707,8 +19795,8 @@ var skill2 = {
         }
       },
       async execute(params, context) {
-        const fs11 = await import("fs");
-        const path11 = await import("path");
+        const fs12 = await import("fs");
+        const path12 = await import("path");
         const { POLYFILL_REGISTRY: POLYFILL_REGISTRY2 } = await Promise.resolve().then(() => (init_web(), web_exports));
         if (params.packageName) {
           const entry = POLYFILL_REGISTRY2[params.packageName];
@@ -19726,11 +19814,11 @@ var skill2 = {
             data: { package: params.packageName, status, ...entry }
           };
         }
-        const pkgPath = path11.join(context.projectDir, "package.json");
-        if (!fs11.existsSync(pkgPath)) {
+        const pkgPath = path12.join(context.projectDir, "package.json");
+        if (!fs12.existsSync(pkgPath)) {
           return { success: false, message: "No package.json found" };
         }
-        const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf8"));
+        const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf8"));
         const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
         const results = {
           full: [],
@@ -19748,9 +19836,9 @@ var skill2 = {
             results.unknown.push(dep);
           }
         }
-        const reportPath = path11.join(context.outputDir, "compat-report.json");
-        fs11.mkdirSync(path11.dirname(reportPath), { recursive: true });
-        fs11.writeFileSync(reportPath, JSON.stringify(results, null, 2));
+        const reportPath = path12.join(context.outputDir, "compat-report.json");
+        fs12.mkdirSync(path12.dirname(reportPath), { recursive: true });
+        fs12.writeFileSync(reportPath, JSON.stringify(results, null, 2));
         return {
           success: results.unsupported.length === 0,
           message: `${results.full.length} full, ${results.partial.length} partial, ${results.unsupported.length} unsupported, ${results.unknown.length} unknown`,
@@ -19788,8 +19876,8 @@ var skill3 = {
         record: { type: "boolean", description: "Record video of the flow" }
       },
       async execute(params, context) {
-        const fs11 = await import("fs");
-        const path11 = await import("path");
+        const fs12 = await import("fs");
+        const path12 = await import("path");
         const yaml2 = await import("yaml");
         const { DEFAULT_SOOTSIM_BRIDGE_PORT: DEFAULT_SOOTSIM_BRIDGE_PORT2 } = await Promise.resolve().then(() => (init_bridge_constants(), bridge_constants_exports));
         const { SootSimBridgeHost: SootSimBridgeHost2 } = await Promise.resolve().then(() => (init_bridge_host(), bridge_host_exports));
@@ -19798,7 +19886,7 @@ var skill3 = {
         const host = new SootSimBridgeHost2({ port: DEFAULT_SOOTSIM_BRIDGE_PORT2 });
         host.start({ silent: true });
         try {
-          const flowContent = fs11.readFileSync(params.flowPath, "utf8");
+          const flowContent = fs12.readFileSync(params.flowPath, "utf8");
           const fmMatch = flowContent.match(/^---\n([\s\S]*?)\n---\n?/);
           const stepsBody = fmMatch ? flowContent.slice(fmMatch[0].length) : flowContent;
           const steps = yaml2.parse(stepsBody);
@@ -19823,7 +19911,7 @@ var skill3 = {
           });
           const driver = new SootSimBridgeFlowRunner2(bridge, {
             screenshotDir: context.outputDir,
-            flowDir: path11.dirname(path11.resolve(params.flowPath)),
+            flowDir: path12.dirname(path12.resolve(params.flowPath)),
             simId,
             recordingOutputDir: params.record ? context.outputDir : void 0
           });
@@ -19845,7 +19933,7 @@ var skill3 = {
                 simId,
                 videoPath: videoPath || void 0
               },
-              artifacts: videoPath ? [{ type: "video", name: path11.basename(videoPath), path: videoPath }] : void 0
+              artifacts: videoPath ? [{ type: "video", name: path12.basename(videoPath), path: videoPath }] : void 0
             };
           } finally {
             try {
@@ -19892,8 +19980,8 @@ var skill4 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path11 = await import("path");
-        const fs11 = await import("fs");
+        const path12 = await import("path");
+        const fs12 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -19919,9 +20007,9 @@ var skill4 = {
             ...profile,
             fps: syncCount > 0 ? (syncCount / (duration / 1e3)).toFixed(1) : "0"
           };
-          const reportPath = path11.join(context.outputDir, "perf-report.json");
-          fs11.mkdirSync(path11.dirname(reportPath), { recursive: true });
-          fs11.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path12.join(context.outputDir, "perf-report.json");
+          fs12.mkdirSync(path12.dirname(reportPath), { recursive: true });
+          fs12.writeFileSync(reportPath, JSON.stringify(report, null, 2));
           return {
             success: true,
             message: `${report.fps} fps, ${profile.avgSyncMs?.toFixed(1)}ms avg sync, ${nodeCount} nodes`,
@@ -19954,8 +20042,8 @@ var skill5 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path11 = await import("path");
-        const fs11 = await import("fs");
+        const path12 = await import("path");
+        const fs12 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -19963,8 +20051,8 @@ var skill5 = {
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const outputPath = path11.join(context.outputDir, `${params.name}.png`);
-          fs11.mkdirSync(path11.dirname(outputPath), { recursive: true });
+          const outputPath = path12.join(context.outputDir, `${params.name}.png`);
+          fs12.mkdirSync(path12.dirname(outputPath), { recursive: true });
           await page.screenshot({ path: outputPath });
           return {
             success: true,
@@ -20005,8 +20093,8 @@ var skill6 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path11 = await import("path");
-        const fs11 = await import("fs");
+        const path12 = await import("path");
+        const fs12 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -20014,14 +20102,14 @@ var skill6 = {
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const currentPath = path11.join(context.outputDir, `${params.name}-current.png`);
-          fs11.mkdirSync(path11.dirname(currentPath), { recursive: true });
+          const currentPath = path12.join(context.outputDir, `${params.name}-current.png`);
+          fs12.mkdirSync(path12.dirname(currentPath), { recursive: true });
           await page.screenshot({ path: currentPath });
           try {
             const { PNG } = await import("pngjs");
             const pixelmatch = (await import("pixelmatch")).default;
-            const baseline = PNG.sync.read(fs11.readFileSync(params.baseline));
-            const current = PNG.sync.read(fs11.readFileSync(currentPath));
+            const baseline = PNG.sync.read(fs12.readFileSync(params.baseline));
+            const current = PNG.sync.read(fs12.readFileSync(currentPath));
             const { width, height } = baseline;
             const diff = new PNG({ width, height });
             const numDiffPixels = pixelmatch(
@@ -20032,8 +20120,8 @@ var skill6 = {
               height,
               { threshold: params.threshold || 0.1 }
             );
-            const diffPath = path11.join(context.outputDir, `${params.name}-diff.png`);
-            fs11.writeFileSync(diffPath, PNG.sync.write(diff));
+            const diffPath = path12.join(context.outputDir, `${params.name}-diff.png`);
+            fs12.writeFileSync(diffPath, PNG.sync.write(diff));
             const totalPixels = width * height;
             const diffPercent = (numDiffPixels / totalPixels * 100).toFixed(2);
             return {
@@ -20097,10 +20185,10 @@ var skillRegistry = {
   },
   // load skills from a project manifest (sootsim-skills.json)
   async loadFromManifest(projectDir) {
-    const manifestPath = path10.join(projectDir, "sootsim-skills.json");
-    if (!fs10.existsSync(manifestPath)) return;
+    const manifestPath = path11.join(projectDir, "sootsim-skills.json");
+    if (!fs11.existsSync(manifestPath)) return;
     try {
-      const manifest = JSON.parse(fs10.readFileSync(manifestPath, "utf8"));
+      const manifest = JSON.parse(fs11.readFileSync(manifestPath, "utf8"));
       if (Array.isArray(manifest.skills)) {
         for (const entry of manifest.skills) {
           if (typeof entry === "string") {
@@ -20111,7 +20199,7 @@ var skillRegistry = {
             }
           } else if (entry.file) {
             try {
-              const mod = await import(path10.resolve(projectDir, entry.file));
+              const mod = await import(path11.resolve(projectDir, entry.file));
               if (mod.skill) this.register(mod.skill);
             } catch {
             }
@@ -20124,10 +20212,10 @@ var skillRegistry = {
   // auto-discover skills based on project dependencies
   suggestSkills(projectDir) {
     const suggestions = [];
-    const pkgPath = path10.join(projectDir, "package.json");
-    if (!fs10.existsSync(pkgPath)) return suggestions;
+    const pkgPath = path11.join(projectDir, "package.json");
+    if (!fs11.existsSync(pkgPath)) return suggestions;
     try {
-      const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps["detox"] || deps["maestro"]) {
         suggestions.push("maestro-test");