@buoy-gg/mcp 7.0.33 → 7.0.35

package/dist/cli.js

@@ -641,7 +641,7 @@ var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 
 // src/server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_zod24 = require("zod");
+var import_zod26 = require("zod");
 
 // src/tools/generic.ts
 var import_zod = require("zod");
@@ -652,7 +652,7 @@ var import_node_os = __toESM(require("os"));
 var import_node_path = __toESM(require("path"));
 
 // src/version.ts
-var VERSION = "7.0.33" ? "7.0.33" : "0.0.0-dev";
+var VERSION = "7.0.35" ? "7.0.35" : "0.0.0-dev";
 var PACKAGE_NAME = "@buoy-gg/mcp";
 
 // src/update/checkForUpdate.ts
@@ -827,7 +827,40 @@ function errMsg(e) {
 }
 
 // src/tools/packs/perfMonitor.ts
+var import_zod3 = require("zod");
+
+// src/tools/packKit.ts
 var import_zod2 = require("zod");
+var text = (s) => ({
+  content: [{ type: "text", text: s }]
+});
+var fail2 = (message) => ({
+  isError: true,
+  content: [{ type: "text", text: message }]
+});
+var errMsg2 = (e) => e instanceof Error ? e.message : String(e);
+var deviceIdInput = import_zod2.z.string().optional().describe("Target device id (auto-selected if one is connected).");
+function clampLimit(value, fallback) {
+  return typeof value === "number" && value > 0 ? value : fallback;
+}
+function staleHeader(stale) {
+  return stale ? `${stale}
+
+` : "";
+}
+function inactiveToolMessage(options) {
+  return `No ${options.toolId} result from the device. The ${options.toolId} tool may be inactive, or the app needs a newer Buoy (${options.mcpTool} requires the ${options.action} action).`;
+}
+function withDevice(sync, run2) {
+  return async (args) => {
+    try {
+      const target = sync.requireProDevice(args.deviceId);
+      return await run2(args, target);
+    } catch (e) {
+      return fail2(errMsg2(e));
+    }
+  };
+}
 
 // src/tools/packs/perfMonitorTypes.ts
 var PERF_TOOL_ID = "perf-monitor";
@@ -1144,13 +1177,10 @@ function round(n, d) {
 var POLL_INTERVAL_MS = 1500;
 var delay2 = (ms) => new Promise((r) => setTimeout(r, ms));
 var json2 = (value) => ({ content: [{ type: "text", text: JSON.stringify(value, null, 2) }] });
-var text = (s) => ({ content: [{ type: "text", text: s }] });
-var fail2 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg2 = (e) => e instanceof Error ? e.message : String(e);
-var caseSchema = import_zod2.z.object({
-  name: import_zod2.z.string().describe("Display name for this variant (becomes the saved run's name)."),
-  params: import_zod2.z.record(import_zod2.z.string()).optional().describe('Query params applied to the route for this case, e.g. { "renderer": "v2", "count": "100" }.'),
-  route: import_zod2.z.string().optional().describe("Optional per-case route override; defaults to targetRoute.")
+var caseSchema = import_zod3.z.object({
+  name: import_zod3.z.string().describe("Display name for this variant (becomes the saved run's name)."),
+  params: import_zod3.z.record(import_zod3.z.string()).optional().describe('Query params applied to the route for this case, e.g. { "renderer": "v2", "count": "100" }.'),
+  route: import_zod3.z.string().optional().describe("Optional per-case route override; defaults to targetRoute.")
 });
 async function readDeviceSettings(sync, deviceId) {
   try {
@@ -1269,22 +1299,22 @@ function registerPerfMonitorTools(server, sync) {
     {
       description: "Run a perf-monitor benchmark batch and return a RANKED comparison of all cases (winner by UI FPS). Give it a target route and a matrix of cases (each a name + query params that select a variant on that route); it navigates, records, and benchmarks each case on the device, then ranks them. This blocks until the batch completes (can be minutes for large batches). The app must have the target route render its variants from the params.",
       inputSchema: {
-        targetRoute: import_zod2.z.string().describe('The screen to benchmark, e.g. "/perf-test". Reads case params to pick a variant.'),
-        cases: import_zod2.z.array(caseSchema).min(1).describe("The variants to compare. Case #0 is the baseline for deltas."),
-        bounceRoute: import_zod2.z.string().optional().describe('Screen to bounce to between runs so the test screen fully remounts. Defaults to "/" (or a stub if target is "/").'),
-        runsPerCase: import_zod2.z.number().optional().describe("Runs per case; the median becomes the canonical result. Default 3 (1\u201310)."),
-        perCaseDurationMs: import_zod2.z.number().optional().describe("How long to record each run. Default 5000."),
-        settleMs: import_zod2.z.number().optional().describe("Idle gap after navigation before recording. Default 600."),
-        coolDownMs: import_zod2.z.number().optional().describe("Idle between runs/cases for thermal recovery. Default 2000."),
-        navTimeoutMs: import_zod2.z.number().optional().describe("Max wait for navigation per run. Default 5000."),
-        discardWarmupRuns: import_zod2.z.number().optional().describe("Discard first N runs of each case before taking the median. Default 0."),
-        shuffleCases: import_zod2.z.boolean().optional().describe("Interleave + shuffle case order to cancel thermal bias. Default on for >3 cases."),
-        reloadBetweenCases: import_zod2.z.boolean().optional().describe("Fully reload JS between cases (needs <AutomationResumer/> mounted). Default false."),
-        captureRenders: import_zod2.z.boolean().optional().describe(
+        targetRoute: import_zod3.z.string().describe('The screen to benchmark, e.g. "/perf-test". Reads case params to pick a variant.'),
+        cases: import_zod3.z.array(caseSchema).min(1).describe("The variants to compare. Case #0 is the baseline for deltas."),
+        bounceRoute: import_zod3.z.string().optional().describe('Screen to bounce to between runs so the test screen fully remounts. Defaults to "/" (or a stub if target is "/").'),
+        runsPerCase: import_zod3.z.number().optional().describe("Runs per case; the median becomes the canonical result. Default 3 (1\u201310)."),
+        perCaseDurationMs: import_zod3.z.number().optional().describe("How long to record each run. Default 5000."),
+        settleMs: import_zod3.z.number().optional().describe("Idle gap after navigation before recording. Default 600."),
+        coolDownMs: import_zod3.z.number().optional().describe("Idle between runs/cases for thermal recovery. Default 2000."),
+        navTimeoutMs: import_zod3.z.number().optional().describe("Max wait for navigation per run. Default 5000."),
+        discardWarmupRuns: import_zod3.z.number().optional().describe("Discard first N runs of each case before taking the median. Default 0."),
+        shuffleCases: import_zod3.z.boolean().optional().describe("Interleave + shuffle case order to cancel thermal bias. Default on for >3 cases."),
+        reloadBetweenCases: import_zod3.z.boolean().optional().describe("Fully reload JS between cases (needs <AutomationResumer/> mounted). Default false."),
+        captureRenders: import_zod3.z.boolean().optional().describe(
           "Capture per-component render counts/durations during each run (needs @buoy-gg/highlight-updates installed; dev builds only). Adds slight JS-thread overhead applied equally to every case. Default true."
         ),
-        deviceId: import_zod2.z.string().optional().describe("Target device id. Omit to auto-select when one device is connected."),
-        maxWaitMs: import_zod2.z.number().optional().describe("Safety cap for how long to wait for completion. Defaults to ~3\xD7 the estimate + 60s.")
+        deviceId: import_zod3.z.string().optional().describe("Target device id. Omit to auto-select when one device is connected."),
+        maxWaitMs: import_zod3.z.number().optional().describe("Safety cap for how long to wait for completion. Defaults to ~3\xD7 the estimate + 60s.")
       }
     },
     async (args) => {
@@ -1354,7 +1384,7 @@ ${JSON.stringify(summary, null, 2)}
     "get_automation_status",
     {
       description: "Get the perf-monitor automation batch status (current phase + last completed batch) without waiting.",
-      inputSchema: { deviceId: import_zod2.z.string().optional().describe("Target device id (auto-selected if one is connected).") }
+      inputSchema: { deviceId: import_zod3.z.string().optional().describe("Target device id (auto-selected if one is connected).") }
     },
     async ({ deviceId }) => {
       try {
@@ -1375,8 +1405,8 @@ ${JSON.stringify(summary, null, 2)}
     {
       description: "Block until the in-flight perf-monitor batch finishes, then return its ranked comparison. Use this if a batch was started another way (e.g. on the device).",
       inputSchema: {
-        deviceId: import_zod2.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        maxWaitMs: import_zod2.z.number().optional().describe("Max time to wait. Default 600000 (10 min).")
+        deviceId: deviceIdInput,
+        maxWaitMs: import_zod3.z.number().optional().describe("Max time to wait. Default 600000 (10 min).")
       }
     },
     async ({ deviceId, maxWaitMs }) => {
@@ -1449,8 +1479,8 @@ ${JSON.stringify(ranking, null, 2)}
     {
       description: "Re-rank a previously-run benchmark batch by its batchId (from the saved recordings index).",
       inputSchema: {
-        batchId: import_zod2.z.string().describe("The batch id to report on."),
-        deviceId: import_zod2.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        batchId: import_zod3.z.string().describe("The batch id to report on."),
+        deviceId: deviceIdInput
       }
     },
     async ({ batchId, deviceId }) => {
@@ -1477,9 +1507,9 @@ ${JSON.stringify(ranking, null, 2)}
     {
       description: "Compare two saved benchmark runs head-to-head: avg + p95 for FPS/CPU/memory, jank, AND render counts \u2014 total, commits, and wasted (parent cascades + identity-only prop churn) \u2014 each with deltas. Use this to prove a memoization or re-render fix actually landed: the wasted-render delta is the number that says so.",
       inputSchema: {
-        reportIdA: import_zod2.z.string().describe("First (baseline) report id."),
-        reportIdB: import_zod2.z.string().describe("Second report id to compare against the baseline."),
-        deviceId: import_zod2.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        reportIdA: import_zod3.z.string().describe("First (baseline) report id."),
+        reportIdB: import_zod3.z.string().describe("Second report id to compare against the baseline."),
+        deviceId: deviceIdInput
       }
     },
     async ({ reportIdA, reportIdB, deviceId }) => {
@@ -1507,8 +1537,8 @@ ${JSON.stringify(ranking, null, 2)}
     {
       description: "Read the device's saved benchmark settings (per-page duration, runs, cooldown, reload, shuffle) in plain English with a time estimate. Call this before run_benchmark_batch so you can tell the user what the run will do \u2014 run_benchmark_batch inherits these unless you override them.",
       inputSchema: {
-        pages: import_zod2.z.number().optional().describe("How many pages/variants you plan to test, for a total-time estimate. Default 1."),
-        deviceId: import_zod2.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        pages: import_zod3.z.number().optional().describe("How many pages/variants you plan to test, for a total-time estimate. Default 1."),
+        deviceId: deviceIdInput
       }
     },
     async ({ pages, deviceId }) => {
@@ -1538,16 +1568,16 @@ ${JSON.stringify(settings, null, 2)}
     {
       description: `PERSIST benchmark settings on the device so they stick across runs. Only use when the user explicitly wants to save a change ("always", "save this"). For a one-off, pass overrides to run_benchmark_batch instead \u2014 don't change their saved profile.`,
       inputSchema: {
-        perCaseDurationMs: import_zod2.z.number().optional().describe("Recording length per page (ms)."),
-        settleMs: import_zod2.z.number().optional().describe("Idle after navigation before recording (ms)."),
-        coolDownMs: import_zod2.z.number().optional().describe("Idle between runs/cases (ms)."),
-        navTimeoutMs: import_zod2.z.number().optional().describe("Max wait for navigation per run (ms)."),
-        runsPerCase: import_zod2.z.number().optional().describe("Runs per page; median is the canonical result (1\u201310)."),
-        discardWarmupRuns: import_zod2.z.number().optional().describe("Discard first N runs of each page before the median."),
-        shuffleCases: import_zod2.z.boolean().optional().describe("Interleave + shuffle case order to cancel thermal bias."),
-        reloadBetweenCases: import_zod2.z.boolean().optional().describe("Fully reload JS between pages (needs <AutomationResumer/> mounted)."),
-        captureRenders: import_zod2.z.boolean().optional().describe("Capture per-component render counts/durations during each run."),
-        deviceId: import_zod2.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        perCaseDurationMs: import_zod3.z.number().optional().describe("Recording length per page (ms)."),
+        settleMs: import_zod3.z.number().optional().describe("Idle after navigation before recording (ms)."),
+        coolDownMs: import_zod3.z.number().optional().describe("Idle between runs/cases (ms)."),
+        navTimeoutMs: import_zod3.z.number().optional().describe("Max wait for navigation per run (ms)."),
+        runsPerCase: import_zod3.z.number().optional().describe("Runs per page; median is the canonical result (1\u201310)."),
+        discardWarmupRuns: import_zod3.z.number().optional().describe("Discard first N runs of each page before the median."),
+        shuffleCases: import_zod3.z.boolean().optional().describe("Interleave + shuffle case order to cancel thermal bias."),
+        reloadBetweenCases: import_zod3.z.boolean().optional().describe("Fully reload JS between pages (needs <AutomationResumer/> mounted)."),
+        captureRenders: import_zod3.z.boolean().optional().describe("Capture per-component render counts/durations during each run."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -1595,11 +1625,8 @@ ${JSON.stringify(saved ?? settings, null, 2)}
 }
 
 // src/tools/packs/events.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 var EVENTS_TOOL_ID = "events";
-var text2 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail3 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg3 = (e) => e instanceof Error ? e.message : String(e);
 var SOURCE_ALIASES = {
   storage: ["storage-async", "storage-mmkv"],
   "react-query": ["react-query", "react-query-query", "react-query-mutation"]
@@ -1614,13 +1641,13 @@ function registerEventsTools(server, sync) {
     {
       description: "The UNIVERSAL, token-bounded activity reader for what's happening in the app across ALL Buoy tools. Check this timeline BEFORE driving the UI to reproduce a bug \u2014 the failure is usually already recorded here. The events tool aggregates every source \u2014 network requests, redux/zustand/jotai actions, react-query query/mutation updates, storage writes, route changes, renders \u2014 so filter to one with `sources`: ['network'] lists HTTP requests, ['redux'] dispatched actions, ['react-query'] query updates, ['storage'] writes, ['route'] navigation. Returns a compact one-line summary per event (source \xB7 status \xB7 title \xB7 timing) by DEFAULT \u2014 not the heavy raw payloads \u2014 so it's cheap. Re-call with includeData:true, a bigger limit, or specific sources only when you need detail. PREFER this over get_snapshot (and over reading source code) for any 'what happened' / 'show me the requests/actions' question; get_snapshot is the raw heavy current-state escape hatch.",
       inputSchema: {
-        limit: import_zod3.z.number().optional().describe("Most-recent N events to include. Default 25."),
-        sources: import_zod3.z.array(import_zod3.z.string()).optional().describe('Only these sources. Coarse names accepted: "network", "redux", "react-query", "storage", "route", "render", "zustand", "jotai". Omit for all.'),
-        status: import_zod3.z.enum(["all", "errors", "success", "pending"]).optional().describe("Filter by status. Default all."),
-        includeData: import_zod3.z.boolean().optional().describe("Include each event's full raw payload (HEAVY \u2014 network bodies, state trees). Default false (compact)."),
-        format: import_zod3.z.enum(["markdown", "json", "text", "mermaid"]).optional().describe("Output format. Default markdown."),
-        preset: import_zod3.z.enum(["llm", "bugReport", "json", "errors", "minimal", "mermaid"]).optional().describe("Start from a named Copy-Settings preset (then your other args override it)."),
-        deviceId: import_zod3.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        limit: import_zod4.z.number().optional().describe("Most-recent N events to include. Default 25."),
+        sources: import_zod4.z.array(import_zod4.z.string()).optional().describe('Only these sources. Coarse names accepted: "network", "redux", "react-query", "storage", "route", "render", "zustand", "jotai". Omit for all.'),
+        status: import_zod4.z.enum(["all", "errors", "success", "pending"]).optional().describe("Filter by status. Default all."),
+        includeData: import_zod4.z.boolean().optional().describe("Include each event's full raw payload (HEAVY \u2014 network bodies, state trees). Default false (compact)."),
+        format: import_zod4.z.enum(["markdown", "json", "text", "mermaid"]).optional().describe("Output format. Default markdown."),
+        preset: import_zod4.z.enum(["llm", "bugReport", "json", "errors", "minimal", "mermaid"]).optional().describe("Start from a named Copy-Settings preset (then your other args override it)."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -1639,7 +1666,7 @@ function registerEventsTools(server, sync) {
           target
         );
         if (!res || typeof res.output !== "string") {
-          return fail3(
+          return fail2(
             "No events result from the device. The events tool may be inactive, or the app needs a newer Buoy (get_events requires the exportEvents action)."
           );
         }
@@ -1647,20 +1674,17 @@ function registerEventsTools(server, sync) {
         const note = `
 
 _Showing ${res.returned} of ${res.totalAvailable} captured event(s)${more}._`;
-        return text2((res.output || "(no events captured)") + note);
+        return text((res.output || "(no events captured)") + note);
       } catch (e) {
-        return fail3(errMsg3(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/network.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var NETWORK_TOOL_ID = "network";
-var text3 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail4 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg4 = (e) => e instanceof Error ? e.message : String(e);
 var masterNote = (state) => {
   if (state?.enabled !== false) return "";
   return state.autoPaused ? ' \u2014 AUTO-PAUSED after the app failed to settle on launch with overrides active; nothing is firing. Re-arm with network_override({action:"enable"}).' : " \u2014 MASTER SWITCH IS OFF, nothing is firing";
@@ -1786,12 +1810,12 @@ function registerNetworkTools(server, sync) {
     {
       description: "List captured HTTP requests WITH their request ids, plus which ones are pinned/saved. API data wrong or calls failing \u2192 read the actual request+response bodies here instead of guessing from code; capture starts at app launch, so boot-time requests (session bootstrap, first queries) are included. Use this (not get_events) when you need to ACT on a request \u2014 every network action is keyed by the id, and get_events does not emit ids. Compact by default: one line per request (id \xB7 status \xB7 method \xB7 path \xB7 timing \xB7 size). Set flagged:'pinned'|'saved'|'any' to read the developer's KEPT requests \u2014 those are snapshots that outlive Clear, the 500-request cap and app restarts, so treat a pinned request as 'a human flagged this as the problem'. Filter with status:'errors' to go straight to failures, or `pattern` to match a URL substring. includeBodies:true adds truncated request/response payloads (heavier).",
       inputSchema: {
-        limit: import_zod4.z.number().optional().describe("Most-recent N requests. Default 25."),
-        pattern: import_zod4.z.string().optional().describe("Only requests whose URL contains this substring (case-insensitive)."),
-        status: import_zod4.z.enum(["all", "errors", "success", "pending"]).optional().describe("Filter by outcome. Default all."),
-        flagged: import_zod4.z.enum(["pinned", "saved", "any"]).optional().describe("Read KEPT requests instead of the live list: 'pinned' (held at the top of the developer's list), 'saved' (their favorites), 'any' (either). These survive Clear and app restarts."),
-        includeBodies: import_zod4.z.boolean().optional().describe("Include truncated request/response bodies. Default false (compact)."),
-        deviceId: import_zod4.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        limit: import_zod5.z.number().optional().describe("Most-recent N requests. Default 25."),
+        pattern: import_zod5.z.string().optional().describe("Only requests whose URL contains this substring (case-insensitive)."),
+        status: import_zod5.z.enum(["all", "errors", "success", "pending"]).optional().describe("Filter by outcome. Default all."),
+        flagged: import_zod5.z.enum(["pinned", "saved", "any"]).optional().describe("Read KEPT requests instead of the live list: 'pinned' (held at the top of the developer's list), 'saved' (their favorites), 'any' (either). These survive Clear and app restarts."),
+        includeBodies: import_zod5.z.boolean().optional().describe("Include truncated request/response bodies. Default false (compact)."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -1815,7 +1839,7 @@ function registerNetworkTools(server, sync) {
           );
           const rows2 = wanted.filter((r) => r.event && matchesStatus(r.event, args.status)).filter((r) => !pattern || (r.event.url ?? "").toLowerCase().includes(pattern)).slice(0, limit);
           if (rows2.length === 0) {
-            return text3(
+            return text(
               `No ${args.flagged === "any" ? "pinned or saved" : args.flagged} requests on ${target}.
 
 The developer pins/saves a request from the Network tool (long-press a row, or the pin/bookmark buttons in the request detail header), or you can with network_action.`
@@ -1832,7 +1856,7 @@ The developer pins/saves a request from the Network tool (long-press a row, or t
             if (args.includeBodies) out += bodyLines(r.event, kept.bodies);
             return out;
           }).join("\n");
-          return text3(
+          return text(
             `**Kept requests on ${target}** \u2014 ${rows2.length} of ${wanted.length}
 
 ${body2}
@@ -1843,7 +1867,7 @@ _These are snapshots: they survive Clear, the 500-request cap and app restarts.
         const rows = events.filter((e) => matchesStatus(e, args.status)).filter((e) => !pattern || (e.url ?? "").toLowerCase().includes(pattern)).slice(0, limit);
         if (rows.length === 0) {
           const why = events.length === 0 ? await captureDiagnosis(sync, target) : "No request matched the filter.";
-          return text3(`No requests on ${target}. ${why}`);
+          return text(`No requests on ${target}. ${why}`);
         }
         const live = args.includeBodies ? await resolveBodies(sync, rows, target) : { bodies: /* @__PURE__ */ new Map(), skipped: 0 };
         const body = rows.map((e, i) => {
@@ -1853,7 +1877,7 @@ _These are snapshots: they survive Clear, the 500-request cap and app restarts.
           return out;
         }).join("\n");
         const keptNote = saved.length > 0 ? ` \xB7 ${saved.length} kept (flagged:'any' to list)` : "";
-        return text3(
+        return text(
           `**Network requests on ${target}** \u2014 ${rows.length} of ${events.length}${keptNote}
 
 ${body}
@@ -1861,7 +1885,7 @@ ${body}
 _\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_action({action:"pin", id:"${rows[0].id}"})._${skippedNote(live.skipped)}`
         );
       } catch (e) {
-        return fail4(errMsg4(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -1870,10 +1894,10 @@ _\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_act
     {
       description: "Act on captured HTTP requests: PIN one (holds it at the top of the developer's Network list, ignoring their filters), SAVE one to their favorites, or clear the list. Pinning and saving keep a full snapshot that survives Clear, the 500-request cap and app restarts \u2014 so this is how you hand a request to a human ('I pinned the failing call') or keep one you'll need after the log rolls over. Get ids from get_network_requests (get_events does not emit them). `remove` takes the record `key` from get_network_requests({flagged:'any'}), not a request id.",
       inputSchema: {
-        action: import_zod4.z.enum(["pin", "unpin", "save", "unsave", "remove", "clearPinned", "clearSaved", "clearRequests"]).describe("pin/unpin/save/unsave act on one request by `id`. remove drops one kept record by `key`. clearPinned/clearSaved drop all of that kind. clearRequests wipes the live capture list (kept requests survive)."),
-        id: import_zod4.z.string().optional().describe("Request id for pin/unpin/save/unsave \u2014 from get_network_requests."),
-        key: import_zod4.z.string().optional().describe("Kept-record key for `remove` \u2014 from get_network_requests({flagged:'any'})."),
-        deviceId: import_zod4.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        action: import_zod5.z.enum(["pin", "unpin", "save", "unsave", "remove", "clearPinned", "clearSaved", "clearRequests"]).describe("pin/unpin/save/unsave act on one request by `id`. remove drops one kept record by `key`. clearPinned/clearSaved drop all of that kind. clearRequests wipes the live capture list (kept requests survive)."),
+        id: import_zod5.z.string().optional().describe("Request id for pin/unpin/save/unsave \u2014 from get_network_requests."),
+        key: import_zod5.z.string().optional().describe("Kept-record key for `remove` \u2014 from get_network_requests({flagged:'any'})."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -1881,10 +1905,10 @@ _\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_act
         const target = sync.requireProDevice(args.deviceId);
         const needsId = ["pin", "unpin", "save", "unsave"].includes(args.action);
         if (needsId && !args.id) {
-          return fail4(`"${args.action}" needs an \`id\`. List requests with get_network_requests to get one.`);
+          return fail2(`"${args.action}" needs an \`id\`. List requests with get_network_requests to get one.`);
         }
         if (args.action === "remove" && !args.key) {
-          return fail4('"remove" needs a `key` (not a request id). Get it from get_network_requests({flagged:"any"}).');
+          return fail2('"remove" needs a `key` (not a request id). Get it from get_network_requests({flagged:"any"}).');
         }
         switch (args.action) {
           case "pin":
@@ -1895,10 +1919,10 @@ _\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_act
               { id: args.id, pinned: args.action === "pin" },
               target
             );
-            if (res === null) return fail4(`No request "${args.id}" on ${target}. It may have been cleared or aged out \u2014 re-list with get_network_requests.`);
+            if (res === null) return fail2(`No request "${args.id}" on ${target}. It may have been cleared or aged out \u2014 re-list with get_network_requests.`);
             const capped = typeof res === "object" && res !== null && res.reason === "pin-cap";
-            if (capped) return fail4(`Pin limit reached on ${target}. Unpin something first (network_action({action:"clearPinned"}) drops them all).`);
-            return text3(`${args.action === "pin" ? "\u{1F4CC} Pinned" : "Unpinned"} \`${args.id}\` on ${target}.`);
+            if (capped) return fail2(`Pin limit reached on ${target}. Unpin something first (network_action({action:"clearPinned"}) drops them all).`);
+            return text(`${args.action === "pin" ? "\u{1F4CC} Pinned" : "Unpinned"} \`${args.id}\` on ${target}.`);
           }
           case "save":
           case "unsave": {
@@ -1908,26 +1932,26 @@ _\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_act
               { id: args.id, saved: args.action === "save" },
               target
             );
-            if (res === null) return fail4(`No request "${args.id}" on ${target}. It may have been cleared or aged out \u2014 re-list with get_network_requests.`);
+            if (res === null) return fail2(`No request "${args.id}" on ${target}. It may have been cleared or aged out \u2014 re-list with get_network_requests.`);
             const capped = typeof res === "object" && res !== null && res.reason === "saved-cap";
-            if (capped) return fail4(`Saved-request limit reached on ${target}. Remove one first, or network_action({action:"clearSaved"}).`);
-            return text3(`${args.action === "save" ? "\u{1F516} Saved" : "Unsaved"} \`${args.id}\` on ${target}.`);
+            if (capped) return fail2(`Saved-request limit reached on ${target}. Remove one first, or network_action({action:"clearSaved"}).`);
+            return text(`${args.action === "save" ? "\u{1F516} Saved" : "Unsaved"} \`${args.id}\` on ${target}.`);
           }
           case "remove":
             await sync.callAction(NETWORK_TOOL_ID, "removeSavedRecord", { key: args.key }, target);
-            return text3(`Removed kept record \`${args.key}\` on ${target}.`);
+            return text(`Removed kept record \`${args.key}\` on ${target}.`);
           case "clearPinned":
             await sync.callAction(NETWORK_TOOL_ID, "clearPinnedRequests", {}, target);
-            return text3(`Unpinned all requests on ${target} (saved ones kept).`);
+            return text(`Unpinned all requests on ${target} (saved ones kept).`);
           case "clearSaved":
             await sync.callAction(NETWORK_TOOL_ID, "clearSavedRequests", {}, target);
-            return text3(`Cleared saved requests on ${target} (pinned ones kept).`);
+            return text(`Cleared saved requests on ${target} (pinned ones kept).`);
           case "clearRequests":
             await sync.callAction(NETWORK_TOOL_ID, "clearEvents", {}, target);
-            return text3(`Cleared the captured request list on ${target}. Pinned/saved requests are unaffected.`);
+            return text(`Cleared the captured request list on ${target}. Pinned/saved requests are unaffected.`);
         }
       } catch (e) {
-        return fail4(errMsg4(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -1936,48 +1960,48 @@ _\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_act
     {
       description: "Force matching HTTP requests to return a chosen status/body, to fail outright, or to arrive late \u2014 without touching the backend or the app's code. This is how you drive an app into a state it won't reach on its own: force a 500 and see whether the error UI appears, return [] and check the empty state, simulate offline or a slow connection. Rules run INSIDE the app and survive an app reload, so they also cover the boot path. After adding one, trigger the request (navigate/tap_element) and read the result with get_network_requests or describe_screen. ALWAYS remove your rules when done \u2014 a forgotten rule looks exactly like a real bug. Requires Buoy Pro.",
       inputSchema: {
-        action: import_zod4.z.enum(["list", "add", "remove", "clear", "enable", "disable", "debug"]).describe(
+        action: import_zod5.z.enum(["list", "add", "remove", "clear", "enable", "disable", "debug"]).describe(
           "add creates a rule (or replaces one when `id` is given). remove drops one by `id`. clear drops all. enable/disable flip ONE rule when `id` is given, otherwise the master switch \u2014 rules are kept either way. list shows every rule with its hit counts; pass `id` to dump one rule in full, body included. debug reports why a rule is or isn't firing."
         ),
-        urlPattern: import_zod4.z.string().optional().describe(
+        urlPattern: import_zod5.z.string().optional().describe(
           "For `add`: glob matched against the WHOLE request URL, query string included. `*` is the only wildcard, e.g. '*pokeapi.co*' or 'https://api.example.com/v1/users*'. Careful with an exact URL copied from get_network_requests \u2014 if the client cache-busts or pages, the next call won't match it and the rule sits at 0 hits. Prefer `fromRequestId`, which handles that for you."
         ),
-        fromRequestId: import_zod4.z.string().optional().describe(
+        fromRequestId: import_zod5.z.string().optional().describe(
           "For `add`: build the rule from a captured request id (from get_network_requests) \u2014 the same 'Override this request' the developer gets in the UI. Seeds the pattern (query string replaced with `*` so it keeps matching), the method, the status, and the REAL response body, so you can change two fields of a payload you just saw instead of authoring one from scratch. Anything you pass explicitly overrides the prefill."
         ),
-        methods: import_zod4.z.array(import_zod4.z.string()).optional().describe("For `add`: restrict to these HTTP methods. Omit for any."),
-        kind: import_zod4.z.enum(["respond", "fail", "delay"]).optional().describe(
+        methods: import_zod5.z.array(import_zod5.z.string()).optional().describe("For `add`: restrict to these HTTP methods. Omit for any."),
+        kind: import_zod5.z.enum(["respond", "fail", "delay"]).optional().describe(
           "respond = return your status/body, never hitting the network (default). fail = a transport failure, as if the device were offline. delay = let the real request run, just late."
         ),
-        status: import_zod4.z.number().optional().describe(
+        status: import_zod5.z.number().optional().describe(
           "For kind 'respond': HTTP status, 200\u2013599 (default 200). Outside that range fetch itself throws, so use kind 'fail' for connection errors rather than status 0."
         ),
-        body: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.record(import_zod4.z.unknown()), import_zod4.z.array(import_zod4.z.unknown())]).optional().describe(
+        body: import_zod5.z.union([import_zod5.z.string(), import_zod5.z.record(import_zod5.z.unknown()), import_zod5.z.array(import_zod5.z.unknown())]).optional().describe(
           "For kind 'respond': the response body. Pass JSON directly (an object or array) or a raw string; content-type is inferred."
         ),
-        statusText: import_zod4.z.string().optional().describe(
+        statusText: import_zod5.z.string().optional().describe(
           "For kind 'respond': the status line's text, e.g. 'Service Unavailable'. Cosmetic \u2014 React Native's XMLHttpRequest has no statusText field, so the app never sees it; it only makes the developer's rule list read correctly."
         ),
-        headers: import_zod4.z.record(import_zod4.z.string()).optional().describe("For kind 'respond': response headers to send."),
-        failKind: import_zod4.z.enum(["network", "timeout"]).optional().describe("For kind 'fail': 'network' (default) or 'timeout'."),
-        delayMs: import_zod4.z.number().optional().describe("Latency before the outcome, in ms. Works with every kind."),
-        times: import_zod4.z.number().optional().describe(
+        headers: import_zod5.z.record(import_zod5.z.string()).optional().describe("For kind 'respond': response headers to send."),
+        failKind: import_zod5.z.enum(["network", "timeout"]).optional().describe("For kind 'fail': 'network' (default) or 'timeout'."),
+        delayMs: import_zod5.z.number().optional().describe("Latency before the outcome, in ms. Works with every kind."),
+        times: import_zod5.z.number().optional().describe(
           "Auto-disable the rule after N matches. Use 1 for 'make the next call fail' so it can't linger."
         ),
-        alternate: import_zod4.z.boolean().optional().describe(
+        alternate: import_zod5.z.boolean().optional().describe(
           "Apply to every OTHER matching request, forever: the first goes through, the second is overridden, and so on. This is how you test retry logic and flaky endpoints \u2014 a rule that is always on or always off can't reach those paths."
         ),
-        name: import_zod4.z.string().optional().describe("Label shown in the developer's UI."),
-        enabled: import_zod4.z.boolean().optional().describe(
+        name: import_zod5.z.string().optional().describe("Label shown in the developer's UI."),
+        enabled: import_zod5.z.boolean().optional().describe(
           "For `add`: create the rule switched off (default true). Useful for staging a rule you'll arm later with enable({id})."
         ),
-        id: import_zod4.z.string().optional().describe(
+        id: import_zod5.z.string().optional().describe(
           "Rule id. Required for `remove`. For `add` it replaces that rule. For `enable`/`disable` it targets ONE rule instead of the master switch. For `list` it dumps that rule in full."
         ),
-        url: import_zod4.z.string().optional().describe(
+        url: import_zod5.z.string().optional().describe(
           "For `debug`: a concrete URL to test the rules against, so the report says which rule would match it and why."
         ),
-        deviceId: import_zod4.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -1986,7 +2010,7 @@ _\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_act
         switch (args.action) {
           case "add": {
             if (!args.urlPattern && !args.fromRequestId) {
-              return fail4(
+              return fail2(
                 "`add` needs a `urlPattern` or a `fromRequestId`. Take an id from get_network_requests to override a request you just saw, or pass a glob like '*pokeapi.co*'."
               );
             }
@@ -2018,13 +2042,13 @@ _\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_act
             );
             const shaped = res;
             if (!shaped?.ok) {
-              return fail4(shaped?.error ?? `Could not add the rule on ${target}.`);
+              return fail2(shaped?.error ?? `Could not add the rule on ${target}.`);
             }
             const pattern = shaped.rule?.urlPattern ?? args.urlPattern;
             const armed = shaped.rule?.enabled === false ? `
 
 It is switched OFF \u2014 arm it with network_override({action:"enable", id:"${shaped.rule?.id}"}).` : "";
-            return text3(
+            return text(
               `Override added on ${target} \u2014 \`${shaped.rule?.id}\` matching \`${pattern}\`.${armed}
 
 Trigger the request now (navigate / tap_element), then check it with get_network_requests or describe_screen. Remove it with network_override({action:"remove", id:"${shaped.rule?.id}"}) when you're done.`
@@ -2032,14 +2056,14 @@ Trigger the request now (navigate / tap_element), then check it with get_network
           }
           case "remove": {
             if (!args.id) {
-              return fail4('`remove` needs an `id`. List them with network_override({action:"list"}).');
+              return fail2('`remove` needs an `id`. List them with network_override({action:"list"}).');
             }
             await sync.callAction(NETWORK_TOOL_ID, "deleteOverrideRule", { id: args.id }, target);
-            return text3(`Removed override \`${args.id}\` on ${target}.`);
+            return text(`Removed override \`${args.id}\` on ${target}.`);
           }
           case "clear":
             await sync.callAction(NETWORK_TOOL_ID, "clearOverrideRules", {}, target);
-            return text3(`Removed all override rules on ${target}. Traffic is real again.`);
+            return text(`Removed all override rules on ${target}. Traffic is real again.`);
           case "enable":
           case "disable": {
             const enabled = args.action === "enable";
@@ -2050,12 +2074,12 @@ Trigger the request now (navigate / tap_element), then check it with get_network
                 { id: args.id, enabled },
                 target
               );
-              return text3(
+              return text(
                 `Rule \`${args.id}\` is now ${enabled ? "ON" : "OFF"} on ${target}. The other rules and the master switch are unchanged.`
               );
             }
             await sync.callAction(NETWORK_TOOL_ID, "setOverridesEnabled", { enabled }, target);
-            return text3(
+            return text(
               enabled ? `Overrides switched ON for ${target}.` : `Overrides switched OFF for ${target}. Rules are kept \u2014 re-enable with network_override({action:"enable"}).`
             );
           }
@@ -2070,11 +2094,11 @@ Trigger the request now (navigate / tap_element), then check it with get_network
             if (args.id) {
               const rule = rules.find((r) => r.id === args.id);
               if (!rule) {
-                return fail4(
+                return fail2(
                   `No override rule \`${args.id}\` on ${target}. List them with network_override({action:"list"}).`
                 );
               }
-              return text3(
+              return text(
                 `**Override rule \`${rule.id}\`** on ${target}${masterNote(res)}
 
 \`\`\`json
@@ -2083,7 +2107,7 @@ ${JSON.stringify(rule, null, 2)}
               );
             }
             if (rules.length === 0) {
-              return text3(
+              return text(
                 `No override rules on ${target}.
 
 Add one with network_override({action:"add", urlPattern:"*", status:500}) to force an error state.`
@@ -2111,7 +2135,7 @@ Add one with network_override({action:"add", urlPattern:"*", status:500}) to for
               return `${i + 1}. \`${rule.id}\`${rule.name ? ` ${rule.name}` : ""}
    \u2514\u2500 \`${rule.urlPattern}\` \xB7 ${bits.join(" \xB7 ")}`;
             });
-            return text3(
+            return text(
               `**Override rules on ${target}**${masterNote(res)}
 
 ${rows.join("\n")}
@@ -2127,11 +2151,11 @@ Full detail incl. body: network_override({action:"list", id:"${rules[0]?.id}"}).
               target
             );
             if (!res) {
-              return fail4(
+              return fail2(
                 `${target} did not answer the diagnostics call \u2014 the network tool may not be mounted.`
               );
             }
-            return text3(
+            return text(
               `**Override diagnostics on ${target}**${args.url ? ` for \`${args.url}\`` : ""}
 
 \`\`\`json
@@ -2143,24 +2167,21 @@ A rule that never fires is usually one of: the master switch is off, the interce
           }
         }
       } catch (e) {
-        return fail4(errMsg4(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/reactQuery.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var RQ_TOOL_ID = "query";
 var RQ_TOOL_ID_LEGACY = "react-query";
-var text4 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail5 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg5 = (e) => e instanceof Error ? e.message : String(e);
 async function callQueryAction(sync, action, params, target) {
   try {
     return await sync.callAction(RQ_TOOL_ID, action, params, target);
   } catch (e) {
-    const msg = errMsg5(e);
+    const msg = errMsg2(e);
     if (!/unknown tool/i.test(msg)) throw e;
     return await sync.callAction(RQ_TOOL_ID_LEGACY, action, params, target);
   }
@@ -2188,10 +2209,10 @@ function registerReactQueryTools(server, sync) {
     {
       description: "Read the app's CURRENT React Query cache \u2014 every query with its status (fresh/stale/fetching/error), staleness, observer count, last-updated time, and any error. Compact by DEFAULT (no cached payloads) so it's token-cheap; pass includeData:true for the actual cached data, or staleOnly:true to see just stale queries. Use this for 'what's in the cache / why is this stale / which queries errored'. (For the history of query updates over time, use get_events with sources:['react-query'].) Each row's hash is what you pass to react_query_action.",
       inputSchema: {
-        includeData: import_zod5.z.boolean().optional().describe("Include each query's full cached data payload (HEAVY). Default false."),
-        staleOnly: import_zod5.z.boolean().optional().describe("Only stale queries. Default false."),
-        limit: import_zod5.z.number().optional().describe("Most-recently-updated N queries. Default 25."),
-        deviceId: import_zod5.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        includeData: import_zod6.z.boolean().optional().describe("Include each query's full cached data payload (HEAVY). Default false."),
+        staleOnly: import_zod6.z.boolean().optional().describe("Only stale queries. Default false."),
+        limit: import_zod6.z.number().optional().describe("Most-recently-updated N queries. Default 25."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -2204,12 +2225,12 @@ function registerReactQueryTools(server, sync) {
           target
         );
         if (!res || !Array.isArray(res.queries)) {
-          return fail5(
+          return fail2(
             "No react-query result from the device. The react-query tool may be inactive, or the app needs a newer Buoy (get_react_query requires the listQueries action)."
           );
         }
         if (res.queries.length === 0) {
-          return text4(`React Query cache is empty (0 of ${res.total} queries${args.staleOnly ? " match staleOnly" : ""}).`);
+          return text(`React Query cache is empty (0 of ${res.total} queries${args.staleOnly ? " match staleOnly" : ""}).`);
         }
         const lines = res.queries.map((q, i) => {
           const icon = STATUS_ICON[q.status] ?? "\u2022";
@@ -2222,11 +2243,11 @@ function registerReactQueryTools(server, sync) {
         const staleCount = res.queries.filter((q) => q.isStale).length;
         const header = `**React Query cache \u2014 ${res.total} queries (showing ${res.returned}, ${staleCount} stale):**`;
         const note = res.includedData ? "" : "\n\n_Compact view. Pass includeData:true for cached payloads, staleOnly:true to narrow. Act on one with react_query_action using the `hash` in backticks._";
-        return text4(`${header}
+        return text(`${header}
 
 ${lines.join("\n")}${note}`);
       } catch (e) {
-        return fail5(errMsg5(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -2235,9 +2256,9 @@ ${lines.join("\n")}${note}`);
     {
       description: "Mutate the app's React Query cache: invalidate / refetch / reset / remove a single query (by queryHash, from get_react_query), or clear the entire query cache. Use this to fix stale data, force a refetch, or reset state during debugging.",
       inputSchema: {
-        action: import_zod5.z.enum(["invalidate", "refetch", "reset", "remove", "clear"]).describe("invalidate/refetch/reset/remove a single query (needs queryHash); clear empties the whole query cache."),
-        queryHash: import_zod5.z.string().optional().describe("The target query's hash (from get_react_query, shown in backticks). Required for all actions except clear."),
-        deviceId: import_zod5.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        action: import_zod6.z.enum(["invalidate", "refetch", "reset", "remove", "clear"]).describe("invalidate/refetch/reset/remove a single query (needs queryHash); clear empties the whole query cache."),
+        queryHash: import_zod6.z.string().optional().describe("The target query's hash (from get_react_query, shown in backticks). Required for all actions except clear."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -2245,174 +2266,145 @@ ${lines.join("\n")}${note}`);
         const target = sync.requireProDevice(args.deviceId);
         if (args.action === "clear") {
           await callQueryAction(sync, "clearQueryCache", {}, target);
-          return text4("Cleared the entire React Query cache.");
+          return text("Cleared the entire React Query cache.");
         }
         if (!args.queryHash) {
-          return fail5(`'${args.action}' needs a queryHash. Call get_react_query first and use a row's hash (in backticks).`);
+          return fail2(`'${args.action}' needs a queryHash. Call get_react_query first and use a row's hash (in backticks).`);
         }
         await callQueryAction(sync, args.action, { queryHash: args.queryHash }, target);
-        return text4(`Ran ${args.action} on query \`${args.queryHash}\`.`);
+        return text(`Ran ${args.action} on query \`${args.queryHash}\`.`);
       } catch (e) {
-        return fail5(errMsg5(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/zustand.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 var ZUSTAND_TOOL_ID = "zustand";
-var text5 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail6 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg6 = (e) => e instanceof Error ? e.message : String(e);
 function registerZustandTools(server, sync) {
   server.registerTool(
     "get_zustand_state",
     {
       description: "Read the app's CURRENT Zustand store state \u2014 each registered store with its name, change count, persistence, and (by default) just its top-level keys so it's token-cheap. Pass includeValues:true for the full state objects. Use this for 'what's in my zustand stores / what's the current count'. (For the history of state changes over time, use get_events with sources:['zustand'].)",
       inputSchema: {
-        includeValues: import_zod6.z.boolean().optional().describe("Include each store's full current state object (HEAVY). Default false (keys only)."),
-        limit: import_zod6.z.number().optional().describe("First N stores. Default all."),
-        deviceId: import_zod6.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        includeValues: import_zod7.z.boolean().optional().describe("Include each store's full current state object (HEAVY). Default false (keys only)."),
+        limit: import_zod7.z.number().optional().describe("First N stores. Default all."),
+        deviceId: deviceIdInput
       }
     },
-    async (args) => {
-      try {
-        const target = sync.requireProDevice(args.deviceId);
-        const res = await sync.callAction(
-          ZUSTAND_TOOL_ID,
-          "listStores",
-          { includeValues: args.includeValues ?? false, limit: args.limit },
-          target
+    withDevice(sync, async (args, target) => {
+      const res = await sync.callAction(
+        ZUSTAND_TOOL_ID,
+        "listStores",
+        { includeValues: args.includeValues ?? false, limit: args.limit },
+        target
+      );
+      if (!res || !Array.isArray(res.stores)) {
+        return fail2(
+          inactiveToolMessage({ toolId: ZUSTAND_TOOL_ID, mcpTool: "get_zustand_state", action: "listStores" })
         );
-        if (!res || !Array.isArray(res.stores)) {
-          return fail6(
-            "No zustand result from the device. The zustand tool may be inactive, or the app needs a newer Buoy (get_zustand_state requires the listStores action)."
-          );
-        }
-        if (res.stores.length === 0) {
-          return text5("No Zustand stores are registered (call watchStores to register them).");
-        }
-        const lines = res.stores.map((s, i) => {
-          const persist = s.isPersisted ? ` \xB7 persisted${s.persistName ? ` (${s.persistName})` : ""}` : "";
-          const body = res.includedValues ? `
+      }
+      if (res.stores.length === 0) {
+        return text("No Zustand stores are registered (call watchStores to register them).");
+      }
+      const lines = res.stores.map((s, i) => {
+        const persist = s.isPersisted ? ` \xB7 persisted${s.persistName ? ` (${s.persistName})` : ""}` : "";
+        const body = res.includedValues ? `
    ${JSON.stringify(s.currentState)}` : ` \xB7 keys: ${(s.keys ?? []).join(", ") || "\u2014"}`;
-          return `${i + 1}. **${s.name}** \xB7 ${s.changes} changes${persist}${body}`;
-        });
-        const note = res.includedValues ? "" : "\n\n_Compact view (keys only). Pass includeValues:true for full state. Mutate with zustand_action({store, state})._";
-        return text5(`**Zustand stores \u2014 ${res.total} (showing ${res.returned}):**
+        return `${i + 1}. **${s.name}** \xB7 ${s.changes} changes${persist}${body}`;
+      });
+      const note = res.includedValues ? "" : "\n\n_Compact view (keys only). Pass includeValues:true for full state. Mutate with zustand_action({store, state})._";
+      return text(`**Zustand stores \u2014 ${res.total} (showing ${res.returned}):**
 
 ${lines.join("\n")}${note}`);
-      } catch (e) {
-        return fail6(errMsg6(e));
-      }
-    }
+    })
   );
   server.registerTool(
     "zustand_action",
     {
       description: "Set the state of a Zustand store (time-travel / reset / tweak during debugging). Targets a store by name (from get_zustand_state). By default replaces the whole state; pass replace:false to merge a partial.",
       inputSchema: {
-        store: import_zod6.z.string().describe("Store name to target (from get_zustand_state)."),
-        state: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).describe("The new state object."),
-        replace: import_zod6.z.boolean().optional().describe("Replace the whole state (default true) or merge a partial (false)."),
-        deviceId: import_zod6.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        store: import_zod7.z.string().describe("Store name to target (from get_zustand_state)."),
+        state: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).describe("The new state object."),
+        replace: import_zod7.z.boolean().optional().describe("Replace the whole state (default true) or merge a partial (false)."),
+        deviceId: deviceIdInput
       }
     },
-    async (args) => {
-      try {
-        const target = sync.requireProDevice(args.deviceId);
-        await sync.callAction(
-          ZUSTAND_TOOL_ID,
-          "setState",
-          { storeName: args.store, state: args.state, replace: args.replace ?? true },
-          target
-        );
-        return text5(`Set state on Zustand store "${args.store}" (${args.replace === false ? "merged" : "replaced"}).`);
-      } catch (e) {
-        return fail6(errMsg6(e));
-      }
-    }
+    withDevice(sync, async (args, target) => {
+      await sync.callAction(
+        ZUSTAND_TOOL_ID,
+        "setState",
+        { storeName: args.store, state: args.state, replace: args.replace ?? true },
+        target
+      );
+      return text(`Set state on Zustand store "${args.store}" (${args.replace === false ? "merged" : "replaced"}).`);
+    })
   );
 }
 
 // src/tools/packs/jotai.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var JOTAI_TOOL_ID = "jotai";
-var text6 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail7 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg7 = (e) => e instanceof Error ? e.message : String(e);
 function registerJotaiTools(server, sync) {
   server.registerTool(
     "get_jotai_state",
     {
       description: "Read the app's CURRENT Jotai atom values \u2014 each watched atom with its label, change count, and whether it's writable. Compact by DEFAULT (no values) so it's token-cheap; pass includeValues:true for the actual current values. Use this for 'what are my jotai atoms / what's the current value'. (For the history of atom changes over time, use get_events with sources:['jotai'].)",
       inputSchema: {
-        includeValues: import_zod7.z.boolean().optional().describe("Include each atom's current value (HEAVY). Default false."),
-        limit: import_zod7.z.number().optional().describe("First N atoms. Default all."),
-        deviceId: import_zod7.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        includeValues: import_zod8.z.boolean().optional().describe("Include each atom's current value (HEAVY). Default false."),
+        limit: import_zod8.z.number().optional().describe("First N atoms. Default all."),
+        deviceId: deviceIdInput
       }
     },
-    async (args) => {
-      try {
-        const target = sync.requireProDevice(args.deviceId);
-        const res = await sync.callAction(
-          JOTAI_TOOL_ID,
-          "listAtoms",
-          { includeValues: args.includeValues ?? false, limit: args.limit },
-          target
+    withDevice(sync, async (args, target) => {
+      const res = await sync.callAction(
+        JOTAI_TOOL_ID,
+        "listAtoms",
+        { includeValues: args.includeValues ?? false, limit: args.limit },
+        target
+      );
+      if (!res || !Array.isArray(res.atoms)) {
+        return fail2(
+          inactiveToolMessage({ toolId: JOTAI_TOOL_ID, mcpTool: "get_jotai_state", action: "listAtoms" })
         );
-        if (!res || !Array.isArray(res.atoms)) {
-          return fail7(
-            "No jotai result from the device. The jotai tool may be inactive, or the app needs a newer Buoy (get_jotai_state requires the listAtoms action)."
-          );
-        }
-        if (res.atoms.length === 0) {
-          return text6("No Jotai atoms are being watched (call watchAtoms to register them).");
-        }
-        const lines = res.atoms.map((a, i) => {
-          const kind = a.writable ? "writable" : "read-only";
-          const value = res.includedValues ? `
+      }
+      if (res.atoms.length === 0) {
+        return text("No Jotai atoms are being watched (call watchAtoms to register them).");
+      }
+      const lines = res.atoms.map((a, i) => {
+        const kind = a.writable ? "writable" : "read-only";
+        const value = res.includedValues ? `
    ${JSON.stringify(a.currentValue)}` : "";
-          return `${i + 1}. **${a.label}** \xB7 ${a.changes} changes \xB7 ${kind}${value}`;
-        });
-        const note = res.includedValues ? "" : "\n\n_Compact view. Pass includeValues:true for current values. Set a writable atom with jotai_action({atom, value})._";
-        return text6(`**Jotai atoms \u2014 ${res.total} (showing ${res.returned}):**
+        return `${i + 1}. **${a.label}** \xB7 ${a.changes} changes \xB7 ${kind}${value}`;
+      });
+      const note = res.includedValues ? "" : "\n\n_Compact view. Pass includeValues:true for current values. Set a writable atom with jotai_action({atom, value})._";
+      return text(`**Jotai atoms \u2014 ${res.total} (showing ${res.returned}):**
 
 ${lines.join("\n")}${note}`);
-      } catch (e) {
-        return fail7(errMsg7(e));
-      }
-    }
+    })
   );
   server.registerTool(
     "jotai_action",
     {
       description: "Set the value of a writable Jotai atom (by label, from get_jotai_state). Read-only/derived atoms cannot be set (you'll get a clear error). Use for tweaking state during debugging.",
       inputSchema: {
-        atom: import_zod7.z.string().describe("Atom label to set (from get_jotai_state; must be writable)."),
-        value: import_zod7.z.unknown().describe("The new value (any JSON \u2014 number, string, object, etc.)."),
-        deviceId: import_zod7.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        atom: import_zod8.z.string().describe("Atom label to set (from get_jotai_state; must be writable)."),
+        value: import_zod8.z.unknown().describe("The new value (any JSON \u2014 number, string, object, etc.)."),
+        deviceId: deviceIdInput
       }
     },
-    async (args) => {
-      try {
-        const target = sync.requireProDevice(args.deviceId);
-        await sync.callAction(JOTAI_TOOL_ID, "setAtom", { label: args.atom, value: args.value }, target);
-        return text6(`Set Jotai atom "${args.atom}" to ${JSON.stringify(args.value)}.`);
-      } catch (e) {
-        return fail7(errMsg7(e));
-      }
-    }
+    withDevice(sync, async (args, target) => {
+      await sync.callAction(JOTAI_TOOL_ID, "setAtom", { label: args.atom, value: args.value }, target);
+      return text(`Set Jotai atom "${args.atom}" to ${JSON.stringify(args.value)}.`);
+    })
   );
 }
 
 // src/tools/packs/redux.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var REDUX_TOOL_ID = "redux";
-var text7 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail8 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg8 = (e) => e instanceof Error ? e.message : String(e);
 function noStoreMessage(reason) {
   switch (reason) {
     case "no-react-redux":
@@ -2431,8 +2423,8 @@ function registerReduxTools(server, sync) {
     {
       description: "Read the app's CURRENT Redux state. Compact by DEFAULT \u2014 just the top-level slice names \u2014 so it's token-cheap; pass includeValues:true for the full state tree. Use this for 'what's in my redux store / current auth state'. (For the history of dispatched actions over time, use get_events with sources:['redux'].)",
       inputSchema: {
-        includeValues: import_zod8.z.boolean().optional().describe("Include the full current state tree (HEAVY). Default false (slice names only)."),
-        deviceId: import_zod8.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        includeValues: import_zod9.z.boolean().optional().describe("Include the full current state tree (HEAVY). Default false (slice names only)."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -2445,15 +2437,15 @@ function registerReduxTools(server, sync) {
           target
         );
         if (!res) {
-          return fail8(
+          return fail2(
             "No redux result from the device. The redux tool may be inactive, or the app needs a newer Buoy (get_redux_state requires the getState action)."
           );
         }
-        if (!res.available) return fail8(noStoreMessage(res.reason));
+        if (!res.available) return fail2(noStoreMessage(res.reason));
         const slices = res.slices.length ? res.slices.join(", ") : "(none)";
         const captureNote = res.capture === "top-level-only" ? TOP_LEVEL_ONLY_NOTE : "";
         if (args.includeValues) {
-          return text7(
+          return text(
             `**Redux store \u2014 slices: ${slices}**
 
 \`\`\`json
@@ -2461,13 +2453,13 @@ ${JSON.stringify(res.state, null, 2)}
 \`\`\`${captureNote}`
           );
         }
-        return text7(
+        return text(
           `**Redux store \u2014 slices: ${slices}**
 
 _Compact view. Pass includeValues:true for the full state tree. Dispatch with redux_dispatch({type, payload})._${captureNote}`
         );
       } catch (e) {
-        return fail8(errMsg8(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -2476,9 +2468,9 @@ _Compact view. Pass includeValues:true for the full state tree. Dispatch with re
     {
       description: "Dispatch a Redux action to the app's store (e.g. to trigger a state change while debugging). Provide the action type and optional payload \u2014 they're sent as { type, payload }.",
       inputSchema: {
-        type: import_zod8.z.string().describe('The action type, e.g. "counter/increment" or "auth/logout".'),
-        payload: import_zod8.z.unknown().optional().describe("Optional action payload (any JSON)."),
-        deviceId: import_zod8.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        type: import_zod9.z.string().describe('The action type, e.g. "counter/increment" or "auth/logout".'),
+        payload: import_zod9.z.unknown().optional().describe("Optional action payload (any JSON)."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -2487,21 +2479,18 @@ _Compact view. Pass includeValues:true for the full state tree. Dispatch with re
         const action = { type: args.type };
         if (args.payload !== void 0) action.payload = args.payload;
         const res = await sync.callAction(REDUX_TOOL_ID, "dispatch", { action }, target);
-        if (!res || !res.dispatched) return fail8(noStoreMessage(res?.reason));
-        return text7(`Dispatched \`${args.type}\`${args.payload !== void 0 ? ` with payload ${JSON.stringify(args.payload)}` : ""}.`);
+        if (!res || !res.dispatched) return fail2(noStoreMessage(res?.reason));
+        return text(`Dispatched \`${args.type}\`${args.payload !== void 0 ? ` with payload ${JSON.stringify(args.payload)}` : ""}.`);
       } catch (e) {
-        return fail8(errMsg8(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/storage.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var STORAGE_TOOL_ID = "storage";
-var text8 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail9 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg9 = (e) => e instanceof Error ? e.message : String(e);
 function truncate2(v, n = 200) {
   if (v === null || v === void 0) return "(null)";
   const s = typeof v === "string" ? v : JSON.stringify(v);
@@ -2513,10 +2502,10 @@ function registerStorageTools(server, sync) {
     {
       description: "Read the app's storage keys across ALL backends: AsyncStorage, MMKV (per instance), and Expo SecureStore. Data wrong or missing after an app restart \u2192 read the persisted values here FIRST \u2014 the bug is usually a stale, missing, or malformed stored value, and reading it beats hunting for it in code. Compact by DEFAULT \u2014 keys only \u2014 so it's token-cheap; pass includeValues:true for the values (truncated), or a `pattern` substring to narrow. Buoy's own internal keys are already filtered out.",
       inputSchema: {
-        pattern: import_zod9.z.string().optional().describe("Only keys containing this substring (case-insensitive)."),
-        includeValues: import_zod9.z.boolean().optional().describe("Include each key's value (truncated). Default false (keys only)."),
-        limit: import_zod9.z.number().optional().describe("Max keys per backend section. Default 100."),
-        deviceId: import_zod9.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        pattern: import_zod10.z.string().optional().describe("Only keys containing this substring (case-insensitive)."),
+        includeValues: import_zod10.z.boolean().optional().describe("Include each key's value (truncated). Default false (keys only)."),
+        limit: import_zod10.z.number().optional().describe("Max keys per backend section. Default 100."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -2528,7 +2517,7 @@ function registerStorageTools(server, sync) {
         const sections = [];
         const allKeys = await sync.callAction(STORAGE_TOOL_ID, "async.getAllKeys", {}, target);
         if (!Array.isArray(allKeys)) {
-          return fail9("No storage result from the device. The storage tool may be inactive.");
+          return fail2("No storage result from the device. The storage tool may be inactive.");
         }
         const asyncKeys = allKeys.filter(matches2).slice(0, limit);
         if (asyncKeys.length > 0) {
@@ -2569,12 +2558,12 @@ ${lines.join("\n")}`);
 ${lines.join("\n")}`);
         }
         if (sections.length === 0) {
-          return text8(`No storage keys${pattern ? ` matching "${args.pattern}"` : ""} in any backend.`);
+          return text(`No storage keys${pattern ? ` matching "${args.pattern}"` : ""} in any backend.`);
         }
         const note = args.includeValues ? "" : "\n\n_Keys only. Pass includeValues:true for values, or a pattern to filter. Modify AsyncStorage with storage_action._";
-        return text8(`${sections.join("\n\n")}${note}`);
+        return text(`${sections.join("\n\n")}${note}`);
       } catch (e) {
-        return fail9(errMsg9(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -2583,10 +2572,10 @@ ${lines.join("\n")}`);
     {
       description: "Modify the app's AsyncStorage: set a key, remove a key, or clear all app storage (Buoy's own devtool keys are preserved). Values are stored as strings \u2014 JSON-encode objects yourself.",
       inputSchema: {
-        action: import_zod9.z.enum(["set", "remove", "clear"]).describe("set/remove a key, or clear all app storage."),
-        key: import_zod9.z.string().optional().describe("The key (required for set and remove)."),
-        value: import_zod9.z.string().optional().describe("The string value to store (required for set; JSON-encode objects)."),
-        deviceId: import_zod9.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        action: import_zod10.z.enum(["set", "remove", "clear"]).describe("set/remove a key, or clear all app storage."),
+        key: import_zod10.z.string().optional().describe("The key (required for set and remove)."),
+        value: import_zod10.z.string().optional().describe("The string value to store (required for set; JSON-encode objects)."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -2594,33 +2583,30 @@ ${lines.join("\n")}`);
         const target = sync.requireProDevice(args.deviceId);
         if (args.action === "clear") {
           await sync.callAction(STORAGE_TOOL_ID, "clearAppStorage", {}, target);
-          return text8("Cleared all app storage (Buoy's own devtool keys preserved).");
+          return text("Cleared all app storage (Buoy's own devtool keys preserved).");
         }
         if (!args.key) {
-          return fail9(`'${args.action}' needs a key.`);
+          return fail2(`'${args.action}' needs a key.`);
         }
         if (args.action === "remove") {
           await sync.callAction(STORAGE_TOOL_ID, "async.removeItem", { key: args.key }, target);
-          return text8(`Removed storage key "${args.key}".`);
+          return text(`Removed storage key "${args.key}".`);
         }
         if (args.value === void 0) {
-          return fail9("'set' needs a value (a string).");
+          return fail2("'set' needs a value (a string).");
         }
         await sync.callAction(STORAGE_TOOL_ID, "async.setItem", { key: args.key, value: args.value }, target);
-        return text8(`Set storage key "${args.key}".`);
+        return text(`Set storage key "${args.key}".`);
       } catch (e) {
-        return fail9(errMsg9(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/routes.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var ROUTES_TOOL_ID = "route-events";
-var text9 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail10 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg10 = (e) => e instanceof Error ? e.message : String(e);
 function flattenRoutes(routes, acc = []) {
   for (const r of routes ?? []) {
     if (r.path) acc.push(r.path);
@@ -2634,8 +2620,8 @@ function registerRoutesTools(server, sync) {
     {
       description: "Read the app's CURRENT route + navigation stack (where the user is and how they got there). Compact by DEFAULT; pass includeSitemap:true to also list every route path the app defines (useful before navigate). Use for 'what screen am I on / what's the nav stack / what routes exist'. (For navigation history over time, use get_events with sources:['route'].)",
       inputSchema: {
-        includeSitemap: import_zod10.z.boolean().optional().describe("Also list all defined route paths (can be long). Default false."),
-        deviceId: import_zod10.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        includeSitemap: import_zod11.z.boolean().optional().describe("Also list all defined route paths (can be long). Default false."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -2668,9 +2654,9 @@ ${shown.map((r) => `- \`${r}\``).join("\n")}`
 **Sitemap:** ${allPaths.length} routes _(pass includeSitemap:true to list them)_`);
         }
         parts.push("\n_Navigate with navigate({ path })._");
-        return text9(parts.join("\n"));
+        return text(parts.join("\n"));
       } catch (e) {
-        return fail10(errMsg10(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -2679,9 +2665,9 @@ ${shown.map((r) => `- \`${r}\``).join("\n")}`
     {
       description: "Navigate the app to a route path (e.g. '/pokemon/25' or '/settings'). Use a concrete path \u2014 resolve any dynamic segments (like [id]) to real values first. See get_routes with includeSitemap:true for valid paths. Pushes by default (back still works); pass replace:true to leave the current screen instead of stacking on top of it (e.g. resetting to '/').",
       inputSchema: {
-        path: import_zod10.z.string().describe("The concrete path to navigate to, e.g. '/pokemon/25'."),
-        replace: import_zod10.z.boolean().optional().describe("Replace the current screen instead of pushing (use when resetting, e.g. to '/')."),
-        deviceId: import_zod10.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        path: import_zod11.z.string().describe("The concrete path to navigate to, e.g. '/pokemon/25'."),
+        replace: import_zod11.z.boolean().optional().describe("Replace the current screen instead of pushing (use when resetting, e.g. to '/')."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -2693,20 +2679,17 @@ ${shown.map((r) => `- \`${r}\``).join("\n")}`
           { path: args.path, replace: args.replace === true },
           target
         );
-        return text9(`Navigated to \`${args.path}\`${args.replace ? " (replaced current screen)" : ""}.`);
+        return text(`Navigated to \`${args.path}\`${args.replace ? " (replaced current screen)" : ""}.`);
       } catch (e) {
-        return fail10(errMsg10(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/console.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var CONSOLE_TOOL_ID = "console";
-var text10 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail11 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg11 = (e) => e instanceof Error ? e.message : String(e);
 var SEVERITY = { verbose: 0, info: 1, warning: 2, error: 3 };
 var TAG = { verbose: "\xB7", info: "info", warning: "warn", error: "ERR" };
 function hhmmss(ts) {
@@ -2720,57 +2703,275 @@ function registerConsoleTools(server, sync) {
     {
       description: "Read the app's captured console logs (console.log/warn/error/\u2026) as a compact tail \u2014 time \xB7 level \xB7 message. App crashing or erroring \u2192 read this FIRST: it captures crashes and errors including FATAL uncaught JS errors (tagged [FATAL], hooked from RN's global error handler), so a dead app's last words are here, not in the code. Token-cheap (uses each entry's pre-rendered message, not raw args). Filter by minimum level (e.g. level:'warning' for warnings+errors) or a message substring. For full args/stack of an entry, fall back to get_snapshot('console').",
       inputSchema: {
-        level: import_zod11.z.enum(["verbose", "info", "warning", "error"]).optional().describe("Minimum level to include (severity threshold). e.g. 'warning' = warnings + errors. Default all."),
-        limit: import_zod11.z.number().optional().describe("Most-recent N entries. Default 50."),
-        pattern: import_zod11.z.string().optional().describe("Only entries whose message contains this substring (case-insensitive)."),
-        deviceId: import_zod11.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        level: import_zod12.z.enum(["verbose", "info", "warning", "error"]).optional().describe("Minimum level to include (severity threshold). e.g. 'warning' = warnings + errors. Default all."),
+        limit: import_zod12.z.number().optional().describe("Most-recent N entries. Default 50."),
+        pattern: import_zod12.z.string().optional().describe("Only entries whose message contains this substring (case-insensitive)."),
+        deviceId: deviceIdInput
+      }
+    },
+    withDevice(sync, async (args, target) => {
+      const { payload, stale } = await sync.getSnapshot(CONSOLE_TOOL_ID, target);
+      const banner = staleHeader(stale);
+      const p = Array.isArray(payload) ? { entries: payload } : payload ?? {};
+      const all = Array.isArray(p.entries) ? p.entries : [];
+      const minSev = args.level ? SEVERITY[args.level] : 0;
+      const pattern = args.pattern?.toLowerCase();
+      const filtered = all.filter(
+        (e) => SEVERITY[e.level] >= minSev && (!pattern || (e.message ?? "").toLowerCase().includes(pattern))
+      );
+      const sorted = [...filtered].sort((a, b) => a.id - b.id);
+      const limit = clampLimit(args.limit, 50);
+      const shown = sorted.slice(-limit);
+      if (shown.length === 0) {
+        return text(`${banner}No console entries${args.level ? ` at level \u2265 ${args.level}` : ""}${pattern ? ` matching "${args.pattern}"` : ""} (${all.length} total captured).`);
+      }
+      const lines = shown.map((e) => `${hhmmss(e.timestamp)} [${TAG[e.level] ?? e.level}] ${e.message}`);
+      const levelNote = args.level ? `, level \u2265 ${args.level}` : "";
+      const header = `**Console \u2014 ${all.length} entries (showing ${shown.length}${levelNote}):**`;
+      return text(`${banner}${header}
+
+\`\`\`
+${lines.join("\n")}
+\`\`\`
+
+_Tail of recent logs. Use get_snapshot('console') for full args/stacks._`);
+    })
+  );
+}
+
+// src/tools/packs/sentry.ts
+var import_zod13 = require("zod");
+var SENTRY_TOOL_ID = "sentry";
+var text2 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail3 = (message) => ({
+  isError: true,
+  content: [{ type: "text", text: message }]
+});
+var errMsg3 = (e) => e instanceof Error ? e.message : String(e);
+function hhmmss2(ts) {
+  const d = new Date(ts);
+  const p = (n) => String(n).padStart(2, "0");
+  return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+function bytes(n) {
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(2)}MB`;
+}
+function units(n, format) {
+  if (format === "bytes") return bytes(n);
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+var FREE_QUOTA = {
+  errors: 5e3,
+  spans: 5e6,
+  replays: 50,
+  logBytes: 5 * 1024 ** 3,
+  attachmentBytes: 1 * 1024 ** 3
+};
+var CATEGORY_FORMAT = {
+  errors: "count",
+  spans: "count",
+  replays: "count",
+  logBytes: "bytes",
+  attachmentBytes: "bytes"
+};
+function statusNote(status) {
+  switch (status) {
+    case "attached":
+      return "";
+    case "sdk-not-found":
+      return "\n\n\u26A0\uFE0F The tool never found @sentry/react-native \u2014 nothing is being captured. The app must pass `getClient` to SentryRoot, or the SDK isn't installed.";
+    case "no-client":
+      return "\n\n\u26A0\uFE0F The SDK is present but no client appeared \u2014 is Sentry.init() being called?";
+    default:
+      return "\n\n\u23F3 Still looking for the app's Sentry client.";
+  }
+}
+function registerSentryTools(server, sync) {
+  server.registerTool(
+    "get_sentry_envelopes",
+    {
+      description: "Read what the app is actually sending to Sentry \u2014 every outgoing envelope with its item types, byte size, span count, and summary. Use this to answer 'is this error reaching Sentry', 'what does my app send at startup', or 'why is my Sentry bill high'. Debugging an error locally? These payloads are the final post-processing event, so you can read the exception, breadcrumbs and contexts here WITHOUT waiting for ingestion or spending quota. Filter by envelope item type (event / transaction / log / session / client_report / attachment / replay_event).",
+      inputSchema: {
+        type: import_zod13.z.string().optional().describe(
+          "Only envelopes containing this item type, e.g. 'event' for errors or 'transaction' for traces."
+        ),
+        limit: import_zod13.z.number().optional().describe("Most-recent N envelopes. Default 25."),
+        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, stale } = await sync.getSnapshot(CONSOLE_TOOL_ID, target);
-        const staleHeader = stale ? `${stale}
+        const { payload, stale } = await sync.getSnapshot(SENTRY_TOOL_ID, target);
+        const staleHeader2 = stale ? `${stale}
 
 ` : "";
-        const p = Array.isArray(payload) ? { entries: payload } : payload ?? {};
-        const all = Array.isArray(p.entries) ? p.entries : [];
-        const minSev = args.level ? SEVERITY[args.level] : 0;
-        const pattern = args.pattern?.toLowerCase();
-        const filtered = all.filter(
-          (e) => SEVERITY[e.level] >= minSev && (!pattern || (e.message ?? "").toLowerCase().includes(pattern))
-        );
-        const sorted = [...filtered].sort((a, b) => a.id - b.id);
-        const limit = typeof args.limit === "number" && args.limit > 0 ? args.limit : 50;
-        const shown = sorted.slice(-limit);
+        const p = payload ?? {};
+        const all = Array.isArray(p.envelopes) ? p.envelopes : [];
+        const filtered = args.type ? all.filter((e) => e.items.some((i) => i.type === args.type)) : all;
+        const limit = typeof args.limit === "number" && args.limit > 0 ? args.limit : 25;
+        const shown = filtered.slice(-limit);
         if (shown.length === 0) {
-          return text10(`${staleHeader}No console entries${args.level ? ` at level \u2265 ${args.level}` : ""}${pattern ? ` matching "${args.pattern}"` : ""} (${all.length} total captured).`);
+          return text2(
+            `${staleHeader2}No Sentry envelopes${args.type ? ` containing a '${args.type}' item` : ""} (${all.length} captured this session).${statusNote(p.status)}`
+          );
         }
-        const lines = shown.map((e) => `${hhmmss(e.timestamp)} [${TAG[e.level] ?? e.level}] ${e.message}`);
-        const levelNote = args.level ? `, level \u2265 ${args.level}` : "";
-        const header = `**Console \u2014 ${all.length} entries (showing ${shown.length}${levelNote}):**`;
-        return text10(`${staleHeader}${header}
+        const lines = shown.map((e) => {
+          const types = e.items.map((i) => i.type).join("+");
+          const spans = e.items.reduce((sum, i) => sum + (i.spanCount ?? 0), 0);
+          const spanNote = spans > 0 ? ` \xB7 ${spans} span${spans === 1 ? "" : "s"}` : "";
+          const head = `${e.id}. ${hhmmss2(e.timestamp)} [${types}] ${bytes(e.totalBytes)}${spanNote}`;
+          return `${head}
+   \u2514\u2500 ${e.items[0]?.summary ?? "envelope"}`;
+        });
+        const header = `**Sentry \u2014 ${all.length} envelope${all.length === 1 ? "" : "s"} sent (showing ${shown.length}${args.type ? `, type '${args.type}'` : ""}):**`;
+        return text2(
+          `${staleHeader2}${header}${statusNote(p.status)}
 
-\`\`\`
 ${lines.join("\n")}
+
+_Full payloads (exception, breadcrumbs, contexts) via get_snapshot('sentry'). Billing units via get_sentry_cost._`
+        );
+      } catch (e) {
+        return fail3(errMsg3(e));
+      }
+    }
+  );
+  server.registerTool(
+    "get_sentry_cost",
+    {
+      description: "What this session would cost in Sentry's billing units, and what that rate implies for a month against the free plan. Sentry bills on RECEIPT \u2014 data its server-side sampling later discards is still charged \u2014 and spans are billed individually, so one transaction is many units. Use this before shipping a Sentry config, or when asked why a Sentry bill is high.",
+      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, stale } = await sync.getSnapshot(SENTRY_TOOL_ID, target);
+        const staleHeader2 = stale ? `${stale}
+
+` : "";
+        const p = payload ?? {};
+        const usage = p.usage;
+        if (!usage?.session) {
+          return text2(
+            `${staleHeader2}No usage recorded yet \u2014 nothing has been sent to Sentry this session.${statusNote(p.status)}`
+          );
+        }
+        const session = usage.session;
+        const projected = usage.projectedMonthly;
+        const keys = Object.keys(session);
+        const rows = keys.map((key) => {
+          const format = CATEGORY_FORMAT[key];
+          const now = units(session[key], format);
+          if (!projected) return `- ${key}: ${now} this session`;
+          const month = projected[key];
+          const quota = FREE_QUOTA[key];
+          const pct = quota > 0 ? Math.round(month / quota * 100) : null;
+          const pctNote = pct === null ? " (not on the free plan)" : ` \u2014 ${pct}% of the free plan's ${units(quota, format)}`;
+          return `- ${key}: ${now} this session \u2192 ~${units(month, format)}/mo${pctNote}`;
+        });
+        const windowNote = usage.windowMs ? ` over ${Math.round(usage.windowMs / 1e3)}s` : "";
+        const contributors = usage.topContributors?.length ? `
+
+**What produced it:**
+${usage.topContributors.map((c) => `- ${c.label} \u2014 ${c.units} ${c.category}`).join("\n")}` : "";
+        const caveat = projected ? "\n\n_The monthly figure extrapolates one session on one device \u2014 it catches a config that is orders of magnitude off, it is not a forecast._" : "\n\n_Session too short to project a month from._";
+        return text2(
+          `${staleHeader2}**Sentry cost \u2014 ${p.envelopes?.length ?? 0} envelopes${windowNote}:**
+
+${rows.join("\n")}${contributors}${caveat}`
+        );
+      } catch (e) {
+        return fail3(errMsg3(e));
+      }
+    }
+  );
+  server.registerTool(
+    "get_sentry_drops",
+    {
+      description: "Why events never reached Sentry. Answers 'I called captureException but the event isn't in Sentry' \u2014 the single most common Sentry problem \u2014 by naming the layer that discarded it: a beforeSend callback returning null, a sample-rate roll, dedupe or another event processor, React Native tracing discarding an empty transaction, or a native rate limit.",
+      inputSchema: {
+        limit: import_zod13.z.number().optional().describe("Most-recent N drop records. Default 30."),
+        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, stale } = await sync.getSnapshot(SENTRY_TOOL_ID, target);
+        const staleHeader2 = stale ? `${stale}
+
+` : "";
+        const p = payload ?? {};
+        const summary = p.drops?.summary ?? [];
+        const recent = p.drops?.recent ?? [];
+        if (summary.length === 0) {
+          return text2(
+            `${staleHeader2}Nothing dropped this session \u2014 every captured event reached the transport.${statusNote(p.status)}
+
+_If an event is still missing from sentry.io, it left the device: check the DSN, the project, and Sentry's own inbound filters and quota._`
+          );
+        }
+        const limit = typeof args.limit === "number" && args.limit > 0 ? args.limit : 30;
+        const shown = recent.slice(-limit);
+        const summaryLines = summary.map(
+          (s) => `- ${s.reason}: ${s.units} unit${s.units === 1 ? "" : "s"} across ${s.records} record${s.records === 1 ? "" : "s"}`
+        );
+        const rows = shown.map(
+          (d) => `${hhmmss2(d.timestamp)} [${d.reason}] ${d.category}${d.quantity > 1 ? ` \xD7${d.quantity}` : ""} \u2014 ${d.detail} (${d.source})`
+        );
+        return text2(
+          `${staleHeader2}**Sentry drops \u2014 by reason:**
+
+${summaryLines.join("\n")}
+
+**Recent (${shown.length}):**
+
+\`\`\`
+${rows.join("\n")}
 \`\`\`
 
-_Tail of recent logs. Use get_snapshot('console') for full args/stacks._`);
+_"observed" means the tool watched it happen; "reported" means the SDK counted it afterwards. Native drops only appear when the SDK runs with debug enabled._`
+        );
+      } catch (e) {
+        return fail3(errMsg3(e));
+      }
+    }
+  );
+  server.registerTool(
+    "sentry_action",
+    {
+      description: "Act on the Sentry inspector. 'clear' drops every captured envelope and drop record \u2014 use it to get a clean window before driving a flow you want to measure.",
+      inputSchema: {
+        action: import_zod13.z.enum(["clear"]).describe("The action to perform."),
+        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);
+        await sync.callAction(SENTRY_TOOL_ID, "clearEnvelopes", {}, target);
+        return text2(
+          "Cleared the Sentry inspector \u2014 envelopes and drop records. Drive your flow, then read get_sentry_envelopes or get_sentry_cost."
+        );
       } catch (e) {
-        return fail11(errMsg11(e));
+        return fail3(errMsg3(e));
       }
     }
   );
 }
 
 // src/tools/packs/timeMachine.ts
-var import_zod12 = require("zod");
+var import_zod14 = require("zod");
 var TIME_MACHINE_TOOL_ID = "time-machine";
-var text11 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail12 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg12 = (e) => e instanceof Error ? e.message : String(e);
-function kb(bytes) {
-  return bytes < 1024 ? `${bytes} B` : `${(bytes / 1024).toFixed(1)} KB`;
+function kb(bytes2) {
+  return bytes2 < 1024 ? `${bytes2} B` : `${(bytes2 / 1024).toFixed(1)} KB`;
 }
 function formatOutcome(outcome) {
   const lines = Object.entries(outcome.results).map(([sid, r2]) => {
@@ -2795,7 +2996,7 @@ function registerTimeMachineTools(server, sync) {
     {
       description: "List the app's Time Machine state snapshots (restore points) and which state sources (storage/redux/zustand/jotai/react-query) can currently be captured/restored. Each snapshot also records the route it was captured on (shown as `route`), which a restore can navigate back to. Use time_machine_action to capture a snapshot before driving a flow, then restore it to re-run the flow from the same state.",
       inputSchema: {
-        deviceId: import_zod12.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -2828,9 +3029,9 @@ ${providerLines.join("\n") || "_no providers registered_"}`
         ];
         if (p.lastOutcome) parts.push(`**Last restore:**
 ${formatOutcome(p.lastOutcome)}`);
-        return text11(parts.join("\n\n"));
+        return text(parts.join("\n\n"));
       } catch (e) {
-        return fail12(errMsg12(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -2839,14 +3040,14 @@ ${formatOutcome(p.lastOutcome)}`);
     {
       description: "Manage Time Machine state snapshots: capture the app's current state as a named restore point, preview what restoring one would change (per-item added/removed/changed/won't-apply verdicts \u2014 check the blast radius BEFORE restoring), restore one (mode 'live' replaces state in place; 'reload' restores persisted storage then reloads the JS bundle \u2014 baselines always reload; pass restoreRoute:true to also return to the screen the snapshot was captured on), capture_baseline (an empty wipe-to-fresh-install restore point), delete, or rename. The restore result reports per-source applied/skipped counts \u2014 check them rather than assuming success.",
       inputSchema: {
-        action: import_zod12.z.enum(["capture", "capture_baseline", "preview", "restore", "delete", "rename"]).describe("What to do."),
-        id: import_zod12.z.string().optional().describe("Snapshot id (required for restore/delete/rename; from get_time_machine)."),
-        name: import_zod12.z.string().optional().describe("Snapshot name (for capture and rename)."),
-        mode: import_zod12.z.enum(["live", "reload"]).optional().describe("Restore mode. Default 'live'."),
-        excludeKeys: import_zod12.z.array(import_zod12.z.string()).optional().describe('Restore only: item keys to LEAVE UNTOUCHED, as "sourceId::itemKey" (itemKey = the key shown by the preview action, e.g. "query::[\\"pokemon\\"]" or "storage::async:@cart").'),
-        restoreRoute: import_zod12.z.boolean().optional().describe("Restore only: also navigate back to the route the snapshot was captured on (shown as `route` by get_time_machine). With mode 'reload' the navigation happens automatically on the next boot. Default false \u2014 state is restored but the app stays on the current screen."),
-        sourceIds: import_zod12.z.array(import_zod12.z.string()).optional().describe("Capture/restore only these source ids (default all)."),
-        deviceId: import_zod12.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        action: import_zod14.z.enum(["capture", "capture_baseline", "preview", "restore", "delete", "rename"]).describe("What to do."),
+        id: import_zod14.z.string().optional().describe("Snapshot id (required for restore/delete/rename; from get_time_machine)."),
+        name: import_zod14.z.string().optional().describe("Snapshot name (for capture and rename)."),
+        mode: import_zod14.z.enum(["live", "reload"]).optional().describe("Restore mode. Default 'live'."),
+        excludeKeys: import_zod14.z.array(import_zod14.z.string()).optional().describe('Restore only: item keys to LEAVE UNTOUCHED, as "sourceId::itemKey" (itemKey = the key shown by the preview action, e.g. "query::[\\"pokemon\\"]" or "storage::async:@cart").'),
+        restoreRoute: import_zod14.z.boolean().optional().describe("Restore only: also navigate back to the route the snapshot was captured on (shown as `route` by get_time_machine). With mode 'reload' the navigation happens automatically on the next boot. Default false \u2014 state is restored but the app stays on the current screen."),
+        sourceIds: import_zod14.z.array(import_zod14.z.string()).optional().describe("Capture/restore only these source ids (default all)."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -2859,14 +3060,14 @@ ${formatOutcome(p.lastOutcome)}`);
             const s = result.snapshot;
             const warnings = Object.entries(s.sources).flatMap(([sid, src]) => src.warnings.map((w) => `
   \u26A0 ${sid}: ${w}`)).join("");
-            return text11(`Captured \`${s.id}\` "${s.name}" \u2014 ${kb(s.sizeBytes)} \xB7 ${Object.keys(s.sources).join(", ")}${warnings}`);
+            return text(`Captured \`${s.id}\` "${s.name}" \u2014 ${kb(s.sizeBytes)} \xB7 ${Object.keys(s.sources).join(", ")}${warnings}`);
           }
           case "capture_baseline": {
             const result = await call("captureBaseline", {});
-            return text11(`Captured baseline \`${result.snapshot.id}\` \u2014 restoring it wipes app storage and reloads.`);
+            return text(`Captured baseline \`${result.snapshot.id}\` \u2014 restoring it wipes app storage and reloads.`);
           }
           case "preview": {
-            if (!args.id) return fail12("preview requires `id` (from get_time_machine).");
+            if (!args.id) return fail2("preview requires `id` (from get_time_machine).");
             const result = await call("preview", { id: args.id });
             const lines = [];
             let totalApplies = 0;
@@ -2885,46 +3086,46 @@ ${formatOutcome(p.lastOutcome)}`);
               for (const note of src.notes) lines.push(`    \xB7 ${note}`);
             }
             const head = totalApplies === 0 ? "**Restore would change NOTHING** (states identical or nothing applicable)." : `**Restore would apply ${totalApplies} change(s):**`;
-            return text11(`${head}
+            return text(`${head}
 ${lines.join("\n")}`);
           }
           case "restore": {
-            if (!args.id) return fail12("restore requires `id` (from get_time_machine).");
+            if (!args.id) return fail2("restore requires `id` (from get_time_machine).");
             const outcome = await call("restore", {
               id: args.id,
               mode: args.mode ?? "live",
               excludeKeys: args.excludeKeys,
               restoreRoute: args.restoreRoute
             });
-            return text11(formatOutcome(outcome));
+            return text(formatOutcome(outcome));
           }
           case "delete": {
-            if (!args.id) return fail12("delete requires `id`.");
+            if (!args.id) return fail2("delete requires `id`.");
             await call("delete", { id: args.id });
-            return text11(`Deleted snapshot \`${args.id}\`.`);
+            return text(`Deleted snapshot \`${args.id}\`.`);
           }
           case "rename": {
-            if (!args.id || !args.name) return fail12("rename requires `id` and `name`.");
+            if (!args.id || !args.name) return fail2("rename requires `id` and `name`.");
             await call("rename", { id: args.id, name: args.name });
-            return text11(`Renamed \`${args.id}\` to "${args.name}".`);
+            return text(`Renamed \`${args.id}\` to "${args.name}".`);
           }
         }
       } catch (e) {
-        return fail12(errMsg12(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/scenarios.ts
-var import_zod13 = require("zod");
+var import_zod15 = require("zod");
 var SCENARIOS_TOOL_ID = "scenarios";
-var text12 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail13 = (message) => ({
+var text3 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail4 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg13 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg4 = (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)})` : "";
@@ -2986,7 +3187,7 @@ function registerScenariosTools(server, sync) {
     {
       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).")
+        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -3016,9 +3217,9 @@ ${formatActive(p.active)}` : "**No scenario active** \u2014 the app is showing r
 ${drafts.map(summarize).join("\n")}`
           );
         }
-        return text12(parts.join("\n\n"));
+        return text3(parts.join("\n\n"));
       } catch (e) {
-        return fail13(errMsg13(e));
+        return fail4(errMsg4(e));
       }
     }
   );
@@ -3027,66 +3228,66 @@ ${drafts.map(summarize).join("\n")}`
     {
       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(
+        action: import_zod15.z.enum(["preview", "run", "deactivate", "save", "setFolder", "delete"]).describe("What to do."),
+        folder: import_zod15.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(
+        id: import_zod15.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(
+        params: import_zod15.z.record(import_zod15.z.union([import_zod15.z.string(), import_zod15.z.number(), import_zod15.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(
+        scenario: import_zod15.z.object({
+          id: import_zod15.z.string().describe("Stable kebab-case id."),
+          name: import_zod15.z.string().describe("Human name; may contain {{variable}} placeholders."),
+          description: import_zod15.z.string().optional(),
+          expectedOutcome: import_zod15.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(
+          author: import_zod15.z.string().optional(),
+          authoredAgainst: import_zod15.z.string().optional().describe("App version this was written against."),
+          folder: import_zod15.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()
+          tags: import_zod15.z.array(import_zod15.z.string()).optional(),
+          vars: import_zod15.z.array(
+            import_zod15.z.object({
+              key: import_zod15.z.string(),
+              label: import_zod15.z.string().optional(),
+              type: import_zod15.z.enum(["string", "number", "boolean", "enum"]),
+              options: import_zod15.z.array(import_zod15.z.union([import_zod15.z.string(), import_zod15.z.number(), import_zod15.z.boolean()])).optional(),
+              default: import_zod15.z.union([import_zod15.z.string(), import_zod15.z.number(), import_zod15.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(
+          steps: import_zod15.z.array(
+            import_zod15.z.object({
+              id: import_zod15.z.string().optional(),
+              tool: import_zod15.z.string().describe(
                 "Tool id: network | storage | impersonate | route-events | query | time-machine"
               ),
-              action: import_zod13.z.string().describe(
+              action: import_zod15.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()
+              params: import_zod15.z.unknown().optional(),
+              label: import_zod15.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()
+          undoSteps: import_zod15.z.array(
+            import_zod15.z.object({
+              id: import_zod15.z.string().optional(),
+              tool: import_zod15.z.string(),
+              action: import_zod15.z.string(),
+              params: import_zod15.z.unknown().optional(),
+              label: import_zod15.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).")
+        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -3095,7 +3296,7 @@ ${drafts.map(summarize).join("\n")}`
         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).");
+            if (!args.id) return fail4("preview requires `id` (from get_scenarios).");
             const r = await call("preview", {
               id: args.id,
               params: args.params ?? {}
@@ -3118,16 +3319,16 @@ ${r.warnings.map((w) => `  \xB7 ${w}`).join("\n")}`);
               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"));
+            return text3(lines.join("\n\n"));
           }
           case "run": {
-            if (!args.id) return fail13("run requires `id` (from get_scenarios).");
+            if (!args.id) return fail4("run requires `id` (from get_scenarios).");
             const r = await call("run", {
               id: args.id,
               params: args.params ?? {}
             });
             if (r.preflightErrors?.length) {
-              return fail13(
+              return fail4(
                 `Pre-flight refused to run \`${args.id}\` \u2014 nothing was changed:
 ${r.preflightErrors.map((e) => `  \xB7 ${e}`).join("\n")}`
               );
@@ -3139,14 +3340,14 @@ ${r.preflightErrors.map((e) => `  \xB7 ${e}`).join("\n")}`
               return `  ${mark} ${s.label} (${s.ms}ms)${err}`;
             }).join("\n");
             if (!r.ok) {
-              return fail13(
+              return fail4(
                 `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(
+            return text3(
               [
                 `\u2705 **Scenario active \u2014 ${r.name ?? args.id}**`,
                 steps,
@@ -3170,49 +3371,49 @@ ${(r.effects ?? []).map((e) => `  \xB7 ${e.label} [${e.kind}]`).join("\n")}`,
             const errs = rep.errors.length ? `
 
 Errors: ${rep.errors.join("; ")}` : "";
-            return text12(`**Deactivated.**
+            return text3(`**Deactivated.**
 ${lines.map((l) => `  \xB7 ${l}`).join("\n")}${warn}${errs}`);
           }
           case "save": {
-            if (!args.scenario) return fail13("save requires `scenario`.");
+            if (!args.scenario) return fail4("save requires `scenario`.");
             const r = await call("save", { scenario: args.scenario });
             if (!r.ok) {
-              return fail13(
+              return fail4(
                 `Save rejected:
 ${(r.errors ?? [r.error ?? "unknown error"]).map((e) => `  \xB7 ${e}`).join("\n")}`
               );
             }
-            return text12(
+            return text3(
               `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).");
+            if (!args.id) return fail4("setFolder requires `id` (from get_scenarios).");
             const r = await call("setFolder", {
               id: args.id,
               folder: args.folder
             });
-            return text12(
+            return text3(
               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`.");
+            if (!args.id) return fail4("delete requires `id`.");
             await call("delete", { id: args.id });
-            return text12(`Deleted \`${args.id}\` from the device library.`);
+            return text3(`Deleted \`${args.id}\` from the device library.`);
           }
         }
       } catch (e) {
-        return fail13(errMsg13(e));
+        return fail4(errMsg4(e));
       }
     }
   );
 }
 
 // src/tools/packs/screenshot.ts
-var import_zod14 = require("zod");
+var import_zod16 = require("zod");
 
 // src/capture/simctl.ts
 var import_node_child_process = require("child_process");
@@ -3326,8 +3527,8 @@ function frameToRect(frame, screen) {
 var TOOL_ID = "highlight-updates";
 var MARGIN_PT = 12;
 var CAPTURE_PADDING_PT = 6;
-var fail14 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg14 = (e) => e instanceof Error ? e.message : String(e);
+var fail5 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg5 = (e) => e instanceof Error ? e.message : String(e);
 function reasonMessage(res, query) {
   switch (res.reason) {
     case "no-renders":
@@ -3357,10 +3558,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_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).")
+        query: import_zod16.z.string().optional().describe('Fuzzy match against testID, nativeID, accessibilityLabel, component name, or view type \u2014 e.g. "submit-button".'),
+        nativeTag: import_zod16.z.number().optional().describe("An exact nativeTag (from a previous call's candidates) to skip fuzzy matching."),
+        scrollIntoView: import_zod16.z.boolean().optional().describe("Scroll the component into view before capturing, if it's off-screen. Default true."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -3402,11 +3603,11 @@ function registerScreenshotTools(server, sync) {
           }
         }
         if (!located.matched || !located.rect || !located.screen) {
-          return fail14(reasonMessage(located, args.query) + candidatesText(located.candidates));
+          return fail5(reasonMessage(located, args.query) + candidatesText(located.candidates));
         }
         const shot = await captureIosFramebuffer();
         if (!shot.ok || !shot.srcPath || !shot.width || !shot.height) {
-          return fail14(shot.error ?? "Screenshot capture failed.");
+          return fail5(shot.error ?? "Screenshot capture failed.");
         }
         const pxScale = shot.width / located.screen.width;
         const r = located.rect;
@@ -3422,7 +3623,7 @@ function registerScreenshotTools(server, sync) {
           }
         );
         if (!crop.ok || !crop.buffer) {
-          return fail14(crop.error ?? "Crop failed.");
+          return fail5(crop.error ?? "Crop failed.");
         }
         const label = located.componentName || "component";
         const idPart = located.testID ? ` (testID: "${located.testID}")` : "";
@@ -3435,14 +3636,14 @@ function registerScreenshotTools(server, sync) {
           ]
         };
       } catch (e) {
-        return fail14(errMsg14(e));
+        return fail5(errMsg5(e));
       }
     }
   );
 }
 
 // src/tools/packs/camera.ts
-var import_zod15 = require("zod");
+var import_zod17 = require("zod");
 
 // src/capture/camera.ts
 var import_node_child_process2 = require("child_process");
@@ -3598,9 +3799,9 @@ _Tell the user to enter a licence in Buoy Desktop, or see https://buoy.gg/pricin
 }
 
 // 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) => ({
+var text4 = (s) => ({ content: [{ type: "text", text: s }] });
+var gate = (tool) => readEntitlement().isPro ? null : fail6(proRequired(tool));
+var fail6 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
@@ -3610,11 +3811,11 @@ function registerCameraTools(server) {
     {
       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(
+        kind: import_zod17.z.enum(["barcode", "image", "video", "camera", "screen", "pattern"]).describe("What the camera should show."),
+        value: import_zod17.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.")
+        format: import_zod17.z.enum(["qr", "pdf417", "aztec", "code128"]).optional().describe("Barcode symbology; defaults to qr.")
       }
     },
     async (args) => {
@@ -3625,12 +3826,12 @@ function registerCameraTools(server) {
       if (args.format) cmd.push("--format", args.format);
       const result = await run(cmd);
       if (!result.ok) {
-        return fail15(
+        return fail6(
           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(
+      return text4(
         `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._`
@@ -3648,15 +3849,15 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
       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");
+        return fail6(result.error ?? "could not read the simulator camera status");
       }
       const { publishing, fps, codes } = result.data;
       if (!publishing) {
-        return text13(
+        return text4(
           "The simulator camera is not publishing anything.\n\n_Set a source with `camera_source` first._"
         );
       }
-      return text13(
+      return text4(
         [
           `Publishing at ${fps} fps.`,
           codes.length ? `Currently decoding: ${codes.map((c) => `\`${c}\``).join(", ")}` : "No barcode in the current frame.",
@@ -3671,8 +3872,8 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
     {
       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.")
+        bundleId: import_zod17.z.string().describe("The app's bundle identifier."),
+        udid: import_zod17.z.string().optional().describe("Simulator udid, if more than one is booted.")
       }
     },
     async (args) => {
@@ -3682,9 +3883,9 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
       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 fail6(result.error ?? result.data?.error ?? "could not launch the app");
       }
-      return text13(
+      return text4(
         `Relaunched \`${args.bundleId}\` with the camera attached${result.data?.pid ? ` (pid ${result.data.pid})` : ""}.`
       );
     }
@@ -3694,7 +3895,7 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
     {
       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.")
+        bundleId: import_zod17.z.string().optional().describe("Check a specific app \u2014 whether the library is actually loaded in it.")
       }
     },
     async (args) => {
@@ -3702,11 +3903,11 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
       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");
+        return fail6(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);
+      return text4(describeDiagnosis(result.data.checks) + tierNote);
     }
   );
   server.registerTool(
@@ -3720,9 +3921,9 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
       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 fail6(result.error ?? result.data?.error ?? "could not stop the camera");
       }
-      return text13("The simulator camera is off.");
+      return text4("The simulator camera is off.");
     }
   );
   server.registerTool(
@@ -3730,7 +3931,7 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
     {
       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.")
+        udid: import_zod17.z.string().optional().describe("Which simulator's apps to list. Only needed when several are booted.")
       }
     },
     async (args) => {
@@ -3738,7 +3939,7 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
       if (blocked) return blocked;
       const devicesResult = await run(["devices"]);
       if (!devicesResult.ok || !devicesResult.data) {
-        return fail15(devicesResult.error ?? "could not list booted simulators");
+        return fail6(devicesResult.error ?? "could not list booted simulators");
       }
       const devices = devicesResult.data.devices ?? [];
       let apps = null;
@@ -3749,7 +3950,7 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
         ]);
         apps = appsResult.ok ? appsResult.data?.apps ?? [] : null;
       }
-      return text13(describeDevices(devices, apps));
+      return text4(describeDevices(devices, apps));
     }
   );
   server.registerTool(
@@ -3766,11 +3967,11 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
         run(["windows"])
       ]);
       if (!cams.ok && !wins.ok) {
-        return fail15(
+        return fail6(
           cams.error ?? wins.error ?? "could not list the Mac's cameras or windows"
         );
       }
-      return text13(
+      return text4(
         describeInputs(cams.data?.cameras ?? [], wins.data?.windows ?? [])
       );
     }
@@ -3780,8 +3981,8 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
     {
       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.")
+        action: import_zod17.z.enum(["on", "off", "status"]).describe("Turn it on, off, or report the current state."),
+        udid: import_zod17.z.string().optional().describe("Which simulator. Only needed when several are booted.")
       }
     },
     async (args) => {
@@ -3789,36 +3990,36 @@ _Apps already running do not pick up a camera they started without \u2014 use \`
       if (blocked) return blocked;
       const result = await run(["zero-setup", args.action, ...args.udid ? ["--udid", args.udid] : []]);
       if (!result.ok) {
-        return fail15(
+        return fail6(
           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(
+        if (!d.enabled) return text4("Zero-setup mode is **off**.");
+        return text4(
           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(
+        return text4(
           "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**.");
+      return text4("Zero-setup mode is **off**.");
     }
   );
 }
 
 // src/tools/packs/interact.ts
-var import_zod16 = require("zod");
+var import_zod18 = require("zod");
 var TOOL_ID2 = "highlight-updates";
-var text14 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail16 = (message) => ({
+var text5 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail7 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg15 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg6 = (e) => e instanceof Error ? e.message : String(e);
 function formatElement(e) {
   let line = e.interactive ? "\u2022 " : "  ";
   line += e.name;
@@ -3841,8 +4042,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_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).")
+        interactiveOnly: import_zod18.z.boolean().optional().describe("Only return tappable (onPress) elements. Default false (include labels/text for context)."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -3852,16 +4053,16 @@ function registerInteractTools(server, sync) {
         const all = res?.elements ?? [];
         const elements = args.interactiveOnly ? all.filter((e) => e.interactive) : all;
         if (elements.length === 0) {
-          return text14(
+          return text5(
             "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 text14(`${header}
+        return text5(`${header}
 
 ${elements.map(formatElement).join("\n")}`);
       } catch (e) {
-        return fail16(errMsg15(e));
+        return fail7(errMsg6(e));
       }
     }
   );
@@ -3870,20 +4071,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_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).")
+        nativeTag: import_zod18.z.number().optional().describe("Exact nativeTag from describe_screen (most precise)."),
+        testID: import_zod18.z.string().optional().describe("Exact testID of the element."),
+        query: import_zod18.z.string().optional().describe('Fuzzy match against testID / label / visible text / component name \u2014 e.g. "Sign in".'),
+        value: import_zod18.z.union([import_zod18.z.number(), import_zod18.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_zod18.z.string().optional().describe("For a text input: the string to set via onChangeText."),
+        longPress: import_zod18.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_zod18.z.boolean().optional().describe("Scroll the target into view first if it's off-screen. Default true."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
       try {
         if (args.nativeTag == null && !args.testID && !args.query) {
-          return fail16("Provide one of: nativeTag, testID, or query (from describe_screen).");
+          return fail7("Provide one of: nativeTag, testID, or query (from describe_screen).");
         }
         const target = sync.requireProDevice(args.deviceId);
         const res = await sync.callAction(
@@ -3908,26 +4109,23 @@ ${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 text14(`${verb}${scrolledNote}.${flowTip}`);
+          return text5(`${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 fail16(msg);
+        return fail7(msg);
       } catch (e) {
-        return fail16(errMsg15(e));
+        return fail7(errMsg6(e));
       }
     }
   );
 }
 
 // src/tools/packs/jsThread.ts
-var import_zod17 = require("zod");
+var import_zod19 = require("zod");
 var JS_TOP_TOOL_ID = "js-top";
-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);
@@ -3998,9 +4196,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_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.")
+        deviceId: deviceIdInput,
+        durationMs: import_zod19.z.number().optional().describe("How long to sample before reading the table. Default 3000, max 30000."),
+        clearFirst: import_zod19.z.boolean().optional().describe("Reset all stats before sampling, so the result attributes only what happens during this sample.")
       }
     },
     async ({ deviceId, durationMs, clearFirst }) => {
@@ -4013,7 +4211,7 @@ function registerJsThreadTools(server, sync) {
           { durationMs: duration, clearFirst: clearFirst === true },
           target
         );
-        if (!snap) return fail17("Device returned no snapshot \u2014 is @buoy-gg/js-top installed in the app?");
+        if (!snap) return fail2("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,
@@ -4032,13 +4230,13 @@ function registerJsThreadTools(server, sync) {
             worstFreezeMs: r.worstFreezeMs
           }))
         };
-        return text15(`${md}
+        return text(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail17(errMsg16(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -4047,8 +4245,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_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.")
+        deviceId: deviceIdInput,
+        key: import_zod19.z.string().describe("Origin key from get_js_thread_top's JSON rows.")
       }
     },
     async ({ deviceId, key }) => {
@@ -4061,18 +4259,18 @@ ${JSON.stringify(slim)}
           target
         );
         if (!detail) {
-          return fail17(
+          return fail2(
             `Origin "${key}" is not tracked (cleared, evicted, or never existed). Re-run get_js_thread_top for current keys.`
           );
         }
         const md = formatDetailMarkdown(detail);
-        return text15(`${md}
+        return text(`${md}
 
 \`\`\`json
 ${JSON.stringify(detail)}
 \`\`\``);
       } catch (e) {
-        return fail17(errMsg16(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -4081,27 +4279,24 @@ ${JSON.stringify(detail)}
     {
       description: "Reset the js-top task table, freeze history, and busy history on the device (fresh measurement window).",
       inputSchema: {
-        deviceId: import_zod17.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        deviceId: deviceIdInput
       }
     },
     async ({ deviceId }) => {
       try {
         const target = sync.requireProDevice(deviceId);
         await sync.callAction(JS_TOP_TOOL_ID, "clear", {}, target);
-        return text15("Cleared js-top stats.");
+        return text("Cleared js-top stats.");
       } catch (e) {
-        return fail17(errMsg16(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/images.ts
-var import_zod18 = require("zod");
+var import_zod20 = require("zod");
 var IMAGES_TOOL_ID = "images";
-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=([^&?]+)/);
@@ -4121,8 +4316,8 @@ function cacheLabel(r) {
   if (r.progressSeen) return "network";
   return "?";
 }
-function mb(bytes) {
-  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+function mb(bytes2) {
+  return `${(bytes2 / (1024 * 1024)).toFixed(1)}MB`;
 }
 function formatListMarkdown(list, limit) {
   const lines = [];
@@ -4189,9 +4384,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_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).")
+        deviceId: deviceIdInput,
+        limit: import_zod20.z.number().optional().describe("Max records to return (newest first). Default 30, max 200."),
+        status: import_zod20.z.enum(["pending", "loading", "loaded", "error"]).optional().describe("Only records in this state (e.g. 'error' for the failure log).")
       }
     },
     async ({ deviceId, limit, status }) => {
@@ -4204,7 +4399,7 @@ function registerImagesTools(server, sync) {
           { limit: capped, status },
           target
         );
-        if (!list) return fail18("Device returned nothing \u2014 is @buoy-gg/images installed in the app?");
+        if (!list) return fail2("Device returned nothing \u2014 is @buoy-gg/images installed in the app?");
         const md = formatListMarkdown(list, capped);
         const slim = {
           stats: list.stats,
@@ -4231,13 +4426,13 @@ function registerImagesTools(server, sync) {
             layoutShifts: r.layoutShifts
           }))
         };
-        return text16(`${md}
+        return text(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail18(errMsg17(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -4246,9 +4441,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_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([
+        deviceId: deviceIdInput,
+        id: import_zod20.z.number().describe("Record id from get_images."),
+        action: import_zod20.z.enum([
           "hard_reload",
           "retry",
           "evict_disk",
@@ -4260,7 +4455,7 @@ ${JSON.stringify(slim)}
           "swap_url",
           "restore"
         ]).describe("What to do."),
-        url: import_zod18.z.string().optional().describe("Replacement URL (swap_url only).")
+        url: import_zod20.z.string().optional().describe("Replacement URL (swap_url only).")
       }
     },
     async ({ deviceId, id, action, url }) => {
@@ -4268,8 +4463,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 fail18("Device returned nothing for proveSavings.");
-          if (!savings.ok) return fail18(savings.message);
+          if (!savings) return fail2("Device returned nothing for proveSavings.");
+          if (!savings.ok) return fail2(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})`);
@@ -4281,11 +4476,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 text16(parts.join("\n"));
+          return text(parts.join("\n"));
         }
         const entry = ACTION_MAP[action];
-        if (!entry) return fail18(`Unknown action: ${action}`);
-        if (action === "swap_url" && !url) return fail18("swap_url requires the `url` param.");
+        if (!entry) return fail2(`Unknown action: ${action}`);
+        if (action === "swap_url" && !url) return fail2("swap_url requires the `url` param.");
         const result = await sync.callAction(
           IMAGES_TOOL_ID,
           entry.action,
@@ -4305,9 +4500,9 @@ ${JSON.stringify(slim)}
           );
           if (detail.error) lines.push(`Error: ${detail.error}`);
         }
-        return text16(lines.join("\n"));
+        return text(lines.join("\n"));
       } catch (e) {
-        return fail18(errMsg17(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -4316,12 +4511,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_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.")
+        deviceId: deviceIdInput,
+        network: import_zod20.z.enum(["normal", "offline", "cold"]).optional().describe("Network simulation mode."),
+        blankImages: import_zod20.z.boolean().optional().describe("Render all images without a source."),
+        massAction: import_zod20.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_zod20.z.boolean().optional().describe("Clear the captured image log."),
+        clearExpoCaches: import_zod20.z.boolean().optional().describe("Clear expo-image memory + disk caches.")
       }
     },
     async ({ deviceId, network, blankImages, massAction, clearRegistry, clearExpoCaches }) => {
@@ -4348,17 +4543,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 fail18("Pass at least one of: network, blankImages, massAction, clearRegistry, clearExpoCaches.");
-        return text16(`Applied: ${done.join(" \xB7 ")}`);
+        if (done.length === 0) return fail2("Pass at least one of: network, blankImages, massAction, clearRegistry, clearExpoCaches.");
+        return text(`Applied: ${done.join(" \xB7 ")}`);
       } catch (e) {
-        return fail18(errMsg17(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/assets.ts
-var import_zod19 = require("zod");
+var import_zod21 = require("zod");
 
 // src/tools/packs/assetsGraphNote.ts
 function graphUnavailableNote(ss) {
@@ -4373,14 +4568,11 @@ function graphUnavailableNote(ss) {
 
 // src/tools/packs/assets.ts
 var ASSETS_TOOL_ID = "assets";
-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`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(2)}MB`;
+function kb2(bytes2) {
+  if (bytes2 == null || bytes2 <= 0) return "\u2013";
+  if (bytes2 < 1024) return `${bytes2}B`;
+  if (bytes2 < 1024 * 1024) return `${(bytes2 / 1024).toFixed(1)}KB`;
+  return `${(bytes2 / (1024 * 1024)).toFixed(2)}MB`;
 }
 function sizeLabel(r) {
   if (r.sizeBytes == null) return "\u2013";
@@ -4463,10 +4655,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_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.")
+        deviceId: deviceIdInput,
+        limit: import_zod21.z.number().optional().describe("Max records to return (largest first). Default 40, max 500."),
+        kind: import_zod21.z.enum(["image", "font", "video", "audio", "data", "other"]).optional().describe("Only assets of this kind."),
+        unusedOnly: import_zod21.z.boolean().optional().describe("Only assets shipped in the bundle but never loaded at runtime.")
       }
     },
     async ({ deviceId, limit, kind, unusedOnly }) => {
@@ -4479,7 +4671,7 @@ function registerAssetsTools(server, sync) {
           { limit: unusedOnly ? 500 : capped, kind, loadedOnly: false },
           target
         );
-        if (!list) return fail19("Device returned nothing \u2014 is @buoy-gg/assets installed in the app?");
+        if (!list) return fail2("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);
         }
@@ -4503,13 +4695,13 @@ function registerAssetsTools(server, sync) {
             sizeSource: r.sizeSource
           }))
         };
-        return text17(`${md}
+        return text(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail19(errMsg18(e));
+        return fail2(errMsg2(e));
       }
     }
   );
@@ -4518,9 +4710,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_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).")
+        deviceId: deviceIdInput,
+        action: import_zod21.z.enum(["rescan", "measure_sizes", "detail", "save_baseline", "clear_baseline", "clear_records"]).describe("What to do."),
+        id: import_zod21.z.number().optional().describe("Asset id from get_assets (detail only).")
       }
     },
     async ({ deviceId, action, id }) => {
@@ -4530,19 +4722,19 @@ ${JSON.stringify(slim)}
           case "rescan": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "rescan", {}, target);
             const ss = result?.scanStatus;
-            if (!ss) return fail19("Device returned nothing for rescan.");
-            return text17(
+            if (!ss) return fail2("Device returned nothing for rescan.");
+            return text(
               `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 text17(`Measured ${result?.measured ?? 0} of ${result?.total ?? 0} assets.`);
+            return text(`Measured ${result?.measured ?? 0} of ${result?.total ?? 0} assets.`);
           }
           case "detail": {
-            if (id == null) return fail19("detail requires the `id` param (from get_assets).");
+            if (id == null) return fail2("detail requires the `id` param (from get_assets).");
             const detail = await sync.callAction(ASSETS_TOOL_ID, "getDetail", { id }, target);
-            if (!detail) return fail19(`Asset ${id} not found \u2014 re-run get_assets for current ids.`);
+            if (!detail) return fail2(`Asset ${id} not found \u2014 re-run get_assets for current ids.`);
             const lines = [
               `## ${detail.name}.${detail.type} (#${detail.id})`,
               "",
@@ -4550,8 +4742,8 @@ ${JSON.stringify(slim)}
             ];
             if (detail.width != null) lines.push(`- Dimensions: ${detail.width}\xD7${detail.height} logical \xB7 scales ${scalesLabel(detail.scales)}`);
             if (detail.sizesByScale) {
-              for (const [scale, bytes] of Object.entries(detail.sizesByScale)) {
-                lines.push(`- Size @${scale}x: ${kb2(bytes)}`);
+              for (const [scale, bytes2] of Object.entries(detail.sizesByScale)) {
+                lines.push(`- Size @${scale}x: ${kb2(bytes2)}`);
               }
             }
             if (detail.sizeBytes != null) lines.push(`- Total: ${sizeLabel(detail)}`);
@@ -4560,32 +4752,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 text17(lines.join("\n"));
+            return text(lines.join("\n"));
           }
           case "save_baseline": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "saveBaseline", {}, target);
-            return text17(
+            return text(
               `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 text17("Baseline cleared.");
+            return text("Baseline cleared.");
           }
           case "clear_records": {
             const result = await sync.callAction(ASSETS_TOOL_ID, "clearRecords", {}, target);
-            return text17(result?.message ?? "Inventory cleared.");
+            return text(result?.message ?? "Inventory cleared.");
           }
         }
       } catch (e) {
-        return fail19(errMsg18(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/reload.ts
-var import_zod20 = require("zod");
+var import_zod22 = require("zod");
 
 // src/capture/devServerReload.ts
 var import_ws = require("ws");
@@ -4648,9 +4840,6 @@ var DEFAULT_WAIT_MS = 3e4;
 var TEARDOWN_GRACE_MS = 1200;
 var PROBE_TIMEOUT_MS = 1500;
 var PROBE_INTERVAL_MS = 400;
-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 {
@@ -4689,12 +4878,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_zod20.z.enum(["auto", "dev-settings", "expo-updates"]).optional().describe(
+        strategy: import_zod22.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_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.')
+        wait: import_zod22.z.boolean().optional().describe("Wait for the app to come back before returning. Default true \u2014 turn off for fire-and-forget."),
+        timeoutMs: import_zod22.z.number().optional().describe("How long to wait for the app to reconnect, in ms. Default 30000."),
+        deviceId: import_zod22.z.string().optional().describe('Target device id (auto-selected if one is connected). Use "All" to reload every connected app.')
       }
     },
     async (args) => {
@@ -4736,39 +4925,39 @@ 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 text18(`Reload requested${via}. The app is restarting \u2014 its in-memory state is gone; re-read anything you cached.`);
+          return text(`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 fail20(
+          return fail2(
             `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 text18(
+        return text(
           `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 fail20(errMsg19(e));
+        return fail2(errMsg2(e));
       }
     }
   );
 }
 
 // src/tools/packs/triage.ts
-var import_zod21 = require("zod");
-var text19 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail21 = (message) => ({
+var import_zod23 = require("zod");
+var text6 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail8 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg20 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg7 = (e) => e instanceof Error ? e.message : String(e);
 var PROBE_TIMEOUT_MS2 = 5e3;
 var MAX_STORAGE_KEYS = 20;
 var MAX_STORAGE_VALUE = 400;
 var STORAGE_VALUE_BUDGET = 1600;
 var MAX_LINE = 160;
 var cap = (s, n = MAX_LINE) => s.length > n ? `${s.slice(0, n)}\u2026` : s;
-function hhmmss2(ts) {
+function hhmmss3(ts) {
   if (!ts) return "--:--:--";
   const d = new Date(ts);
   const p = (n) => String(n).padStart(2, "0");
@@ -4798,7 +4987,7 @@ async function section(title, run2) {
     return body ? `${title}
 ${body}` : null;
   } catch (e) {
-    const msg = errMsg20(e);
+    const msg = errMsg7(e);
     if (/not responding|timed out|got no answer/i.test(msg)) {
       return `${title}
 (no answer \u2014 see the note above)`;
@@ -4813,7 +5002,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_zod21.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        deviceId: import_zod23.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -4837,7 +5026,7 @@ function registerTriageTools(server, sync) {
               return `(none \u2014 ${entries.length} entries captured)`;
             }
             return shown.map(
-              (e) => `${hhmmss2(e.timestamp)} [${e.level === "error" ? "ERR" : "warn"}] ${cap(
+              (e) => `${hhmmss3(e.timestamp)} [${e.level === "error" ? "ERR" : "warn"}] ${cap(
                 (e.message ?? "").split("\n").map((l) => l.trim()).filter(Boolean).slice(0, 3).join(" \u23CE "),
                 220
               )}`
@@ -4920,7 +5109,7 @@ _Values: get_storage includeValues:true_`;
 
 \u{1F6D1} ${sync.unresponsiveNote(target)}` : "";
         const body = [consoleSec, netSec, storeSec, screenSec].filter(Boolean).join("\n\n");
-        return text19(
+        return text6(
           `${head}${banner}
 
 ${body}
@@ -4928,22 +5117,22 @@ ${body}
 _Drill in with get_console, get_network_requests (includeBodies:true for response bodies), get_storage (includeValues:true), describe_screen._`
         );
       } catch (e) {
-        return fail21(errMsg20(e));
+        return fail8(errMsg7(e));
       }
     }
   );
 }
 
 // src/tools/packs/flow.ts
-var import_zod22 = require("zod");
+var import_zod24 = require("zod");
 var UI_TOOL_ID = "highlight-updates";
 var APP_TOOL_ID2 = "app";
-var text20 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail22 = (message) => ({
+var text7 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail9 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg21 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg8 = (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;
@@ -4960,19 +5149,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_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).")
+var stepSchema = import_zod24.z.object({
+  tap: import_zod24.z.string().optional().describe("Tap this element: exact testID, or fuzzy visible text."),
+  longPress: import_zod24.z.boolean().optional().describe("Make `tap` a long-press instead."),
+  type: import_zod24.z.string().optional().describe("Text to type (needs `into`)."),
+  into: import_zod24.z.string().optional().describe("Target text input for `type`: testID or fuzzy text."),
+  set: import_zod24.z.union([import_zod24.z.number(), import_zod24.z.boolean()]).optional().describe("Set a toggle (true/false) or slider (number) \u2014 pair with `tap` as the target."),
+  reload: import_zod24.z.boolean().optional().describe("Reload the JS bundle before this step's action."),
+  waitMs: import_zod24.z.number().min(0).max(3e4).optional().describe("Fixed pause after the action, in ms (max 30000)."),
+  waitFor: import_zod24.z.string().optional().describe("Wait until an element matching this appears (default 5s)."),
+  waitGone: import_zod24.z.string().optional().describe("Wait until no element matches this (default 5s)."),
+  expect: import_zod24.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_zod24.z.string().optional().describe("Assert nothing matches this (waits up to 2s for it to go); fails the flow if something does."),
+  timeoutMs: import_zod24.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(
@@ -4980,10 +5169,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_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).")
+        steps: import_zod24.z.array(stepSchema).min(1).describe("Steps to run, in order."),
+        include: import_zod24.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_zod24.z.boolean().optional().describe("Keep going after a failed step instead of stopping. Default false."),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -5155,7 +5344,7 @@ function registerFlowTools(server, sync) {
               else stepErrors.push(`expected "${step.expectGone}" to be gone \u2014 still on screen`);
             }
           } catch (e) {
-            stepErrors.push(errMsg21(e));
+            stepErrors.push(errMsg8(e));
           }
           if (stepErrors.length) {
             lines.push(`${label} \u2717 ${describeStep(step)} \u2014 ${stepErrors.join("; ")}`);
@@ -5178,7 +5367,7 @@ function registerFlowTools(server, sync) {
 ${shown.map(formatElement2).join("\n")}`
             );
           } catch (e) {
-            parts.push(`**Screen now:** unavailable \u2014 ${cap2(errMsg21(e))}`);
+            parts.push(`**Screen now:** unavailable \u2014 ${cap2(errMsg8(e))}`);
           }
         }
         if (include === "all") {
@@ -5207,9 +5396,9 @@ ${shown.map(formatElement2).join("\n")}`
             }
           }
         }
-        return text20(parts.join("\n\n"));
+        return text7(parts.join("\n\n"));
       } catch (e) {
-        return fail22(errMsg21(e));
+        return fail9(errMsg8(e));
       }
     }
   );
@@ -5230,25 +5419,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_zod23 = require("zod");
+var import_zod25 = require("zod");
 var UI_TOOL_ID2 = "highlight-updates";
-var text21 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail23 = (message) => ({
+var text8 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail10 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg22 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg9 = (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_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'.")
+var stepSchema2 = import_zod25.z.object({
+  tap: import_zod25.z.string().optional().describe("Tap this element: exact testID, or fuzzy visible text."),
+  type: import_zod25.z.string().optional().describe("Text to type (needs `into`)."),
+  into: import_zod25.z.string().optional().describe("Target text input for `type`: testID or fuzzy text."),
+  waitMs: import_zod25.z.number().min(0).max(1e4).optional().describe("Pause after the action, in ms."),
+  repeat: import_zod25.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 };
@@ -5341,14 +5530,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_zod23.z.array(stepSchema2).max(20).optional().describe(
+        steps: import_zod25.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_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).")
+        idleMs: import_zod25.z.number().min(500).max(2e4).optional().describe(`Idle sample length when no steps are given. Default ${DEFAULT_IDLE_MS}.`),
+        label: import_zod25.z.string().optional().describe('Name this measurement, e.g. "before fix". Shown in the next comparison.'),
+        compareToPrevious: import_zod25.z.boolean().optional().describe("Diff against the previous measure_renders on this device. Use after an edit to prove the fix."),
+        top: import_zod25.z.number().min(1).max(40).optional().describe(`Components to list. Default ${DEFAULT_TOP}.`),
+        deviceId: deviceIdInput
       }
     },
     async (args) => {
@@ -5357,18 +5546,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 fail23(
+          return fail10(
             "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 fail23(
+          return fail10(
             "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 fail23(`Can't measure renders: ${began.reason ?? "capture unavailable"}`);
+          return fail10(`Can't measure renders: ${began.reason ?? "capture unavailable"}`);
         }
         await delay5(SETTLE_MS);
         const startedAt = Date.now();
@@ -5413,7 +5602,7 @@ function registerRenderTools(server, sync) {
         const ended = await sync.callAction(UI_TOOL_ID2, "endMeasurement", {}, target);
         const summary = ended?.summary;
         if (!summary) {
-          return fail23(
+          return fail10(
             "The capture window closed without returning anything. If the app reloaded mid-measurement, try again."
           );
         }
@@ -5438,9 +5627,9 @@ 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 text21(parts.join("\n"));
+        return text8(parts.join("\n"));
       } catch (e) {
-        return fail23(errMsg22(e));
+        return fail10(errMsg9(e));
       }
     }
   );
@@ -5724,6 +5913,7 @@ function createMcpServer(sync) {
   registerStorageTools(server, sync);
   registerRoutesTools(server, sync);
   registerConsoleTools(server, sync);
+  registerSentryTools(server, sync);
   registerTimeMachineTools(server, sync);
   registerScenariosTools(server, sync);
   registerScreenshotTools(server, sync);
@@ -5736,7 +5926,7 @@ function createMcpServer(sync) {
   return server;
 }
 var deviceIdField = {
-  deviceId: import_zod24.z.string().optional().describe(
+  deviceId: import_zod26.z.string().optional().describe(
     'Target device id (from list_devices). Omit to auto-select when exactly one device is connected. Use "All" to broadcast.'
   )
 };