@buoy-gg/mcp 7.0.4 → 7.0.6

package/dist/index.js

@@ -360,7 +360,7 @@ var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 
 // src/server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_zod15 = require("zod");
+var import_zod17 = require("zod");
 
 // src/tools/generic.ts
 var import_zod = require("zod");
@@ -371,7 +371,7 @@ var import_node_os = __toESM(require("os"));
 var import_node_path = __toESM(require("path"));
 
 // src/version.ts
-var VERSION = "7.0.4" ? "7.0.4" : "0.0.0-dev";
+var VERSION = "7.0.6" ? "7.0.6" : "0.0.0-dev";
 var PACKAGE_NAME = "@buoy-gg/mcp";
 
 // src/update/checkForUpdate.ts
@@ -1320,12 +1320,233 @@ _Showing ${res.returned} of ${res.totalAvailable} captured event(s)${more}._`;
   );
 }
 
-// src/tools/packs/reactQuery.ts
+// src/tools/packs/network.ts
 var import_zod4 = require("zod");
-var RQ_TOOL_ID = "react-query";
+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);
+function parseSnapshot(payload) {
+  if (Array.isArray(payload)) return { events: payload, saved: [] };
+  if (payload && typeof payload === "object") {
+    const shaped = payload;
+    return {
+      events: Array.isArray(shaped.events) ? shaped.events : [],
+      saved: Array.isArray(shaped.saved) ? shaped.saved : []
+    };
+  }
+  return { events: [], saved: [] };
+}
+function statusIcon(e) {
+  if (e.error) return "\u274C";
+  if (e.status === void 0) return "\u23F3";
+  if (e.status >= 400) return "\u274C";
+  if (e.status >= 300) return "\u21AA\uFE0F";
+  return "\u2705";
+}
+function statusLabel(e) {
+  if (e.error) return `ERR ${e.error}`;
+  if (e.status === void 0) return "pending";
+  return String(e.status);
+}
+function formatBytes(n) {
+  if (!n) return "";
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${Math.round(n / 1024)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}
+function matchesStatus(e, status) {
+  if (!status || status === "all") return true;
+  const failed = !!e.error || e.status !== void 0 && e.status >= 400;
+  if (status === "errors") return failed;
+  if (status === "pending") return e.status === void 0 && !e.error;
+  if (status === "success") return !failed && e.status !== void 0;
+  return true;
+}
+function truncate(v, n = 600) {
+  if (v === null || v === void 0) return "(none)";
+  const s = typeof v === "string" ? v : JSON.stringify(v);
+  return s.length > n ? `${s.slice(0, n)}\u2026(+${s.length - n} chars)` : s;
+}
+function formatRow(index, e, markers) {
+  const where = e.path || e.url;
+  const bits = [
+    `${e.duration !== void 0 ? `${Math.round(e.duration)}ms` : "\u2014"}`,
+    formatBytes(e.responseSize),
+    e.host ?? "",
+    e.requestClient ?? ""
+  ].filter(Boolean);
+  const op = e.operationName ? ` (${e.operationName})` : "";
+  return `${index}. \`${e.id}\` ${statusIcon(e)} ${statusLabel(e)} ${e.method} ${where}${op}${markers ? ` ${markers}` : ""}
+   \u2514\u2500 ${bits.join(" \xB7 ")}`;
+}
+function registerNetworkTools(server, sync) {
+  server.registerTool(
+    "get_network_requests",
+    {
+      description: "List captured HTTP requests WITH their request ids, plus which ones are pinned/saved. 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).")
+      }
+    },
+    async (args) => {
+      try {
+        const target = sync.requireProDevice(args.deviceId);
+        const { payload } = await sync.getSnapshot(NETWORK_TOOL_ID, target);
+        const { events, saved } = parseSnapshot(payload);
+        const limit = typeof args.limit === "number" && args.limit > 0 ? args.limit : 25;
+        const pattern = args.pattern?.toLowerCase();
+        const pinnedIds = /* @__PURE__ */ new Set();
+        const savedIds = /* @__PURE__ */ new Set();
+        for (const r of saved) {
+          if (r.pinned) pinnedIds.add(r.event?.id);
+          if (r.saved) savedIds.add(r.event?.id);
+          if (r.pinned) pinnedIds.add(r.liveId);
+          if (r.saved) savedIds.add(r.liveId);
+        }
+        if (args.flagged) {
+          const wanted = saved.filter(
+            (r) => args.flagged === "pinned" ? r.pinned : args.flagged === "saved" ? r.saved : r.pinned || r.saved
+          );
+          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(
+              `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.`
+            );
+          }
+          const body2 = rows2.map((r, i) => {
+            const marks = [r.pinned ? "\u{1F4CC} pinned" : "", r.saved ? "\u{1F516} saved" : ""].filter(Boolean).join(" ");
+            const stale = r.event.id?.startsWith("saved:") ? " \xB7 from an earlier app run" : "";
+            const trunc = r.bodyTruncated ? " \xB7 body truncated" : "";
+            let out = formatRow(i + 1, r.event, marks);
+            out += `
+   \u2514\u2500 key \`${r.key}\`${stale}${trunc}`;
+            if (args.includeBodies) {
+              out += `
+   \u2514\u2500 request: ${truncate(r.event.requestData)}`;
+              out += `
+   \u2514\u2500 response: ${truncate(r.event.responseData)}`;
+            }
+            return out;
+          }).join("\n");
+          return text3(
+            `**Kept requests on ${target}** \u2014 ${rows2.length} of ${wanted.length}
+
+${body2}
+
+_These are snapshots: they survive Clear, the 500-request cap and app restarts. Remove one with network_action({action:"remove", key}). Ids starting \`saved:\` are from an earlier run of the app._`
+          );
+        }
+        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 ? "The network tool has captured nothing yet (is it enabled, and has the app made a request?)." : "No request matched the filter.";
+          return text3(`No requests on ${target}. ${why}`);
+        }
+        const body = rows.map((e, i) => {
+          const marks = [pinnedIds.has(e.id) ? "\u{1F4CC}" : "", savedIds.has(e.id) ? "\u{1F516}" : ""].filter(Boolean).join("");
+          let out = formatRow(i + 1, e, marks);
+          if (args.includeBodies) {
+            out += `
+   \u2514\u2500 request: ${truncate(e.requestData)}`;
+            out += `
+   \u2514\u2500 response: ${truncate(e.responseData)}`;
+          }
+          return out;
+        }).join("\n");
+        const keptNote = saved.length > 0 ? ` \xB7 ${saved.length} kept (flagged:'any' to list)` : "";
+        return text3(
+          `**Network requests on ${target}** \u2014 ${rows.length} of ${events.length}${keptNote}
+
+${body}
+
+_\u{1F4CC} pinned \xB7 \u{1F516} saved. Act on one with its id, e.g. network_action({action:"pin", id:"${rows[0].id}"})._`
+        );
+      } catch (e) {
+        return fail4(errMsg4(e));
+      }
+    }
+  );
+  server.registerTool(
+    "network_action",
+    {
+      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).")
+      }
+    },
+    async (args) => {
+      try {
+        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.`);
+        }
+        if (args.action === "remove" && !args.key) {
+          return fail4('"remove" needs a `key` (not a request id). Get it from get_network_requests({flagged:"any"}).');
+        }
+        switch (args.action) {
+          case "pin":
+          case "unpin": {
+            const res = await sync.callAction(
+              NETWORK_TOOL_ID,
+              "setPinned",
+              { 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.`);
+            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}.`);
+          }
+          case "save":
+          case "unsave": {
+            const res = await sync.callAction(
+              NETWORK_TOOL_ID,
+              "setSaved",
+              { 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.`);
+            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}.`);
+          }
+          case "remove":
+            await sync.callAction(NETWORK_TOOL_ID, "removeSavedRecord", { key: args.key }, target);
+            return text3(`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).`);
+          case "clearSaved":
+            await sync.callAction(NETWORK_TOOL_ID, "clearSavedRequests", {}, target);
+            return text3(`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.`);
+        }
+      } catch (e) {
+        return fail4(errMsg4(e));
+      }
+    }
+  );
+}
+
+// src/tools/packs/reactQuery.ts
+var import_zod5 = require("zod");
+var RQ_TOOL_ID = "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);
 var STATUS_ICON = {
   fresh: "\u{1F7E2}",
   stale: "\u{1F7E1}",
@@ -1349,10 +1570,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_zod4.z.boolean().optional().describe("Include each query's full cached data payload (HEAVY). Default false."),
-        staleOnly: import_zod4.z.boolean().optional().describe("Only stale queries. Default false."),
-        limit: import_zod4.z.number().optional().describe("Most-recently-updated N queries. Default 25."),
-        deviceId: import_zod4.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
@@ -1365,12 +1586,12 @@ function registerReactQueryTools(server, sync) {
           target
         );
         if (!res || !Array.isArray(res.queries)) {
-          return fail4(
+          return fail5(
             "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 text3(`React Query cache is empty (0 of ${res.total} queries${args.staleOnly ? " match staleOnly" : ""}).`);
+          return text4(`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";
@@ -1383,11 +1604,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 text3(`${header}
+        return text4(`${header}
 
 ${lines.join("\n")}${note}`);
       } catch (e) {
-        return fail4(errMsg4(e));
+        return fail5(errMsg5(e));
       }
     }
   );
@@ -1396,9 +1617,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_zod4.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_zod4.z.string().optional().describe("The target query's hash (from get_react_query, shown in backticks). Required for all actions except clear."),
-        deviceId: import_zod4.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
@@ -1406,35 +1627,35 @@ ${lines.join("\n")}${note}`);
         const target = sync.requireProDevice(args.deviceId);
         if (args.action === "clear") {
           await sync.callAction(RQ_TOOL_ID, "clearQueryCache", {}, target);
-          return text3("Cleared the entire React Query cache.");
+          return text4("Cleared the entire React Query cache.");
         }
         if (!args.queryHash) {
-          return fail4(`'${args.action}' needs a queryHash. Call get_react_query first and use a row's hash (in backticks).`);
+          return fail5(`'${args.action}' needs a queryHash. Call get_react_query first and use a row's hash (in backticks).`);
         }
         await sync.callAction(RQ_TOOL_ID, args.action, { queryHash: args.queryHash }, target);
-        return text3(`Ran ${args.action} on query \`${args.queryHash}\`.`);
+        return text4(`Ran ${args.action} on query \`${args.queryHash}\`.`);
       } catch (e) {
-        return fail4(errMsg4(e));
+        return fail5(errMsg5(e));
       }
     }
   );
 }
 
 // src/tools/packs/zustand.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var ZUSTAND_TOOL_ID = "zustand";
-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);
+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_zod5.z.boolean().optional().describe("Include each store's full current state object (HEAVY). Default false (keys only)."),
-        limit: import_zod5.z.number().optional().describe("First N stores. Default all."),
-        deviceId: import_zod5.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
@@ -1447,12 +1668,12 @@ function registerZustandTools(server, sync) {
           target
         );
         if (!res || !Array.isArray(res.stores)) {
-          return fail5(
+          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 text4("No Zustand stores are registered (call watchStores to register them).");
+          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})` : ""}` : "";
@@ -1461,11 +1682,11 @@ function registerZustandTools(server, sync) {
           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 text4(`**Zustand stores \u2014 ${res.total} (showing ${res.returned}):**
+        return text5(`**Zustand stores \u2014 ${res.total} (showing ${res.returned}):**
 
 ${lines.join("\n")}${note}`);
       } catch (e) {
-        return fail5(errMsg5(e));
+        return fail6(errMsg6(e));
       }
     }
   );
@@ -1474,10 +1695,10 @@ ${lines.join("\n")}${note}`);
     {
       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_zod5.z.string().describe("Store name to target (from get_zustand_state)."),
-        state: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).describe("The new state object."),
-        replace: import_zod5.z.boolean().optional().describe("Replace the whole state (default true) or merge a partial (false)."),
-        deviceId: import_zod5.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
@@ -1489,29 +1710,29 @@ ${lines.join("\n")}${note}`);
           { storeName: args.store, state: args.state, replace: args.replace ?? true },
           target
         );
-        return text4(`Set state on Zustand store "${args.store}" (${args.replace === false ? "merged" : "replaced"}).`);
+        return text5(`Set state on Zustand store "${args.store}" (${args.replace === false ? "merged" : "replaced"}).`);
       } catch (e) {
-        return fail5(errMsg5(e));
+        return fail6(errMsg6(e));
       }
     }
   );
 }
 
 // src/tools/packs/jotai.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 var JOTAI_TOOL_ID = "jotai";
-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);
+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_zod6.z.boolean().optional().describe("Include each atom's current value (HEAVY). Default false."),
-        limit: import_zod6.z.number().optional().describe("First N atoms. 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 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).")
       }
     },
     async (args) => {
@@ -1524,12 +1745,12 @@ function registerJotaiTools(server, sync) {
           target
         );
         if (!res || !Array.isArray(res.atoms)) {
-          return fail6(
+          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 text5("No Jotai atoms are being watched (call watchAtoms to register them).");
+          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";
@@ -1538,11 +1759,11 @@ function registerJotaiTools(server, sync) {
           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 text5(`**Jotai atoms \u2014 ${res.total} (showing ${res.returned}):**
+        return text6(`**Jotai atoms \u2014 ${res.total} (showing ${res.returned}):**
 
 ${lines.join("\n")}${note}`);
       } catch (e) {
-        return fail6(errMsg6(e));
+        return fail7(errMsg7(e));
       }
     }
   );
@@ -1551,38 +1772,49 @@ ${lines.join("\n")}${note}`);
     {
       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_zod6.z.string().describe("Atom label to set (from get_jotai_state; must be writable)."),
-        value: import_zod6.z.unknown().describe("The new value (any JSON \u2014 number, string, object, etc.)."),
-        deviceId: import_zod6.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
       try {
         const target = sync.requireProDevice(args.deviceId);
         await sync.callAction(JOTAI_TOOL_ID, "setAtom", { label: args.atom, value: args.value }, target);
-        return text5(`Set Jotai atom "${args.atom}" to ${JSON.stringify(args.value)}.`);
+        return text6(`Set Jotai atom "${args.atom}" to ${JSON.stringify(args.value)}.`);
       } catch (e) {
-        return fail6(errMsg6(e));
+        return fail7(errMsg7(e));
       }
     }
   );
 }
 
 // src/tools/packs/redux.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var REDUX_TOOL_ID = "redux";
-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);
-var NO_STORE = "No instrumented Redux store found. Open the app with Buoy redux devtools active (auto-instrumentation), then retry.";
+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":
+      return "react-redux is not installed in the app \u2014 the Redux tool requires it (npm install react-redux).";
+    case "no-provider":
+      return "No Redux Provider above <FloatingDevTools />. Move <FloatingDevTools /> inside your <Provider store={store}> and retry.";
+    case "not-instrumented":
+    default:
+      return "Redux store not instrumented yet. On current Buoy versions the store binds automatically at app startup \u2014 this usually means the app is running an older @buoy-gg/core (upgrade it), or the Redux tool hasn't been opened once (older versions only). Apps can also bind explicitly with registerReduxStore(store) from @buoy-gg/redux.";
+  }
+}
+var TOP_LEVEL_ONLY_NOTE = "\n\n_Note: capture is top-level-only on this device (thunk-internal / RTK Query actions aren't recorded). Put `import '@buoy-gg/redux';` first in the app entry, or add `buoyReduxMiddleware`, for full capture._";
 function registerReduxTools(server, sync) {
   server.registerTool(
     "get_redux_state",
     {
       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_zod7.z.boolean().optional().describe("Include the full current state tree (HEAVY). Default false (slice names only)."),
-        deviceId: import_zod7.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
@@ -1595,26 +1827,29 @@ function registerReduxTools(server, sync) {
           target
         );
         if (!res) {
-          return fail7(
+          return fail8(
             "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 text6(NO_STORE);
+        if (!res.available) return fail8(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 text6(`**Redux store \u2014 slices: ${slices}**
+          return text7(
+            `**Redux store \u2014 slices: ${slices}**
 
 \`\`\`json
 ${JSON.stringify(res.state, null, 2)}
-\`\`\``);
+\`\`\`${captureNote}`
+          );
         }
-        return text6(
+        return text7(
           `**Redux store \u2014 slices: ${slices}**
 
-_Compact view. Pass includeValues:true for the full state tree. Dispatch with redux_dispatch({type, payload})._`
+_Compact view. Pass includeValues:true for the full state tree. Dispatch with redux_dispatch({type, payload})._${captureNote}`
         );
       } catch (e) {
-        return fail7(errMsg7(e));
+        return fail8(errMsg8(e));
       }
     }
   );
@@ -1623,9 +1858,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_zod7.z.string().describe('The action type, e.g. "counter/increment" or "auth/logout".'),
-        payload: import_zod7.z.unknown().optional().describe("Optional action payload (any JSON)."),
-        deviceId: import_zod7.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
@@ -1634,22 +1869,22 @@ _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 fail7(NO_STORE);
-        return text6(`Dispatched \`${args.type}\`${args.payload !== void 0 ? ` with payload ${JSON.stringify(args.payload)}` : ""}.`);
+        if (!res || !res.dispatched) return fail8(noStoreMessage(res?.reason));
+        return text7(`Dispatched \`${args.type}\`${args.payload !== void 0 ? ` with payload ${JSON.stringify(args.payload)}` : ""}.`);
       } catch (e) {
-        return fail7(errMsg7(e));
+        return fail8(errMsg8(e));
       }
     }
   );
 }
 
 // src/tools/packs/storage.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var STORAGE_TOOL_ID = "storage";
-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 truncate(v, n = 200) {
+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);
   return s.length > n ? `${s.slice(0, n)}\u2026(+${s.length - n} chars)` : s;
@@ -1660,10 +1895,10 @@ function registerStorageTools(server, sync) {
     {
       description: "Read the app's storage keys across ALL backends: AsyncStorage, MMKV (per instance), and Expo SecureStore. 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. Use for 'what's in storage / read this key'.",
       inputSchema: {
-        pattern: import_zod8.z.string().optional().describe("Only keys containing this substring (case-insensitive)."),
-        includeValues: import_zod8.z.boolean().optional().describe("Include each key's value (truncated). Default false (keys only)."),
-        limit: import_zod8.z.number().optional().describe("Max keys per backend section. Default 100."),
-        deviceId: import_zod8.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
@@ -1675,7 +1910,7 @@ function registerStorageTools(server, sync) {
         const sections = [];
         const allKeys = await sync.callAction(STORAGE_TOOL_ID, "async.getAllKeys", {}, target);
         if (!Array.isArray(allKeys)) {
-          return fail8("No storage result from the device. The storage tool may be inactive.");
+          return fail9("No storage result from the device. The storage tool may be inactive.");
         }
         const asyncKeys = allKeys.filter(matches).slice(0, limit);
         if (asyncKeys.length > 0) {
@@ -1683,7 +1918,7 @@ function registerStorageTools(server, sync) {
           if (args.includeValues) {
             const pairs = await sync.callAction(STORAGE_TOOL_ID, "async.multiGet", { keys: asyncKeys }, target);
             const map = new Map((pairs ?? []).map(([k, v]) => [k, v]));
-            lines = asyncKeys.map((k) => `- \`${k}\` = ${truncate(map.get(k) ?? null)}`);
+            lines = asyncKeys.map((k) => `- \`${k}\` = ${truncate2(map.get(k) ?? null)}`);
           } else {
             lines = asyncKeys.map((k) => `- \`${k}\``);
           }
@@ -1695,7 +1930,7 @@ ${lines.join("\n")}`);
           const entries = inst.entries.filter((e) => matches(e.key)).slice(0, limit);
           if (entries.length === 0) continue;
           const lines = entries.map(
-            (e) => args.includeValues ? `- \`${e.key}\` (${e.valueType}) = ${truncate(e.value)}` : `- \`${e.key}\``
+            (e) => args.includeValues ? `- \`${e.key}\` (${e.valueType}) = ${truncate2(e.value)}` : `- \`${e.key}\``
           );
           const flags = [inst.encrypted && "encrypted", inst.readOnly && "read-only"].filter(Boolean).join(", ");
           sections.push(`**MMKV \`${inst.id}\`${flags ? ` (${flags})` : ""} (${entries.length}/${inst.entries.length} keys):**
@@ -1709,19 +1944,19 @@ ${lines.join("\n")}`);
               if (d.requireAuthentication) return `- \`${d.key}\` \u{1F512} (biometric-protected \u2014 not read)`;
               if (!args.includeValues) return `- \`${d.key}\``;
               const v = await sync.callAction(STORAGE_TOOL_ID, "secure.get", { key: d.key }, target).catch(() => null);
-              return `- \`${d.key}\` = ${truncate(v)}`;
+              return `- \`${d.key}\` = ${truncate2(v)}`;
             })
           );
           sections.push(`**SecureStore (${secureKeys.length} registered keys):**
 ${lines.join("\n")}`);
         }
         if (sections.length === 0) {
-          return text7(`No storage keys${pattern ? ` matching "${args.pattern}"` : ""} in any backend.`);
+          return text8(`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 text7(`${sections.join("\n\n")}${note}`);
+        return text8(`${sections.join("\n\n")}${note}`);
       } catch (e) {
-        return fail8(errMsg8(e));
+        return fail9(errMsg9(e));
       }
     }
   );
@@ -1730,10 +1965,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_zod8.z.enum(["set", "remove", "clear"]).describe("set/remove a key, or clear all app storage."),
-        key: import_zod8.z.string().optional().describe("The key (required for set and remove)."),
-        value: import_zod8.z.string().optional().describe("The string value to store (required for set; JSON-encode objects)."),
-        deviceId: import_zod8.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
@@ -1741,33 +1976,33 @@ ${lines.join("\n")}`);
         const target = sync.requireProDevice(args.deviceId);
         if (args.action === "clear") {
           await sync.callAction(STORAGE_TOOL_ID, "clearAppStorage", {}, target);
-          return text7("Cleared all app storage (Buoy's own devtool keys preserved).");
+          return text8("Cleared all app storage (Buoy's own devtool keys preserved).");
         }
         if (!args.key) {
-          return fail8(`'${args.action}' needs a key.`);
+          return fail9(`'${args.action}' needs a key.`);
         }
         if (args.action === "remove") {
           await sync.callAction(STORAGE_TOOL_ID, "async.removeItem", { key: args.key }, target);
-          return text7(`Removed storage key "${args.key}".`);
+          return text8(`Removed storage key "${args.key}".`);
         }
         if (args.value === void 0) {
-          return fail8("'set' needs a value (a string).");
+          return fail9("'set' needs a value (a string).");
         }
         await sync.callAction(STORAGE_TOOL_ID, "async.setItem", { key: args.key, value: args.value }, target);
-        return text7(`Set storage key "${args.key}".`);
+        return text8(`Set storage key "${args.key}".`);
       } catch (e) {
-        return fail8(errMsg8(e));
+        return fail9(errMsg9(e));
       }
     }
   );
 }
 
 // src/tools/packs/routes.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var ROUTES_TOOL_ID = "route-events";
-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);
+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);
@@ -1781,8 +2016,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_zod9.z.boolean().optional().describe("Also list all defined route paths (can be long). Default false."),
-        deviceId: import_zod9.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
@@ -1815,9 +2050,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 text8(parts.join("\n"));
+        return text9(parts.join("\n"));
       } catch (e) {
-        return fail9(errMsg9(e));
+        return fail10(errMsg10(e));
       }
     }
   );
@@ -1826,28 +2061,28 @@ ${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.",
       inputSchema: {
-        path: import_zod9.z.string().describe("The concrete path to navigate to, e.g. '/pokemon/25'."),
-        deviceId: import_zod9.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        path: import_zod10.z.string().describe("The concrete path to navigate to, e.g. '/pokemon/25'."),
+        deviceId: import_zod10.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(ROUTES_TOOL_ID, "navigate", { path: args.path }, target);
-        return text8(`Navigated to \`${args.path}\`.`);
+        return text9(`Navigated to \`${args.path}\`.`);
       } catch (e) {
-        return fail9(errMsg9(e));
+        return fail10(errMsg10(e));
       }
     }
   );
 }
 
 // src/tools/packs/console.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var CONSOLE_TOOL_ID = "console";
-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);
+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) {
@@ -1861,10 +2096,10 @@ 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. 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. Use for 'what's logging / any console errors'. For full args/stack of an entry, fall back to get_snapshot('console').",
       inputSchema: {
-        level: import_zod10.z.enum(["verbose", "info", "warning", "error"]).optional().describe("Minimum level to include (severity threshold). e.g. 'warning' = warnings + errors. Default all."),
-        limit: import_zod10.z.number().optional().describe("Most-recent N entries. Default 50."),
-        pattern: import_zod10.z.string().optional().describe("Only entries whose message contains this substring (case-insensitive)."),
-        deviceId: import_zod10.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        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).")
       }
     },
     async (args) => {
@@ -1882,12 +2117,12 @@ function registerConsoleTools(server, sync) {
         const limit = typeof args.limit === "number" && args.limit > 0 ? args.limit : 50;
         const shown = sorted.slice(-limit);
         if (shown.length === 0) {
-          return text9(`No console entries${args.level ? ` at level \u2265 ${args.level}` : ""}${pattern ? ` matching "${args.pattern}"` : ""} (${all.length} total captured).`);
+          return text10(`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 text9(`${header}
+        return text10(`${header}
 
 \`\`\`
 ${lines.join("\n")}
@@ -1895,14 +2130,14 @@ ${lines.join("\n")}
 
 _Tail of recent logs. Use get_snapshot('console') for full args/stacks._`);
       } catch (e) {
-        return fail10(errMsg10(e));
+        return fail11(errMsg11(e));
       }
     }
   );
 }
 
 // src/tools/packs/screenshot.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 
 // src/capture/simctl.ts
 var import_node_child_process = require("child_process");
@@ -1982,8 +2217,8 @@ async function cropToBuffer(srcPath, full, region) {
 var TOOL_ID = "highlight-updates";
 var MARGIN_PT = 12;
 var CAPTURE_PADDING_PT = 6;
-var fail11 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg11 = (e) => e instanceof Error ? e.message : String(e);
+var fail12 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg12 = (e) => e instanceof Error ? e.message : String(e);
 function reasonMessage(res, query) {
   switch (res.reason) {
     case "no-renders":
@@ -2013,10 +2248,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. The component must have rendered at least once since the app opened for it to be trackable \u2014 if nothing matches, navigate to the screen that renders it and retry. iOS Simulator only, and the MCP server must be running on the same Mac as the booted Simulator (uses `xcrun simctl` + `sips`). Requires Buoy Pro.",
       inputSchema: {
-        query: import_zod11.z.string().optional().describe('Fuzzy match against testID, nativeID, accessibilityLabel, component name, or view type \u2014 e.g. "submit-button".'),
-        nativeTag: import_zod11.z.number().optional().describe("An exact nativeTag (from a previous call's candidates) to skip fuzzy matching."),
-        scrollIntoView: import_zod11.z.boolean().optional().describe("Scroll the component into view before capturing, if it's off-screen. Default true."),
-        deviceId: import_zod11.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        query: import_zod12.z.string().optional().describe('Fuzzy match against testID, nativeID, accessibilityLabel, component name, or view type \u2014 e.g. "submit-button".'),
+        nativeTag: import_zod12.z.number().optional().describe("An exact nativeTag (from a previous call's candidates) to skip fuzzy matching."),
+        scrollIntoView: import_zod12.z.boolean().optional().describe("Scroll the component into view before capturing, if it's off-screen. Default true."),
+        deviceId: import_zod12.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -2036,11 +2271,11 @@ function registerScreenshotTools(server, sync) {
           target
         );
         if (!res.matched || !res.rect || !res.screen) {
-          return fail11(reasonMessage(res, args.query) + candidatesText(res.candidates));
+          return fail12(reasonMessage(res, args.query) + candidatesText(res.candidates));
         }
         const shot = await captureIosFramebuffer();
         if (!shot.ok || !shot.srcPath || !shot.width || !shot.height) {
-          return fail11(shot.error ?? "Screenshot capture failed.");
+          return fail12(shot.error ?? "Screenshot capture failed.");
         }
         const pxScale = shot.width / res.screen.width;
         const r = res.rect;
@@ -2056,7 +2291,7 @@ function registerScreenshotTools(server, sync) {
           }
         );
         if (!crop.ok || !crop.buffer) {
-          return fail11(crop.error ?? "Crop failed.");
+          return fail12(crop.error ?? "Crop failed.");
         }
         const label = res.componentName || "component";
         const idPart = res.testID ? ` (testID: "${res.testID}")` : "";
@@ -2069,21 +2304,21 @@ function registerScreenshotTools(server, sync) {
           ]
         };
       } catch (e) {
-        return fail11(errMsg11(e));
+        return fail12(errMsg12(e));
       }
     }
   );
 }
 
 // src/tools/packs/interact.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var TOOL_ID2 = "highlight-updates";
-var text10 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail12 = (message) => ({
+var text11 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail13 = (message) => ({
   isError: true,
   content: [{ type: "text", text: message }]
 });
-var errMsg12 = (e) => e instanceof Error ? e.message : String(e);
+var errMsg13 = (e) => e instanceof Error ? e.message : String(e);
 function formatElement(e) {
   let line = e.interactive ? "\u2022 " : "  ";
   line += e.name;
@@ -2091,6 +2326,7 @@ function formatElement(e) {
   if (display) line += ` "${display}"`;
   if (e.role) line += ` <${e.role}>`;
   if (e.control) line += ` {${e.control}${e.value !== void 0 ? `=${JSON.stringify(e.value)}` : ""}}`;
+  if (e.longPressable) line += " {long-press}";
   if (e.testID) line += ` [testID=${e.testID}]`;
   if (e.tap) line += ` (tap: ${e.tap.x},${e.tap.y})`;
   if (e.nativeTag != null) line += ` #${e.nativeTag}`;
@@ -2102,8 +2338,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. Re-run after navigating or when the screen changes, since positions move. Requires Buoy Pro.",
       inputSchema: {
-        interactiveOnly: import_zod12.z.boolean().optional().describe("Only return tappable (onPress) elements. Default false (include labels/text for context)."),
-        deviceId: import_zod12.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        interactiveOnly: import_zod13.z.boolean().optional().describe("Only return tappable (onPress) elements. Default false (include labels/text for context)."),
+        deviceId: import_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
@@ -2113,37 +2349,38 @@ function registerInteractTools(server, sync) {
         const all = res?.elements ?? [];
         const elements = args.interactiveOnly ? all.filter((e) => e.interactive) : all;
         if (elements.length === 0) {
-          return text10(
+          return text11(
             "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 text10(`${header}
+        return text11(`${header}
 
 ${elements.map(formatElement).join("\n")}`);
       } catch (e) {
-        return fail12(errMsg12(e));
+        return fail13(errMsg13(e));
       }
     }
   );
   server.registerTool(
     "tap_element",
     {
-      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), 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`. 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. Requires Buoy Pro.",
+      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. Requires Buoy Pro.",
       inputSchema: {
-        nativeTag: import_zod12.z.number().optional().describe("Exact nativeTag from describe_screen (most precise)."),
-        testID: import_zod12.z.string().optional().describe("Exact testID of the element."),
-        query: import_zod12.z.string().optional().describe('Fuzzy match against testID / label / visible text / component name \u2014 e.g. "Sign in".'),
-        value: import_zod12.z.union([import_zod12.z.number(), import_zod12.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_zod12.z.string().optional().describe("For a text input: the string to set via onChangeText."),
-        scrollIntoView: import_zod12.z.boolean().optional().describe("Scroll the target into view first if it's off-screen. Default true."),
-        deviceId: import_zod12.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        nativeTag: import_zod13.z.number().optional().describe("Exact nativeTag from describe_screen (most precise)."),
+        testID: import_zod13.z.string().optional().describe("Exact testID of the element."),
+        query: import_zod13.z.string().optional().describe('Fuzzy match against testID / label / visible text / component name \u2014 e.g. "Sign in".'),
+        value: import_zod13.z.union([import_zod13.z.number(), import_zod13.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_zod13.z.string().optional().describe("For a text input: the string to set via onChangeText."),
+        longPress: import_zod13.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_zod13.z.boolean().optional().describe("Scroll the target into view first if it's off-screen. Default true."),
+        deviceId: import_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async (args) => {
       try {
         if (args.nativeTag == null && !args.testID && !args.query) {
-          return fail12("Provide one of: nativeTag, testID, or query (from describe_screen).");
+          return fail13("Provide one of: nativeTag, testID, or query (from describe_screen).");
         }
         const target = sync.requireProDevice(args.deviceId);
         const res = await sync.callAction(
@@ -2155,6 +2392,7 @@ ${elements.map(formatElement).join("\n")}`);
             query: args.query,
             value: args.value,
             text: args.text,
+            longPress: args.longPress,
             scrollIntoView: args.scrollIntoView
           },
           target
@@ -2164,27 +2402,27 @@ ${elements.map(formatElement).join("\n")}`);
           const label = m.text ?? m.label ?? m.name;
           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}` : `Tapped "${label}"${id}${m.via === "onLongPress" ? " (via onLongPress)" : ""}`;
-          return text10(`${verb}${scrolledNote}.`);
+          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 text11(`${verb}${scrolledNote}.`);
         }
         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 fail12(msg);
+        return fail13(msg);
       } catch (e) {
-        return fail12(errMsg12(e));
+        return fail13(errMsg13(e));
       }
     }
   );
 }
 
 // src/tools/packs/jsThread.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var JS_TOP_TOOL_ID = "js-top";
-var text11 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail13 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg13 = (e) => e instanceof Error ? e.message : String(e);
+var text12 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail14 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg14 = (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);
@@ -2255,9 +2493,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. Requires @buoy-gg/js-top on the device.",
       inputSchema: {
-        deviceId: import_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        durationMs: import_zod13.z.number().optional().describe("How long to sample before reading the table. Default 3000, max 30000."),
-        clearFirst: import_zod13.z.boolean().optional().describe("Reset all stats before sampling, so the result attributes only what happens during this sample.")
+        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        durationMs: import_zod14.z.number().optional().describe("How long to sample before reading the table. Default 3000, max 30000."),
+        clearFirst: import_zod14.z.boolean().optional().describe("Reset all stats before sampling, so the result attributes only what happens during this sample.")
       }
     },
     async ({ deviceId, durationMs, clearFirst }) => {
@@ -2270,7 +2508,7 @@ function registerJsThreadTools(server, sync) {
           { durationMs: duration, clearFirst: clearFirst === true },
           target
         );
-        if (!snap) return fail13("Device returned no snapshot \u2014 is @buoy-gg/js-top installed in the app?");
+        if (!snap) return fail14("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,
@@ -2289,13 +2527,13 @@ function registerJsThreadTools(server, sync) {
             worstFreezeMs: r.worstFreezeMs
           }))
         };
-        return text11(`${md}
+        return text12(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail13(errMsg13(e));
+        return fail14(errMsg14(e));
       }
     }
   );
@@ -2304,8 +2542,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_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        key: import_zod13.z.string().describe("Origin key from get_js_thread_top's JSON rows.")
+        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        key: import_zod14.z.string().describe("Origin key from get_js_thread_top's JSON rows.")
       }
     },
     async ({ deviceId, key }) => {
@@ -2318,18 +2556,18 @@ ${JSON.stringify(slim)}
           target
         );
         if (!detail) {
-          return fail13(
+          return fail14(
             `Origin "${key}" is not tracked (cleared, evicted, or never existed). Re-run get_js_thread_top for current keys.`
           );
         }
         const md = formatDetailMarkdown(detail);
-        return text11(`${md}
+        return text12(`${md}
 
 \`\`\`json
 ${JSON.stringify(detail)}
 \`\`\``);
       } catch (e) {
-        return fail13(errMsg13(e));
+        return fail14(errMsg14(e));
       }
     }
   );
@@ -2338,27 +2576,27 @@ ${JSON.stringify(detail)}
     {
       description: "Reset the js-top task table, freeze history, and busy history on the device (fresh measurement window).",
       inputSchema: {
-        deviceId: import_zod13.z.string().optional().describe("Target device id (auto-selected if one is connected).")
+        deviceId: import_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected).")
       }
     },
     async ({ deviceId }) => {
       try {
         const target = sync.requireProDevice(deviceId);
         await sync.callAction(JS_TOP_TOOL_ID, "clear", {}, target);
-        return text11("Cleared js-top stats.");
+        return text12("Cleared js-top stats.");
       } catch (e) {
-        return fail13(errMsg13(e));
+        return fail14(errMsg14(e));
       }
     }
   );
 }
 
 // src/tools/packs/images.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 var IMAGES_TOOL_ID = "images";
-var text12 = (s) => ({ content: [{ type: "text", text: s }] });
-var fail14 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
-var errMsg14 = (e) => e instanceof Error ? e.message : String(e);
+var text13 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail15 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg15 = (e) => e instanceof Error ? e.message : String(e);
 function uriTail(uri) {
   if (!uri) return "(no source)";
   const unstable = uri.match(/[?&]unstable_path=([^&?]+)/);
@@ -2446,9 +2684,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_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        limit: import_zod14.z.number().optional().describe("Max records to return (newest first). Default 30, max 200."),
-        status: import_zod14.z.enum(["pending", "loading", "loaded", "error"]).optional().describe("Only records in this state (e.g. 'error' for the failure log).")
+        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        limit: import_zod15.z.number().optional().describe("Max records to return (newest first). Default 30, max 200."),
+        status: import_zod15.z.enum(["pending", "loading", "loaded", "error"]).optional().describe("Only records in this state (e.g. 'error' for the failure log).")
       }
     },
     async ({ deviceId, limit, status }) => {
@@ -2461,7 +2699,7 @@ function registerImagesTools(server, sync) {
           { limit: capped, status },
           target
         );
-        if (!list) return fail14("Device returned nothing \u2014 is @buoy-gg/images installed in the app?");
+        if (!list) return fail15("Device returned nothing \u2014 is @buoy-gg/images installed in the app?");
         const md = formatListMarkdown(list, capped);
         const slim = {
           stats: list.stats,
@@ -2486,13 +2724,13 @@ function registerImagesTools(server, sync) {
             loadCount: r.loadCount
           }))
         };
-        return text12(`${md}
+        return text13(`${md}
 
 \`\`\`json
 ${JSON.stringify(slim)}
 \`\`\``);
       } catch (e) {
-        return fail14(errMsg14(e));
+        return fail15(errMsg15(e));
       }
     }
   );
@@ -2501,9 +2739,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_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        id: import_zod14.z.number().describe("Record id from get_images."),
-        action: import_zod14.z.enum([
+        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        id: import_zod15.z.number().describe("Record id from get_images."),
+        action: import_zod15.z.enum([
           "hard_reload",
           "retry",
           "evict_disk",
@@ -2515,7 +2753,7 @@ ${JSON.stringify(slim)}
           "swap_url",
           "restore"
         ]).describe("What to do."),
-        url: import_zod14.z.string().optional().describe("Replacement URL (swap_url only).")
+        url: import_zod15.z.string().optional().describe("Replacement URL (swap_url only).")
       }
     },
     async ({ deviceId, id, action, url }) => {
@@ -2523,8 +2761,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 fail14("Device returned nothing for proveSavings.");
-          if (!savings.ok) return fail14(savings.message);
+          if (!savings) return fail15("Device returned nothing for proveSavings.");
+          if (!savings.ok) return fail15(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})`);
@@ -2536,11 +2774,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 text12(parts.join("\n"));
+          return text13(parts.join("\n"));
         }
         const entry = ACTION_MAP[action];
-        if (!entry) return fail14(`Unknown action: ${action}`);
-        if (action === "swap_url" && !url) return fail14("swap_url requires the `url` param.");
+        if (!entry) return fail15(`Unknown action: ${action}`);
+        if (action === "swap_url" && !url) return fail15("swap_url requires the `url` param.");
         const result = await sync.callAction(
           IMAGES_TOOL_ID,
           entry.action,
@@ -2560,9 +2798,9 @@ ${JSON.stringify(slim)}
           );
           if (detail.error) lines.push(`Error: ${detail.error}`);
         }
-        return text12(lines.join("\n"));
+        return text13(lines.join("\n"));
       } catch (e) {
-        return fail14(errMsg14(e));
+        return fail15(errMsg15(e));
       }
     }
   );
@@ -2571,12 +2809,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_zod14.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
-        network: import_zod14.z.enum(["normal", "offline", "cold"]).optional().describe("Network simulation mode."),
-        blankImages: import_zod14.z.boolean().optional().describe("Render all images without a source."),
-        massAction: import_zod14.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_zod14.z.boolean().optional().describe("Clear the captured image log."),
-        clearExpoCaches: import_zod14.z.boolean().optional().describe("Clear expo-image memory + disk caches.")
+        deviceId: import_zod15.z.string().optional().describe("Target device id (auto-selected if one is connected)."),
+        network: import_zod15.z.enum(["normal", "offline", "cold"]).optional().describe("Network simulation mode."),
+        blankImages: import_zod15.z.boolean().optional().describe("Render all images without a source."),
+        massAction: import_zod15.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_zod15.z.boolean().optional().describe("Clear the captured image log."),
+        clearExpoCaches: import_zod15.z.boolean().optional().describe("Clear expo-image memory + disk caches.")
       }
     },
     async ({ deviceId, network, blankImages, massAction, clearRegistry, clearExpoCaches }) => {
@@ -2603,10 +2841,94 @@ ${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 fail14("Pass at least one of: network, blankImages, massAction, clearRegistry, clearExpoCaches.");
-        return text12(`Applied: ${done.join(" \xB7 ")}`);
+        if (done.length === 0) return fail15("Pass at least one of: network, blankImages, massAction, clearRegistry, clearExpoCaches.");
+        return text13(`Applied: ${done.join(" \xB7 ")}`);
       } catch (e) {
-        return fail14(errMsg14(e));
+        return fail15(errMsg15(e));
+      }
+    }
+  );
+}
+
+// src/tools/packs/reload.ts
+var import_zod16 = require("zod");
+var APP_TOOL_ID = "app";
+var RELOAD_ACTION = "reloadApp";
+var DEFAULT_WAIT_MS = 3e4;
+var TEARDOWN_GRACE_MS = 1200;
+var PROBE_TIMEOUT_MS = 1500;
+var PROBE_INTERVAL_MS = 400;
+var text14 = (s) => ({ content: [{ type: "text", text: s }] });
+var fail16 = (message) => ({ isError: true, content: [{ type: "text", text: message }] });
+var errMsg16 = (e) => e instanceof Error ? e.message : String(e);
+var delay3 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function ping(sync, deviceId, timeoutMs) {
+  try {
+    const pong = await sync.callAction(APP_TOOL_ID, "ping", {}, deviceId, { timeoutMs });
+    return typeof pong?.startedAt === "number" ? pong.startedAt : null;
+  } catch {
+    return null;
+  }
+}
+function assertReloadSupported(sync, deviceId) {
+  if (deviceId === ALL_DEVICES) return;
+  const entry = sync.toolActions(APP_TOOL_ID).find((t) => t.deviceId === deviceId);
+  if (!entry?.actions.includes(RELOAD_ACTION)) {
+    throw new Error(
+      `This app doesn't expose remote reload \u2014 its @buoy-gg/core is too old. Upgrade @buoy-gg/core, then reload the app once by hand.`
+    );
+  }
+}
+async function waitForAppBack(sync, deviceId, timeoutMs, previousRealm) {
+  const waitStart = Date.now();
+  await delay3(TEARDOWN_GRACE_MS);
+  while (Date.now() - waitStart < timeoutMs) {
+    const realm = await ping(sync, deviceId, PROBE_TIMEOUT_MS);
+    if (realm !== null && realm !== previousRealm) return Date.now() - waitStart;
+    await delay3(PROBE_INTERVAL_MS);
+  }
+  return null;
+}
+function registerReloadTools(server, sync) {
+  server.registerTool(
+    "reload_app",
+    {
+      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, or to re-run app startup. 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. 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_zod16.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_zod16.z.boolean().optional().describe("Wait for the app to come back before returning. Default true \u2014 turn off for fire-and-forget."),
+        timeoutMs: import_zod16.z.number().optional().describe("How long to wait for the app to reconnect, in ms. Default 30000."),
+        deviceId: import_zod16.z.string().optional().describe('Target device id (auto-selected if one is connected). Use "All" to reload every connected app.')
+      }
+    },
+    async (args) => {
+      try {
+        const target = sync.requireProDevice(args.deviceId);
+        assertReloadSupported(sync, target);
+        const previousRealm = args.wait === false ? null : await ping(sync, target, PROBE_TIMEOUT_MS);
+        const ack = await sync.callAction(
+          APP_TOOL_ID,
+          RELOAD_ACTION,
+          { strategy: args.strategy ?? "auto" },
+          target
+        );
+        const via = ack?.strategy ? ` via ${ack.strategy}` : "";
+        if (args.wait === false) {
+          return text14(`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 fail16(
+            `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 text14(
+          `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 fail16(errMsg16(e));
       }
     }
   );
@@ -2625,6 +2947,13 @@ filter (e.g. sources:["network"] to list HTTP requests). It's the universal, tok
 activity reader across ALL tools and is compact by default \u2014 reach for it before reading source
 code, and prefer it over \`get_snapshot\` for any "what happened / show me the requests" question.
 
+Working on ONE HTTP request rather than skimming activity? \`get_events\` deliberately emits no
+request ids, so use \`get_network_requests\` \u2014 same compact style, but it leads with the id every
+network action is keyed by, and marks which requests are pinned/saved. \`flagged:'any'\` lists the
+requests the DEVELOPER kept: 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". \`network_action\`
+pins/saves one \u2014 pin the failing call you want a human to see, or keep one before the log rolls over.
+
 Need to SEE a component (verify a UI change, check styling/layout)? Use \`screenshot_component\` with
 a testID/name \u2014 it locates the live component on-device and returns a cropped screenshot inline.
 iOS Simulator only, and only works when this MCP server runs on the same Mac as the booted Simulator.
@@ -2643,6 +2972,11 @@ Debugging images (not loading, slow, stale cache, memory)? \`get_images\` lists
 expo-image load with cache verdicts and oversize audits; \`image_action\` reloads, retries, or
 simulates failures per image; \`set_image_simulation\` flips app-wide offline/cold/blank modes.
 
+Need the app RESTARTED (a change Fast Refresh didn't pick up, leaked in-memory state before a
+measurement, re-running startup)? \`reload_app\` reloads the JS bundle \u2014 DevSettings.reload() in dev
+builds, expo-updates otherwise \u2014 and waits for the app to reconnect. It wipes in-memory state, so
+re-read anything you cached.
+
 For everything else:
 - \`list_tool_actions\` to see what a tool can do,
 - \`get_snapshot\` ONLY when you need a tool's full current state (returns raw, heavy payloads),
@@ -2662,6 +2996,7 @@ function createMcpServer(sync) {
   registerGenericTools(server, sync);
   registerPerfMonitorTools(server, sync);
   registerEventsTools(server, sync);
+  registerNetworkTools(server, sync);
   registerReactQueryTools(server, sync);
   registerZustandTools(server, sync);
   registerJotaiTools(server, sync);
@@ -2673,10 +3008,11 @@ function createMcpServer(sync) {
   registerInteractTools(server, sync);
   registerJsThreadTools(server, sync);
   registerImagesTools(server, sync);
+  registerReloadTools(server, sync);
   return server;
 }
 var deviceIdField = {
-  deviceId: import_zod15.z.string().optional().describe(
+  deviceId: import_zod17.z.string().optional().describe(
     'Target device id (from list_devices). Omit to auto-select when exactly one device is connected. Use "All" to broadcast.'
   )
 };
@@ -2687,7 +3023,7 @@ var import_node_fs3 = __toESM(require("fs"));
 var import_node_os3 = __toESM(require("os"));
 var import_node_path3 = __toESM(require("path"));
 var PUBLIC_REGISTRY = "https://registry.npmjs.org";
-var PROBE_TIMEOUT_MS = 3e3;
+var PROBE_TIMEOUT_MS2 = 3e3;
 function runInit(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const skillSrcDir = opts.skillSrcDir ?? import_node_path3.default.resolve(__dirname, "../skill");
@@ -2800,7 +3136,7 @@ function effectiveRegistry() {
 }
 function npmConfigGet(key) {
   const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-  const res = (0, import_node_child_process2.spawnSync)(npm, ["config", "get", key], { encoding: "utf8", timeout: PROBE_TIMEOUT_MS });
+  const res = (0, import_node_child_process2.spawnSync)(npm, ["config", "get", key], { encoding: "utf8", timeout: PROBE_TIMEOUT_MS2 });
   if (res.status !== 0 || typeof res.stdout !== "string") return null;
   const val = res.stdout.trim();
   if (!val || val === "undefined" || val === "null") return null;
@@ -2809,8 +3145,8 @@ function npmConfigGet(key) {
 function hostReachable(registry) {
   const done = (0, import_node_child_process2.spawnSync)(
     process.execPath,
-    ["-e", REACHABILITY_PROBE, registry, String(PROBE_TIMEOUT_MS)],
-    { encoding: "utf8", timeout: PROBE_TIMEOUT_MS + 2e3 }
+    ["-e", REACHABILITY_PROBE, registry, String(PROBE_TIMEOUT_MS2)],
+    { encoding: "utf8", timeout: PROBE_TIMEOUT_MS2 + 2e3 }
   );
   return done.status === 0;
 }