@buoy-gg/mcp 7.0.30 → 7.0.32

package/dist/cli.js

@@ -640,7 +640,7 @@ var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 
 // src/server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_zod22 = require("zod");
+var import_zod24 = require("zod");
 
 // src/tools/generic.ts
 var import_zod = require("zod");
@@ -651,7 +651,7 @@ var import_node_os = __toESM(require("os"));
 var import_node_path = __toESM(require("path"));
 
 // src/version.ts
-var VERSION = "7.0.30" ? "7.0.30" : "0.0.0-dev";
+var VERSION = "7.0.32" ? "7.0.32" : "0.0.0-dev";
 var PACKAGE_NAME = "@buoy-gg/mcp";
 
 // src/update/checkForUpdate.ts
@@ -1384,7 +1384,7 @@ ${JSON.stringify(summary, null, 2)}
         let sawActive = false;
         let idleStreak = 0;
         let lastCount = -1;
-        let resolved = null;
+        let resolved2 = null;
         while (Date.now() - start < cap3) {
           let snap2;
           try {
@@ -1396,7 +1396,7 @@ ${JSON.stringify(summary, null, 2)}
           const completed = snap2.live?.automationCompleted;
           if (completed?.phase === "cancelled") return fail2(`Batch ${completed.batchId} was cancelled.`);
           if (completed?.phase === "done") {
-            resolved = { batchId: completed.batchId, failures: completed.failures ?? failuresFromIndex(snap2.index, completed.batchId) };
+            resolved2 = { batchId: completed.batchId, failures: completed.failures ?? failuresFromIndex(snap2.index, completed.batchId) };
             break;
           }
           const phase = snap2.live?.automation?.phase ?? "idle";
@@ -1406,11 +1406,11 @@ ${JSON.stringify(summary, null, 2)}
             const count = runCountFor(snap2.index, newest);
             if (count === lastCount) {
               if (sawActive && ++idleStreak >= 3) {
-                resolved = { batchId: newest, failures: failuresFromIndex(snap2.index, newest) };
+                resolved2 = { batchId: newest, failures: failuresFromIndex(snap2.index, newest) };
                 break;
               }
               if (!sawActive && Date.now() - start > 4e3) {
-                resolved = { batchId: newest, failures: failuresFromIndex(snap2.index, newest) };
+                resolved2 = { batchId: newest, failures: failuresFromIndex(snap2.index, newest) };
                 break;
               }
             } else {
@@ -1422,11 +1422,11 @@ ${JSON.stringify(summary, null, 2)}
           }
           await delay2(POLL_INTERVAL_MS);
         }
-        if (!resolved) return fail2("No automation batch completed within the wait window.");
+        if (!resolved2) return fail2("No automation batch completed within the wait window.");
         await sync.callAction(PERF_TOOL_ID, "refreshIndex", {}, target).catch(() => {
         });
         const snap = await readPerfSnapshot(sync, target);
-        const ranking = rankBatchFromIndex(snap.index ?? [], resolved.batchId, void 0, resolved.failures);
+        const ranking = rankBatchFromIndex(snap.index ?? [], resolved2.batchId, void 0, resolved2.failures);
         await sync.callAction(PERF_TOOL_ID, "acknowledgeAutomation", {}, target).catch(() => {
         });
         return text(`${formatRankingMarkdown(ranking)}
@@ -1753,8 +1753,8 @@ _${skipped} more withheld ${skipped === 1 ? "body was" : "bodies were"} not fetc
 }
 function bodyLines(e, fetched) {
   const got = e.id ? fetched.get(e.id) : void 0;
-  const label = (inline, resolved, omitted) => {
-    const value = inline ?? resolved;
+  const label = (inline, resolved2, omitted) => {
+    const value = inline ?? resolved2;
     if (value !== void 0 && value !== null) return truncate(value);
     if (!omitted) return "(none)";
     return got?.unresolved ? "(withheld \u2014 the device did not answer getEventBody)" : "(none)";
@@ -2911,8 +2911,303 @@ ${lines.join("\n")}`);
   );
 }
 
-// src/tools/packs/screenshot.ts
+// src/tools/packs/scenarios.ts
 var import_zod13 = require("zod");
+var SCENARIOS_TOOL_ID = "scenarios";
+var text12 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail13 = (message) => ({
+  isError: true,
+  content: [{ type: "text", text: message }]
+});
+var errMsg13 = (e) => e instanceof Error ? e.message : String(e);
+function varSpec(v) {
+  const opts = v.options?.length ? ` one of ${v.options.join("|")}` : "";
+  const def = v.default !== void 0 ? ` (default ${String(v.default)})` : "";
+  return `${v.key}: ${v.type}${opts}${def}`;
+}
+function summarize(s) {
+  const vars = s.vars?.length ? `
+  variables: ${s.vars.map(varSpec).join("; ")}` : "";
+  const steps = s.stepLines?.length ? `
+${s.stepLines.map((st) => `    \xB7 ${st.label}  [${st.durability}]`).join("\n")}` : "";
+  const meta = [
+    `v${s.version}`,
+    s.author,
+    s.usage?.runs ? `${s.usage.runs} run(s)` : null,
+    s.authoredAgainst ? `authored against ${s.authoredAgainst}` : null,
+    s.unsavedToRepo ? "unsaved to repo" : null
+  ].filter(Boolean).join(" \xB7 ");
+  const outcome = s.expectedOutcome ? `
+  expected: ${s.expectedOutcome}` : "";
+  return `- \`${s.id}\` **${s.name}** \u2014 ${meta}${vars}${outcome}${steps}`;
+}
+function renderSection(title, list, folders) {
+  if (!list.length) return `**${title} (0):**
+_none_`;
+  if (!folders.length) {
+    return `**${title} (${list.length}):**
+${list.map(summarize).join("\n")}`;
+  }
+  const parts = [`**${title} (${list.length}):**`];
+  for (const folder of folders) {
+    const inIt = list.filter(
+      (s) => (s.folder ?? "").toLowerCase() === folder.toLowerCase()
+    );
+    if (!inIt.length) continue;
+    parts.push(`_${folder} (${inIt.length})_
+${inIt.map(summarize).join("\n")}`);
+  }
+  const ungrouped = list.filter((s) => !s.folder);
+  if (ungrouped.length) {
+    parts.push(
+      `_Ungrouped (${ungrouped.length})_
+${ungrouped.map(summarize).join("\n")}`
+    );
+  }
+  return parts.join("\n");
+}
+function formatActive(a) {
+  const vars = Object.entries(a.varValues).map(([k, v]) => `${k}=${String(v)}`).join(", ");
+  return [
+    `**${a.name}** (\`${a.scenarioId}\` v${a.version}) \u2014 active since ${new Date(a.runAt).toISOString()}`,
+    vars ? `variables: ${vars}` : null,
+    `effects:
+${a.effects.map((e) => `  \xB7 ${e.label} [${e.kind}]`).join("\n")}`
+  ].filter(Boolean).join("\n");
+}
+function registerScenariosTools(server, sync) {
+  server.registerTool(
+    "get_scenarios",
+    {
+      description: "List the app's saved Scenarios \u2014 named, parameterized app states that can be applied with one call (override a response, write storage, impersonate a user, navigate). Shows what each one WILL do in plain English with a durability label per step, plus which scenario is currently active and what it changed. Use scenario_action to run one as a deterministic fixture BEFORE driving a flow, so the flow starts from a known state instead of whatever the app happened to be in. If a scenario is active, whatever you observe on the device is partly simulated \u2014 check here first when the app's data looks wrong.",
+      inputSchema: {
+        deviceId: import_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+      }
+    },
+    async (args) => {
+      try {
+        const target = sync.requireProDevice(args.deviceId);
+        const { payload } = await sync.getSnapshot(SCENARIOS_TOOL_ID, target);
+        const p = payload ?? {};
+        const code = p.code ?? [];
+        const device = p.device ?? [];
+        const drafts = p.drafts ?? [];
+        const folders = p.folders ?? [];
+        const parts = [];
+        parts.push(
+          p.active ? `\u26A0\uFE0F **SIMULATED \u2014 a scenario is active.** The app is showing bent state right now.
+${formatActive(p.active)}` : "**No scenario active** \u2014 the app is showing real data."
+        );
+        if (folders.length) {
+          parts.push(
+            `**Folders:** ${folders.join(" \xB7 ")} \u2014 the flows this team organizes by. Scenarios below are grouped under them; file new ones into an existing folder with \`scenario_action setFolder\` rather than inventing a name.`
+          );
+        }
+        parts.push(renderSection("Shipped with this app", code, folders));
+        parts.push(renderSection("Saved on this device", device, folders));
+        if (drafts.length) {
+          parts.push(
+            `**Drafts awaiting review on the device (${drafts.length}):** these are INERT and cannot run until a human accepts them on the device.
+${drafts.map(summarize).join("\n")}`
+          );
+        }
+        return text12(parts.join("\n\n"));
+      } catch (e) {
+        return fail13(errMsg13(e));
+      }
+    }
+  );
+  server.registerTool(
+    "scenario_action",
+    {
+      description: `Drive Buoy Scenarios: 'preview' dry-runs one and reports exactly what it WOULD change (plus any conflict with the active scenario) without touching the app \u2014 do this before running an unfamiliar scenario; 'run' applies it and resolves only once every step has landed, which makes it a deterministic fixture to call before run_flow; 'deactivate' reverses it and reports what it could NOT restore (storage writes have no automatic inverse); 'save' writes a new scenario onto the device \u2014 it lands as a DRAFT that a human must accept on the device before it can run, so tell the user to go accept it; 'setFolder' files a saved scenario under a flow ("Checkout", "Login") or clears its folder, which is how a QA library stays navigable \u2014 check get_scenarios for the folders already in use and reuse one instead of inventing a near-duplicate; 'delete' removes a device scenario. Prefer a network override step over a query-cache poke: the override survives refetch and restart, the poke dies on the next fetch.`,
+      inputSchema: {
+        action: import_zod13.z.enum(["preview", "run", "deactivate", "save", "setFolder", "delete"]).describe("What to do."),
+        folder: import_zod13.z.string().optional().describe(
+          "Folder name for action 'setFolder' \u2014 omit to un-file the scenario. Matching an existing folder case-insensitively files it there rather than creating a second one."
+        ),
+        id: import_zod13.z.string().optional().describe(
+          "Scenario id (required for preview/run/delete; from get_scenarios)."
+        ),
+        params: import_zod13.z.record(import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number(), import_zod13.z.boolean()])).optional().describe(
+          "Variable values for preview/run, e.g. {storeId:'220'}. Declared defaults fill in the rest."
+        ),
+        scenario: import_zod13.z.object({
+          id: import_zod13.z.string().describe("Stable kebab-case id."),
+          name: import_zod13.z.string().describe("Human name; may contain {{variable}} placeholders."),
+          description: import_zod13.z.string().optional(),
+          expectedOutcome: import_zod13.z.string().optional().describe(
+            "What SHOULD happen once applied \u2014 this is how a tester tells a bug from expected behavior without asking a developer. Write it."
+          ),
+          author: import_zod13.z.string().optional(),
+          authoredAgainst: import_zod13.z.string().optional().describe("App version this was written against."),
+          folder: import_zod13.z.string().optional().describe(
+            'The flow this belongs to \u2014 "Checkout", "Login". Reuse a folder from get_scenarios; a scenario nobody can find is a scenario nobody runs.'
+          ),
+          tags: import_zod13.z.array(import_zod13.z.string()).optional(),
+          vars: import_zod13.z.array(
+            import_zod13.z.object({
+              key: import_zod13.z.string(),
+              label: import_zod13.z.string().optional(),
+              type: import_zod13.z.enum(["string", "number", "boolean", "enum"]),
+              options: import_zod13.z.array(import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number(), import_zod13.z.boolean()])).optional(),
+              default: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number(), import_zod13.z.boolean()]).optional()
+            })
+          ).optional().describe(
+            "Declare a variable for every value a tester might want to change (a store id, a user, a status code) instead of freezing it into the steps."
+          ),
+          steps: import_zod13.z.array(
+            import_zod13.z.object({
+              id: import_zod13.z.string().optional(),
+              tool: import_zod13.z.string().describe(
+                "Tool id: network | storage | impersonate | route-events | query | time-machine"
+              ),
+              action: import_zod13.z.string().describe(
+                "Action name on that tool, e.g. upsertOverrideRule, async.setItem, startImpersonation, navigate."
+              ),
+              params: import_zod13.z.unknown().optional(),
+              label: import_zod13.z.string().optional()
+            })
+          ).describe("Steps, in order."),
+          undoSteps: import_zod13.z.array(
+            import_zod13.z.object({
+              id: import_zod13.z.string().optional(),
+              tool: import_zod13.z.string(),
+              action: import_zod13.z.string(),
+              params: import_zod13.z.unknown().optional(),
+              label: import_zod13.z.string().optional()
+            })
+          ).optional().describe(
+            "How to reverse effects that have no automatic inverse. Supply these whenever a step writes or removes storage, or deactivation will honestly report the key as unrestored."
+          )
+        }).optional().describe("The scenario to save (action 'save')."),
+        deviceId: import_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+      }
+    },
+    async (args) => {
+      try {
+        const target = sync.requireProDevice(args.deviceId);
+        const call = (action, params) => sync.callAction(SCENARIOS_TOOL_ID, action, params, target);
+        switch (args.action) {
+          case "preview": {
+            if (!args.id) return fail13("preview requires `id` (from get_scenarios).");
+            const r = await call("preview", {
+              id: args.id,
+              params: args.params ?? {}
+            });
+            const lines = [
+              `**Dry run \u2014 \`${args.id}\`** (nothing has been changed)`,
+              `variables: ${Object.entries(r.values).map(([k, v]) => `${k}=${String(v)}`).join(", ") || "none"}`,
+              `**Would do:**
+${r.willDo.map((s) => `  \xB7 ${s.label}  [${s.durability}]`).join("\n")}`
+            ];
+            if (r.expectedOutcome) lines.push(`**Expected outcome:** ${r.expectedOutcome}`);
+            if (r.conflict) {
+              lines.push(
+                `\u26A0\uFE0F **Conflict:** "${r.conflict.activeName}" is active and touches the same target(s): ${r.conflict.overlaps.join(", ")}. Running will SWAP \u2014 it deactivates first.`
+              );
+            }
+            if (r.warnings?.length) lines.push(`**Warnings:**
+${r.warnings.map((w) => `  \xB7 ${w}`).join("\n")}`);
+            lines.push(
+              r.ok ? "\u2705 Pre-flight passed \u2014 safe to run." : `\u274C **Cannot run:**
+${r.errors.map((e) => `  \xB7 ${e}`).join("\n")}`
+            );
+            return text12(lines.join("\n\n"));
+          }
+          case "run": {
+            if (!args.id) return fail13("run requires `id` (from get_scenarios).");
+            const r = await call("run", {
+              id: args.id,
+              params: args.params ?? {}
+            });
+            if (r.preflightErrors?.length) {
+              return fail13(
+                `Pre-flight refused to run \`${args.id}\` \u2014 nothing was changed:
+${r.preflightErrors.map((e) => `  \xB7 ${e}`).join("\n")}`
+              );
+            }
+            const steps = (r.steps ?? []).map((s) => {
+              const mark = s.skipped ? "\u2013" : s.ok ? "\u2713" : "\u2717";
+              const err = s.error ? `
+      ${s.error}` : "";
+              return `  ${mark} ${s.label} (${s.ms}ms)${err}`;
+            }).join("\n");
+            if (!r.ok) {
+              return fail13(
+                `Run FAILED \u2014 it stopped at the failing step and nothing after it ran. The steps before it DID apply:
+${steps}
+
+The device is now in a partial state. Deactivate to reverse what landed, or fix the step and run again.`
+              );
+            }
+            return text12(
+              [
+                `\u2705 **Scenario active \u2014 ${r.name ?? args.id}**`,
+                steps,
+                `**Now bent:**
+${(r.effects ?? []).map((e) => `  \xB7 ${e.label} [${e.kind}]`).join("\n")}`,
+                "The device shows a SIMULATED banner while this is active. Deactivate when done, or anything you observe from here is partly fake."
+              ].join("\n\n")
+            );
+          }
+          case "deactivate": {
+            const r = await call("deactivate", {});
+            const rep = r.report;
+            const lines = [
+              `Removed ${rep.removedRules} override rule(s)`,
+              rep.stoppedImpersonation ? "Ended impersonation" : null,
+              rep.undoStepsRan ? `Ran ${rep.undoStepsRan} undo step(s)` : null
+            ].filter(Boolean);
+            const warn = rep.unrestoredStorageKeys.length ? `
+
+\u26A0\uFE0F **NOT restored:** ${rep.unrestoredStorageKeys.join(", ")} \u2014 a storage write has no automatic inverse. The app still holds these values.` : "";
+            const errs = rep.errors.length ? `
+
+Errors: ${rep.errors.join("; ")}` : "";
+            return text12(`**Deactivated.**
+${lines.map((l) => `  \xB7 ${l}`).join("\n")}${warn}${errs}`);
+          }
+          case "save": {
+            if (!args.scenario) return fail13("save requires `scenario`.");
+            const r = await call("save", { scenario: args.scenario });
+            if (!r.ok) {
+              return fail13(
+                `Save rejected:
+${(r.errors ?? [r.error ?? "unknown error"]).map((e) => `  \xB7 ${e}`).join("\n")}`
+              );
+            }
+            return text12(
+              `Saved \`${r.id}\` **as a draft**.
+
+It is INERT and cannot run yet. Ask the user to open Scenarios on the device, review what it will do, and tap **Accept to library** \u2014 a scenario never becomes runnable on someone's device without them seeing it first.`
+            );
+          }
+          case "setFolder": {
+            if (!args.id) return fail13("setFolder requires `id` (from get_scenarios).");
+            const r = await call("setFolder", {
+              id: args.id,
+              folder: args.folder
+            });
+            return text12(
+              r.folder ? `Filed \`${r.id}\` under **${r.folder}**.` : `Removed \`${r.id}\` from its folder \u2014 it now shows under Ungrouped.`
+            );
+          }
+          case "delete": {
+            if (!args.id) return fail13("delete requires `id`.");
+            await call("delete", { id: args.id });
+            return text12(`Deleted \`${args.id}\` from the device library.`);
+          }
+        }
+      } catch (e) {
+        return fail13(errMsg13(e));
+      }
+    }
+  );
+}
+
+// src/tools/packs/screenshot.ts
+var import_zod14 = require("zod");
 
 // src/capture/simctl.ts
 var import_node_child_process = require("child_process");
@@ -3026,8 +3321,8 @@ function frameToRect(frame, screen) {
 var TOOL_ID = "highlight-updates";
 var MARGIN_PT = 12;
 var CAPTURE_PADDING_PT = 6;
-var fail13 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg13 = (e) => e instanceof Error ? e.message : String(e);
+var fail14 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg14 = (e) => e instanceof Error ? e.message : String(e);
 function reasonMessage(res, query) {
   switch (res.reason) {
     case "no-renders":
@@ -3040,9 +3335,9 @@ function reasonMessage(res, query) {
       return res.reason ? `Locate failed: ${res.reason}` : "Couldn't locate that component.";
   }
 }
-function candidatesText(candidates) {
-  if (!candidates || candidates.length === 0) return "";
-  const lines = candidates.map((c) => {
+function candidatesText(candidates2) {
+  if (!candidates2 || candidates2.length === 0) return "";
+  const lines = candidates2.map((c) => {
     const id = c.testID || c.nativeID;
     return `- ${c.componentName || c.viewType}${id ? ` (${id})` : ""} \u2014 nativeTag ${c.nativeTag}, rendered \xD7${c.renderCount}`;
   });
@@ -3057,10 +3352,10 @@ function registerScreenshotTools(server, sync) {
     {
       description: "Take a tight, cropped screenshot of a single React Native component running in the iOS Simulator \u2014 no manual coordinates needed. Give a testID, nativeID, accessibilityLabel, or component name in `query` (or an exact `nativeTag` from a previous call's candidates) and it locates the live component on-device (scrolling it into view), then captures + crops the Simulator framebuffer to just that component. If highlight tracking hasn't seen a render yet, it falls back to a live fiber walk (same as describe_screen). iOS Simulator only, and the MCP server must run on the same Mac as the booted Simulator. Requires Buoy Pro.",
       inputSchema: {
-        query: import_zod13.z.string().optional().describe('Fuzzy match against testID, nativeID, accessibilityLabel, component name, or view type \u2014 e.g. "submit-button".'),
-        nativeTag: import_zod13.z.number().optional().describe("An exact nativeTag (from a previous call's candidates) to skip fuzzy matching."),
-        scrollIntoView: import_zod13.z.boolean().optional().describe("Scroll the component into view before capturing, if it's off-screen. Default true."),
-        deviceId: import_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        query: import_zod14.z.string().optional().describe('Fuzzy match against testID, nativeID, accessibilityLabel, component name, or view type \u2014 e.g. "submit-button".'),
+        nativeTag: import_zod14.z.number().optional().describe("An exact nativeTag (from a previous call's candidates) to skip fuzzy matching."),
+        scrollIntoView: import_zod14.z.boolean().optional().describe("Scroll the component into view before capturing, if it's off-screen. Default true."),
+        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -3102,11 +3397,11 @@ function registerScreenshotTools(server, sync) {
           }
         }
         if (!located.matched || !located.rect || !located.screen) {
-          return fail13(reasonMessage(located, args.query) + candidatesText(located.candidates));
+          return fail14(reasonMessage(located, args.query) + candidatesText(located.candidates));
         }
         const shot = await captureIosFramebuffer();
         if (!shot.ok || !shot.srcPath || !shot.width || !shot.height) {
-          return fail13(shot.error ?? "Screenshot capture failed.");
+          return fail14(shot.error ?? "Screenshot capture failed.");
         }
         const pxScale = shot.width / located.screen.width;
         const r = located.rect;
@@ -3122,7 +3417,7 @@ function registerScreenshotTools(server, sync) {
           }
         );
         if (!crop.ok || !crop.buffer) {
-          return fail13(crop.error ?? "Crop failed.");
+          return fail14(crop.error ?? "Crop failed.");
         }
         const label = located.componentName || "component";
         const idPart = located.testID ? ` (testID: "${located.testID}")` : "";
@@ -3135,21 +3430,390 @@ function registerScreenshotTools(server, sync) {
           ]
         };
       } catch (e) {
-        return fail13(errMsg13(e));
+        return fail14(errMsg14(e));
+      }
+    }
+  );
+}
+
+// src/tools/packs/camera.ts
+var import_zod15 = require("zod");
+
+// src/capture/camera.ts
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+var import_node_fs3 = require("fs");
+var import_node_os3 = __toESM(require("os"));
+var import_node_path3 = __toESM(require("path"));
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+function candidates() {
+  const fromEnv = process.env.BUOY_SIMCAM_DIR;
+  const list = [
+    ...fromEnv ? [import_node_path3.default.join(fromEnv, "buoycam")] : [],
+    "/Applications/Buoy.app/Contents/Resources/simcam/buoycam",
+    import_node_path3.default.join(import_node_os3.default.homedir(), "Applications/Buoy.app/Contents/Resources/simcam/buoycam")
+  ];
+  let dir = __dirname;
+  for (let i = 0; i < 8; i++) {
+    list.push(import_node_path3.default.join(dir, "apps/desktop/resources/simcam/buoycam"));
+    const parent = import_node_path3.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return list;
+}
+var resolved = null;
+function cliPath() {
+  if (resolved) return resolved;
+  resolved = candidates().find((c) => (0, import_node_fs3.existsSync)(c)) ?? null;
+  return resolved;
+}
+async function run(args) {
+  const cli = cliPath();
+  if (!cli) {
+    return {
+      ok: false,
+      error: "The simulator camera components were not found. They ship with the Buoy desktop app \u2014 install it, or set BUOY_SIMCAM_DIR to the directory holding `buoycam`."
+    };
+  }
+  try {
+    const { stdout } = await execFileAsync2(cli, [...args, "--json"], { timeout: 3e4 });
+    return { ok: true, data: JSON.parse(stdout) };
+  } catch (err) {
+    const stdout = err.stdout ?? "";
+    try {
+      return { ok: false, data: JSON.parse(stdout) };
+    } catch {
+      return {
+        ok: false,
+        error: err.message || "the simulator camera CLI failed"
+      };
+    }
+  }
+}
+function describeDiagnosis(checks) {
+  const failed = checks.filter((c) => c.level === "fail");
+  const warned = checks.filter((c) => c.level === "warn");
+  if (failed.length === 0 && warned.length === 0) {
+    return "The simulator camera is healthy \u2014 every check passed.";
+  }
+  const lines = [];
+  for (const c of [...failed, ...warned]) {
+    lines.push(`- **${c.name}** (${c.level}): ${c.detail}`);
+    if (c.fix) lines.push(`  ${c.fix}`);
+  }
+  const headline = failed.length > 0 ? `${failed.length} problem${failed.length === 1 ? "" : "s"} found.` : `No hard failures, but ${warned.length} thing${warned.length === 1 ? "" : "s"} worth knowing.`;
+  return [headline, "", ...lines].join("\n");
+}
+function describeDevices(devices, apps) {
+  if (devices.length === 0) {
+    return "No booted simulators.\n\n_Boot one first \u2014 `xcrun simctl boot <udid>`, or open Simulator.app. The camera attaches to a simulator, so nothing else here works until one is running._";
+  }
+  const lines = [
+    devices.length === 1 ? "1 booted simulator:" : `${devices.length} booted simulators:`,
+    ...devices.map((d) => `- **${d.name}** (${d.runtime}) \u2014 \`${d.udid}\``)
+  ];
+  if (devices.length > 1 && apps === null) {
+    lines.push(
+      "",
+      "_More than one is booted, so pass `udid` to list a specific one's apps \u2014 and to every other camera tool that takes one._"
+    );
+    return lines.join("\n");
+  }
+  if (apps === null) {
+    lines.push("", "_Could not read the installed apps._");
+    return lines.join("\n");
+  }
+  if (apps.length === 0) {
+    lines.push("", "No apps installed on it.");
+    return lines.join("\n");
+  }
+  lines.push(
+    "",
+    `${apps.length} installed app${apps.length === 1 ? "" : "s"}:`,
+    ...apps.map((a) => `- ${a.name} \u2014 \`${a.bundleId}\``),
+    "",
+    "_Pass one of these bundle ids to `camera_launch` to relaunch it with the camera attached._"
+  );
+  return lines.join("\n");
+}
+function describeInputs(cameras, windows) {
+  const lines = [];
+  lines.push(cameras.length ? '**Mac cameras** (for `kind: "camera"`):' : "**Mac cameras**: none found.");
+  if (cameras.length) {
+    lines.push(...cameras.map((c) => `- ${c.name} \u2014 \`${c.uniqueId}\``));
+  } else {
+    lines.push(
+      "_If this Mac has a webcam, Buoy has not been granted Camera permission (System Settings \u2192 Privacy & Security \u2192 Camera)._"
+    );
+  }
+  lines.push("");
+  lines.push(
+    windows.length ? '**Capturable windows** (for `kind: "screen"`, `value: "window:<id>"`):' : "**Capturable windows**: none found."
+  );
+  if (windows.length) {
+    lines.push(
+      ...windows.map((w) => `- ${w.app}${w.title ? ` \u2014 ${w.title}` : ""} \u2014 \`window:${w.id}\``)
+    );
+  } else {
+    lines.push(
+      "_Screen Recording permission is almost certainly missing (System Settings \u2192 Privacy & Security \u2192 Screen & System Audio Recording)._"
+    );
+  }
+  return lines.join("\n");
+}
+function entitlementPaths() {
+  const fromEnv = process.env.BUOY_ENTITLEMENT_FILE;
+  if (fromEnv) return [fromEnv];
+  return [
+    import_node_path3.default.join(import_node_os3.default.homedir(), "Library/Application Support/Buoy/entitlement.json"),
+    import_node_path3.default.join(import_node_os3.default.homedir(), "Library/Application Support/buoy-desktop/entitlement.json")
+  ];
+}
+function readEntitlement() {
+  for (const p of entitlementPaths()) {
+    try {
+      if (!(0, import_node_fs3.existsSync)(p)) continue;
+      const parsed = JSON.parse((0, import_node_fs3.readFileSync)(p, "utf8"));
+      return {
+        tier: parsed.tier === "pro" || parsed.tier === "free" ? parsed.tier : "anonymous",
+        isPro: parsed.isPro === true
+      };
+    } catch {
+    }
+  }
+  return { tier: "anonymous", isPro: false };
+}
+function proRequired(tool) {
+  return `\`${tool}\` is a Buoy Pro feature.
+
+The simulator camera itself is free \u2014 the Mac camera, image, video, test-pattern and QR sources all work in the Buoy desktop panel without a licence. Pro adds the screen region, the non-QR symbologies (PDF417, Aztec, DataMatrix, Code 128), and driving any of it from an agent.
+
+_Tell the user to enter a licence in Buoy Desktop, or see https://buoy.gg/pricing. Don't try to work around it \u2014 use the desktop panel by hand instead._`;
+}
+
+// src/tools/packs/camera.ts
+var text13 = (s) => ({ content: [{ type: "text", text: s }] });
+var gate = (tool) => readEntitlement().isPro ? null : fail15(proRequired(tool));
+var fail15 = (message) => ({
+  isError: true,
+  content: [{ type: "text", text: message }]
+});
+function registerCameraTools(server) {
+  server.registerTool(
+    "camera_source",
+    {
+      description: "Give the iOS Simulator a camera, and choose what it shows. Use this before testing anything that opens a camera \u2014 a QR or barcode scanner, document capture, an avatar picker. `barcode` generates the code from text, so testing a scanner needs no printed code and no second device; pdf417 is the barcode on a driver's licence. `screen` points the phone's camera at this Mac's screen. Needs no Buoy integration in the app under test.",
+      inputSchema: {
+        kind: import_zod15.z.enum(["barcode", "image", "video", "camera", "screen", "pattern"]).describe("What the camera should show."),
+        value: import_zod15.z.string().optional().describe(
+          "Text for `barcode`, a file path for `image`/`video`, a camera uniqueId for `camera` (see `camera_inputs`), or one of `behind` / `display` / `window:<id>` / `region:<id>[:<gutter>]` for `screen`."
+        ),
+        format: import_zod15.z.enum(["qr", "pdf417", "aztec", "code128"]).optional().describe("Barcode symbology; defaults to qr.")
+      }
+    },
+    async (args) => {
+      const blocked = gate("camera_source");
+      if (blocked) return blocked;
+      const cmd = ["source", args.kind];
+      if (args.value) cmd.push(args.value);
+      if (args.format) cmd.push("--format", args.format);
+      const result = await run(cmd);
+      if (!result.ok) {
+        return fail15(
+          result.error ?? result.data?.error ?? "could not set the camera source"
+        );
+      }
+      const what = args.kind === "barcode" ? `a ${args.format ?? "qr"} code reading "${args.value}"` : args.kind === "screen" ? `this Mac's screen (${args.value ?? "behind the simulator window"})` : args.value ?? args.kind;
+      return text13(
+        `The simulator camera is now showing ${what}, at ${result.data?.fps ?? 0} fps.
+
+_Apps already running do not pick up a camera they started without \u2014 use \`camera_launch\` to relaunch one, or \`camera_zero_setup\` so that anything the simulator launches gets it._`
+      );
+    }
+  );
+  server.registerTool(
+    "camera_status",
+    {
+      description: "Check what the simulator camera is doing and what it is currently decoding. Use this to confirm a scanner test is actually seeing a code before concluding the app is broken.",
+      inputSchema: {}
+    },
+    async () => {
+      const blocked = gate("camera_status");
+      if (blocked) return blocked;
+      const result = await run(["status"]);
+      if (!result.ok || !result.data) {
+        return fail15(result.error ?? "could not read the simulator camera status");
+      }
+      const { publishing, fps, codes } = result.data;
+      if (!publishing) {
+        return text13(
+          "The simulator camera is not publishing anything.\n\n_Set a source with `camera_source` first._"
+        );
+      }
+      return text13(
+        [
+          `Publishing at ${fps} fps.`,
+          codes.length ? `Currently decoding: ${codes.map((c) => `\`${c}\``).join(", ")}` : "No barcode in the current frame.",
+          "",
+          "_A code shown here is what the app receives. If the app is not reacting to it, the problem is in the app, not the camera \u2014 `camera_diagnose` will say whether the app is even reading the feed._"
+        ].join("\n")
+      );
+    }
+  );
+  server.registerTool(
+    "camera_launch",
+    {
+      description: "Relaunch a simulator app with the camera attached. A camera can only be attached when a process starts, so an app that is already running cannot be given one \u2014 this terminates and relaunches it.",
+      inputSchema: {
+        bundleId: import_zod15.z.string().describe("The app's bundle identifier."),
+        udid: import_zod15.z.string().optional().describe("Simulator udid, if more than one is booted.")
+      }
+    },
+    async (args) => {
+      const blocked = gate("camera_launch");
+      if (blocked) return blocked;
+      const cmd = ["launch", args.bundleId];
+      if (args.udid) cmd.push("--udid", args.udid);
+      const result = await run(cmd);
+      if (!result.ok) {
+        return fail15(result.error ?? result.data?.error ?? "could not launch the app");
+      }
+      return text13(
+        `Relaunched \`${args.bundleId}\` with the camera attached${result.data?.pid ? ` (pid ${result.data.pid})` : ""}.`
+      );
+    }
+  );
+  server.registerTool(
+    "camera_diagnose",
+    {
+      description: "Work out why the simulator camera is not working. Checks that the pieces are present, a simulator is booted, something is publishing, SOMETHING IS READING IT, the library is loaded in the target app, no other tool owns the injection, and no camera library in the project disables simulator cameras at compile time.",
+      inputSchema: {
+        bundleId: import_zod15.z.string().optional().describe("Check a specific app \u2014 whether the library is actually loaded in it.")
+      }
+    },
+    async (args) => {
+      const cmd = ["diagnose"];
+      if (args.bundleId) cmd.push(args.bundleId);
+      const result = await run(cmd);
+      if (!result.data?.checks) {
+        return fail15(result.error ?? "could not run the simulator camera diagnosis");
+      }
+      const ent = readEntitlement();
+      const tierNote = ent.isPro ? "" : "\n\n_This install is on the **free** tier, so the other `camera_*` tools are blocked. The camera still works by hand in the Buoy desktop panel._";
+      return text13(describeDiagnosis(result.data.checks) + tierNote);
+    }
+  );
+  server.registerTool(
+    "camera_stop",
+    {
+      description: "Turn the simulator camera off and stop publishing frames. The camera stays on until stopped \u2014 across app relaunches and after a test finishes \u2014 so call this when done, or the next thing that opens a camera will still see the last source.",
+      inputSchema: {}
+    },
+    async () => {
+      const blocked = gate("camera_stop");
+      if (blocked) return blocked;
+      const result = await run(["stop"]);
+      if (!result.ok) {
+        return fail15(result.error ?? result.data?.error ?? "could not stop the camera");
+      }
+      return text13("The simulator camera is off.");
+    }
+  );
+  server.registerTool(
+    "camera_devices",
+    {
+      description: "List booted simulators and the apps installed on one. Use this to find the bundle id `camera_launch` needs, or the udid to pass when more than one simulator is booted. Lists every app on the simulator, not just Buoy-integrated ones \u2014 the camera works on any of them.",
+      inputSchema: {
+        udid: import_zod15.z.string().optional().describe("Which simulator's apps to list. Only needed when several are booted.")
+      }
+    },
+    async (args) => {
+      const blocked = gate("camera_devices");
+      if (blocked) return blocked;
+      const devicesResult = await run(["devices"]);
+      if (!devicesResult.ok || !devicesResult.data) {
+        return fail15(devicesResult.error ?? "could not list booted simulators");
+      }
+      const devices = devicesResult.data.devices ?? [];
+      let apps = null;
+      if (devices.length === 1 || args.udid) {
+        const appsResult = await run([
+          "apps",
+          ...args.udid ? ["--udid", args.udid] : []
+        ]);
+        apps = appsResult.ok ? appsResult.data?.apps ?? [] : null;
+      }
+      return text13(describeDevices(devices, apps));
+    }
+  );
+  server.registerTool(
+    "camera_inputs",
+    {
+      description: "List what this Mac can point the simulator camera at: its webcams (the uniqueId for `camera_source` with kind `camera`) and the windows the screen source can film (the id for `window:<id>`). Call this before choosing a `camera` or windowed `screen` source \u2014 those ids cannot be guessed.",
+      inputSchema: {}
+    },
+    async () => {
+      const blocked = gate("camera_inputs");
+      if (blocked) return blocked;
+      const [cams, wins] = await Promise.all([
+        run(["cameras"]),
+        run(["windows"])
+      ]);
+      if (!cams.ok && !wins.ok) {
+        return fail15(
+          cams.error ?? wins.error ?? "could not list the Mac's cameras or windows"
+        );
+      }
+      return text13(
+        describeInputs(cams.data?.cameras ?? [], wins.data?.windows ?? [])
+      );
+    }
+  );
+  server.registerTool(
+    "camera_zero_setup",
+    {
+      description: "Make every app the simulator launches get a camera, however it was launched \u2014 `expo start`, `react-native run-ios`, Xcode, a test runner. Use this when you are not the one starting the app, so `camera_launch` is not an option. It loads Buoy's library into every process in that simulator, SpringBoard included, so turn it off when finished.",
+      inputSchema: {
+        action: import_zod15.z.enum(["on", "off", "status"]).describe("Turn it on, off, or report the current state."),
+        udid: import_zod15.z.string().optional().describe("Which simulator. Only needed when several are booted.")
       }
+    },
+    async (args) => {
+      const blocked = gate("camera_zero_setup");
+      if (blocked) return blocked;
+      const result = await run(["zero-setup", args.action, ...args.udid ? ["--udid", args.udid] : []]);
+      if (!result.ok) {
+        return fail15(
+          result.error ?? result.data?.error ?? "could not change zero-setup mode"
+        );
+      }
+      const d = result.data ?? {};
+      if (args.action === "status") {
+        if (!d.enabled) return text13("Zero-setup mode is **off**.");
+        return text13(
+          d.foreign ? `Zero-setup is on, but **another tool owns it** (\`${d.path}\`). Quit that tool before turning Buoy's on.` : "Zero-setup mode is **on** \u2014 anything this simulator launches gets the camera."
+        );
+      }
+      if (args.action === "on") {
+        return text13(
+          "Zero-setup mode is **on**. Anything this simulator launches from now on gets the camera \u2014 start your app however you normally would.\n\n_This loads the library into every process in the simulator. Turn it off with `camera_zero_setup` action `off` when you are done._"
+        );
+      }
+      return text13("Zero-setup mode is **off**.");
     }
   );
 }
 
 // src/tools/packs/interact.ts
-var import_zod14 = require("zod");
+var import_zod16 = require("zod");
 var TOOL_ID2 = "highlight-updates";
-var text12 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail14 = (message) => ({
+var text14 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail16 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg14 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg15 = (e) => e instanceof Error ? e.message : String(e);
 function formatElement(e) {
   let line = e.interactive ? "\u2022 " : "  ";
   line += e.name;
@@ -3172,8 +3836,8 @@ function registerInteractTools(server, sync) {
     {
       description: "List the interactive / labeled elements currently on screen \u2014 the app's live accessibility-style tree walked from the React fiber tree. Each row shows the component name, visible text/label, role, testID, a normalized tap point (tap: x,y in 0\u20131), and its #nativeTag. Rows marked with \u2022 are tappable (have an onPress). Use this to see what's on screen and pick something to tap with tap_element \u2014 no screenshot needed. If you already know the sequence you want to drive, `run_flow` does the whole thing (taps, waits, assertions) in one call instead. Re-run after navigating or when the screen changes, since positions move. Requires Buoy Pro.",
       inputSchema: {
-        interactiveOnly: import_zod14.z.boolean().optional().describe("Only return tappable (onPress) elements. Default false (include labels/text for context)."),
-        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        interactiveOnly: import_zod16.z.boolean().optional().describe("Only return tappable (onPress) elements. Default false (include labels/text for context)."),
+        deviceId: import_zod16.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -3183,16 +3847,16 @@ function registerInteractTools(server, sync) {
         const all = res?.elements ?? [];
         const elements = args.interactiveOnly ? all.filter((e) => e.interactive) : all;
         if (elements.length === 0) {
-          return text12(
+          return text14(
             "No elements found on screen. If the app just navigated, wait a moment and retry; make sure highlight-updates is enabled in the app."
           );
         }
         const header = `Screen ${res.screen.width}\xD7${res.screen.height} \u2014 ${elements.length} element${elements.length === 1 ? "" : "s"} (\u2022 = tappable). Tap with tap_element({ testID | query | nativeTag }).`;
-        return text12(`${header}
+        return text14(`${header}
 
 ${elements.map(formatElement).join("\n")}`);
       } catch (e) {
-        return fail14(errMsg14(e));
+        return fail16(errMsg15(e));
       }
     }
   );
@@ -3201,20 +3865,20 @@ ${elements.map(formatElement).join("\n")}`);
     {
       description: "Interact with an on-screen element by invoking its handler directly in JS (no screenshot, no coordinate math, works on real devices). Handles buttons (onPress + onLongPress), toggles/switches and sliders (onValueChange), and text inputs (onChangeText) \u2014 see each element's `control` in describe_screen. Identify the target with an exact `nativeTag` or `testID`, or a fuzzy `query`. Pass `longPress:true` to invoke onLongPress instead of onPress (elements that support it show {long-press} in describe_screen). For a toggle, pass `value:true/false` (omit to flip); for a slider, pass a numeric `value` (omit to jump to the far end); for a text input, pass `text`. If the element is off-screen it's scrolled into view first (scrollIntoView:false to skip). Call describe_screen first to see options + current values. Driving MORE THAN ONE step (reproducing a bug, verifying a fix)? Use `run_flow` instead \u2014 it runs the whole sequence in one call. Requires Buoy Pro.",
       inputSchema: {
-        nativeTag: import_zod14.z.number().optional().describe("Exact nativeTag from describe_screen (most precise)."),
-        testID: import_zod14.z.string().optional().describe("Exact testID of the element."),
-        query: import_zod14.z.string().optional().describe('Fuzzy match against testID / label / visible text / component name \u2014 e.g. "Sign in".'),
-        value: import_zod14.z.union([import_zod14.z.number(), import_zod14.z.boolean()]).optional().describe("For a toggle: true/false (omit to flip). For a slider: the numeric value (omit to jump to the far end)."),
-        text: import_zod14.z.string().optional().describe("For a text input: the string to set via onChangeText."),
-        longPress: import_zod14.z.boolean().optional().describe("Invoke the element's onLongPress instead of onPress. Fails with a clear reason if the element has no onLongPress handler."),
-        scrollIntoView: import_zod14.z.boolean().optional().describe("Scroll the target into view first if it's off-screen. Default true."),
-        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        nativeTag: import_zod16.z.number().optional().describe("Exact nativeTag from describe_screen (most precise)."),
+        testID: import_zod16.z.string().optional().describe("Exact testID of the element."),
+        query: import_zod16.z.string().optional().describe('Fuzzy match against testID / label / visible text / component name \u2014 e.g. "Sign in".'),
+        value: import_zod16.z.union([import_zod16.z.number(), import_zod16.z.boolean()]).optional().describe("For a toggle: true/false (omit to flip). For a slider: the numeric value (omit to jump to the far end)."),
+        text: import_zod16.z.string().optional().describe("For a text input: the string to set via onChangeText."),
+        longPress: import_zod16.z.boolean().optional().describe("Invoke the element's onLongPress instead of onPress. Fails with a clear reason if the element has no onLongPress handler."),
+        scrollIntoView: import_zod16.z.boolean().optional().describe("Scroll the target into view first if it's off-screen. Default true."),
+        deviceId: import_zod16.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
       try {
         if (args.nativeTag == null && !args.testID && !args.query) {
-          return fail14("Provide one of: nativeTag, testID, or query (from describe_screen).");
+          return fail16("Provide one of: nativeTag, testID, or query (from describe_screen).");
         }
         const target = sync.requireProDevice(args.deviceId);
         const res = await sync.callAction(
@@ -3239,26 +3903,26 @@ ${elements.map(formatElement).join("\n")}`);
           const id = m.testID ? ` [testID=${m.testID}]` : m.nativeTag != null ? ` #${m.nativeTag}` : "";
           const scrolledNote = res.scrolled ? " (scrolled into view)" : "";
           const verb = m.via === "onValueChange" ? `Set "${label}"${id} \u2192 ${JSON.stringify(m.value)}` : m.via === "onChangeText" ? `Typed ${JSON.stringify(m.value)} into "${label}"${id}` : m.via === "onLongPress" ? `Long-pressed "${label}"${id}` : `Tapped "${label}"${id}`;
-          return text12(`${verb}${scrolledNote}.${flowTip}`);
+          return text14(`${verb}${scrolledNote}.${flowTip}`);
         }
         let msg = res?.reason ?? "Tap failed.";
         if (res?.candidates?.length) {
           msg += "\n\nTappable candidates:\n" + res.candidates.map((c) => `- ${c.name}${c.text ? ` "${c.text}"` : ""}${c.testID ? ` [testID=${c.testID}]` : ""}${c.nativeTag != null ? ` #${c.nativeTag}` : ""}`).join("\n");
         }
-        return fail14(msg);
+        return fail16(msg);
       } catch (e) {
-        return fail14(errMsg14(e));
+        return fail16(errMsg15(e));
       }
     }
   );
 }
 
 // src/tools/packs/jsThread.ts
-var import_zod15 = require("zod");
+var import_zod17 = require("zod");
 var JS_TOP_TOOL_ID = "js-top";
-var text13 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail15 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg15 = (e) => e instanceof Error ? e.message : String(e);
+var text15 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail17 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg16 = (e) => e instanceof Error ? e.message : String(e);
 var SPARK_CHARS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
 function sparkline(values) {
   const max = Math.max(1, ...values);
@@ -3329,9 +3993,9 @@ function registerJsThreadTools(server, sync) {
     {
       description: 'Task Manager for the React Native JS thread: sample for a few seconds and return a ranked table of which task origins (timers, Promise chains, rAF callbacks, bridge call-ins) consumed JS-thread time \u2014 plus thread busy% and freeze (50ms+ block) attribution. Use when JS FPS is low and you need to know WHAT is eating the thread. To profile one specific interaction, pass clearFirst:true, then drive the UI with tap_element while the sample runs. Drill into a row with get_js_thread_origin_detail. NOT the tool for React components re-rendering too often \u2014 this measures TASKS on the thread, not renders; for "the page re-renders constantly / typing lags / tapping one button re-renders everything" use measure_renders. Requires @buoy-gg/js-top on the device.',
       inputSchema: {
-        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        durationMs: import_zod15.z.number().optional().describe("How long to sample before reading the table. Default 3000, max 30000."),
-        clearFirst: import_zod15.z.boolean().optional().describe("Reset all stats before sampling, so the result attributes only what happens during this sample.")
+        deviceId: import_zod17.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        durationMs: import_zod17.z.number().optional().describe("How long to sample before reading the table. Default 3000, max 30000."),
+        clearFirst: import_zod17.z.boolean().optional().describe("Reset all stats before sampling, so the result attributes only what happens during this sample.")
       }
     },
     async ({ deviceId, durationMs, clearFirst }) => {
@@ -3344,7 +4008,7 @@ function registerJsThreadTools(server, sync) {
           { durationMs: duration, clearFirst: clearFirst === true },
           target
         );
-        if (!snap) return fail15("Device returned no snapshot \u2014 is @buoy-gg/js-top installed in the app?");
+        if (!snap) return fail17("Device returned no snapshot \u2014 is @buoy-gg/js-top installed in the app?");
         const md = formatTopMarkdown(snap, duration);
         const slim = {
           busyPct: Math.round(snap.busyPct * 10) / 10,
@@ -3363,13 +4027,13 @@ function registerJsThreadTools(server, sync) {
             worstFreezeMs: r.worstFreezeMs
           }))
         };
-        return text13(`${md}
+        return text15(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail15(errMsg15(e));
+        return fail17(errMsg16(e));
       }
     }
   );
@@ -3378,8 +4042,8 @@ ${JSON.stringify(slim)}
     {
       description: 'Inspect one js-top task origin in depth: schedules vs runs, avg/max/total exclusive ms, a 5s activity sparkline, freeze attribution, and the captured scheduling site (caller function + stack frames). Pass a row `key` from get_js_thread_top\'s JSON (e.g. "interval|pollFeed" or "unattributed" for the system row).',
       inputSchema: {
-        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        key: import_zod15.z.string().describe("Origin key from get_js_thread_top's JSON rows.")
+        deviceId: import_zod17.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        key: import_zod17.z.string().describe("Origin key from get_js_thread_top's JSON rows.")
       }
     },
     async ({ deviceId, key }) => {
@@ -3392,18 +4056,18 @@ ${JSON.stringify(slim)}
           target
         );
         if (!detail) {
-          return fail15(
+          return fail17(
             `Origin "${key}" is not tracked (cleared, evicted, or never existed). Re-run get_js_thread_top for current keys.`
           );
         }
         const md = formatDetailMarkdown(detail);
-        return text13(`${md}
+        return text15(`${md}
 
 \`\`\`json
 ${JSON.stringify(detail)}
 \`\`\``);
       } catch (e) {
-        return fail15(errMsg15(e));
+        return fail17(errMsg16(e));
       }
     }
   );
@@ -3412,27 +4076,27 @@ ${JSON.stringify(detail)}
     {
       description: "Reset the js-top task table, freeze history, and busy history on the device (fresh measurement window).",
       inputSchema: {
-        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        deviceId: import_zod17.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async ({ deviceId }) => {
       try {
         const target = sync.requireProDevice(deviceId);
         await sync.callAction(JS_TOP_TOOL_ID, "clear", {}, target);
-        return text13("Cleared js-top stats.");
+        return text15("Cleared js-top stats.");
       } catch (e) {
-        return fail15(errMsg15(e));
+        return fail17(errMsg16(e));
       }
     }
   );
 }
 
 // src/tools/packs/images.ts
-var import_zod16 = require("zod");
+var import_zod18 = require("zod");
 var IMAGES_TOOL_ID = "images";
-var text14 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail16 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg16 = (e) => e instanceof Error ? e.message : String(e);
+var text16 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail18 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg17 = (e) => e instanceof Error ? e.message : String(e);
 function uriTail(uri) {
   if (!uri) return "(no source)";
   const unstable = uri.match(/[?&]unstable_path=([^&?]+)/);
@@ -3520,9 +4184,9 @@ function registerImagesTools(server, sync) {
     {
       description: "Live image registry from the app: every RN <Image> and expo-image load with cache verdict (memory/disk/network), load ms, decoded vs displayed size with an oversize/upscale verdict and wasted-KB estimate, error details, and any active simulation overrides. Image HTTP never hits the JS network stack, so this is the only visibility into image loading. Requires @buoy-gg/images on the device.",
       inputSchema: {
-        deviceId: import_zod16.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        limit: import_zod16.z.number().optional().describe("Max records to return (newest first). Default 30, max 200."),
-        status: import_zod16.z.enum(["pending", "loading", "loaded", "error"]).optional().describe("Only records in this state (e.g. 'error' for the failure log).")
+        deviceId: import_zod18.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        limit: import_zod18.z.number().optional().describe("Max records to return (newest first). Default 30, max 200."),
+        status: import_zod18.z.enum(["pending", "loading", "loaded", "error"]).optional().describe("Only records in this state (e.g. 'error' for the failure log).")
       }
     },
     async ({ deviceId, limit, status }) => {
@@ -3535,7 +4199,7 @@ function registerImagesTools(server, sync) {
           { limit: capped, status },
           target
         );
-        if (!list) return fail16("Device returned nothing \u2014 is @buoy-gg/images installed in the app?");
+        if (!list) return fail18("Device returned nothing \u2014 is @buoy-gg/images installed in the app?");
         const md = formatListMarkdown(list, capped);
         const slim = {
           stats: list.stats,
@@ -3562,13 +4226,13 @@ function registerImagesTools(server, sync) {
             layoutShifts: r.layoutShifts
           }))
         };
-        return text14(`${md}
+        return text16(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail16(errMsg16(e));
+        return fail18(errMsg17(e));
       }
     }
   );
@@ -3577,9 +4241,9 @@ ${JSON.stringify(slim)}
     {
       description: "Act on one image from get_images (by id): hard_reload (bypass caches + refetch), retry, evict_disk (expo disk entry), flash (red border to locate it on screen), prove_savings (re-encode at displayed size as WebP ON DEVICE and return real byte savings + a previewable file:// uri), or simulation overrides \u2014 force_error (instant offline-safe failure), force_loading (request hangs forever), force_blank, swap_url (requires url), restore (remove override). Returns the record's state after the action so the effect is visible.",
       inputSchema: {
-        deviceId: import_zod16.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        id: import_zod16.z.number().describe("Record id from get_images."),
-        action: import_zod16.z.enum([
+        deviceId: import_zod18.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        id: import_zod18.z.number().describe("Record id from get_images."),
+        action: import_zod18.z.enum([
           "hard_reload",
           "retry",
           "evict_disk",
@@ -3591,7 +4255,7 @@ ${JSON.stringify(slim)}
           "swap_url",
           "restore"
         ]).describe("What to do."),
-        url: import_zod16.z.string().optional().describe("Replacement URL (swap_url only).")
+        url: import_zod18.z.string().optional().describe("Replacement URL (swap_url only).")
       }
     },
     async ({ deviceId, id, action, url }) => {
@@ -3599,8 +4263,8 @@ ${JSON.stringify(slim)}
         const target = sync.requireProDevice(deviceId);
         if (action === "prove_savings") {
           const savings = await sync.callAction(IMAGES_TOOL_ID, "proveSavings", { id }, target);
-          if (!savings) return fail16("Device returned nothing for proveSavings.");
-          if (!savings.ok) return fail16(savings.message);
+          if (!savings) return fail18("Device returned nothing for proveSavings.");
+          if (!savings.ok) return fail18(savings.message);
           const parts = [`**prove_savings** on #${id}: ${savings.message}`];
           if (savings.originalBytes != null)
             parts.push(`Original: ${Math.round(savings.originalBytes / 1024)}KB (${savings.originalBytesSource})`);
@@ -3612,11 +4276,11 @@ ${JSON.stringify(slim)}
             parts.push(`**Saved: ${Math.round(savings.savedBytes / 1024)}KB (${savings.savedPct}%)**`);
           if (savings.optimizedUri)
             parts.push(`Preview in place: image_action {id:${id}, action:"swap_url", url:"${savings.optimizedUri}"}`);
-          return text14(parts.join("\n"));
+          return text16(parts.join("\n"));
         }
         const entry = ACTION_MAP[action];
-        if (!entry) return fail16(`Unknown action: ${action}`);
-        if (action === "swap_url" && !url) return fail16("swap_url requires the `url` param.");
+        if (!entry) return fail18(`Unknown action: ${action}`);
+        if (action === "swap_url" && !url) return fail18("swap_url requires the `url` param.");
         const result = await sync.callAction(
           IMAGES_TOOL_ID,
           entry.action,
@@ -3636,9 +4300,9 @@ ${JSON.stringify(slim)}
           );
           if (detail.error) lines.push(`Error: ${detail.error}`);
         }
-        return text14(lines.join("\n"));
+        return text16(lines.join("\n"));
       } catch (e) {
-        return fail16(errMsg16(e));
+        return fail18(errMsg17(e));
       }
     }
   );
@@ -3647,12 +4311,12 @@ ${JSON.stringify(slim)}
     {
       description: "App-wide image simulation modes: network 'offline' (every NETWORK image load fails immediately, both libs \u2014 bundled assets still load; reload/remount on-screen images to see it), 'cold' (every image bypasses caches \u2014 first-launch behavior, nothing cleared), 'normal' to reset. blankImages renders every image without a source. massAction applies per-image simulations to everything mounted. Also clears the registry or expo caches when asked.",
       inputSchema: {
-        deviceId: import_zod16.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        network: import_zod16.z.enum(["normal", "offline", "cold"]).optional().describe("Network simulation mode."),
-        blankImages: import_zod16.z.boolean().optional().describe("Render all images without a source."),
-        massAction: import_zod16.z.enum(["error", "loading", "blank", "reload", "flash", "restore"]).optional().describe("Apply to EVERY mounted image at once: force error/loading/blank overrides, hard-reload all, flash all, or restore all overrides."),
-        clearRegistry: import_zod16.z.boolean().optional().describe("Clear the captured image log."),
-        clearExpoCaches: import_zod16.z.boolean().optional().describe("Clear expo-image memory + disk caches.")
+        deviceId: import_zod18.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        network: import_zod18.z.enum(["normal", "offline", "cold"]).optional().describe("Network simulation mode."),
+        blankImages: import_zod18.z.boolean().optional().describe("Render all images without a source."),
+        massAction: import_zod18.z.enum(["error", "loading", "blank", "reload", "flash", "restore"]).optional().describe("Apply to EVERY mounted image at once: force error/loading/blank overrides, hard-reload all, flash all, or restore all overrides."),
+        clearRegistry: import_zod18.z.boolean().optional().describe("Clear the captured image log."),
+        clearExpoCaches: import_zod18.z.boolean().optional().describe("Clear expo-image memory + disk caches.")
       }
     },
     async ({ deviceId, network, blankImages, massAction, clearRegistry, clearExpoCaches }) => {
@@ -3679,17 +4343,17 @@ ${JSON.stringify(slim)}
           const r = await sync.callAction(IMAGES_TOOL_ID, "clearExpoCaches", {}, target);
           done.push(r?.message ?? "expo caches cleared");
         }
-        if (done.length === 0) return fail16("Pass at least one of: network, blankImages, massAction, clearRegistry, clearExpoCaches.");
-        return text14(`Applied: ${done.join(" \xB7 ")}`);
+        if (done.length === 0) return fail18("Pass at least one of: network, blankImages, massAction, clearRegistry, clearExpoCaches.");
+        return text16(`Applied: ${done.join(" \xB7 ")}`);
       } catch (e) {
-        return fail16(errMsg16(e));
+        return fail18(errMsg17(e));
       }
     }
   );
 }
 
 // src/tools/packs/assets.ts
-var import_zod17 = require("zod");
+var import_zod19 = require("zod");
 
 // src/tools/packs/assetsGraphNote.ts
 function graphUnavailableNote(ss) {
@@ -3704,9 +4368,9 @@ function graphUnavailableNote(ss) {
 
 // src/tools/packs/assets.ts
 var ASSETS_TOOL_ID = "assets";
-var text15 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail17 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg17 = (e) => e instanceof Error ? e.message : String(e);
+var text17 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail19 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg18 = (e) => e instanceof Error ? e.message : String(e);
 function kb2(bytes) {
   if (bytes == null || bytes <= 0) return "\u2013";
   if (bytes < 1024) return `${bytes}B`;
@@ -3794,10 +4458,10 @@ function registerAssetsTools(server, sync) {
     {
       description: "Bundled-asset inventory from the app: every asset (images, fonts, video, audio) with dimensions, @1x/@2x/@3x scale coverage, byte sizes (measured from the Metro server in dev), loaded vs never-loaded state, and audit findings \u2014 duplicates (by content hash), shipped-but-never-loaded, WebP candidates, images decoding larger than the screen, heavy GIFs/fonts, scale gaps \u2014 plus the change vs a saved baseline. This is what the app SHIPS; use get_images for what it RENDERS. Requires @buoy-gg/assets on the device.",
       inputSchema: {
-        deviceId: import_zod17.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        limit: import_zod17.z.number().optional().describe("Max records to return (largest first). Default 40, max 500."),
-        kind: import_zod17.z.enum(["image", "font", "video", "audio", "data", "other"]).optional().describe("Only assets of this kind."),
-        unusedOnly: import_zod17.z.boolean().optional().describe("Only assets shipped in the bundle but never loaded at runtime.")
+        deviceId: import_zod19.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        limit: import_zod19.z.number().optional().describe("Max records to return (largest first). Default 40, max 500."),
+        kind: import_zod19.z.enum(["image", "font", "video", "audio", "data", "other"]).optional().describe("Only assets of this kind."),
+        unusedOnly: import_zod19.z.boolean().optional().describe("Only assets shipped in the bundle but never loaded at runtime.")
       }
     },
     async ({ deviceId, limit, kind, unusedOnly }) => {
@@ -3810,7 +4474,7 @@ function registerAssetsTools(server, sync) {
           { limit: unusedOnly ? 500 : capped, kind, loadedOnly: false },
           target
         );
-        if (!list) return fail17("Device returned nothing \u2014 is @buoy-gg/assets installed in the app?");
+        if (!list) return fail19("Device returned nothing \u2014 is @buoy-gg/assets installed in the app?");
         if (unusedOnly) {
           list.records = list.records.filter((r) => !r.loaded).slice(0, capped);
         }
@@ -3834,13 +4498,13 @@ function registerAssetsTools(server, sync) {
             sizeSource: r.sizeSource
           }))
         };
-        return text15(`${md}
+        return text17(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail17(errMsg17(e));
+        return fail19(errMsg18(e));
       }
     }
   );
@@ -3849,9 +4513,9 @@ ${JSON.stringify(slim)}
     {
       description: "Drive the assets tool: rescan (re-walk the registry + merge the Metro bundle graph + refresh fonts + measure sizes \u2014 run this first if the inventory looks stale or empty), measure_sizes (re-measure byte sizes only), detail (full metadata for one asset by id: source dir, per-scale sizes, resolved URI, per-file graph paths), save_baseline (persist the current inventory for before/after comparison \u2014 save, make your change, then get_assets shows added/removed/grown/net bytes), clear_baseline, clear_records (wipe + rescan rebuilds).",
       inputSchema: {
-        deviceId: import_zod17.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        action: import_zod17.z.enum(["rescan", "measure_sizes", "detail", "save_baseline", "clear_baseline", "clear_records"]).describe("What to do."),
-        id: import_zod17.z.number().optional().describe("Asset id from get_assets (detail only).")
+        deviceId: import_zod19.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        action: import_zod19.z.enum(["rescan", "measure_sizes", "detail", "save_baseline", "clear_baseline", "clear_records"]).describe("What to do."),
+        id: import_zod19.z.number().optional().describe("Asset id from get_assets (detail only).")
       }
     },
     async ({ deviceId, action, id }) => {
@@ -3861,19 +4525,19 @@ ${JSON.stringify(slim)}
           case "rescan": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "rescan", {}, target);
             const ss = result?.scanStatus;
-            if (!ss) return fail17("Device returned nothing for rescan.");
-            return text15(
+            if (!ss) return fail19("Device returned nothing for rescan.");
+            return text17(
               `Rescan done: ${ss.registryCount} registered at runtime` + (ss.graphCount != null ? ` \xB7 ${ss.graphCount} in the bundle graph` : " \xB7 no bundle graph") + (ss.graphError ? ` (graph: ${ss.graphError})` : "") + ` \xB7 ${ss.fontFamilies.length} font families` + (ss.measuring ? " \xB7 size measurement running \u2014 get_assets in a moment" : "")
             );
           }
           case "measure_sizes": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "measureSizes", {}, target);
-            return text15(`Measured ${result?.measured ?? 0} of ${result?.total ?? 0} assets.`);
+            return text17(`Measured ${result?.measured ?? 0} of ${result?.total ?? 0} assets.`);
           }
           case "detail": {
-            if (id == null) return fail17("detail requires the `id` param (from get_assets).");
+            if (id == null) return fail19("detail requires the `id` param (from get_assets).");
             const detail = await sync.callAction(ASSETS_TOOL_ID, "getDetail", { id }, target);
-            if (!detail) return fail17(`Asset ${id} not found \u2014 re-run get_assets for current ids.`);
+            if (!detail) return fail19(`Asset ${id} not found \u2014 re-run get_assets for current ids.`);
             const lines = [
               `## ${detail.name}.${detail.type} (#${detail.id})`,
               "",
@@ -3891,32 +4555,32 @@ ${JSON.stringify(slim)}
             if (detail.fileSystemLocation) lines.push(`- Source dir: ${detail.fileSystemLocation}`);
             if (detail.files?.length) lines.push(`- Files: ${detail.files.join(", ")}`);
             if (detail.uri) lines.push(`- Resolved URI: ${detail.uri}`);
-            return text15(lines.join("\n"));
+            return text17(lines.join("\n"));
           }
           case "save_baseline": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "saveBaseline", {}, target);
-            return text15(
+            return text17(
               `Baseline saved (${result?.assets ?? 0} assets). Make your change, then get_assets reports added/removed/grown/net bytes against it.`
             );
           }
           case "clear_baseline": {
             await sync.callAction(ASSETS_TOOL_ID, "clearBaseline", {}, target);
-            return text15("Baseline cleared.");
+            return text17("Baseline cleared.");
           }
           case "clear_records": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "clearRecords", {}, target);
-            return text15(result?.message ?? "Inventory cleared.");
+            return text17(result?.message ?? "Inventory cleared.");
           }
         }
       } catch (e) {
-        return fail17(errMsg17(e));
+        return fail19(errMsg18(e));
       }
     }
   );
 }
 
 // src/tools/packs/reload.ts
-var import_zod18 = require("zod");
+var import_zod20 = require("zod");
 
 // src/capture/devServerReload.ts
 var import_ws = require("ws");
@@ -3979,9 +4643,9 @@ var DEFAULT_WAIT_MS = 3e4;
 var TEARDOWN_GRACE_MS = 1200;
 var PROBE_TIMEOUT_MS = 1500;
 var PROBE_INTERVAL_MS = 400;
-var text16 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail18 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg18 = (e) => e instanceof Error ? e.message : String(e);
+var text18 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail20 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg19 = (e) => e instanceof Error ? e.message : String(e);
 var delay3 = (ms) => new Promise((r) => setTimeout(r, ms));
 async function ping(sync, deviceId, timeoutMs) {
   try {
@@ -4020,12 +4684,12 @@ function registerReloadTools(server, sync) {
     {
       description: "Reload the running app's JS bundle (Expo Go, dev client, or RN CLI) \u2014 the equivalent of shaking the device and hitting Reload, but from here. Use it to pick up a change Fast Refresh didn't apply, to clear leaked in-memory state before a measurement, to re-run app startup, or to RECOVER A CRASHED APP: after a fatal error the other tools stop answering, and reloading is how you get them back (it falls through to the dev server when the app is too broken to reload itself). In dev builds it uses React Native's DevSettings.reload(); otherwise it falls back to expo-updates (if the app installs it). All in-memory state is lost \u2014 read anything you need from get_console/get_storage BEFORE reloading. By default this waits for the app to come back up and reports how long the reload took. Works on any app running @buoy-gg/core \u2014 no particular tool package needed. Requires Buoy Pro.",
       inputSchema: {
-        strategy: import_zod18.z.enum(["auto", "dev-settings", "expo-updates"]).optional().describe(
+        strategy: import_zod20.z.enum(["auto", "dev-settings", "expo-updates"]).optional().describe(
           "Reload mechanism. 'auto' (default) uses DevSettings in dev builds and expo-updates otherwise. Force one only when debugging the reload itself."
         ),
-        wait: import_zod18.z.boolean().optional().describe("Wait for the app to come back before returning. Default true \u2014 turn off for fire-and-forget."),
-        timeoutMs: import_zod18.z.number().optional().describe("How long to wait for the app to reconnect, in ms. Default 30000."),
-        deviceId: import_zod18.z.string().optional().describe('Target device id (auto-selected if one is connected). Use "All" to reload every connected app.')
+        wait: import_zod20.z.boolean().optional().describe("Wait for the app to come back before returning. Default true \u2014 turn off for fire-and-forget."),
+        timeoutMs: import_zod20.z.number().optional().describe("How long to wait for the app to reconnect, in ms. Default 30000."),
+        deviceId: import_zod20.z.string().optional().describe('Target device id (auto-selected if one is connected). Use "All" to reload every connected app.')
       }
     },
     async (args) => {
@@ -4067,32 +4731,32 @@ function registerReloadTools(server, sync) {
         }
         const via = recovered ? ` via the dev server (the app was unresponsive \u2014 its own reload could not be reached)` : ack?.strategy ? ` via ${ack.strategy}` : "";
         if (args.wait === false) {
-          return text16(`Reload requested${via}. The app is restarting \u2014 its in-memory state is gone; re-read anything you cached.`);
+          return text18(`Reload requested${via}. The app is restarting \u2014 its in-memory state is gone; re-read anything you cached.`);
         }
         const elapsed = await waitForAppBack(sync, target, args.timeoutMs ?? DEFAULT_WAIT_MS, previousRealm);
         if (elapsed == null) {
-          return fail18(
+          return fail20(
             `Reload was accepted${via}, but the app hasn't reconnected yet. It may still be building the bundle (a cold Metro rebuild can take a while) \u2014 check the device, then run list_devices.`
           );
         }
-        return text16(
+        return text18(
           `Reloaded the app${via} \u2014 back and connected after ${(elapsed / 1e3).toFixed(1)}s. All in-memory state was reset, so re-read any state you cached before this.`
         );
       } catch (e) {
-        return fail18(errMsg18(e));
+        return fail20(errMsg19(e));
       }
     }
   );
 }
 
 // src/tools/packs/triage.ts
-var import_zod19 = require("zod");
-var text17 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail19 = (message) => ({
+var import_zod21 = require("zod");
+var text19 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail21 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg19 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg20 = (e) => e instanceof Error ? e.message : String(e);
 var PROBE_TIMEOUT_MS2 = 5e3;
 var MAX_STORAGE_KEYS = 20;
 var MAX_STORAGE_VALUE = 400;
@@ -4123,13 +4787,13 @@ async function otherBackends(sync, target, opts) {
   return notes.length ? `
 ${notes.join(" \xB7 ")} \u2014 read with get_storage` : "";
 }
-async function section(title, run) {
+async function section(title, run2) {
   try {
-    const body = await run();
+    const body = await run2();
     return body ? `${title}
 ${body}` : null;
   } catch (e) {
-    const msg = errMsg19(e);
+    const msg = errMsg20(e);
     if (/not responding|timed out|got no answer/i.test(msg)) {
       return `${title}
 (no answer \u2014 see the note above)`;
@@ -4144,7 +4808,7 @@ function registerTriageTools(server, sync) {
     {
       description: "START HERE when debugging a running app. One call = the app's current runtime state: connected device, recent console errors (including [FATAL] crashes), recent network requests with statuses, persisted storage values, and what's on screen right now. Use it as the first step for ANY 'why is the app doing X' question \u2014 it is far cheaper than calling get_console + get_network_requests + get_storage + describe_screen separately, and it tells you which of those to drill into next. If the app has crashed it says so and shows the crash. Requires Buoy Pro.",
       inputSchema: {
-        deviceId: import_zod19.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        deviceId: import_zod21.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -4251,7 +4915,7 @@ _Values: get_storage includeValues:true_`;
 
 \u{1F6D1} ${sync.unresponsiveNote(target)}` : "";
         const body = [consoleSec, netSec, storeSec, screenSec].filter(Boolean).join("\n\n");
-        return text17(
+        return text19(
           `${head}${banner}
 
 ${body}
@@ -4259,22 +4923,22 @@ ${body}
 _Drill in with get_console, get_network_requests (includeBodies:true for response bodies), get_storage (includeValues:true), describe_screen._`
         );
       } catch (e) {
-        return fail19(errMsg19(e));
+        return fail21(errMsg20(e));
       }
     }
   );
 }
 
 // src/tools/packs/flow.ts
-var import_zod20 = require("zod");
+var import_zod22 = require("zod");
 var UI_TOOL_ID = "highlight-updates";
 var APP_TOOL_ID2 = "app";
-var text18 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail20 = (message) => ({
+var text20 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail22 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg20 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg21 = (e) => e instanceof Error ? e.message : String(e);
 var delay4 = (ms) => new Promise((r) => setTimeout(r, ms));
 var POLL_MS = 250;
 var DEFAULT_WAIT_MS2 = 5e3;
@@ -4291,19 +4955,19 @@ function formatElement2(e) {
   const display = e.text ?? e.label;
   return `${e.interactive ? "\u2022 " : "  "}${e.name}${display ? ` "${display}"` : ""}${e.testID ? ` [testID=${e.testID}]` : ""}`;
 }
-var stepSchema = import_zod20.z.object({
-  tap: import_zod20.z.string().optional().describe("Tap this element: exact testID, or fuzzy visible text."),
-  longPress: import_zod20.z.boolean().optional().describe("Make `tap` a long-press instead."),
-  type: import_zod20.z.string().optional().describe("Text to type (needs `into`)."),
-  into: import_zod20.z.string().optional().describe("Target text input for `type`: testID or fuzzy text."),
-  set: import_zod20.z.union([import_zod20.z.number(), import_zod20.z.boolean()]).optional().describe("Set a toggle (true/false) or slider (number) \u2014 pair with `tap` as the target."),
-  reload: import_zod20.z.boolean().optional().describe("Reload the JS bundle before this step's action."),
-  waitMs: import_zod20.z.number().min(0).max(3e4).optional().describe("Fixed pause after the action, in ms (max 30000)."),
-  waitFor: import_zod20.z.string().optional().describe("Wait until an element matching this appears (default 5s)."),
-  waitGone: import_zod20.z.string().optional().describe("Wait until no element matches this (default 5s)."),
-  expect: import_zod20.z.string().optional().describe("Assert an element matching this IS on screen (waits up to 2s for it); fails the flow if not."),
-  expectGone: import_zod20.z.string().optional().describe("Assert nothing matches this (waits up to 2s for it to go); fails the flow if something does."),
-  timeoutMs: import_zod20.z.number().min(0).max(6e4).optional().describe("Budget for this step's waitFor/waitGone/expect, max 60000. Default 5000 (2000 for expect).")
+var stepSchema = import_zod22.z.object({
+  tap: import_zod22.z.string().optional().describe("Tap this element: exact testID, or fuzzy visible text."),
+  longPress: import_zod22.z.boolean().optional().describe("Make `tap` a long-press instead."),
+  type: import_zod22.z.string().optional().describe("Text to type (needs `into`)."),
+  into: import_zod22.z.string().optional().describe("Target text input for `type`: testID or fuzzy text."),
+  set: import_zod22.z.union([import_zod22.z.number(), import_zod22.z.boolean()]).optional().describe("Set a toggle (true/false) or slider (number) \u2014 pair with `tap` as the target."),
+  reload: import_zod22.z.boolean().optional().describe("Reload the JS bundle before this step's action."),
+  waitMs: import_zod22.z.number().min(0).max(3e4).optional().describe("Fixed pause after the action, in ms (max 30000)."),
+  waitFor: import_zod22.z.string().optional().describe("Wait until an element matching this appears (default 5s)."),
+  waitGone: import_zod22.z.string().optional().describe("Wait until no element matches this (default 5s)."),
+  expect: import_zod22.z.string().optional().describe("Assert an element matching this IS on screen (waits up to 2s for it); fails the flow if not."),
+  expectGone: import_zod22.z.string().optional().describe("Assert nothing matches this (waits up to 2s for it to go); fails the flow if something does."),
+  timeoutMs: import_zod22.z.number().min(0).max(6e4).optional().describe("Budget for this step's waitFor/waitGone/expect, max 60000. Default 5000 (2000 for expect).")
 }).describe("One flow step. Order within a step: reload \u2192 tap/type/set \u2192 waitMs \u2192 waitFor/waitGone \u2192 expect.");
 function registerFlowTools(server, sync) {
   server.registerTool(
@@ -4311,10 +4975,10 @@ function registerFlowTools(server, sync) {
     {
       description: "Run a scripted sequence of UI interactions in ONE call and report what happened: per-step results, the final screen, plus the network requests and console errors the flow produced. Use this instead of alternating describe_screen/tap_element \u2014 reproducing a bug ('open cart, checkout, submit') or verifying a fix after an edit is one call, not a dozen. Steps run in order and stop at the first failure, returning the screen at that point so you can see WHERE it broke. Each step can tap, type, set a toggle/slider, reload, wait for an element, and assert. Requires Buoy Pro.",
       inputSchema: {
-        steps: import_zod20.z.array(stepSchema).min(1).describe("Steps to run, in order."),
-        include: import_zod20.z.enum(["all", "screen", "none"]).optional().describe("What to report after the flow: 'all' (default) = final screen + network/console produced by the flow; 'screen' = final screen only; 'none' = step results only."),
-        continueOnFailure: import_zod20.z.boolean().optional().describe("Keep going after a failed step instead of stopping. Default false."),
-        deviceId: import_zod20.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        steps: import_zod22.z.array(stepSchema).min(1).describe("Steps to run, in order."),
+        include: import_zod22.z.enum(["all", "screen", "none"]).optional().describe("What to report after the flow: 'all' (default) = final screen + network/console produced by the flow; 'screen' = final screen only; 'none' = step results only."),
+        continueOnFailure: import_zod22.z.boolean().optional().describe("Keep going after a failed step instead of stopping. Default false."),
+        deviceId: import_zod22.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -4486,7 +5150,7 @@ function registerFlowTools(server, sync) {
               else stepErrors.push(`expected "${step.expectGone}" to be gone \u2014 still on screen`);
             }
           } catch (e) {
-            stepErrors.push(errMsg20(e));
+            stepErrors.push(errMsg21(e));
           }
           if (stepErrors.length) {
             lines.push(`${label} \u2717 ${describeStep(step)} \u2014 ${stepErrors.join("; ")}`);
@@ -4509,7 +5173,7 @@ function registerFlowTools(server, sync) {
 ${shown.map(formatElement2).join("\n")}`
             );
           } catch (e) {
-            parts.push(`**Screen now:** unavailable \u2014 ${cap2(errMsg20(e))}`);
+            parts.push(`**Screen now:** unavailable \u2014 ${cap2(errMsg21(e))}`);
           }
         }
         if (include === "all") {
@@ -4538,9 +5202,9 @@ ${shown.map(formatElement2).join("\n")}`
             }
           }
         }
-        return text18(parts.join("\n\n"));
+        return text20(parts.join("\n\n"));
       } catch (e) {
-        return fail20(errMsg20(e));
+        return fail22(errMsg21(e));
       }
     }
   );
@@ -4561,25 +5225,25 @@ var cap2 = (s, n = 160) => s.length > n ? `${s.slice(0, n)}\u2026` : s;
 var firstLines = (s, n = 3) => s.split("\n").map((l) => l.trim()).filter(Boolean).slice(0, n).join(" \u23CE ");
 
 // src/tools/packs/renders.ts
-var import_zod21 = require("zod");
+var import_zod23 = require("zod");
 var UI_TOOL_ID2 = "highlight-updates";
-var text19 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail21 = (message) => ({
+var text21 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail23 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg21 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg22 = (e) => e instanceof Error ? e.message : String(e);
 var delay5 = (ms) => new Promise((r) => setTimeout(r, ms));
 var DEFAULT_IDLE_MS = 3e3;
 var SETTLE_MS = 400;
 var DEFAULT_TOP = 12;
 var lastCapture = /* @__PURE__ */ new Map();
-var stepSchema2 = import_zod21.z.object({
-  tap: import_zod21.z.string().optional().describe("Tap this element: exact testID, or fuzzy visible text."),
-  type: import_zod21.z.string().optional().describe("Text to type (needs `into`)."),
-  into: import_zod21.z.string().optional().describe("Target text input for `type`: testID or fuzzy text."),
-  waitMs: import_zod21.z.number().min(0).max(1e4).optional().describe("Pause after the action, in ms."),
-  repeat: import_zod21.z.number().min(1).max(20).optional().describe("Do this step N times (default 1). Useful for 'tap it five times'.")
+var stepSchema2 = import_zod23.z.object({
+  tap: import_zod23.z.string().optional().describe("Tap this element: exact testID, or fuzzy visible text."),
+  type: import_zod23.z.string().optional().describe("Text to type (needs `into`)."),
+  into: import_zod23.z.string().optional().describe("Target text input for `type`: testID or fuzzy text."),
+  waitMs: import_zod23.z.number().min(0).max(1e4).optional().describe("Pause after the action, in ms."),
+  repeat: import_zod23.z.number().min(1).max(20).optional().describe("Do this step N times (default 1). Useful for 'tap it five times'.")
 }).describe("One interaction to measure. Keep it to the thing you're asking about.");
 function selector2(needle) {
   return /\s/.test(needle) ? { query: needle } : { testID: needle, query: needle };
@@ -4672,14 +5336,14 @@ function registerRenderTools(server, sync) {
     {
       description: "Find out WHAT re-rendered on the current screen and WHY, in one call \u2014 no test route, no scaffolding. THE tool for 'this page is slow/laggy/janky', 'typing lags', 'the whole page re-renders when I tap one button'. Give it `steps` to measure a specific interaction (tap a button, type in a field) \u2014 measuring an idle window instead tells you nothing about what taps cost, which is how re-render fixes usually go wrong. Returns per-component render COST in ms (sorted by it \u2014 a component rendering 40x for 0.4ms is noise, one rendering 4x for 38ms is the answer), the CAUSE of each (parent cascade / own state / changed props), which parent dragged it along, and which props changed. `wasted` counts renders that produced nothing new \u2014 that's the removable part. AFTER YOU EDIT, call it again with the same steps and compareToPrevious:true to prove the fix landed and didn't move the cost somewhere else. (For choosing between several implementations of a screen, use run_benchmark_batch instead \u2014 that ranks variants; this explains one screen.) Requires Buoy Pro and @buoy-gg/highlight-updates.",
       inputSchema: {
-        steps: import_zod21.z.array(stepSchema2).max(20).optional().describe(
+        steps: import_zod23.z.array(stepSchema2).max(20).optional().describe(
           "The interaction to measure, e.g. [{tap:'favorite-deal-2', repeat:5}] or [{type:'bench', into:'deals-search'}]. Omit to sample the screen idle \u2014 only useful for churn that happens with nobody touching it."
         ),
-        idleMs: import_zod21.z.number().min(500).max(2e4).optional().describe(`Idle sample length when no steps are given. Default ${DEFAULT_IDLE_MS}.`),
-        label: import_zod21.z.string().optional().describe('Name this measurement, e.g. "before fix". Shown in the next comparison.'),
-        compareToPrevious: import_zod21.z.boolean().optional().describe("Diff against the previous measure_renders on this device. Use after an edit to prove the fix."),
-        top: import_zod21.z.number().min(1).max(40).optional().describe(`Components to list. Default ${DEFAULT_TOP}.`),
-        deviceId: import_zod21.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        idleMs: import_zod23.z.number().min(500).max(2e4).optional().describe(`Idle sample length when no steps are given. Default ${DEFAULT_IDLE_MS}.`),
+        label: import_zod23.z.string().optional().describe('Name this measurement, e.g. "before fix". Shown in the next comparison.'),
+        compareToPrevious: import_zod23.z.boolean().optional().describe("Diff against the previous measure_renders on this device. Use after an edit to prove the fix."),
+        top: import_zod23.z.number().min(1).max(40).optional().describe(`Components to list. Default ${DEFAULT_TOP}.`),
+        deviceId: import_zod23.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -4688,18 +5352,18 @@ function registerRenderTools(server, sync) {
         const device = sync.connectedDevices().find((d) => d.deviceId === target);
         const uiTool = (device?.tools ?? []).find((t) => t.toolId === UI_TOOL_ID2);
         if (!uiTool) {
-          return fail21(
+          return fail23(
             "This app doesn't expose the highlight-updates tool, so renders can't be measured. Install @buoy-gg/highlight-updates."
           );
         }
         if (!(uiTool.actions ?? []).includes("beginMeasurement")) {
-          return fail21(
+          return fail23(
             "This app's @buoy-gg/highlight-updates is too old to measure renders (needs the version with beginMeasurement). Upgrade it, then try again. Meanwhile run_benchmark_batch with captureRenders can still give counts if you have a test route."
           );
         }
         const began = await sync.callAction(UI_TOOL_ID2, "beginMeasurement", {}, target);
         if (began && began.ok === false) {
-          return fail21(`Can't measure renders: ${began.reason ?? "capture unavailable"}`);
+          return fail23(`Can't measure renders: ${began.reason ?? "capture unavailable"}`);
         }
         await delay5(SETTLE_MS);
         const startedAt = Date.now();
@@ -4744,7 +5408,7 @@ function registerRenderTools(server, sync) {
         const ended = await sync.callAction(UI_TOOL_ID2, "endMeasurement", {}, target);
         const summary = ended?.summary;
         if (!summary) {
-          return fail21(
+          return fail23(
             "The capture window closed without returning anything. If the app reloaded mid-measurement, try again."
           );
         }
@@ -4769,17 +5433,17 @@ function registerRenderTools(server, sync) {
         } else if (!args.compareToPrevious) {
           parts.push("", "_Fixed something? Call this again with the same steps and `compareToPrevious:true` to prove it landed._");
         }
-        return text19(parts.join("\n"));
+        return text21(parts.join("\n"));
       } catch (e) {
-        return fail21(errMsg21(e));
+        return fail23(errMsg22(e));
       }
     }
   );
 }
 
 // src/verify/editWatcher.ts
-var import_node_fs3 = __toESM(require("fs"));
-var import_node_path3 = __toESM(require("path"));
+var import_node_fs4 = __toESM(require("fs"));
+var import_node_path4 = __toESM(require("path"));
 var WATCHED_EXT = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -4822,14 +5486,14 @@ var EditWatcher = class {
     if (mode === "never" || this.started) return;
     this.started = true;
     try {
-      this.watcher = import_node_fs3.default.watch(
+      this.watcher = import_node_fs4.default.watch(
         rootDir,
         { recursive: true },
         (_event, filename) => {
           if (!filename) return;
           const rel2 = String(filename);
-          if (rel2.split(import_node_path3.default.sep).some((seg) => IGNORED_DIRS.has(seg))) return;
-          if (!WATCHED_EXT.has(import_node_path3.default.extname(rel2))) return;
+          if (rel2.split(import_node_path4.default.sep).some((seg) => IGNORED_DIRS.has(seg))) return;
+          if (!WATCHED_EXT.has(import_node_path4.default.extname(rel2))) return;
           this.noteEdit(rel2);
         }
       );
@@ -4929,6 +5593,19 @@ requests the DEVELOPER kept: those are snapshots that outlive Clear, the 500-req
 restarts, so treat a pinned request as "a human flagged this as the problem". \`network_action\`
 pins/saves one \u2014 pin the failing call you want a human to see, or keep one before the log rolls over.
 
+Testing anything that opens a CAMERA \u2014 a QR/barcode scanner, document capture, an avatar
+picker? The iOS Simulator has no camera, so those screens normally cannot be exercised at
+all. \`camera_source\` gives it one: \`barcode\` generates the code from text you supply
+(pdf417 is what a driver's licence carries), \`image\`/\`video\` play a file, \`screen\` points
+the phone at this Mac. \`camera_devices\` lists the booted simulators and their apps when
+you need a bundle id; \`camera_inputs\` lists this Mac's cameras and windows when you need
+one of those ids. Then \`camera_launch\` to relaunch the app with it attached \u2014 a camera
+can only be attached at process start \u2014 or \`camera_zero_setup\` when something else starts
+the app. \`camera_status\` shows what is being decoded right now, which separates "the
+scanner is broken" from "it never saw the code", \`camera_diagnose\` says why when nothing
+works, and \`camera_stop\` turns it off when you are done. These need no device connection
+and no Buoy integration in the app.
+
 Need to SEE a component (verify a UI change, check styling/layout)? Use \`screenshot_component\` with
 a testID/name \u2014 it locates the live component on-device and returns a cropped screenshot inline.
 iOS Simulator only, and only works when this MCP server runs on the same Mac as the booted Simulator.
@@ -4992,6 +5669,7 @@ require the connected app to have an active Buoy Pro license. If they error with
 required", tell the user to upgrade to Buoy Pro in the app \u2014 don't try to work around it.`;
 var VERIFYING_TOOLS = /* @__PURE__ */ new Set([
   "measure_renders",
+  "scenario_action",
   "run_flow",
   "run_benchmark_batch",
   "get_triage",
@@ -5042,7 +5720,9 @@ function createMcpServer(sync) {
   registerRoutesTools(server, sync);
   registerConsoleTools(server, sync);
   registerTimeMachineTools(server, sync);
+  registerScenariosTools(server, sync);
   registerScreenshotTools(server, sync);
+  registerCameraTools(server);
   registerInteractTools(server, sync);
   registerJsThreadTools(server, sync);
   registerImagesTools(server, sync);
@@ -5051,16 +5731,16 @@ function createMcpServer(sync) {
   return server;
 }
 var deviceIdField = {
-  deviceId: import_zod22.z.string().optional().describe(
+  deviceId: import_zod24.z.string().optional().describe(
     'Target device id (from list_devices). Omit to auto-select when exactly one device is connected. Use "All" to broadcast.'
   )
 };
 
 // src/init.ts
-var import_node_child_process2 = require("child_process");
-var import_node_fs4 = __toESM(require("fs"));
-var import_node_os3 = __toESM(require("os"));
-var import_node_path4 = __toESM(require("path"));
+var import_node_child_process3 = require("child_process");
+var import_node_fs5 = __toESM(require("fs"));
+var import_node_os4 = __toESM(require("os"));
+var import_node_path5 = __toESM(require("path"));
 function defaultEnv() {
   return { BUOY_VERIFY: "auto" };
 }
@@ -5068,19 +5748,19 @@ var PUBLIC_REGISTRY = "https://registry.npmjs.org";
 var PROBE_TIMEOUT_MS3 = 3e3;
 function runInit(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const skillSrcDir = opts.skillSrcDir ?? import_node_path4.default.resolve(__dirname, "../skill");
+  const skillSrcDir = opts.skillSrcDir ?? import_node_path5.default.resolve(__dirname, "../skill");
   const log = opts.log ?? ((m) => process.stdout.write(m + "\n"));
   const entry = resolveEntry(opts, log);
   const done = [];
-  upsertMcpConfig(import_node_path4.default.join(cwd, ".mcp.json"), "mcpServers", entry, cwd, done);
-  import_node_fs4.default.mkdirSync(import_node_path4.default.join(cwd, ".cursor"), { recursive: true });
-  upsertMcpConfig(import_node_path4.default.join(cwd, ".cursor", "mcp.json"), "mcpServers", entry, cwd, done);
-  if (import_node_fs4.default.existsSync(import_node_path4.default.join(cwd, ".vscode"))) {
-    upsertMcpConfig(import_node_path4.default.join(cwd, ".vscode", "mcp.json"), "servers", entry, cwd, done);
+  upsertMcpConfig(import_node_path5.default.join(cwd, ".mcp.json"), "mcpServers", entry, cwd, done);
+  import_node_fs5.default.mkdirSync(import_node_path5.default.join(cwd, ".cursor"), { recursive: true });
+  upsertMcpConfig(import_node_path5.default.join(cwd, ".cursor", "mcp.json"), "mcpServers", entry, cwd, done);
+  if (import_node_fs5.default.existsSync(import_node_path5.default.join(cwd, ".vscode"))) {
+    upsertMcpConfig(import_node_path5.default.join(cwd, ".vscode", "mcp.json"), "servers", entry, cwd, done);
   }
   installSkills(skillSrcDir, cwd, done);
-  appendDebuggingGuide(import_node_path4.default.join(cwd, "CLAUDE.md"), cwd, done);
-  appendDebuggingGuide(import_node_path4.default.join(cwd, "AGENTS.md"), cwd, done);
+  appendDebuggingGuide(import_node_path5.default.join(cwd, "CLAUDE.md"), cwd, done);
+  appendDebuggingGuide(import_node_path5.default.join(cwd, "AGENTS.md"), cwd, done);
   log("Buoy MCP installed:");
   for (const line of done) log("  \u2022 " + line);
   log("");
@@ -5122,21 +5802,21 @@ function npxEntry() {
   return { type: "stdio", command: "npx", args: ["-y", `${PACKAGE_NAME}@latest`], env: defaultEnv() };
 }
 function localEntry(opts, log) {
-  const installDir = opts.installDir ?? process.env.BUOY_MCP_HOME ?? import_node_path4.default.join(import_node_os3.default.homedir(), ".buoy-mcp");
+  const installDir = opts.installDir ?? process.env.BUOY_MCP_HOME ?? import_node_path5.default.join(import_node_os4.default.homedir(), ".buoy-mcp");
   const registry = opts.registry ?? PUBLIC_REGISTRY;
-  const cliPath = installLocalCopy(installDir, registry, log);
-  if (cliPath) {
-    return { type: "stdio", command: "node", args: [cliPath], env: defaultEnv() };
+  const cliPath2 = installLocalCopy(installDir, registry, log);
+  if (cliPath2) {
+    return { type: "stdio", command: "node", args: [cliPath2], env: defaultEnv() };
   }
   log("\u26A0 local install failed \u2014 writing the npx entry instead (see the error above).");
   return npxEntry();
 }
 function installLocalCopy(installDir, registry, log) {
   const spec = `${PACKAGE_NAME}@${VERSION === "0.0.0-dev" ? "latest" : VERSION}`;
-  import_node_fs4.default.mkdirSync(installDir, { recursive: true });
+  import_node_fs5.default.mkdirSync(installDir, { recursive: true });
   const npm = process.platform === "win32" ? "npm.cmd" : "npm";
   log(`Installing ${spec} into ${installDir} from ${registry} \u2026`);
-  const res = (0, import_node_child_process2.spawnSync)(
+  const res = (0, import_node_child_process3.spawnSync)(
     npm,
     [
       "install",
@@ -5156,12 +5836,12 @@ function installLocalCopy(installDir, registry, log) {
     log(`\u26A0 npm install exited with code ${res.status ?? "?"}${res.error ? ` (${res.error.message})` : ""}.`);
     return null;
   }
-  const cliPath = import_node_path4.default.join(installDir, "node_modules", PACKAGE_NAME, "dist", "cli.js");
-  if (!import_node_fs4.default.existsSync(cliPath)) {
-    log(`\u26A0 install finished but ${cliPath} is missing.`);
+  const cliPath2 = import_node_path5.default.join(installDir, "node_modules", PACKAGE_NAME, "dist", "cli.js");
+  if (!import_node_fs5.default.existsSync(cliPath2)) {
+    log(`\u26A0 install finished but ${cliPath2} is missing.`);
     return null;
   }
-  return cliPath;
+  return cliPath2;
 }
 function probeRegistry() {
   const registry = effectiveRegistry();
@@ -5179,14 +5859,14 @@ function effectiveRegistry() {
 }
 function npmConfigGet(key) {
   const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-  const res = (0, import_node_child_process2.spawnSync)(npm, ["config", "get", key], { encoding: "utf8", timeout: PROBE_TIMEOUT_MS3 });
+  const res = (0, import_node_child_process3.spawnSync)(npm, ["config", "get", key], { encoding: "utf8", timeout: PROBE_TIMEOUT_MS3 });
   if (res.status !== 0 || typeof res.stdout !== "string") return null;
   const val = res.stdout.trim();
   if (!val || val === "undefined" || val === "null") return null;
   return val;
 }
 function hostReachable(registry) {
-  const done = (0, import_node_child_process2.spawnSync)(
+  const done = (0, import_node_child_process3.spawnSync)(
     process.execPath,
     ["-e", REACHABILITY_PROBE, registry, String(PROBE_TIMEOUT_MS3)],
     { encoding: "utf8", timeout: PROBE_TIMEOUT_MS3 + 2e3 }
@@ -5209,22 +5889,22 @@ fetch(url, { method: 'HEAD', signal: c.signal })
 `;
 function upsertMcpConfig(file, key, entry, cwd, done) {
   let json3 = {};
-  if (import_node_fs4.default.existsSync(file)) {
+  if (import_node_fs5.default.existsSync(file)) {
     try {
-      json3 = JSON.parse(import_node_fs4.default.readFileSync(file, "utf8"));
+      json3 = JSON.parse(import_node_fs5.default.readFileSync(file, "utf8"));
     } catch {
-      import_node_fs4.default.copyFileSync(file, file + ".bak");
+      import_node_fs5.default.copyFileSync(file, file + ".bak");
       done.push(`existing ${rel(file, cwd)} was invalid JSON \u2014 backed up to ${rel(file, cwd)}.bak`);
       json3 = {};
     }
   } else {
-    import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
+    import_node_fs5.default.mkdirSync(import_node_path5.default.dirname(file), { recursive: true });
   }
   const servers = json3[key] && typeof json3[key] === "object" ? json3[key] : {};
   const existed = "buoy" in servers;
   servers.buoy = entry;
   json3[key] = servers;
-  import_node_fs4.default.writeFileSync(file, JSON.stringify(json3, null, 2) + "\n");
+  import_node_fs5.default.writeFileSync(file, JSON.stringify(json3, null, 2) + "\n");
   done.push(`${existed ? "updated" : "added"} \`buoy\` in ${rel(file, cwd)}`);
 }
 var GUIDE_HEADING = "# Debugging with Buoy";
@@ -5284,9 +5964,9 @@ mentions it.
 `;
 function appendDebuggingGuide(file, cwd, done) {
   let existing = "";
-  if (import_node_fs4.default.existsSync(file)) {
+  if (import_node_fs5.default.existsSync(file)) {
     try {
-      existing = import_node_fs4.default.readFileSync(file, "utf8");
+      existing = import_node_fs5.default.readFileSync(file, "utf8");
     } catch {
       done.push(`\u26A0 could not read ${rel(file, cwd)} \u2014 skipped the debugging guide`);
       return;
@@ -5298,40 +5978,40 @@ function appendDebuggingGuide(file, cwd, done) {
   }
   const separator = existing === "" ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
   try {
-    import_node_fs4.default.writeFileSync(file, existing + separator + DEBUGGING_GUIDE);
+    import_node_fs5.default.writeFileSync(file, existing + separator + DEBUGGING_GUIDE);
     done.push(`${existing ? "appended" : "created"} "${GUIDE_HEADING}" block in ${rel(file, cwd)}`);
   } catch {
     done.push(`\u26A0 could not write ${rel(file, cwd)} \u2014 skipped the debugging guide`);
   }
 }
 function installSkills(skillSrcDir, cwd, done) {
-  if (!import_node_fs4.default.existsSync(skillSrcDir)) {
+  if (!import_node_fs5.default.existsSync(skillSrcDir)) {
     done.push("\u26A0 no bundled skills found \u2014 skipped");
     return;
   }
-  const skills = import_node_fs4.default.readdirSync(skillSrcDir, { withFileTypes: true }).filter((e) => e.isDirectory() && import_node_fs4.default.existsSync(import_node_path4.default.join(skillSrcDir, e.name, "SKILL.md")));
+  const skills = import_node_fs5.default.readdirSync(skillSrcDir, { withFileTypes: true }).filter((e) => e.isDirectory() && import_node_fs5.default.existsSync(import_node_path5.default.join(skillSrcDir, e.name, "SKILL.md")));
   if (skills.length === 0) {
     done.push("\u26A0 no skills with a SKILL.md found \u2014 skipped");
     return;
   }
   for (const skill of skills) {
-    const from = import_node_path4.default.join(skillSrcDir, skill.name);
-    const to = import_node_path4.default.join(cwd, ".claude", "skills", skill.name);
+    const from = import_node_path5.default.join(skillSrcDir, skill.name);
+    const to = import_node_path5.default.join(cwd, ".claude", "skills", skill.name);
     copyDir(from, to);
-    done.push(`installed the ${skill.name} skill \u2192 ${rel(import_node_path4.default.join(to, "SKILL.md"), cwd)}`);
+    done.push(`installed the ${skill.name} skill \u2192 ${rel(import_node_path5.default.join(to, "SKILL.md"), cwd)}`);
   }
 }
 function copyDir(from, to) {
-  import_node_fs4.default.mkdirSync(to, { recursive: true });
-  for (const entry of import_node_fs4.default.readdirSync(from, { withFileTypes: true })) {
-    const s = import_node_path4.default.join(from, entry.name);
-    const d = import_node_path4.default.join(to, entry.name);
+  import_node_fs5.default.mkdirSync(to, { recursive: true });
+  for (const entry of import_node_fs5.default.readdirSync(from, { withFileTypes: true })) {
+    const s = import_node_path5.default.join(from, entry.name);
+    const d = import_node_path5.default.join(to, entry.name);
     if (entry.isDirectory()) copyDir(s, d);
-    else import_node_fs4.default.copyFileSync(s, d);
+    else import_node_fs5.default.copyFileSync(s, d);
   }
 }
 function rel(file, cwd) {
-  const r = import_node_path4.default.relative(cwd, file);
+  const r = import_node_path5.default.relative(cwd, file);
   return r && !r.startsWith("..") ? r : file;
 }