sootsim 0.1.175 → 0.1.177

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.175 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.177 | (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;
@@ -5530,9 +5530,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"
           }
         ]
       },
@@ -9962,6 +9962,12 @@ function resolveSootsimBridgePortForRuntimeLocation(input = {}) {
   const hrefUrl = parseHrefUrl(input.href);
   const httpPort = parsePort(input.httpPort) ?? parsePort(hrefUrl?.port);
   if (httpPort === null) return DEFAULT_SOOTSIM_BRIDGE_PORT;
+  if (hrefUrl?.pathname.startsWith("/sootsim") && (hrefUrl.searchParams.has("embed") || hrefUrl.searchParams.has("nativePreview"))) {
+    return resolveSootsimBridgePortForHttpPort({
+      httpPort,
+      baseHttpPort: SOOTBEAN_DEV_HTTP_BASE_PORT
+    });
+  }
   if (hrefUrl?.pathname.startsWith("/sootsim") && httpPort >= SOOTSIM_SITE_DEV_HTTP_BASE_PORT && httpPort <= SOOTSIM_SITE_DEV_HTTP_BASE_PORT + MAX_LOCAL_DEV_PORT_OFFSET) {
     return resolveSootsimBridgePortForHttpPort({
       httpPort,
@@ -10100,10 +10106,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());
@@ -11718,6 +11724,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 [
@@ -11732,14 +11829,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 {
@@ -11839,6 +11937,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);
@@ -11870,6 +11970,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) {
@@ -11899,7 +12021,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,
@@ -11910,18 +12032,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 ---
@@ -12961,7 +13083,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;
@@ -14781,6 +14914,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",
@@ -15135,11 +15270,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({
@@ -16142,14 +16277,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;
@@ -16195,26 +16330,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";
@@ -16224,13 +16359,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;
@@ -16286,12 +16421,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_"];
@@ -16481,16 +16616,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") {
@@ -16545,12 +16680,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();
@@ -16772,14 +16907,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) {
@@ -17192,7 +17327,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",
@@ -17208,11 +17343,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() {
@@ -17227,22 +17362,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 {
           }
         };
@@ -17743,8 +17878,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`);
       }
@@ -17983,10 +18118,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 {
@@ -18082,8 +18217,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 = {
@@ -18101,8 +18236,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 {
@@ -18155,9 +18290,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`,
@@ -18195,8 +18330,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];
@@ -18214,11 +18349,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: [],
@@ -18236,9 +18371,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`,
@@ -18276,8 +18411,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 {
@@ -18301,9 +18436,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`,
@@ -18335,15 +18470,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,
@@ -18381,8 +18516,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));
@@ -18391,7 +18526,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);
@@ -18416,7 +18551,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
           });
@@ -18438,7 +18573,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 {
@@ -18486,21 +18621,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(
@@ -18511,8 +18646,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 {
@@ -18576,10 +18711,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") {
@@ -18590,7 +18725,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 {
             }
@@ -18603,10 +18738,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");