sootsim 0.1.268 → 0.1.270

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.268 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.270 | (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;
@@ -1038,7 +1038,7 @@ var init_registry = __esm({
           {
             range: ">=55.0.0",
             coverage: 0.9,
-            note: "SymbolView renders the symbol name as text when SF Symbols / Material Symbols fonts are not loaded \u2014 visible glyph requires the real Apple font (license-restricted, can't bundle) or Google Material Symbols font registered via FontFace API. unstable_getMaterialSymbolSourceAsync returns a stable URI/size shape so apps that gate on the source resolve correctly.",
+            note: "SymbolView renders the shared SootSim SF Symbol vector and preserves the requested system name for frozen Design replay. Unknown names use the supplied fallback. unstable_getMaterialSymbolSourceAsync returns a stable URI/size shape so apps that gate on the source resolve correctly.",
             working: "SymbolView, name object/string selection (string | { ios, android, web }), size/tintColor styling, fallback rendering, unstable_getMaterialSymbolSourceAsync",
             missing: "bundled SF Symbols font (Apple license), bundled Material Symbols font (size budget), animation/effect modifiers (.bounce, .scale)"
           }
@@ -1233,7 +1233,7 @@ var init_registry = __esm({
           {
             range: ">=13.0.0",
             coverage: 0.94,
-            note: "real SQLite via lazy-loaded bedrock-sqlite (~1MB WASM) \u2014 full SQL support including joins, transactions, prepared statements, RETURNING. WASM ships in the runtime tarball, fetched on first openDatabase call. memfs persists to IDB via Module._memfs (requires the bedrock-sqlite build with the memfs-on-module export from orez/sqlite-wasm); reloads restore the prior state \u2014 verified end-to-end via the orbstack/published-runtime probe across 3 page reloads. sync-only methods (execSync/runSync) throw until backend finishes loading; await openDatabaseAsync or whenSqliteReady() first.",
+            note: "real SQLite via lazy-loaded bedrock-sqlite (~1MB WASM) \u2014 full SQL support including joins, transactions, prepared statements, RETURNING. WASM ships in the runtime tarball and loads with the expo-sqlite compatibility chunk, so synchronous APIs are ready as soon as the module import resolves. memfs persists to IDB via Module._memfs (requires the bedrock-sqlite build with the memfs-on-module export from orez/sqlite-wasm); reloads restore the prior state \u2014 verified end-to-end via the orbstack/published-runtime probe across 3 page reloads.",
             working: "openDatabaseAsync / openDatabaseSync (real bedrock instance), execAsync / execSync, prepareAsync / prepareSync, runAsync / runSync, getFirstAsync / getFirstSync, getAllAsync / getAllSync, getEachAsync / getEachSync, withTransactionAsync / withTransactionSync, withExclusiveTransactionAsync, isInTransactionAsync / isInTransactionSync, closeAsync / closeSync, deleteDatabaseAsync / deleteDatabaseSync, SQLiteStatement.executeAsync / executeSync / executeForRawResultAsync / executeForRawResultSync / getColumnNames* / finalize*, SQLiteProvider, useSQLiteContext, defaultDatabaseDirectory, async iteration via for-await-of, RETURNING clauses",
             missing: "serializeAsync (bedrock does not expose sqlite3_serialize through its module surface), backupDatabaseAsync, addDatabaseChangeListener (no sqlite3_update_hook bindings), createSessionAsync, loadExtensionAsync, SQLiteTaggedQuery (Bun-style template literal API)"
           }
@@ -3854,7 +3854,7 @@ var init_registry = __esm({
           {
             range: ">=1.21.0",
             coverage: 0.72,
-            note: "native-seam only for toolbar/menu host views. the real @vxrn/native StackToolbar and MenuAction React code runs from the bundle and converts its public composition API into native host props and native-stack header items.",
+            note: "native-seam only for toolbar/menu host views. One's public Stack.Toolbar components use the real @vxrn/native implementation, whose React code runs from the bundle and converts the composition API into native host props and native-stack header items.",
             working: "StackToolbar header and bottom placements, Button, Label, Icon with SF Symbols/image sources, Badge, fixed/fluid Spacer, View children, nested Menu/MenuAction trees, disabled/selected/destructive actions, visible action callbacks, and native-stack header bar item integration",
             missing: "Color and zoom-transition native hosts, SplitView gamma host, bottom SearchBarSlot integration with a configured native search controller, exact UIKit shared-background grouping"
           }
@@ -10326,7 +10326,8 @@ __export(bridge_constants_exports, {
   resolveSootsimBridgePort: () => resolveSootsimBridgePort,
   resolveSootsimBridgePortForHttpPort: () => resolveSootsimBridgePortForHttpPort,
   resolveSootsimBridgePortForRuntimeLocation: () => resolveSootsimBridgePortForRuntimeLocation,
-  resolveSootsimBridgeWebSocketUrl: () => resolveSootsimBridgeWebSocketUrl
+  resolveSootsimBridgeWebSocketUrl: () => resolveSootsimBridgeWebSocketUrl,
+  resolveSootsimWebSocketProxyUrl: () => resolveSootsimWebSocketProxyUrl
 });
 function parsePort(value) {
   if (typeof value === "number") {
@@ -10393,16 +10394,31 @@ function resolveSootsimBridgePortForRuntimeLocation(input = {}) {
   if (baseHttpPort === null) return DEFAULT_SOOTSIM_BRIDGE_PORT;
   return resolveSootsimBridgePortForHttpPort({ httpPort, baseHttpPort });
 }
-function resolveSootsimBridgeWebSocketUrl(input) {
+function resolveSootsimWebSocketProxyUrl(input) {
   const pageUrl = parseHrefUrl(input.href);
   if (!pageUrl || pageUrl.protocol !== "http:" && pageUrl.protocol !== "https:") {
-    throw new Error(`invalid SootSim browser bridge page URL: ${input.href}`);
+    throw new Error(`invalid SootSim websocket proxy page URL: ${input.href}`);
+  }
+  let targetUrl;
+  try {
+    targetUrl = new URL(input.targetUrl);
+  } catch {
+    throw new Error(`invalid SootSim websocket proxy target URL: ${input.targetUrl}`);
+  }
+  if (targetUrl.protocol !== "ws:" && targetUrl.protocol !== "wss:") {
+    throw new Error(`invalid SootSim websocket proxy target URL: ${input.targetUrl}`);
   }
   const proxyUrl = new URL("/__websocket-proxy", pageUrl);
   proxyUrl.protocol = pageUrl.protocol === "https:" ? "wss:" : "ws:";
-  proxyUrl.searchParams.set("url", `ws://localhost:${input.bridgePort}`);
+  proxyUrl.searchParams.set("url", input.targetUrl);
   return proxyUrl.href;
 }
+function resolveSootsimBridgeWebSocketUrl(input) {
+  return resolveSootsimWebSocketProxyUrl({
+    targetUrl: `ws://localhost:${input.bridgePort}`,
+    href: input.href
+  });
+}
 var DEFAULT_SOOTSIM_BRIDGE_PORT, CONTRAST_DEV_HTTP_BASE_PORT, SOOTSIM_SITE_DEV_HTTP_BASE_PORT, SOOTSIM_SHELL_DEV_HTTP_BASE_PORT, LOCAL_DEV_HTTP_BASE_PORTS, MAX_LOCAL_DEV_PORT_OFFSET, SOOTSIM_BRIDGE_SIM_CLOSE_CODE, SOOTSIM_BRIDGE_SIM_CLOSE_REASON;
 var init_bridge_constants = __esm({
   "src/bridge-constants.ts"() {
@@ -10541,10 +10557,10 @@ function tcpPing(port, timeout = TCP_GATE_MS) {
     sock.connect(port, "localhost");
   });
 }
-function httpGet(port, path12, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(port, path11, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve5) => {
     const req = import_http.default.request(
-      { hostname: "localhost", port, path: path12, method, timeout, headers },
+      { hostname: "localhost", port, path: path11, method, timeout, headers },
       (res) => {
         let body = "";
         res.on("data", (c) => body += c.toString());
@@ -11885,21 +11901,37 @@ function listSessions(projectId) {
   const all = loadStore().agentSessions;
   return projectId ? all.filter((s) => s.projectId === projectId) : all;
 }
-function updateSessionStatus(id, patch) {
+function applySessionStatusPatch(existing, patch, now = Date.now()) {
+  return {
+    ...existing,
+    ...patch,
+    id: existing.id,
+    projectId: existing.projectId,
+    createdAt: existing.createdAt,
+    lastSeenAt: now
+  };
+}
+function updateSessionStatuses(updates) {
+  if (updates.length === 0) return;
   mutateStore((store) => {
-    const existing = store.agentSessions.find((s) => s.id === id);
-    if (!existing) return;
-    const idx = store.agentSessions.indexOf(existing);
-    store.agentSessions[idx] = {
-      ...existing,
-      ...patch,
-      id: existing.id,
-      projectId: existing.projectId,
-      createdAt: existing.createdAt,
-      lastSeenAt: Date.now()
-    };
+    const now = Date.now();
+    const indexById = new Map(
+      store.agentSessions.map((session, index) => [session.id, index])
+    );
+    for (const { id, patch } of updates) {
+      const idx = indexById.get(id);
+      if (idx === void 0) continue;
+      store.agentSessions[idx] = applySessionStatusPatch(
+        store.agentSessions[idx],
+        patch,
+        now
+      );
+    }
   });
 }
+function updateSessionStatus(id, patch) {
+  updateSessionStatuses([{ id, patch }]);
+}
 async function seedFromDemoAppRegistry() {
   const existing = loadStore().attachedProjects;
   if (existing.length > 0) return;
@@ -12382,46 +12414,42 @@ var init_agent_sessions = __esm({
 });
 
 // src/agent-identity.ts
-function agentbusSessionIdFromCliIdentity(identity) {
+function teamMachineSessionIdFromCliIdentity(identity) {
   if (!identity?.startsWith("AGENTBUS_SESSION:")) return null;
   const sessionId = identity.slice("AGENTBUS_SESSION:".length).trim();
-  if (!AGENTBUS_SESSION_RE.test(sessionId)) return null;
+  if (!TEAM_MACHINE_SESSION_RE.test(sessionId)) return null;
   return sessionId;
 }
-function isValidAgentbusSessionId(sessionId) {
-  return AGENTBUS_SESSION_RE.test(sessionId);
+function isValidTeamMachineSessionId(sessionId) {
+  return TEAM_MACHINE_SESSION_RE.test(sessionId);
 }
-var AGENTBUS_SESSION_RE;
+var TEAM_MACHINE_SESSION_RE;
 var init_agent_identity = __esm({
   "src/agent-identity.ts"() {
     "use strict";
-    AGENTBUS_SESSION_RE = /^[A-Za-z0-9._:-]{1,160}$/;
+    TEAM_MACHINE_SESSION_RE = /^[A-Za-z0-9._:-]{1,160}$/;
   }
 });
 
-// src/agentbus-prompt.ts
-function formatAgentbusPromptText(prompt) {
+// src/team-machine-prompt.ts
+function formatTeamMachinePromptText(prompt) {
   return typeof prompt.text === "string" ? prompt.text.trim() : "";
 }
-function resolveAgentbusCommand(explicit) {
+function resolveTeamMachineCommand(explicit) {
   const fromArg = explicit?.trim();
   if (fromArg) return fromArg;
-  const fromEnv = process.env.AGENTBUS_COMMAND?.trim();
-  if (fromEnv) return fromEnv;
-  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";
+  return "tm";
 }
-async function sendPromptToAgentbusSession(input) {
+async function sendPromptToTeamMachineSession(input) {
   const sessionId = input.sessionId.trim();
-  if (!isValidAgentbusSessionId(sessionId)) {
-    throw new Error(`invalid agentbus session id: ${sessionId || "<empty>"}`);
+  if (!isValidTeamMachineSessionId(sessionId)) {
+    throw new Error(`invalid Team Machine session id: ${sessionId || "<empty>"}`);
   }
-  const text = formatAgentbusPromptText(input.prompt);
+  const text = formatTeamMachinePromptText(input.prompt);
   if (!text) {
     throw new Error("prompt text is empty");
   }
-  const command = resolveAgentbusCommand(input.command);
+  const command = resolveTeamMachineCommand(input.command);
   const timeoutMs = input.timeoutMs ?? 15e3;
   await new Promise((resolve5, reject) => {
     const child = (0, import_node_child_process4.spawn)(command, ["send", sessionId, text], {
@@ -12434,7 +12462,7 @@ async function sendPromptToAgentbusSession(input) {
         child.kill("SIGTERM");
       } catch {
       }
-      reject(new Error(`agentbus send timed out after ${Math.round(timeoutMs / 1e3)}s`));
+      reject(new Error(`tm send timed out after ${Math.round(timeoutMs / 1e3)}s`));
     }, timeoutMs);
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (chunk) => {
@@ -12453,20 +12481,17 @@ async function sendPromptToAgentbusSession(input) {
       const detail = stderr.trim();
       reject(
         new Error(
-          detail || `agentbus send exited with ${signal ? `signal ${signal}` : `code ${code ?? "unknown"}`}`
+          detail || `tm send exited with ${signal ? `signal ${signal}` : `code ${code ?? "unknown"}`}`
         )
       );
     });
   });
 }
-var import_node_child_process4, import_node_fs7, import_node_os2, import_node_path6;
-var init_agentbus_prompt = __esm({
-  "src/agentbus-prompt.ts"() {
+var import_node_child_process4;
+var init_team_machine_prompt = __esm({
+  "src/team-machine-prompt.ts"() {
     "use strict";
     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_path6 = __toESM(require("node:path"), 1);
     init_agent_identity();
     init_agent_identity();
   }
@@ -12485,17 +12510,18 @@ function mapFrameworkToProjectFramework(fw) {
   if (fw === "one" || fw === "vxrn") return "one";
   return "unknown";
 }
-var import_node_fs8, import_node_path7, WS_OPEN, AgentHost;
+var import_node_fs7, import_node_path6, WS_OPEN, SESSION_STATUS_PERSIST_DELAY_MS, AgentHost;
 var init_agent_host = __esm({
   "src/host/agent-host.ts"() {
     "use strict";
-    import_node_fs8 = __toESM(require("node:fs"), 1);
-    import_node_path7 = __toESM(require("node:path"), 1);
+    import_node_fs7 = __toESM(require("node:fs"), 1);
+    import_node_path6 = __toESM(require("node:path"), 1);
     init_dev_server_scanner();
     init_agent_sessions();
-    init_agentbus_prompt();
     init_attached_projects();
+    init_team_machine_prompt();
     WS_OPEN = 1;
+    SESSION_STATUS_PERSIST_DELAY_MS = 25;
     AgentHost = class {
       // live fan-out, keyed by sessionId. refcount tracks how many sockets have
       // subscribed; the FIFO reader stays open as long as refcount > 0.
@@ -12517,6 +12543,12 @@ var init_agent_host = __esm({
       // in-memory count so session status stays `working` until that backlog
       // truly drains.
       pendingTurns = /* @__PURE__ */ new Map();
+      // status fan-out is realtime state. keep the current value in memory and
+      // batch its durable store write so an fsync cannot delay the websocket event
+      // it describes. close() flushes the final batch synchronously.
+      pendingSessionStates = /* @__PURE__ */ new Map();
+      pendingSessionPatches = /* @__PURE__ */ new Map();
+      sessionStatusPersistTimer = null;
       opts;
       constructor(opts = {}) {
         this.opts = opts;
@@ -12567,6 +12599,11 @@ var init_agent_host = __esm({
       /** terminate every subscription and drop every socket reference. called
        *  by the bridge host during shutdown. */
       close() {
+        if (this.sessionStatusPersistTimer) {
+          clearTimeout(this.sessionStatusPersistTimer);
+          this.sessionStatusPersistTimer = null;
+        }
+        this.flushSessionStatuses();
         for (const sub of this.subscriptions.values()) {
           try {
             sub.unsubscribe();
@@ -12635,18 +12672,18 @@ var init_agent_host = __esm({
         if (!lease || lease.kind !== "cli" || lease.expiresAt <= Date.now()) {
           throw new AgentSessionError("NO_CLAIM", `sim ${simId} has no active CLI claim`);
         }
-        const sessionId = agentbusSessionIdFromCliIdentity(lease.cliIdentityKey);
+        const sessionId = teamMachineSessionIdFromCliIdentity(lease.cliIdentityKey);
         if (!sessionId) {
           throw new AgentSessionError(
             "UNSUPPORTED_CLAIM",
             `sim ${simId} is claimed by a CLI identity that is not promptable`
           );
         }
-        await sendPromptToAgentbusSession({
+        await sendPromptToTeamMachineSession({
           sessionId,
           prompt: this.normalizePromptEnvelope(msg)
         });
-        return { ok: true, routed: "agentbus", sessionId };
+        return { ok: true, routed: "team-machine", sessionId };
       }
       async doStartSession(input) {
         const project = findProjectById(input.projectId);
@@ -12677,7 +12714,7 @@ var init_agent_host = __esm({
         );
         const project = upsertProject({
           cwd: match.cwd,
-          name: match.projectName ?? import_node_path7.default.basename(match.cwd),
+          name: match.projectName ?? import_node_path6.default.basename(match.cwd),
           preferredProvider: input.provider ?? existing?.preferredProvider,
           sourceRoots: existing?.sourceRoots ?? [match.cwd],
           knownBundleUrls,
@@ -12688,18 +12725,18 @@ var init_agent_host = __esm({
       }
       getTranscript(sessionId) {
         const p = transcriptPath(sessionId);
-        if (!import_node_fs8.default.existsSync(p)) {
+        if (!import_node_fs7.default.existsSync(p)) {
           return { error: "transcript not found", code: "NO_TRANSCRIPT" };
         }
-        return import_node_fs8.default.readFileSync(p, "utf8");
+        return import_node_fs7.default.readFileSync(p, "utf8");
       }
       getPaths() {
         const dir = getUserDataDir();
         return {
           userDataDir: dir,
-          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")
+          storeFile: import_node_path6.default.join(dir, "attached-projects.json"),
+          sessionsDir: import_node_path6.default.join(dir, "sessions"),
+          transcriptsDir: import_node_path6.default.join(dir, "transcripts")
         };
       }
       // --- subscription management ---
@@ -12879,10 +12916,45 @@ var init_agent_host = __esm({
         }
       }
       patchSession(sessionId, patch) {
-        updateSessionStatus(sessionId, patch);
-        const updated = findSessionById(sessionId);
-        if (updated) {
-          this.broadcastSessionStatus(updated);
+        const existing = this.pendingSessionStates.get(sessionId) ?? findSessionById(sessionId);
+        if (!existing) return;
+        const updated = applySessionStatusPatch(existing, patch);
+        this.pendingSessionStates.set(sessionId, updated);
+        this.pendingSessionPatches.set(sessionId, {
+          ...this.pendingSessionPatches.get(sessionId),
+          ...patch
+        });
+        this.broadcastSessionStatus(updated);
+        if (this.sessionStatusPersistTimer) return;
+        this.sessionStatusPersistTimer = setTimeout(() => {
+          this.sessionStatusPersistTimer = null;
+          this.flushSessionStatuses();
+        }, SESSION_STATUS_PERSIST_DELAY_MS);
+      }
+      flushSessionStatuses() {
+        if (this.pendingSessionPatches.size === 0) return;
+        const pendingStates = this.pendingSessionStates;
+        const pendingPatches = this.pendingSessionPatches;
+        this.pendingSessionStates = /* @__PURE__ */ new Map();
+        this.pendingSessionPatches = /* @__PURE__ */ new Map();
+        try {
+          updateSessionStatuses([...pendingPatches].map(([id, patch]) => ({ id, patch })));
+        } catch (error) {
+          for (const [id, session] of pendingStates) {
+            if (!this.pendingSessionStates.has(id)) {
+              this.pendingSessionStates.set(id, session);
+            }
+          }
+          for (const [id, patch] of pendingPatches) {
+            this.pendingSessionPatches.set(id, {
+              ...patch,
+              ...this.pendingSessionPatches.get(id)
+            });
+          }
+          process.stderr.write(
+            `[sootsim-agent] session status persistence failed: ${error instanceof Error ? error.message : String(error)}
+`
+          );
         }
       }
       coalescePromptEcho(sessionId, event) {
@@ -15766,7 +15838,7 @@ var init_current_sim = __esm({
       "SOOTSIM_CLI_IDENTITY",
       // explicit override — fastest path, skips all pid lookups
       "AGENTBUS_SESSION",
-      // agentbus session id; lets sootsim route prompt-bar followups back to this agent
+      // Team Machine session id; routes prompt-bar followups back to this agent
       "CLAUDE_CODE_SESSION_ID",
       // claude code, if ever set
       "CODEX_THREAD_ID",
@@ -15790,7 +15862,7 @@ var init_current_sim = __esm({
       "VSCODE_INJECTION"
       // vscode integrated terminal
     ];
-    IMMORTAL_HOST_COMM_RE = /^(?:tmux|screen)|^(?:agentbus|tm)$/i;
+    IMMORTAL_HOST_COMM_RE = /^(?:tmux|screen)|^tm$/i;
   }
 });
 
@@ -16199,11 +16271,11 @@ async function evalInBridge(bridge, code, opts = {}) {
   if (opts.acquireLock) payload.acquireLock = true;
   return bridge.send(payload);
 }
-async function callInBridge(bridge, path12, ...args) {
-  return bridge.send({ type: "call", path: path12, args });
+async function callInBridge(bridge, path11, ...args) {
+  return bridge.send({ type: "call", path: path11, args });
 }
-async function callInBridgeWrite(bridge, path12, ...args) {
-  return bridge.send({ type: "call", path: path12, args, acquireLock: true });
+async function callInBridgeWrite(bridge, path11, ...args) {
+  return bridge.send({ type: "call", path: path11, args, acquireLock: true });
 }
 var import_ws3, resolvedWorld, BridgeSimLockedError;
 var init_ws_bridge = __esm({
@@ -17431,14 +17503,14 @@ process.stdin.on('end', async () => {
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path8.dirname)((0, import_node_path8.resolve)(explicit));
+    return (0, import_node_path7.dirname)((0, import_node_path7.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path8.resolve)(explicit);
-  return (0, import_node_path8.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path7.resolve)(explicit);
+  return (0, import_node_path7.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -17484,26 +17556,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs9.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs8.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs8.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs9.rmSync)(filepath, { force: true });
+      (0, import_node_fs8.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs9.rmSync)(filepath, { force: true });
+    (0, import_node_fs8.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs9, import_node_path8, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs8, import_node_path7, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs9 = require("node:fs");
-    import_node_path8 = require("node:path");
+    import_node_fs8 = require("node:fs");
+    import_node_path7 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;
     SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
@@ -17779,16 +17851,16 @@ function resolveFlowScreenshotPath(screenshotDir, name) {
 }
 function resolveProjectRelativeFlowBase(flowDir) {
   if (!flowDir) return process.cwd();
-  return path10.basename(flowDir) === ".maestro" ? path10.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 (path10.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 path10.resolve(baseDir, normalizedName);
+    return path9.resolve(baseDir, normalizedName);
   }
-  return path10.join(screenshotDir, normalizedName);
+  return path9.join(screenshotDir, normalizedName);
 }
 function normalizeFlowScreenshotSpec(step) {
   if (typeof step === "string") {
@@ -17845,12 +17917,12 @@ function parseFlowSteps(content) {
   const parsed = import_yaml.default.parse(candidate);
   return Array.isArray(parsed) ? parsed : [];
 }
-var fs10, path10, import_settings2, import_yaml, DEFAULT_TIMEOUT, FLOW_TIMEOUT_SCALE, scaledTimeout, SCREEN_W, SCREEN_H, SootSimBridgeFlowRunner;
+var fs9, path9, 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";
-    fs10 = __toESM(require("fs"), 1);
-    path10 = __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();
@@ -18138,14 +18210,14 @@ var init_bridge_flow_runner = __esm({
         if (chunks.length === 0) {
           throw new Error("recording requested but no video buffer was produced");
         }
-        fs10.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 = path10.join(
+        const outputPath = path9.join(
           this.opts.recordingOutputDir,
           `sootsim-${Date.now()}.${extension}`
         );
-        fs10.writeFileSync(outputPath, Buffer.concat(chunks));
+        fs9.writeFileSync(outputPath, Buffer.concat(chunks));
         return outputPath;
       }
       async waitForRecordingTail(opts) {
@@ -18654,7 +18726,7 @@ var init_bridge_flow_runner = __esm({
             flowDir: this.opts.flowDir
           }
         );
-        fs10.mkdirSync(path10.dirname(outputPath), { recursive: true });
+        fs9.mkdirSync(path9.dirname(outputPath), { recursive: true });
         const layers = spec.layers ?? this.opts.screenshotLayers;
         const screenshotRequest = {
           type: "screenshot",
@@ -18670,11 +18742,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);
-          fs10.writeFileSync(outputPath, framed);
+          fs9.writeFileSync(outputPath, framed);
           console.log(`[flow] screenshot: ${outputPath} (frame: ${model})`);
           return outputPath;
         }
-        fs10.writeFileSync(outputPath, rawBuffer);
+        fs9.writeFileSync(outputPath, rawBuffer);
         console.log(`[flow] screenshot: ${outputPath}`);
         return outputPath;
       }
@@ -18690,22 +18762,22 @@ var init_bridge_flow_runner = __esm({
         return model;
       }
       async captureScreenshot(outputPath) {
-        fs10.mkdirSync(path10.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,/, "");
-        fs10.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) {
-        fs10.mkdirSync(outputDir, { recursive: true });
+        fs9.mkdirSync(outputDir, { recursive: true });
         const write = (name, content) => {
           try {
-            fs10.writeFileSync(path10.join(outputDir, name), content);
+            fs9.writeFileSync(path9.join(outputDir, name), content);
           } catch {
           }
         };
@@ -19247,8 +19319,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 = path10.resolve(this.opts.flowDir, spec.file);
-        const source = fs10.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`);
       }
@@ -19542,10 +19614,10 @@ var init_bridge_flow_runner = __esm({
               for (const [k, v] of Object.entries(env)) this.js.putEnv(k, v);
             }
             if (file) {
-              const flowPath = path10.resolve(this.opts.flowDir, file);
-              const flowContent = fs10.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 = path10.dirname(flowPath);
+              this.opts.flowDir = path9.dirname(flowPath);
               try {
                 await this.runFlow(parseFlowSteps(flowContent));
               } finally {
@@ -19700,8 +19772,8 @@ __export(registry_exports, {
   skillRegistry: () => skillRegistry
 });
 module.exports = __toCommonJS(registry_exports);
-var fs11 = __toESM(require("fs"), 1);
-var path11 = __toESM(require("path"), 1);
+var fs10 = __toESM(require("fs"), 1);
+var path10 = __toESM(require("path"), 1);
 
 // src/skills/builtin/a11y-review.ts
 init_reap_browser();
@@ -19720,8 +19792,8 @@ var skill = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path12 = await import("path");
-        const fs12 = await import("fs");
+        const path11 = await import("path");
+        const fs11 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -19776,9 +19848,9 @@ var skill = {
             warnings: issues.filter((i) => i.severity === "warning").length,
             tree: typeof tree === "string" ? tree : JSON.stringify(tree)
           };
-          const reportPath = path12.join(context.outputDir, "a11y-report.json");
-          fs12.mkdirSync(path12.dirname(reportPath), { recursive: true });
-          fs12.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`,
@@ -19816,8 +19888,8 @@ var skill2 = {
         }
       },
       async execute(params, context) {
-        const fs12 = await import("fs");
-        const path12 = 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];
@@ -19835,11 +19907,11 @@ var skill2 = {
             data: { package: params.packageName, status, ...entry }
           };
         }
-        const pkgPath = path12.join(context.projectDir, "package.json");
-        if (!fs12.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(fs12.readFileSync(pkgPath, "utf8"));
+        const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf8"));
         const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
         const results = {
           full: [],
@@ -19857,9 +19929,9 @@ var skill2 = {
             results.unknown.push(dep);
           }
         }
-        const reportPath = path12.join(context.outputDir, "compat-report.json");
-        fs12.mkdirSync(path12.dirname(reportPath), { recursive: true });
-        fs12.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`,
@@ -19897,8 +19969,8 @@ var skill3 = {
         record: { type: "boolean", description: "Record video of the flow" }
       },
       async execute(params, context) {
-        const fs12 = await import("fs");
-        const path12 = 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));
@@ -19907,7 +19979,7 @@ var skill3 = {
         const host = new SootSimBridgeHost2({ port: DEFAULT_SOOTSIM_BRIDGE_PORT2 });
         host.start({ silent: true });
         try {
-          const flowContent = fs12.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);
@@ -19932,7 +20004,7 @@ var skill3 = {
           });
           const driver = new SootSimBridgeFlowRunner2(bridge, {
             screenshotDir: context.outputDir,
-            flowDir: path12.dirname(path12.resolve(params.flowPath)),
+            flowDir: path11.dirname(path11.resolve(params.flowPath)),
             simId,
             recordingOutputDir: params.record ? context.outputDir : void 0
           });
@@ -19954,7 +20026,7 @@ var skill3 = {
                 simId,
                 videoPath: videoPath || void 0
               },
-              artifacts: videoPath ? [{ type: "video", name: path12.basename(videoPath), path: videoPath }] : void 0
+              artifacts: videoPath ? [{ type: "video", name: path11.basename(videoPath), path: videoPath }] : void 0
             };
           } finally {
             try {
@@ -20001,8 +20073,8 @@ var skill4 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path12 = await import("path");
-        const fs12 = await import("fs");
+        const path11 = await import("path");
+        const fs11 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -20028,9 +20100,9 @@ var skill4 = {
             ...profile,
             fps: syncCount > 0 ? (syncCount / (duration / 1e3)).toFixed(1) : "0"
           };
-          const reportPath = path12.join(context.outputDir, "perf-report.json");
-          fs12.mkdirSync(path12.dirname(reportPath), { recursive: true });
-          fs12.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`,
@@ -20063,8 +20135,8 @@ var skill5 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path12 = await import("path");
-        const fs12 = await import("fs");
+        const path11 = await import("path");
+        const fs11 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -20072,8 +20144,8 @@ var skill5 = {
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const outputPath = path12.join(context.outputDir, `${params.name}.png`);
-          fs12.mkdirSync(path12.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,
@@ -20114,8 +20186,8 @@ var skill6 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path12 = await import("path");
-        const fs12 = await import("fs");
+        const path11 = await import("path");
+        const fs11 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -20123,14 +20195,14 @@ var skill6 = {
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const currentPath = path12.join(context.outputDir, `${params.name}-current.png`);
-          fs12.mkdirSync(path12.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(fs12.readFileSync(params.baseline));
-            const current = PNG.sync.read(fs12.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(
@@ -20141,8 +20213,8 @@ var skill6 = {
               height,
               { threshold: params.threshold || 0.1 }
             );
-            const diffPath = path12.join(context.outputDir, `${params.name}-diff.png`);
-            fs12.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 {
@@ -20206,10 +20278,10 @@ var skillRegistry = {
   },
   // load skills from a project manifest (sootsim-skills.json)
   async loadFromManifest(projectDir) {
-    const manifestPath = path11.join(projectDir, "sootsim-skills.json");
-    if (!fs11.existsSync(manifestPath)) return;
+    const manifestPath = path10.join(projectDir, "sootsim-skills.json");
+    if (!fs10.existsSync(manifestPath)) return;
     try {
-      const manifest = JSON.parse(fs11.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") {
@@ -20220,7 +20292,7 @@ var skillRegistry = {
             }
           } else if (entry.file) {
             try {
-              const mod = await import(path11.resolve(projectDir, entry.file));
+              const mod = await import(path10.resolve(projectDir, entry.file));
               if (mod.skill) this.register(mod.skill);
             } catch {
             }
@@ -20233,10 +20305,10 @@ var skillRegistry = {
   // auto-discover skills based on project dependencies
   suggestSkills(projectDir) {
     const suggestions = [];
-    const pkgPath = path11.join(projectDir, "package.json");
-    if (!fs11.existsSync(pkgPath)) return suggestions;
+    const pkgPath = path10.join(projectDir, "package.json");
+    if (!fs10.existsSync(pkgPath)) return suggestions;
     try {
-      const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps["detox"] || deps["maestro"]) {
         suggestions.push("maestro-test");