sootsim 0.1.185 → 0.1.186

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.185 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.186 | (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;
@@ -10119,10 +10119,10 @@ function tcpPing(port, timeout = TCP_GATE_MS) {
     sock.connect(port, "localhost");
   });
 }
-function httpGet(port, path10, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(port, path11, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve6) => {
     const req = import_http.default.request(
-      { hostname: "localhost", port, path: path10, method, timeout, headers },
+      { hostname: "localhost", port, path: path11, method, timeout, headers },
       (res) => {
         let body = "";
         res.on("data", (c) => body += c.toString());
@@ -10580,27 +10580,6 @@ function sootsimHomeDir() {
   if (override && override.length > 0) return import_node_path.default.resolve(override);
   return import_node_path.default.join((0, import_node_os.homedir)(), ".sootsim");
 }
-function isSootsimDevCheckout() {
-  if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === "1") return false;
-  const env = process.env.SOOTSIM_DEV;
-  if (env === "1" || env === "true") return true;
-  if (env === "0" || env === "false") return false;
-  const argv1 = process.argv[1];
-  if (!argv1) return false;
-  try {
-    const real = import_node_fs2.default.realpathSync(argv1);
-    return real.includes(`${import_node_path.default.sep}packages${import_node_path.default.sep}sootsim${import_node_path.default.sep}`);
-  } catch {
-    return false;
-  }
-}
-function isDevWorkstation() {
-  if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === "1") return false;
-  return process.env.IS_TAMAGUI_DEV === "1";
-}
-function shouldSkipPersistentDaemon() {
-  return isSootsimDevCheckout() || isDevWorkstation();
-}
 function runtimesDir() {
   return import_node_path.default.join(sootsimHomeDir(), "runtimes");
 }
@@ -10741,7 +10720,7 @@ function readDevBridgeLockfile() {
       const bytesRead = import_node_fs2.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
       const raw = buf.subarray(0, bytesRead).toString("utf8");
       const parsed = JSON.parse(raw);
-      if (parsed && parsed.schema === 1 && parsed.source === "vite-dev" && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.cwd === "string" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number") {
+      if (parsed && parsed.schema === 1 && parsed.source === "vite-dev" && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.cwd === "string" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.shellPort === void 0 || typeof parsed.shellPort === "number")) {
         return parsed;
       }
       return null;
@@ -10824,10 +10803,45 @@ var init_home_paths = __esm({
   }
 });
 
+// src/runtime-assets.ts
+function findMonorepoRoot() {
+  if (_monorepoRootCache !== void 0) return _monorepoRootCache;
+  let dir = import_path.default.dirname((0, import_url.fileURLToPath)(__sootsim_import_meta_url));
+  for (let i = 0; i < 12 && dir !== import_path.default.dirname(dir); i++) {
+    if (import_fs.default.existsSync(import_path.default.join(dir, "packages/sootsim-engine/package.json")) && import_fs.default.existsSync(import_path.default.join(dir, "public/sootsim"))) {
+      _monorepoRootCache = dir;
+      return dir;
+    }
+    dir = import_path.default.dirname(dir);
+  }
+  _monorepoRootCache = null;
+  return null;
+}
+function resolveDevCheckoutRuntimeRoot() {
+  if (process.env.SOOTSIM_HOME && readActiveRuntime()) return null;
+  const root = findMonorepoRoot();
+  if (!root) return null;
+  const devBuild = import_path.default.join(root, "public/sootsim");
+  if (import_fs.default.existsSync(import_path.default.join(devBuild, "index.html")) && import_fs.default.existsSync(import_path.default.join(devBuild, "engine/index.html")) && import_fs.default.existsSync(import_path.default.join(devBuild, "engine-tenant/worker.js"))) {
+    return devBuild;
+  }
+  return null;
+}
+var import_fs, import_path, import_url, _monorepoRootCache;
+var init_runtime_assets = __esm({
+  "src/runtime-assets.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"), 1);
+    import_path = __toESM(require("path"), 1);
+    import_url = require("url");
+    init_home_paths();
+  }
+});
+
 // src/runtime-delivery.ts
 function readConfig() {
   try {
-    const parsed = JSON.parse(import_fs.default.readFileSync(configFilePath(), "utf8"));
+    const parsed = JSON.parse(import_fs2.default.readFileSync(configFilePath(), "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -10881,7 +10895,7 @@ async function installRuntime(opts = {}) {
   const { version, channel, entry } = resolveRuntimeVersion(manifest, opts);
   const destDir = runtimeDir(version);
   const setActive = opts.setActive !== false;
-  if (!opts.force && import_fs.default.existsSync(import_path.default.join(destDir, "index.html"))) {
+  if (!opts.force && import_fs2.default.existsSync(import_path2.default.join(destDir, "index.html"))) {
     if (setActive) writeActiveRuntime(version);
     return {
       version,
@@ -10894,7 +10908,7 @@ async function installRuntime(opts = {}) {
     };
   }
   const tarUrl = entry.tarball || runtimeTarballUrl(version, cdnOrigin);
-  const tarCachePath = import_path.default.join(cacheDir(), `sootsim-runtime-${version}.tar.gz`);
+  const tarCachePath = import_path2.default.join(cacheDir(), `sootsim-runtime-${version}.tar.gz`);
   process.stderr.write(`sootsim: downloading runtime ${version}\u2026
 `);
   await downloadToFile(tarUrl, tarCachePath);
@@ -10902,23 +10916,23 @@ async function installRuntime(opts = {}) {
 `);
   const actualSha = await sha256File(tarCachePath);
   if (actualSha !== entry.sha256) {
-    import_fs.default.rmSync(tarCachePath, { force: true });
+    import_fs2.default.rmSync(tarCachePath, { force: true });
     throw new Error(
       `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
     );
   }
-  const tmpDir = import_path.default.join(import_path.default.dirname(destDir), `.installing-${version}-${process.pid}`);
-  import_fs.default.rmSync(tmpDir, { recursive: true, force: true });
-  import_fs.default.mkdirSync(tmpDir, { recursive: true });
+  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_fs.default.existsSync(import_path.default.join(tmpDir, "index.html"))) {
+    if (!import_fs2.default.existsSync(import_path2.default.join(tmpDir, "index.html"))) {
       throw new Error(`extracted tarball for runtime ${version} is missing index.html`);
     }
-    import_fs.default.rmSync(destDir, { recursive: true, force: true });
-    import_fs.default.renameSync(tmpDir, destDir);
+    import_fs2.default.rmSync(destDir, { recursive: true, force: true });
+    import_fs2.default.renameSync(tmpDir, destDir);
   } catch (err) {
-    import_fs.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_fs2.default.rmSync(tmpDir, { recursive: true, force: true });
     throw err;
   }
   if (setActive) writeActiveRuntime(version);
@@ -10958,7 +10972,7 @@ async function updateRuntimeToLatest(opts = {}) {
   }
   const activeVersion = readActiveRuntime();
   const activeDir = activeVersion ? runtimeDir(activeVersion) : null;
-  const activeInstalled = activeDir ? import_fs.default.existsSync(import_path.default.join(activeDir, "index.html")) : false;
+  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 {
@@ -10988,17 +11002,17 @@ async function downloadToFile(url, destPath) {
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  import_fs.default.mkdirSync(import_path.default.dirname(destPath), { recursive: true });
+  import_fs2.default.mkdirSync(import_path2.default.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.partial`;
   try {
     await (0, import_promises.pipeline)(
       import_stream.Readable.fromWeb(res.body),
-      import_fs.default.createWriteStream(tmp)
+      import_fs2.default.createWriteStream(tmp)
     );
-    import_fs.default.renameSync(tmp, destPath);
+    import_fs2.default.renameSync(tmp, destPath);
   } catch (err) {
     try {
-      import_fs.default.unlinkSync(tmp);
+      import_fs2.default.unlinkSync(tmp);
     } catch {
     }
     throw err;
@@ -11007,7 +11021,7 @@ async function downloadToFile(url, destPath) {
 function sha256File(filePath) {
   return new Promise((resolve6, reject) => {
     const hash = import_crypto.default.createHash("sha256");
-    const stream = import_fs.default.createReadStream(filePath);
+    const stream = import_fs2.default.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve6(hash.digest("hex")));
@@ -11025,14 +11039,14 @@ function extractTarball(tarPath, destDir) {
     });
   });
 }
-var import_child_process2, import_crypto, import_fs, import_path, import_stream, import_promises, DEFAULT_RUNTIME_CDN_ORIGIN, RUNTIME_CDN_ORIGIN_ENV, RUNTIME_CHANNEL_ENV;
+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;
 var init_runtime_delivery = __esm({
   "src/runtime-delivery.ts"() {
     "use strict";
     import_child_process2 = require("child_process");
     import_crypto = __toESM(require("crypto"), 1);
-    import_fs = __toESM(require("fs"), 1);
-    import_path = __toESM(require("path"), 1);
+    import_fs2 = __toESM(require("fs"), 1);
+    import_path2 = __toESM(require("path"), 1);
     import_stream = require("stream");
     import_promises = require("stream/promises");
     init_home_paths();
@@ -12647,12 +12661,12 @@ var init_fetch_proxy_handler = __esm({
 
 // src/host/open-url.ts
 function expandHome(candidate) {
-  return candidate.startsWith("~/") ? (0, import_path2.join)((0, import_os.homedir)(), candidate.slice(2)) : candidate;
+  return candidate.startsWith("~/") ? (0, import_path3.join)((0, import_os.homedir)(), candidate.slice(2)) : candidate;
 }
 function firstExisting(candidates) {
   for (const candidate of candidates) {
     const expanded = expandHome(candidate);
-    if ((0, import_fs2.existsSync)(expanded)) return expanded;
+    if ((0, import_fs3.existsSync)(expanded)) return expanded;
   }
   return null;
 }
@@ -12671,7 +12685,7 @@ function lookupExecutable(command, platform) {
 }
 function resolveChromiumBinary(platform = process.platform) {
   const envCandidate = process.env.CHROME_PATH || process.env.CHROMIUM_PATH;
-  if (envCandidate && (0, import_fs2.existsSync)(envCandidate)) return envCandidate;
+  if (envCandidate && (0, import_fs3.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;
@@ -12751,14 +12765,14 @@ async function launchUrl(url, options = {}) {
 async function openUrl(url, options = {}) {
   await launchUrl(url, options);
 }
-var import_child_process3, import_fs2, import_os, import_path2, MAC_CHROMIUM_CANDIDATES, LINUX_CHROMIUM_CANDIDATES, WINDOWS_CHROMIUM_CANDIDATES, UNIX_CHROMIUM_COMMANDS, WINDOWS_CHROMIUM_COMMANDS;
+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 init_open_url = __esm({
   "src/host/open-url.ts"() {
     "use strict";
     import_child_process3 = require("child_process");
-    import_fs2 = require("fs");
+    import_fs3 = require("fs");
     import_os = require("os");
-    import_path2 = require("path");
+    import_path3 = require("path");
     MAC_CHROMIUM_CANDIDATES = [
       "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
       "~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
@@ -13013,19 +13027,20 @@ function unrefTimer(timer) {
     timer.unref();
   }
 }
-var import_child_process4, 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 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 init_bridge_host = __esm({
   "src/host/bridge-host.ts"() {
     "use strict";
     import_child_process4 = require("child_process");
-    import_fs3 = __toESM(require("fs"), 1);
+    import_fs4 = __toESM(require("fs"), 1);
     import_http3 = require("http");
-    import_path3 = __toESM(require("path"), 1);
+    import_path4 = __toESM(require("path"), 1);
     import_ws2 = require("ws");
     init_dev_server_scanner();
     init_bridge_constants();
     init_cli_version();
     init_home_paths();
+    init_runtime_assets();
     init_runtime_delivery();
     init_agent_host();
     init_fetch_proxy_handler();
@@ -13118,6 +13133,7 @@ var init_bridge_host = __esm({
       automationSimActiveGraceMs;
       shouldWriteLockfile;
       shouldWriteDevLockfile;
+      getShellPort;
       sootbeanOrigin = null;
       effectivePort = 0;
       startedAt = 0;
@@ -13150,6 +13166,7 @@ var init_bridge_host = __esm({
         this.port = this.preferredPort;
         this.shouldWriteLockfile = opts.writeLockfile === true;
         this.shouldWriteDevLockfile = opts.writeDevLockfile === true;
+        this.getShellPort = opts.getShellPort ?? null;
         this.portFallbackCount = Math.max(1, opts.portFallbackCount ?? 10);
         this.openUrlHandler = opts.openUrl;
         this.agentHost = new AgentHost({
@@ -13755,12 +13772,14 @@ var init_bridge_host = __esm({
         };
       }
       buildDevLockfileSnapshot() {
+        const shellPort = this.getShellPort?.() ?? null;
         return {
           schema: 1,
           pid: process.pid,
           platform: process.platform,
           bridgePort: this.effectivePort,
           runtimePort: this.effectivePort,
+          ...shellPort && shellPort > 0 ? { shellPort } : {},
           cwd: process.cwd(),
           startedAt: this.startedAt,
           heartbeatAt: Date.now(),
@@ -13775,7 +13794,7 @@ var init_bridge_host = __esm({
       }
       refreshActiveRuntime() {
         this.activeRuntimeVersion = readActiveRuntime();
-        this.activeRuntimeDirPath = activeRuntimeDir();
+        this.activeRuntimeDirPath = resolveDevCheckoutRuntimeRoot() ?? activeRuntimeDir();
       }
       runServerScan() {
         if (this.inflightScan) return this.inflightScan;
@@ -14065,34 +14084,34 @@ var init_bridge_host = __esm({
             return;
           }
         }
-        const resolved = import_path3.default.resolve(baseDir, "." + rel);
-        const baseWithSep = baseDir.endsWith(import_path3.default.sep) ? baseDir : baseDir + import_path3.default.sep;
+        const resolved = import_path4.default.resolve(baseDir, "." + rel);
+        const baseWithSep = baseDir.endsWith(import_path4.default.sep) ? baseDir : baseDir + import_path4.default.sep;
         if (!resolved.startsWith(baseWithSep) && resolved !== baseDir) {
           res.writeHead(403);
           res.end("forbidden");
           return;
         }
-        import_fs3.default.realpath(resolved, (realErr, realResolved) => {
+        import_fs4.default.realpath(resolved, (realErr, realResolved) => {
           const servePath = realErr ? resolved : realResolved;
-          const servePathWithSep = servePath.endsWith(import_path3.default.sep) ? servePath : servePath + import_path3.default.sep;
+          const servePathWithSep = servePath.endsWith(import_path4.default.sep) ? servePath : servePath + import_path4.default.sep;
           if (!realErr) {
             const realBaseWithSep = (() => {
               try {
-                const rb = import_fs3.default.realpathSync(baseDir);
-                return rb.endsWith(import_path3.default.sep) ? rb : rb + import_path3.default.sep;
+                const rb = import_fs4.default.realpathSync(baseDir);
+                return rb.endsWith(import_path4.default.sep) ? rb : rb + import_path4.default.sep;
               } catch {
                 return baseWithSep;
               }
             })();
-            if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path3.default.sep !== realBaseWithSep) {
+            if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path4.default.sep !== realBaseWithSep) {
               res.writeHead(403);
               res.end("forbidden");
               return;
             }
           }
-          import_fs3.default.stat(servePath, (err, stats) => {
+          import_fs4.default.stat(servePath, (err, stats) => {
             if (err || !stats?.isFile()) {
-              const ext2 = import_path3.default.extname(rel).toLowerCase();
+              const ext2 = import_path4.default.extname(rel).toLowerCase();
               if (ext2 && ext2 !== ".html") {
                 res.writeHead(404);
                 res.end("not found");
@@ -14103,8 +14122,8 @@ var init_bridge_host = __esm({
                 res.end("not found");
                 return;
               }
-              const indexPath = import_path3.default.join(baseDir, "index.html");
-              import_fs3.default.readFile(indexPath, (err2, data) => {
+              const indexPath = import_path4.default.join(baseDir, "index.html");
+              import_fs4.default.readFile(indexPath, (err2, data) => {
                 if (err2) {
                   res.writeHead(404);
                   res.end("not found");
@@ -14124,7 +14143,7 @@ var init_bridge_host = __esm({
               });
               return;
             }
-            const ext = import_path3.default.extname(servePath).toLowerCase();
+            const ext = import_path4.default.extname(servePath).toLowerCase();
             const contentType = HTTP_MIME_TYPES[ext] || "application/octet-stream";
             res.writeHead(200, {
               "Content-Type": contentType,
@@ -14135,7 +14154,7 @@ var init_bridge_host = __esm({
               return;
             }
             if (ext === ".html") {
-              import_fs3.default.readFile(servePath, (readErr, data) => {
+              import_fs4.default.readFile(servePath, (readErr, data) => {
                 if (readErr) {
                   try {
                     res.end();
@@ -14149,7 +14168,7 @@ var init_bridge_host = __esm({
               });
               return;
             }
-            const stream = import_fs3.default.createReadStream(servePath);
+            const stream = import_fs4.default.createReadStream(servePath);
             stream.pipe(res);
             stream.on("error", () => {
               try {
@@ -14819,6 +14838,15 @@ var init_bridge_host = __esm({
   }
 });
 
+// src/cli-constants.ts
+var DEFAULT_SOOTSIM_SHELL_URL;
+var init_cli_constants = __esm({
+  "src/cli-constants.ts"() {
+    "use strict";
+    DEFAULT_SOOTSIM_SHELL_URL = "http://localhost:5173/";
+  }
+});
+
 // cli/parent-pid.ts
 function getParentPid(pid) {
   if (!cached3) cached3 = build();
@@ -14844,7 +14872,7 @@ function build() {
 function buildLinux() {
   return (pid) => {
     try {
-      const raw = (0, import_fs4.readFileSync)(`/proc/${pid}/stat`, "utf8");
+      const raw = (0, import_fs5.readFileSync)(`/proc/${pid}/stat`, "utf8");
       const end = raw.lastIndexOf(")");
       if (end < 0) return null;
       const rest = raw.slice(end + 1).trim().split(/\s+/);
@@ -14897,12 +14925,12 @@ function buildDarwinLsof() {
     }
   };
 }
-var import_child_process5, import_fs4, import_module, cached3, PROC_PIDTBSDINFO, PROC_BSDINFO_SIZE, PBI_PPID_OFFSET;
+var import_child_process5, import_fs5, import_module, cached3, PROC_PIDTBSDINFO, PROC_BSDINFO_SIZE, PBI_PPID_OFFSET;
 var init_parent_pid = __esm({
   "cli/parent-pid.ts"() {
     "use strict";
     import_child_process5 = require("child_process");
-    import_fs4 = require("fs");
+    import_fs5 = require("fs");
     import_module = require("module");
     cached3 = null;
     PROC_PIDTBSDINFO = 3;
@@ -14940,18 +14968,18 @@ function getCliIdentityKey() {
 }
 function getCurrentSimPath() {
   if (process.env[CURRENT_SIM_PATH_ENV]) {
-    return (0, import_path4.resolve)(process.env[CURRENT_SIM_PATH_ENV]);
+    return (0, import_path5.resolve)(process.env[CURRENT_SIM_PATH_ENV]);
   }
   const key = getCliIdentityKey();
-  return (0, import_path4.join)((0, import_os2.tmpdir)(), `sootsim-current-sim-${key}.json`);
+  return (0, import_path5.join)((0, import_os2.tmpdir)(), `sootsim-current-sim-${key}.json`);
 }
 function readCurrentSim() {
   const filepath = getCurrentSimPath();
-  if (!(0, import_fs5.existsSync)(filepath)) return null;
+  if (!(0, import_fs6.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_fs5.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_fs6.readFileSync)(filepath, "utf8"));
     if (parsed.version !== CURRENT_SIM_VERSION || typeof parsed.simId !== "string" || !parsed.simId.trim() || typeof parsed.updatedAt !== "string") {
-      (0, import_fs5.rmSync)(filepath, { force: true });
+      (0, import_fs6.rmSync)(filepath, { force: true });
       return null;
     }
     return {
@@ -14960,7 +14988,7 @@ function readCurrentSim() {
       updatedAt: parsed.updatedAt
     };
   } catch {
-    (0, import_fs5.rmSync)(filepath, { force: true });
+    (0, import_fs6.rmSync)(filepath, { force: true });
     return null;
   }
 }
@@ -14968,15 +14996,15 @@ function readCurrentSimId() {
   return readCurrentSim()?.simId || null;
 }
 function clearCurrentSimId() {
-  (0, import_fs5.rmSync)(getCurrentSimPath(), { force: true });
+  (0, import_fs6.rmSync)(getCurrentSimPath(), { force: true });
 }
-var import_fs5, import_os2, import_path4, CURRENT_SIM_VERSION, CURRENT_SIM_PATH_ENV, IDENTITY_ENV_VARS;
+var import_fs6, import_os2, import_path5, CURRENT_SIM_VERSION, CURRENT_SIM_PATH_ENV, IDENTITY_ENV_VARS;
 var init_current_sim = __esm({
   "cli/current-sim.ts"() {
     "use strict";
-    import_fs5 = require("fs");
+    import_fs6 = require("fs");
     import_os2 = require("os");
-    import_path4 = require("path");
+    import_path5 = require("path");
     init_parent_pid();
     CURRENT_SIM_VERSION = 1;
     CURRENT_SIM_PATH_ENV = "SOOTSIM_CLI_CURRENT_SIM_PATH";
@@ -15015,6 +15043,7 @@ var init_current_sim = __esm({
 var ws_bridge_exports = {};
 __export(ws_bridge_exports, {
   BridgeSimLockedError: () => BridgeSimLockedError,
+  bridgePortForShellBaseUrl: () => bridgePortForShellBaseUrl,
   callInBridge: () => callInBridge,
   callInBridgeWrite: () => callInBridgeWrite,
   checkSimHealth: () => checkSimHealth,
@@ -15022,16 +15051,84 @@ __export(ws_bridge_exports, {
   createBridgeFromParsed: () => createBridgeFromParsed,
   evalInBridge: () => evalInBridge,
   parseBridgeCliArgs: () => parseBridgeCliArgs,
-  resolveDefaultBridgePort: () => resolveDefaultBridgePort
+  printBridgeWorldNotice: () => printBridgeWorldNotice,
+  resolveBridgeWorld: () => resolveBridgeWorld,
+  resolveDefaultBridgePort: () => resolveDefaultBridgePort,
+  worldForBridgePort: () => worldForBridgePort
 });
-function resolveDefaultBridgePort() {
-  if (shouldSkipPersistentDaemon()) {
-    const dev = readDevBridgeLockfile();
-    if (dev && isDevBridgeLockfileFresh(dev)) return dev.bridgePort;
+function resolveBridgeWorld() {
+  const dev = readDevBridgeLockfile();
+  if (dev && isDevBridgeLockfileFresh(dev)) {
+    return {
+      source: "dev-bridge",
+      bridgePort: dev.bridgePort,
+      // older lockfile writers don't record the vite http port; the default
+      // shell URL is the dev shell anyway, so the fallback stays coherent.
+      shellBaseUrl: dev.shellPort ? `http://localhost:${dev.shellPort}/` : DEFAULT_SOOTSIM_SHELL_URL
+    };
   }
   const lock = readDaemonLockfile();
-  if (lock && isDaemonLockfileFresh(lock)) return lock.bridgePort;
-  return DEFAULT_SOOTSIM_BRIDGE_PORT;
+  if (lock && isDaemonLockfileFresh(lock)) {
+    return {
+      source: "daemon",
+      bridgePort: lock.bridgePort,
+      shellBaseUrl: lock.runtimePort > 0 ? `http://localhost:${lock.runtimePort}/` : DEFAULT_SOOTSIM_SHELL_URL
+    };
+  }
+  return {
+    source: "default",
+    bridgePort: DEFAULT_SOOTSIM_BRIDGE_PORT,
+    shellBaseUrl: DEFAULT_SOOTSIM_SHELL_URL
+  };
+}
+function worldForBridgePort(port) {
+  const dev = readDevBridgeLockfile();
+  if (dev && isDevBridgeLockfileFresh(dev) && dev.bridgePort === port) {
+    return {
+      source: "dev-bridge",
+      shellBaseUrl: dev.shellPort ? `http://localhost:${dev.shellPort}/` : DEFAULT_SOOTSIM_SHELL_URL
+    };
+  }
+  const lock = readDaemonLockfile();
+  if (lock && isDaemonLockfileFresh(lock) && lock.bridgePort === port) {
+    return {
+      source: "daemon",
+      shellBaseUrl: lock.runtimePort > 0 ? `http://localhost:${lock.runtimePort}/` : DEFAULT_SOOTSIM_SHELL_URL
+    };
+  }
+  return null;
+}
+function bridgePortForShellBaseUrl(baseUrl) {
+  let port;
+  try {
+    const url = new URL(baseUrl);
+    port = url.port ? Number(url.port) : url.protocol === "https:" ? 443 : 80;
+  } catch {
+    return null;
+  }
+  if (!Number.isFinite(port) || port <= 0) return null;
+  const dev = readDevBridgeLockfile();
+  if (dev && isDevBridgeLockfileFresh(dev) && (dev.shellPort === port || dev.runtimePort === port || dev.bridgePort === port)) {
+    return dev.bridgePort;
+  }
+  const lock = readDaemonLockfile();
+  if (lock && isDaemonLockfileFresh(lock) && (lock.runtimePort === port || lock.bridgePort === port)) {
+    return lock.bridgePort;
+  }
+  return null;
+}
+function resolveDefaultBridgePort() {
+  return resolveBridgeWorld().bridgePort;
+}
+function printBridgeWorldNotice(bridgePort, shellBaseUrl) {
+  const world = worldForBridgePort(bridgePort);
+  const kind = world?.source === "dev-bridge" ? "dev bridge" : world?.source === "daemon" ? "daemon bridge" : "bridge";
+  const origin = world ? `${world.source}.json` : "no lockfile";
+  const shell = shellBaseUrl ?? world?.shellBaseUrl;
+  process.stderr.write(
+    `  \u2192 ${kind} :${bridgePort} (${shell ? `shell ${shell}, ` : ""}${origin})
+`
+  );
 }
 function describeSimIdSource(source) {
   if (source === "flag") return "via --sim";
@@ -15339,11 +15436,11 @@ async function evalInBridge(bridge, code, opts = {}) {
   if (opts.acquireLock) payload.acquireLock = true;
   return bridge.send(payload);
 }
-async function callInBridge(bridge, path10, ...args) {
-  return bridge.send({ type: "call", path: path10, args });
+async function callInBridge(bridge, path11, ...args) {
+  return bridge.send({ type: "call", path: path11, args });
 }
-async function callInBridgeWrite(bridge, path10, ...args) {
-  return bridge.send({ type: "call", path: path10, args, acquireLock: true });
+async function callInBridgeWrite(bridge, path11, ...args) {
+  return bridge.send({ type: "call", path: path11, args, acquireLock: true });
 }
 var import_ws3, BridgeSimLockedError;
 var init_ws_bridge = __esm({
@@ -15351,6 +15448,7 @@ var init_ws_bridge = __esm({
     "use strict";
     import_ws3 = require("ws");
     init_bridge_constants();
+    init_cli_constants();
     init_home_paths();
     init_current_sim();
     BridgeSimLockedError = class extends Error {
@@ -15925,6 +16023,7 @@ var init_core = __esm({
     let externalReady = null
     let externalStatus = ''
     let externalError = ''
+    let suppressedEntryError = ''
     try {
       const getExternalAppState = t?.getExternalAppState
       const external = typeof getExternalAppState === 'function'
@@ -15949,10 +16048,16 @@ var init_core = __esm({
         if (typeof state.error === 'string') externalError = state.error
       }
       if (!externalError && Array.isArray(external?.entryErrors)) {
-        const entry = external.entryErrors.find((item) => {
-          return item && typeof item.message === 'string' && item.message.trim()
-        })
-        if (entry) externalError = entry.message
+        // suppressed-and-continued entry errors (bundle-loader's patched __r
+        // swallows entry throws and moves on) must NOT gate readiness \u2014 the
+        // app frequently runs fine after one (e.g. metro's "Unknown named
+        // module" probing noise). they surface separately as a diagnostic
+        // for the timeout path.
+        const isReal = (item) => item && typeof item.message === 'string' && item.message.trim()
+        const fatal = external.entryErrors.find((item) => isReal(item) && item.suppressed !== true)
+        if (fatal) externalError = fatal.message
+        const suppressed = external.entryErrors.find((item) => isReal(item) && item.suppressed === true)
+        if (suppressed) suppressedEntryError = suppressed.message
       }
       if (externalReady === false && externalStatus) loadingText = externalStatus
     } catch {}
@@ -15968,6 +16073,7 @@ var init_core = __esm({
       externalReady,
       externalStatus,
       externalError,
+      suppressedEntryError,
     }
   })()`;
     READY_CONTENT_NODE_FLOOR = 100;
@@ -16754,16 +16860,16 @@ function resolveFlowScreenshotPath(screenshotDir, name) {
 }
 function resolveProjectRelativeFlowBase(flowDir) {
   if (!flowDir) return process.cwd();
-  return path8.basename(flowDir) === ".maestro" ? path8.dirname(flowDir) : flowDir;
+  return path9.basename(flowDir) === ".maestro" ? path9.dirname(flowDir) : flowDir;
 }
 function resolveFlowScreenshotPathWithMode(screenshotDir, name, opts) {
   const normalizedName = name.endsWith(".png") ? name : `${name}.png`;
-  if (path8.isAbsolute(normalizedName)) return normalizedName;
+  if (path9.isAbsolute(normalizedName)) return normalizedName;
   if (opts.mode === "flow" && /[\\/]/.test(normalizedName)) {
     const baseDir = normalizedName.startsWith("./") || normalizedName.startsWith("../") ? opts.flowDir ?? process.cwd() : resolveProjectRelativeFlowBase(opts.flowDir);
-    return path8.resolve(baseDir, normalizedName);
+    return path9.resolve(baseDir, normalizedName);
   }
-  return path8.join(screenshotDir, normalizedName);
+  return path9.join(screenshotDir, normalizedName);
 }
 function normalizeFlowScreenshotSpec(step) {
   if (typeof step === "string") {
@@ -16818,12 +16924,12 @@ function parseFlowSteps(content) {
   const parsed = import_yaml.default.parse(candidate);
   return Array.isArray(parsed) ? parsed : [];
 }
-var fs8, path8, import_settings2, import_yaml, DEFAULT_TIMEOUT, SCREEN_W, SCREEN_H, CLI_PERF_SESSION_GLOBAL, SootSimBridgeFlowRunner;
+var fs9, path9, import_settings2, import_yaml, DEFAULT_TIMEOUT, SCREEN_W, SCREEN_H, SootSimBridgeFlowRunner;
 var init_bridge_flow_runner = __esm({
   "cli/bridge-flow-runner.ts"() {
     "use strict";
-    fs8 = __toESM(require("fs"), 1);
-    path8 = __toESM(require("path"), 1);
+    fs9 = __toESM(require("fs"), 1);
+    path9 = __toESM(require("path"), 1);
     import_settings2 = require("sootsim-engine/settings");
     import_yaml = __toESM(require("yaml"), 1);
     init_frame_compose();
@@ -16836,7 +16942,6 @@ var init_bridge_flow_runner = __esm({
     DEFAULT_TIMEOUT = 1e4;
     SCREEN_W = 393;
     SCREEN_H = 852;
-    CLI_PERF_SESSION_GLOBAL = "__sootsimCliPerf";
     SootSimBridgeFlowRunner = class {
       constructor(bridge, opts) {
         this.bridge = bridge;
@@ -17047,14 +17152,14 @@ var init_bridge_flow_runner = __esm({
         if (chunks.length === 0) {
           throw new Error("recording requested but no video buffer was produced");
         }
-        fs8.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
+        fs9.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
         const videoMime = stopped.mime || this.opts.recordingFormat || "video/webm";
         const extension = videoMime.includes("mp4") ? "mp4" : "webm";
-        const outputPath = path8.join(
+        const outputPath = path9.join(
           this.opts.recordingOutputDir,
           `sootsim-${Date.now()}.${extension}`
         );
-        fs8.writeFileSync(outputPath, Buffer.concat(chunks));
+        fs9.writeFileSync(outputPath, Buffer.concat(chunks));
         return outputPath;
       }
       async waitForRecordingTail(opts) {
@@ -17493,7 +17598,7 @@ var init_bridge_flow_runner = __esm({
             flowDir: this.opts.flowDir
           }
         );
-        fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
+        fs9.mkdirSync(path9.dirname(outputPath), { recursive: true });
         const layers = spec.layers ?? this.opts.screenshotLayers;
         const screenshotRequest = {
           type: "screenshot",
@@ -17509,11 +17614,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);
-          fs8.writeFileSync(outputPath, framed);
+          fs9.writeFileSync(outputPath, framed);
           console.log(`[flow] screenshot: ${outputPath} (frame: ${model})`);
           return;
         }
-        fs8.writeFileSync(outputPath, rawBuffer);
+        fs9.writeFileSync(outputPath, rawBuffer);
         console.log(`[flow] screenshot: ${outputPath}`);
       }
       async readCurrentDeviceModel() {
@@ -17528,22 +17633,22 @@ var init_bridge_flow_runner = __esm({
         return model;
       }
       async captureFailureScreenshot(outputPath) {
-        fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
+        fs9.mkdirSync(path9.dirname(outputPath), { recursive: true });
         const dataUrl = await this.bridge.send({
           type: "screenshot",
           simId: this.opts.simId
         });
         const base64 = dataUrl.replace(/^data:image\/png;base64,/, "");
-        fs8.writeFileSync(outputPath, Buffer.from(base64, "base64"));
+        fs9.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) {
-        fs8.mkdirSync(outputDir, { recursive: true });
+        fs9.mkdirSync(outputDir, { recursive: true });
         const write = (name, content) => {
           try {
-            fs8.writeFileSync(path8.join(outputDir, name), content);
+            fs9.writeFileSync(path9.join(outputDir, name), content);
           } catch {
           }
         };
@@ -17983,101 +18088,25 @@ var init_bridge_flow_runner = __esm({
         return true;
       }
       async startProfile() {
-        await this.evaluate(`((sessionKey) => {
-      const perf = window.__sootsimPerf
-      const a11y = window.__sootsimA11y
-      perf?.enableFrameStats?.(true)
-      perf?.resetFrameStats?.()
-      a11y?.resetProfile?.()
-      window[sessionKey] = {
-        active: true,
-        mode: window.__sootsimRenderHost ? 'render-worker' : 'main-thread',
-        lastSamples: [],
-        startedAt: performance.now(),
+        const result = await this.evaluate(`(() => {
+      if (!window.__sootsimShellPerf) {
+        return { error: "shell frame profile unavailable (__sootsimShellPerf missing on the page)" }
       }
-    })(${JSON.stringify(CLI_PERF_SESSION_GLOBAL)})`);
+      window.__sootsimShellPerf.start()
+      return { started: true }
+    })()`);
+        if (result?.error) {
+          throw new Error(result.error);
+        }
         this.profilingEnabled = true;
       }
       async stopProfile() {
-        const result = await this.evaluate(`(async (sessionKey) => {
-      const host = window.__sootsimRenderHost
-      if (host?.flushSamples) {
-        const perf = window.__sootsimPerf
-        const session = window[sessionKey] || {}
-        const priorSamples = session.active && Array.isArray(session.lastSamples)
-          ? session.lastSamples
-          : []
-        const flushedSamples = await host.flushSamples()
-        await perf?.disableFrameStats?.()
-        const samples = priorSamples.concat(flushedSamples)
-        window[sessionKey] = {
-          ...session,
-          active: false,
-          mode: 'render-worker',
-          lastSamples: samples,
-          stoppedAt: performance.now(),
-        }
-
-        const frameTimes = samples.map((sample) => Number(sample?.[1]) || 0)
-        const sorted = [...frameTimes].sort((a, b) => a - b)
-        const worstFrames = samples
-          .slice()
-          .sort((a, b) => (Number(b?.[1]) || 0) - (Number(a?.[1]) || 0))
-          .slice(0, 10)
-          .map((sample) => [
-            Number(sample?.[0]) || 0,
-            Number(sample?.[1]) || 0,
-            Number(sample?.[2]) || 0,
-            Number(sample?.[3]) || 0,
-            Number(sample?.[4]) || 0,
-          ])
-
-        return {
-          mode: 'render-worker',
-          frames: frameTimes.length,
-          totalMs: frameTimes.reduce((sum, value) => sum + value, 0),
-          avgMs: frameTimes.length ? frameTimes.reduce((sum, value) => sum + value, 0) / frameTimes.length : 0,
-          maxMs: sorted[sorted.length - 1] || 0,
-          layoutTotalMs: samples.reduce((sum, sample) => sum + (Number(sample?.[2]) || 0), 0),
-          renderTotalMs: samples.reduce((sum, sample) => sum + (Number(sample?.[3]) || 0), 0),
-          copyTotalMs: samples.reduce((sum, sample) => sum + (Number(sample?.[4]) || 0), 0),
-          layoutAvgMs: frameTimes.length ? samples.reduce((sum, sample) => sum + (Number(sample?.[2]) || 0), 0) / frameTimes.length : 0,
-          renderAvgMs: frameTimes.length ? samples.reduce((sum, sample) => sum + (Number(sample?.[3]) || 0), 0) / frameTimes.length : 0,
-          copyAvgMs: frameTimes.length ? samples.reduce((sum, sample) => sum + (Number(sample?.[4]) || 0), 0) / frameTimes.length : 0,
-          p50: sorted[Math.floor(sorted.length * 0.5)] || 0,
-          p95: sorted[Math.floor(sorted.length * 0.95)] || 0,
-          p99: sorted[Math.floor(sorted.length * 0.99)] || 0,
-          jankFrames: frameTimes.filter((value) => value > 16.67).length,
-          sampleCount: frameTimes.length,
-          worstFrames,
-        }
-      }
-
-      const perf = window.__sootsimPerf
-      const a11y = window.__sootsimA11y
-      if (!perf && !a11y) return { error: 'no perf globals available' }
-
-      const stoppedStats = await perf?.disableFrameStats?.()
-      const frameStats = stoppedStats || await perf?.getFrameStats?.() || {}
-      const profile = a11y?.profile?.() || {}
-      const recent = Array.isArray(frameStats.recentFrames) ? frameStats.recentFrames : []
-      const sorted = [...recent].sort((a, b) => a - b)
-
-      return {
-        mode: 'main-thread',
-        frames: frameStats.frames || profile.syncCount || 0,
-        totalMs: frameStats.totalMs || 0,
-        avgMs: frameStats.totalMs && frameStats.frames ? frameStats.totalMs / frameStats.frames : profile.avgSyncMs || 0,
-        maxMs: frameStats.maxMs || profile.maxSyncMs || 0,
-        layoutTotalMs: frameStats.layoutTotalMs || 0,
-        p50: sorted[Math.floor(sorted.length * 0.5)] || 0,
-        p95: sorted[Math.floor(sorted.length * 0.95)] || 0,
-        p99: sorted[Math.floor(sorted.length * 0.99)] || 0,
-        jankFrames: recent.filter((value) => value > 16.67).length,
-        sampleCount: recent.length,
-        worstFrames: recent.slice().sort((a, b) => b - a).slice(0, 10),
+        const result = await this.evaluate(`(async () => {
+      if (!window.__sootsimShellPerf) {
+        return { error: "shell frame profile unavailable (__sootsimShellPerf missing on the page)" }
       }
-    })(${JSON.stringify(CLI_PERF_SESSION_GLOBAL)})`);
+      return await window.__sootsimShellPerf.stop()
+    })()`);
         this.profilingEnabled = false;
         if (result?.error) {
           throw new Error(result.error);
@@ -18139,8 +18168,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 = path8.resolve(this.opts.flowDir, spec.file);
-        const source = fs8.readFileSync(scriptPath, "utf8");
+        const scriptPath = path9.resolve(this.opts.flowDir, spec.file);
+        const source = fs9.readFileSync(scriptPath, "utf8");
         this.js.evaluate(source, { env: spec.env });
         console.log(`[flow]   runScript: ${spec.file} done`);
       }
@@ -18380,10 +18409,10 @@ var init_bridge_flow_runner = __esm({
               for (const [k, v] of Object.entries(env)) this.js.putEnv(k, v);
             }
             if (file) {
-              const flowPath = path8.resolve(this.opts.flowDir, file);
-              const flowContent = fs8.readFileSync(flowPath, "utf8");
+              const flowPath = path9.resolve(this.opts.flowDir, file);
+              const flowContent = fs9.readFileSync(flowPath, "utf8");
               const previousDir = this.opts.flowDir;
-              this.opts.flowDir = path8.dirname(flowPath);
+              this.opts.flowDir = path9.dirname(flowPath);
               try {
                 await this.runFlow(parseFlowSteps(flowContent));
               } finally {
@@ -18479,8 +18508,8 @@ __export(registry_exports, {
   skillRegistry: () => skillRegistry
 });
 module.exports = __toCommonJS(registry_exports);
-var fs9 = __toESM(require("fs"), 1);
-var path9 = __toESM(require("path"), 1);
+var fs10 = __toESM(require("fs"), 1);
+var path10 = __toESM(require("path"), 1);
 
 // src/skills/builtin/a11y-review.ts
 var skill = {
@@ -18498,8 +18527,8 @@ var skill = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path10 = await import("path");
-        const fs10 = await import("fs");
+        const path11 = await import("path");
+        const fs11 = await import("fs");
         const browser = await chromium.launch({ channel: "chrome", headless: true });
         const page = await browser.newPage({ viewport: { width: 500, height: 900 } });
         try {
@@ -18552,9 +18581,9 @@ var skill = {
             warnings: issues.filter((i) => i.severity === "warning").length,
             tree: typeof tree === "string" ? tree : JSON.stringify(tree)
           };
-          const reportPath = path10.join(context.outputDir, "a11y-report.json");
-          fs10.mkdirSync(path10.dirname(reportPath), { recursive: true });
-          fs10.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path11.join(context.outputDir, "a11y-report.json");
+          fs11.mkdirSync(path11.dirname(reportPath), { recursive: true });
+          fs11.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`,
@@ -18592,8 +18621,8 @@ var skill2 = {
         }
       },
       async execute(params, context) {
-        const fs10 = await import("fs");
-        const path10 = await import("path");
+        const fs11 = await import("fs");
+        const path11 = 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];
@@ -18611,11 +18640,11 @@ var skill2 = {
             data: { package: params.packageName, status, ...entry }
           };
         }
-        const pkgPath = path10.join(context.projectDir, "package.json");
-        if (!fs10.existsSync(pkgPath)) {
+        const pkgPath = path11.join(context.projectDir, "package.json");
+        if (!fs11.existsSync(pkgPath)) {
           return { success: false, message: "No package.json found" };
         }
-        const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf8"));
+        const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf8"));
         const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
         const results = {
           full: [],
@@ -18633,9 +18662,9 @@ var skill2 = {
             results.unknown.push(dep);
           }
         }
-        const reportPath = path10.join(context.outputDir, "compat-report.json");
-        fs10.mkdirSync(path10.dirname(reportPath), { recursive: true });
-        fs10.writeFileSync(reportPath, JSON.stringify(results, null, 2));
+        const reportPath = path11.join(context.outputDir, "compat-report.json");
+        fs11.mkdirSync(path11.dirname(reportPath), { recursive: true });
+        fs11.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`,
@@ -18673,8 +18702,8 @@ var skill3 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path10 = await import("path");
-        const fs10 = await import("fs");
+        const path11 = await import("path");
+        const fs11 = await import("fs");
         const browser = await chromium.launch({ channel: "chrome", headless: true });
         const page = await browser.newPage({ viewport: { width: 500, height: 900 } });
         try {
@@ -18698,9 +18727,9 @@ var skill3 = {
             ...profile,
             fps: syncCount > 0 ? (syncCount / (duration / 1e3)).toFixed(1) : "0"
           };
-          const reportPath = path10.join(context.outputDir, "perf-report.json");
-          fs10.mkdirSync(path10.dirname(reportPath), { recursive: true });
-          fs10.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path11.join(context.outputDir, "perf-report.json");
+          fs11.mkdirSync(path11.dirname(reportPath), { recursive: true });
+          fs11.writeFileSync(reportPath, JSON.stringify(report, null, 2));
           return {
             success: true,
             message: `${report.fps} fps, ${profile.avgSyncMs?.toFixed(1)}ms avg sync, ${nodeCount} nodes`,
@@ -18732,15 +18761,15 @@ var skill4 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path10 = await import("path");
-        const fs10 = await import("fs");
+        const path11 = await import("path");
+        const fs11 = await import("fs");
         const browser = await chromium.launch({ channel: "chrome", headless: true });
         const page = await browser.newPage({ viewport: { width: 500, height: 900 } });
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const outputPath = path10.join(context.outputDir, `${params.name}.png`);
-          fs10.mkdirSync(path10.dirname(outputPath), { recursive: true });
+          const outputPath = path11.join(context.outputDir, `${params.name}.png`);
+          fs11.mkdirSync(path11.dirname(outputPath), { recursive: true });
           await page.screenshot({ path: outputPath });
           return {
             success: true,
@@ -18778,8 +18807,8 @@ var skill5 = {
         record: { type: "boolean", description: "Record video of the flow" }
       },
       async execute(params, context) {
-        const fs10 = await import("fs");
-        const path10 = await import("path");
+        const fs11 = await import("fs");
+        const path11 = 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));
@@ -18788,7 +18817,7 @@ var skill5 = {
         const host = new SootSimBridgeHost2({ port: DEFAULT_SOOTSIM_BRIDGE_PORT2 });
         host.start({ silent: true });
         try {
-          const flowContent = fs10.readFileSync(params.flowPath, "utf8");
+          const flowContent = fs11.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);
@@ -18813,7 +18842,7 @@ var skill5 = {
           });
           const driver = new SootSimBridgeFlowRunner2(bridge, {
             screenshotDir: context.outputDir,
-            flowDir: path10.dirname(path10.resolve(params.flowPath)),
+            flowDir: path11.dirname(path11.resolve(params.flowPath)),
             simId,
             recordingOutputDir: params.record ? context.outputDir : void 0
           });
@@ -18835,7 +18864,7 @@ var skill5 = {
                 simId,
                 videoPath: videoPath || void 0
               },
-              artifacts: videoPath ? [{ type: "video", name: path10.basename(videoPath), path: videoPath }] : void 0
+              artifacts: videoPath ? [{ type: "video", name: path11.basename(videoPath), path: videoPath }] : void 0
             };
           } finally {
             try {
@@ -18883,21 +18912,21 @@ var skill6 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path10 = await import("path");
-        const fs10 = await import("fs");
+        const path11 = await import("path");
+        const fs11 = await import("fs");
         const browser = await chromium.launch({ channel: "chrome", headless: true });
         const page = await browser.newPage({ viewport: { width: 500, height: 900 } });
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const currentPath = path10.join(context.outputDir, `${params.name}-current.png`);
-          fs10.mkdirSync(path10.dirname(currentPath), { recursive: true });
+          const currentPath = path11.join(context.outputDir, `${params.name}-current.png`);
+          fs11.mkdirSync(path11.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(fs10.readFileSync(params.baseline));
-            const current = PNG.sync.read(fs10.readFileSync(currentPath));
+            const baseline = PNG.sync.read(fs11.readFileSync(params.baseline));
+            const current = PNG.sync.read(fs11.readFileSync(currentPath));
             const { width, height } = baseline;
             const diff = new PNG({ width, height });
             const numDiffPixels = pixelmatch(
@@ -18908,8 +18937,8 @@ var skill6 = {
               height,
               { threshold: params.threshold || 0.1 }
             );
-            const diffPath = path10.join(context.outputDir, `${params.name}-diff.png`);
-            fs10.writeFileSync(diffPath, PNG.sync.write(diff));
+            const diffPath = path11.join(context.outputDir, `${params.name}-diff.png`);
+            fs11.writeFileSync(diffPath, PNG.sync.write(diff));
             const totalPixels = width * height;
             const diffPercent = (numDiffPixels / totalPixels * 100).toFixed(2);
             return {
@@ -18973,10 +19002,10 @@ var skillRegistry = {
   },
   // load skills from a project manifest (sootsim-skills.json)
   async loadFromManifest(projectDir) {
-    const manifestPath = path9.join(projectDir, "sootsim-skills.json");
-    if (!fs9.existsSync(manifestPath)) return;
+    const manifestPath = path10.join(projectDir, "sootsim-skills.json");
+    if (!fs10.existsSync(manifestPath)) return;
     try {
-      const manifest = JSON.parse(fs9.readFileSync(manifestPath, "utf8"));
+      const manifest = JSON.parse(fs10.readFileSync(manifestPath, "utf8"));
       if (Array.isArray(manifest.skills)) {
         for (const entry of manifest.skills) {
           if (typeof entry === "string") {
@@ -18987,7 +19016,7 @@ var skillRegistry = {
             }
           } else if (entry.file) {
             try {
-              const mod = await import(path9.resolve(projectDir, entry.file));
+              const mod = await import(path10.resolve(projectDir, entry.file));
               if (mod.skill) this.register(mod.skill);
             } catch {
             }
@@ -19000,10 +19029,10 @@ var skillRegistry = {
   // auto-discover skills based on project dependencies
   suggestSkills(projectDir) {
     const suggestions = [];
-    const pkgPath = path9.join(projectDir, "package.json");
-    if (!fs9.existsSync(pkgPath)) return suggestions;
+    const pkgPath = path10.join(projectDir, "package.json");
+    if (!fs10.existsSync(pkgPath)) return suggestions;
     try {
-      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps["detox"] || deps["maestro"]) {
         suggestions.push("test-flow");