sootsim 0.1.176 → 0.1.178

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.176 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.178 | (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;
@@ -3497,6 +3497,19 @@ var init_registry = __esm({
           }
         ]
       },
+      "@bottom-tabs/react-navigation": {
+        category: "Navigation",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.95,
+            note: "pure JS React Navigation adapter over react-native-bottom-tabs; native tab rendering flows through the bottom-tabs seam",
+            working: "createNativeBottomTabNavigator, Navigator, Screen options for title/label/icon/badge/lazy/freeze/testID/role, and TabView-level translucent/labeled/haptic/scroll-edge props via react-native-bottom-tabs",
+            missing: "fidelity is bounded by the react-native-bottom-tabs native seam; no separate web tab implementation is provided by this adapter"
+          }
+        ]
+      },
       "@react-navigation/stack": {
         category: "Navigation",
         stubType: "works",
@@ -5530,9 +5543,9 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=1.0.0",
-            coverage: 0.85,
-            note: "load-safe noop \u2014 Editor passes children through",
-            missing: "no native markdown editing \u2014 recommended swap: marked/markdown-it + textarea on web"
+            coverage: 0.65,
+            note: "native seam for EnrichedMarkdownText/EnrichedMarkdown/EnrichedMarkdownTextInput generated host components; upstream JS wrapper and Streamdown integration run unchanged",
+            missing: "native MD4C fidelity, selection menus, spoilers, math, images, and editable rich-markdown commands are simplified"
           }
         ]
       },
@@ -10106,10 +10119,10 @@ function tcpPing(port, timeout = TCP_GATE_MS) {
     sock.connect(port, "localhost");
   });
 }
-function httpGet(port, path9, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(port, path10, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve6) => {
     const req = import_http.default.request(
-      { hostname: "localhost", port, path: path9, method, timeout, headers },
+      { hostname: "localhost", port, path: path10, method, timeout, headers },
       (res) => {
         let body = "";
         res.on("data", (c) => body += c.toString());
@@ -11724,6 +11737,97 @@ var init_agent_sessions = __esm({
   }
 });
 
+// src/agent-identity.ts
+function agentbusSessionIdFromCliIdentity(identity) {
+  if (!identity?.startsWith("AGENTBUS_SESSION:")) return null;
+  const sessionId = identity.slice("AGENTBUS_SESSION:".length).trim();
+  if (!AGENTBUS_SESSION_RE.test(sessionId)) return null;
+  return sessionId;
+}
+function isValidAgentbusSessionId(sessionId) {
+  return AGENTBUS_SESSION_RE.test(sessionId);
+}
+var AGENTBUS_SESSION_RE;
+var init_agent_identity = __esm({
+  "src/agent-identity.ts"() {
+    "use strict";
+    AGENTBUS_SESSION_RE = /^[A-Za-z0-9._:-]{1,160}$/;
+  }
+});
+
+// src/agentbus-prompt.ts
+function formatAgentbusPromptText(prompt) {
+  return typeof prompt.text === "string" ? prompt.text.trim() : "";
+}
+function resolveAgentbusCommand(explicit) {
+  const fromArg = explicit?.trim();
+  if (fromArg) return fromArg;
+  const fromEnv = process.env.AGENTBUS_COMMAND?.trim();
+  if (fromEnv) return fromEnv;
+  const localBin = import_node_path4.default.join(import_node_os2.default.homedir(), ".local", "bin", "agentbus");
+  if (import_node_fs5.default.existsSync(localBin)) return localBin;
+  return "agentbus";
+}
+async function sendPromptToAgentbusSession(input) {
+  const sessionId = input.sessionId.trim();
+  if (!isValidAgentbusSessionId(sessionId)) {
+    throw new Error(`invalid agentbus session id: ${sessionId || "<empty>"}`);
+  }
+  const text = formatAgentbusPromptText(input.prompt);
+  if (!text) {
+    throw new Error("prompt text is empty");
+  }
+  const command = resolveAgentbusCommand(input.command);
+  const timeoutMs = input.timeoutMs ?? 15e3;
+  await new Promise((resolve6, reject) => {
+    const child = (0, import_node_child_process2.spawn)(command, ["send", sessionId, text], {
+      stdio: ["ignore", "ignore", "pipe"],
+      env: process.env
+    });
+    let stderr = "";
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      reject(new Error(`agentbus send timed out after ${Math.round(timeoutMs / 1e3)}s`));
+    }, timeoutMs);
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < 4e3) stderr += String(chunk);
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("exit", (code, signal) => {
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve6();
+        return;
+      }
+      const detail = stderr.trim();
+      reject(
+        new Error(
+          detail || `agentbus send exited with ${signal ? `signal ${signal}` : `code ${code ?? "unknown"}`}`
+        )
+      );
+    });
+  });
+}
+var import_node_child_process2, import_node_fs5, import_node_os2, import_node_path4;
+var init_agentbus_prompt = __esm({
+  "src/agentbus-prompt.ts"() {
+    "use strict";
+    import_node_child_process2 = require("node:child_process");
+    import_node_fs5 = __toESM(require("node:fs"), 1);
+    import_node_os2 = __toESM(require("node:os"), 1);
+    import_node_path4 = __toESM(require("node:path"), 1);
+    init_agent_identity();
+    init_agent_identity();
+  }
+});
+
 // src/host/agent-host.ts
 function defaultExcludePorts() {
   return [
@@ -11738,14 +11842,15 @@ function mapFrameworkToProjectFramework(fw) {
   if (fw === "one" || fw === "vxrn") return "one";
   return "unknown";
 }
-var import_node_fs5, import_node_path4, WS_OPEN, AgentHost;
+var import_node_fs6, import_node_path5, WS_OPEN, AgentHost;
 var init_agent_host = __esm({
   "src/host/agent-host.ts"() {
     "use strict";
-    import_node_fs5 = __toESM(require("node:fs"), 1);
-    import_node_path4 = __toESM(require("node:path"), 1);
+    import_node_fs6 = __toESM(require("node:fs"), 1);
+    import_node_path5 = __toESM(require("node:path"), 1);
     init_dev_server_scanner();
     init_agent_sessions();
+    init_agentbus_prompt();
     init_attached_projects();
     WS_OPEN = 1;
     AgentHost = class {
@@ -11845,6 +11950,8 @@ var init_agent_host = __esm({
             return listSessions(msg.projectId ? String(msg.projectId) : void 0);
           case "agent:start-session":
             return this.doStartSession(msg.input ?? {});
+          case "agent:send-claimed-prompt":
+            return this.sendClaimedPrompt(msg);
           case "agent:send-prompt": {
             const sessionId = String(msg.sessionId);
             const session = findSessionById(sessionId);
@@ -11876,6 +11983,28 @@ var init_agent_host = __esm({
         }
       }
       // --- operation impls ---
+      async sendClaimedPrompt(msg) {
+        const simId = typeof msg.simId === "string" ? msg.simId.trim() : "";
+        if (!simId) {
+          throw new AgentSessionError("NO_SIM", "agent:send-claimed-prompt requires simId");
+        }
+        const lease = this.opts.resolveCliLease?.(simId) ?? null;
+        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);
+        if (!sessionId) {
+          throw new AgentSessionError(
+            "UNSUPPORTED_CLAIM",
+            `sim ${simId} is claimed by a CLI identity that is not promptable`
+          );
+        }
+        await sendPromptToAgentbusSession({
+          sessionId,
+          prompt: this.normalizePromptEnvelope(msg)
+        });
+        return { ok: true, routed: "agentbus", sessionId };
+      }
       async doStartSession(input) {
         const project = findProjectById(input.projectId);
         if (!project) {
@@ -11905,7 +12034,7 @@ var init_agent_host = __esm({
         );
         const project = upsertProject({
           cwd: match.cwd,
-          name: match.projectName ?? import_node_path4.default.basename(match.cwd),
+          name: match.projectName ?? import_node_path5.default.basename(match.cwd),
           preferredProvider: input.provider ?? existing?.preferredProvider,
           sourceRoots: existing?.sourceRoots ?? [match.cwd],
           knownBundleUrls,
@@ -11916,18 +12045,18 @@ var init_agent_host = __esm({
       }
       getTranscript(sessionId) {
         const p = transcriptPath(sessionId);
-        if (!import_node_fs5.default.existsSync(p)) {
+        if (!import_node_fs6.default.existsSync(p)) {
           return { error: "transcript not found", code: "NO_TRANSCRIPT" };
         }
-        return import_node_fs5.default.readFileSync(p, "utf8");
+        return import_node_fs6.default.readFileSync(p, "utf8");
       }
       getPaths() {
         const dir = getUserDataDir();
         return {
           userDataDir: dir,
-          storeFile: import_node_path4.default.join(dir, "attached-projects.json"),
-          sessionsDir: import_node_path4.default.join(dir, "sessions"),
-          transcriptsDir: import_node_path4.default.join(dir, "transcripts")
+          storeFile: import_node_path5.default.join(dir, "attached-projects.json"),
+          sessionsDir: import_node_path5.default.join(dir, "sessions"),
+          transcriptsDir: import_node_path5.default.join(dir, "transcripts")
         };
       }
       // --- subscription management ---
@@ -12967,7 +13096,18 @@ var init_bridge_host = __esm({
         this.shouldWriteDevLockfile = opts.writeDevLockfile === true;
         this.portFallbackCount = Math.max(1, opts.portFallbackCount ?? 10);
         this.openUrlHandler = opts.openUrl;
-        this.agentHost = new AgentHost({ getExcludePorts: opts.agentScanExcludes });
+        this.agentHost = new AgentHost({
+          getExcludePorts: opts.agentScanExcludes,
+          resolveCliLease: (simId) => {
+            const sim = this.sims.get(simId);
+            const lease = sim ? this.getActiveLease(sim) : null;
+            return lease ? {
+              kind: lease.kind,
+              cliIdentityKey: lease.cliIdentityKey,
+              expiresAt: lease.expiresAt
+            } : null;
+          }
+        });
         this.sootbeanOrigin = opts.sootbeanOrigin?.replace(/\/$/, "") || null;
         this.simIdleReapTtlMs = opts.simIdleReapTtlMs ?? _SootSimBridgeHost.SIM_IDLE_REAP_TTL_MS;
         this.automationSimIdleReapTtlMs = opts.automationSimIdleReapTtlMs ?? _SootSimBridgeHost.AUTOMATION_SIM_IDLE_REAP_TTL_MS;
@@ -14787,6 +14927,8 @@ var init_current_sim = __esm({
     IDENTITY_ENV_VARS = [
       "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
       "CLAUDE_CODE_SESSION_ID",
       // claude code, if ever set
       "CODEX_THREAD_ID",
@@ -15141,11 +15283,11 @@ async function evalInBridge(bridge, code, opts = {}) {
   if (opts.acquireLock) payload.acquireLock = true;
   return bridge.send(payload);
 }
-async function callInBridge(bridge, path9, ...args) {
-  return bridge.send({ type: "call", path: path9, args });
+async function callInBridge(bridge, path10, ...args) {
+  return bridge.send({ type: "call", path: path10, args });
 }
-async function callInBridgeWrite(bridge, path9, ...args) {
-  return bridge.send({ type: "call", path: path9, args, acquireLock: true });
+async function callInBridgeWrite(bridge, path10, ...args) {
+  return bridge.send({ type: "call", path: path10, args, acquireLock: true });
 }
 var import_ws3, BridgeSimLockedError;
 var init_ws_bridge = __esm({
@@ -16148,14 +16290,14 @@ process.stdin.on('end', async () => {
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path5.dirname)((0, import_node_path5.resolve)(explicit));
+    return (0, import_node_path6.dirname)((0, import_node_path6.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path5.resolve)(explicit);
-  return (0, import_node_path5.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path6.resolve)(explicit);
+  return (0, import_node_path6.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -16201,26 +16343,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs6.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs7.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs6.rmSync)(filepath, { force: true });
+      (0, import_node_fs7.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs6.rmSync)(filepath, { force: true });
+    (0, import_node_fs7.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs6, import_node_path5, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs7, import_node_path6, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs6 = require("node:fs");
-    import_node_path5 = require("node:path");
+    import_node_fs7 = require("node:fs");
+    import_node_path6 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;
     SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
@@ -16230,13 +16372,13 @@ var init_shared_session = __esm({
 
 // cli/auth.ts
 function credentialsPath() {
-  return (0, import_node_path6.join)(electronUserDataDir(), "credentials.json");
+  return (0, import_node_path7.join)(electronUserDataDir(), "credentials.json");
 }
 function readStoredApiKey() {
   const file = credentialsPath();
-  if (!(0, import_node_fs7.existsSync)(file)) return null;
+  if (!(0, import_node_fs8.existsSync)(file)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(file, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs8.readFileSync)(file, "utf8"));
     if (parsed.version !== 1) return null;
     if (typeof parsed.apiKey !== "string" || !parsed.apiKey.startsWith("sk_sootsim_")) {
       return null;
@@ -16292,12 +16434,12 @@ function resolveCliAuth() {
 function authHeaderValue(auth) {
   return auth.kind === "api-key" ? `Bearer ${auth.secret}` : `Bearer ${auth.token}`;
 }
-var import_node_fs7, import_node_path6, GITHUB_TOKEN_PREFIXES;
+var import_node_fs8, import_node_path7, GITHUB_TOKEN_PREFIXES;
 var init_auth = __esm({
   "cli/auth.ts"() {
     "use strict";
-    import_node_fs7 = require("node:fs");
-    import_node_path6 = require("node:path");
+    import_node_fs8 = require("node:fs");
+    import_node_path7 = require("node:path");
     init_shared_session();
     init_home_paths();
     GITHUB_TOKEN_PREFIXES = ["ghs_", "ghp_", "gho_", "ghu_", "github_pat_"];
@@ -16487,16 +16629,16 @@ function resolveFlowScreenshotPath(screenshotDir, name) {
 }
 function resolveProjectRelativeFlowBase(flowDir) {
   if (!flowDir) return process.cwd();
-  return path7.basename(flowDir) === ".maestro" ? path7.dirname(flowDir) : flowDir;
+  return path8.basename(flowDir) === ".maestro" ? path8.dirname(flowDir) : flowDir;
 }
 function resolveFlowScreenshotPathWithMode(screenshotDir, name, opts) {
   const normalizedName = name.endsWith(".png") ? name : `${name}.png`;
-  if (path7.isAbsolute(normalizedName)) return normalizedName;
+  if (path8.isAbsolute(normalizedName)) return normalizedName;
   if (opts.mode === "flow" && /[\\/]/.test(normalizedName)) {
     const baseDir = normalizedName.startsWith("./") || normalizedName.startsWith("../") ? opts.flowDir ?? process.cwd() : resolveProjectRelativeFlowBase(opts.flowDir);
-    return path7.resolve(baseDir, normalizedName);
+    return path8.resolve(baseDir, normalizedName);
   }
-  return path7.join(screenshotDir, normalizedName);
+  return path8.join(screenshotDir, normalizedName);
 }
 function normalizeFlowScreenshotSpec(step) {
   if (typeof step === "string") {
@@ -16551,12 +16693,12 @@ function parseFlowSteps(content) {
   const parsed = import_yaml.default.parse(candidate);
   return Array.isArray(parsed) ? parsed : [];
 }
-var fs7, path7, import_settings2, import_yaml, DEFAULT_TIMEOUT, SCREEN_W, SCREEN_H, CLI_PERF_SESSION_GLOBAL, SootSimBridgeFlowRunner;
+var fs8, path8, import_settings2, import_yaml, DEFAULT_TIMEOUT, SCREEN_W, SCREEN_H, CLI_PERF_SESSION_GLOBAL, SootSimBridgeFlowRunner;
 var init_bridge_flow_runner = __esm({
   "cli/bridge-flow-runner.ts"() {
     "use strict";
-    fs7 = __toESM(require("fs"), 1);
-    path7 = __toESM(require("path"), 1);
+    fs8 = __toESM(require("fs"), 1);
+    path8 = __toESM(require("path"), 1);
     import_settings2 = require("sootsim-engine/settings");
     import_yaml = __toESM(require("yaml"), 1);
     init_frame_compose();
@@ -16778,14 +16920,14 @@ var init_bridge_flow_runner = __esm({
         if (chunks.length === 0) {
           throw new Error("recording requested but no video buffer was produced");
         }
-        fs7.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
+        fs8.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
         const videoMime = stopped.mime || this.opts.recordingFormat || "video/webm";
         const extension = videoMime.includes("mp4") ? "mp4" : "webm";
-        const outputPath = path7.join(
+        const outputPath = path8.join(
           this.opts.recordingOutputDir,
           `sootsim-${Date.now()}.${extension}`
         );
-        fs7.writeFileSync(outputPath, Buffer.concat(chunks));
+        fs8.writeFileSync(outputPath, Buffer.concat(chunks));
         return outputPath;
       }
       async waitForRecordingTail(opts) {
@@ -17198,7 +17340,7 @@ var init_bridge_flow_runner = __esm({
             flowDir: this.opts.flowDir
           }
         );
-        fs7.mkdirSync(path7.dirname(outputPath), { recursive: true });
+        fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
         const layers = spec.layers ?? this.opts.screenshotLayers;
         const screenshotRequest = {
           type: "screenshot",
@@ -17214,11 +17356,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);
-          fs7.writeFileSync(outputPath, framed);
+          fs8.writeFileSync(outputPath, framed);
           console.log(`[flow] screenshot: ${outputPath} (frame: ${model})`);
           return;
         }
-        fs7.writeFileSync(outputPath, rawBuffer);
+        fs8.writeFileSync(outputPath, rawBuffer);
         console.log(`[flow] screenshot: ${outputPath}`);
       }
       async readCurrentDeviceModel() {
@@ -17233,22 +17375,22 @@ var init_bridge_flow_runner = __esm({
         return model;
       }
       async captureFailureScreenshot(outputPath) {
-        fs7.mkdirSync(path7.dirname(outputPath), { recursive: true });
+        fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
         const dataUrl = await this.bridge.send({
           type: "screenshot",
           simId: this.opts.simId
         });
         const base64 = dataUrl.replace(/^data:image\/png;base64,/, "");
-        fs7.writeFileSync(outputPath, Buffer.from(base64, "base64"));
+        fs8.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) {
-        fs7.mkdirSync(outputDir, { recursive: true });
+        fs8.mkdirSync(outputDir, { recursive: true });
         const write = (name, content) => {
           try {
-            fs7.writeFileSync(path7.join(outputDir, name), content);
+            fs8.writeFileSync(path8.join(outputDir, name), content);
           } catch {
           }
         };
@@ -17749,8 +17891,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 = path7.resolve(this.opts.flowDir, spec.file);
-        const source = fs7.readFileSync(scriptPath, "utf8");
+        const scriptPath = path8.resolve(this.opts.flowDir, spec.file);
+        const source = fs8.readFileSync(scriptPath, "utf8");
         this.js.evaluate(source, { env: spec.env });
         console.log(`[flow]   runScript: ${spec.file} done`);
       }
@@ -17989,10 +18131,10 @@ var init_bridge_flow_runner = __esm({
               for (const [k, v] of Object.entries(env)) this.js.putEnv(k, v);
             }
             if (file) {
-              const flowPath = path7.resolve(this.opts.flowDir, file);
-              const flowContent = fs7.readFileSync(flowPath, "utf8");
+              const flowPath = path8.resolve(this.opts.flowDir, file);
+              const flowContent = fs8.readFileSync(flowPath, "utf8");
               const previousDir = this.opts.flowDir;
-              this.opts.flowDir = path7.dirname(flowPath);
+              this.opts.flowDir = path8.dirname(flowPath);
               try {
                 await this.runFlow(parseFlowSteps(flowContent));
               } finally {
@@ -18088,8 +18230,8 @@ __export(registry_exports, {
   skillRegistry: () => skillRegistry
 });
 module.exports = __toCommonJS(registry_exports);
-var fs8 = __toESM(require("fs"), 1);
-var path8 = __toESM(require("path"), 1);
+var fs9 = __toESM(require("fs"), 1);
+var path9 = __toESM(require("path"), 1);
 
 // src/skills/builtin/a11y-review.ts
 var skill = {
@@ -18107,8 +18249,8 @@ var skill = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path9 = await import("path");
-        const fs9 = await import("fs");
+        const path10 = await import("path");
+        const fs10 = await import("fs");
         const browser = await chromium.launch({ channel: "chrome", headless: true });
         const page = await browser.newPage({ viewport: { width: 500, height: 900 } });
         try {
@@ -18161,9 +18303,9 @@ var skill = {
             warnings: issues.filter((i) => i.severity === "warning").length,
             tree: typeof tree === "string" ? tree : JSON.stringify(tree)
           };
-          const reportPath = path9.join(context.outputDir, "a11y-report.json");
-          fs9.mkdirSync(path9.dirname(reportPath), { recursive: true });
-          fs9.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path10.join(context.outputDir, "a11y-report.json");
+          fs10.mkdirSync(path10.dirname(reportPath), { recursive: true });
+          fs10.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`,
@@ -18201,8 +18343,8 @@ var skill2 = {
         }
       },
       async execute(params, context) {
-        const fs9 = await import("fs");
-        const path9 = await import("path");
+        const fs10 = await import("fs");
+        const path10 = 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];
@@ -18220,11 +18362,11 @@ var skill2 = {
             data: { package: params.packageName, status, ...entry }
           };
         }
-        const pkgPath = path9.join(context.projectDir, "package.json");
-        if (!fs9.existsSync(pkgPath)) {
+        const pkgPath = path10.join(context.projectDir, "package.json");
+        if (!fs10.existsSync(pkgPath)) {
           return { success: false, message: "No package.json found" };
         }
-        const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf8"));
+        const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf8"));
         const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
         const results = {
           full: [],
@@ -18242,9 +18384,9 @@ var skill2 = {
             results.unknown.push(dep);
           }
         }
-        const reportPath = path9.join(context.outputDir, "compat-report.json");
-        fs9.mkdirSync(path9.dirname(reportPath), { recursive: true });
-        fs9.writeFileSync(reportPath, JSON.stringify(results, null, 2));
+        const reportPath = path10.join(context.outputDir, "compat-report.json");
+        fs10.mkdirSync(path10.dirname(reportPath), { recursive: true });
+        fs10.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`,
@@ -18282,8 +18424,8 @@ var skill3 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path9 = await import("path");
-        const fs9 = await import("fs");
+        const path10 = await import("path");
+        const fs10 = await import("fs");
         const browser = await chromium.launch({ channel: "chrome", headless: true });
         const page = await browser.newPage({ viewport: { width: 500, height: 900 } });
         try {
@@ -18307,9 +18449,9 @@ var skill3 = {
             ...profile,
             fps: syncCount > 0 ? (syncCount / (duration / 1e3)).toFixed(1) : "0"
           };
-          const reportPath = path9.join(context.outputDir, "perf-report.json");
-          fs9.mkdirSync(path9.dirname(reportPath), { recursive: true });
-          fs9.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path10.join(context.outputDir, "perf-report.json");
+          fs10.mkdirSync(path10.dirname(reportPath), { recursive: true });
+          fs10.writeFileSync(reportPath, JSON.stringify(report, null, 2));
           return {
             success: true,
             message: `${report.fps} fps, ${profile.avgSyncMs?.toFixed(1)}ms avg sync, ${nodeCount} nodes`,
@@ -18341,15 +18483,15 @@ var skill4 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path9 = await import("path");
-        const fs9 = await import("fs");
+        const path10 = await import("path");
+        const fs10 = 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 = path9.join(context.outputDir, `${params.name}.png`);
-          fs9.mkdirSync(path9.dirname(outputPath), { recursive: true });
+          const outputPath = path10.join(context.outputDir, `${params.name}.png`);
+          fs10.mkdirSync(path10.dirname(outputPath), { recursive: true });
           await page.screenshot({ path: outputPath });
           return {
             success: true,
@@ -18387,8 +18529,8 @@ var skill5 = {
         record: { type: "boolean", description: "Record video of the flow" }
       },
       async execute(params, context) {
-        const fs9 = await import("fs");
-        const path9 = await import("path");
+        const fs10 = await import("fs");
+        const path10 = 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));
@@ -18397,7 +18539,7 @@ var skill5 = {
         const host = new SootSimBridgeHost2({ port: DEFAULT_SOOTSIM_BRIDGE_PORT2 });
         host.start({ silent: true });
         try {
-          const flowContent = fs9.readFileSync(params.flowPath, "utf8");
+          const flowContent = fs10.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);
@@ -18422,7 +18564,7 @@ var skill5 = {
           });
           const driver = new SootSimBridgeFlowRunner2(bridge, {
             screenshotDir: context.outputDir,
-            flowDir: path9.dirname(path9.resolve(params.flowPath)),
+            flowDir: path10.dirname(path10.resolve(params.flowPath)),
             simId,
             recordingOutputDir: params.record ? context.outputDir : void 0
           });
@@ -18444,7 +18586,7 @@ var skill5 = {
                 simId,
                 videoPath: videoPath || void 0
               },
-              artifacts: videoPath ? [{ type: "video", name: path9.basename(videoPath), path: videoPath }] : void 0
+              artifacts: videoPath ? [{ type: "video", name: path10.basename(videoPath), path: videoPath }] : void 0
             };
           } finally {
             try {
@@ -18492,21 +18634,21 @@ var skill6 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path9 = await import("path");
-        const fs9 = await import("fs");
+        const path10 = await import("path");
+        const fs10 = 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 = path9.join(context.outputDir, `${params.name}-current.png`);
-          fs9.mkdirSync(path9.dirname(currentPath), { recursive: true });
+          const currentPath = path10.join(context.outputDir, `${params.name}-current.png`);
+          fs10.mkdirSync(path10.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(fs9.readFileSync(params.baseline));
-            const current = PNG.sync.read(fs9.readFileSync(currentPath));
+            const baseline = PNG.sync.read(fs10.readFileSync(params.baseline));
+            const current = PNG.sync.read(fs10.readFileSync(currentPath));
             const { width, height } = baseline;
             const diff = new PNG({ width, height });
             const numDiffPixels = pixelmatch(
@@ -18517,8 +18659,8 @@ var skill6 = {
               height,
               { threshold: params.threshold || 0.1 }
             );
-            const diffPath = path9.join(context.outputDir, `${params.name}-diff.png`);
-            fs9.writeFileSync(diffPath, PNG.sync.write(diff));
+            const diffPath = path10.join(context.outputDir, `${params.name}-diff.png`);
+            fs10.writeFileSync(diffPath, PNG.sync.write(diff));
             const totalPixels = width * height;
             const diffPercent = (numDiffPixels / totalPixels * 100).toFixed(2);
             return {
@@ -18582,10 +18724,10 @@ var skillRegistry = {
   },
   // load skills from a project manifest (sootsim-skills.json)
   async loadFromManifest(projectDir) {
-    const manifestPath = path8.join(projectDir, "sootsim-skills.json");
-    if (!fs8.existsSync(manifestPath)) return;
+    const manifestPath = path9.join(projectDir, "sootsim-skills.json");
+    if (!fs9.existsSync(manifestPath)) return;
     try {
-      const manifest = JSON.parse(fs8.readFileSync(manifestPath, "utf8"));
+      const manifest = JSON.parse(fs9.readFileSync(manifestPath, "utf8"));
       if (Array.isArray(manifest.skills)) {
         for (const entry of manifest.skills) {
           if (typeof entry === "string") {
@@ -18596,7 +18738,7 @@ var skillRegistry = {
             }
           } else if (entry.file) {
             try {
-              const mod = await import(path8.resolve(projectDir, entry.file));
+              const mod = await import(path9.resolve(projectDir, entry.file));
               if (mod.skill) this.register(mod.skill);
             } catch {
             }
@@ -18609,10 +18751,10 @@ var skillRegistry = {
   // auto-discover skills based on project dependencies
   suggestSkills(projectDir) {
     const suggestions = [];
-    const pkgPath = path8.join(projectDir, "package.json");
-    if (!fs8.existsSync(pkgPath)) return suggestions;
+    const pkgPath = path9.join(projectDir, "package.json");
+    if (!fs9.existsSync(pkgPath)) return suggestions;
     try {
-      const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps["detox"] || deps["maestro"]) {
         suggestions.push("test-flow");