@buoy-gg/core 7.0.30 → 7.0.31

package/lib/commonjs/floatingMenu/AppHost.js

@@ -346,6 +346,7 @@ const AppOverlay = () => {
   } = useAppHost();
   const {
     minimize: addToMinimizedStack,
+    restore: removeFromMinimizedStack,
     getNextIconPosition,
     minimizedTools
   } = (0, _MinimizedToolsContext.useMinimizedTools)();
@@ -378,7 +379,30 @@ const AppOverlay = () => {
         }
       }
     });
-  }, [openApps, minimizedTools, addToMinimizedStack]);
+
+    // ...and take out anything the rail is still showing that is no longer
+    // minimized, or no longer open at all.
+    //
+    // WHY THIS HALF EXISTS. `openApps` and the rail are two separate stores
+    // for one fact, and only the ADD side was reliable. Minimizing goes
+    // through an event handler; un-minimizing happens inside `open`, which
+    // schedules the rail removal with a `setTimeout` from INSIDE a
+    // `setOpenApps` updater. Updaters are not a safe place for side effects —
+    // React may double-invoke or discard them — so the removal could be
+    // skipped while `minimized: false` still landed. The rail then kept an
+    // icon for an already-open tool, and tapping it did nothing except delete
+    // the icon: the tool looked like it vanished, with no way back to it, and
+    // both stores are persisted so it survived every reload.
+    //
+    // Reconciling here makes the rail eventually consistent with `openApps`
+    // whichever way the state moved, without moving the side effect.
+    minimizedTools.forEach(tool => {
+      const app = openApps.find(a => a.instanceId === tool.instanceId);
+      if (!app || !app.minimized) {
+        removeFromMinimizedStack(tool.instanceId);
+      }
+    });
+  }, [openApps, minimizedTools, addToMinimizedStack, removeFromMinimizedStack]);
 
   // Filter to renderable apps (exclude toggle-only)
   const renderableApps = openApps.filter(app => app.launchMode !== "toggle-only");

package/lib/commonjs/floatingMenu/DevToolsSettingsModal.js

@@ -968,13 +968,13 @@ const styles = _reactNative.StyleSheet.create({
     // Transparent so JsModal's night star field shows through everything.
     backgroundColor: "transparent"
   },
-  // Header — the segmented control, inset so it clears the absolutely
-  // positioned window controls on the right.
+  // Header — the segmented control. The window controls are cleared
+  // vertically by JsModal's drag-indicator strip, so this runs full width.
   headerRow: {
     flexDirection: "row",
     alignItems: "center",
     paddingLeft: _sharedUi.night.gutter,
-    paddingRight: 64,
+    paddingRight: _sharedUi.night.gutter,
     paddingBottom: 8
   },
   // Scroll content — labeled groups on a 24pt rhythm (Everlights create screen)

package/lib/commonjs/floatingMenu/DevToolsSettingsModal.web.js

@@ -794,8 +794,8 @@ function SettingsModal({
       display: 'flex',
       alignItems: 'center',
       paddingLeft: 16,
-      paddingRight: 64,
-      // clears JsModal's absolutely-positioned window controls
+      paddingRight: 16,
+      // window controls are cleared vertically, not sideways
       paddingBottom: 8
     },
     children: /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {

package/lib/commonjs/floatingMenu/FloatingDevTools.js

@@ -8,6 +8,7 @@ var _react = _interopRequireWildcard(require("react"));
 var _reactNative = require("react-native");
 var _AppHost = require("./AppHost");
 var _FloatingMenu = require("./FloatingMenu.js");
+var _ToolOpenerBridge = require("./ToolOpenerBridge.js");
 var _autoDiscoverPresets = require("./autoDiscoverPresets.js");
 var _installPing = require("../telemetry/installPing.js");
 var _Buoy = require("../Buoy.js");
@@ -336,6 +337,23 @@ const FloatingDevTools = ({
     }
   }, []);
 
+  // Check if react-query is installed and auto-render the ReactQueryTracker.
+  // Without it the event store has no QueryClient unless someone opens the
+  // React Query TOOL, so every other consumer of those events — the Events
+  // timeline most visibly — sits at a confident zero forever.
+  const ReactQueryTracker = (0, _react.useMemo)(() => {
+    try {
+      // @ts-ignore - Dynamic import that may not exist
+      const {
+        ReactQueryTracker: Tracker
+      } = require("@buoy-gg/react-query");
+      return Tracker;
+    } catch (e) {
+      (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/react-query", e);
+      return null;
+    }
+  }, []);
+
   // Check if impersonate is installed and auto-render the floating banner
   const ImpersonateOverlay = (0, _react.useMemo)(() => {
     try {
@@ -350,6 +368,23 @@ const FloatingDevTools = ({
     }
   }, []);
 
+  // Check if scenarios is installed and auto-render the SIMULATED banner.
+  // Not optional and not suppressible: while a scenario is active the app is
+  // showing state that isn't real, and the banner is what stops that reaching
+  // a bug report or a screenshot as if it were.
+  const ScenariosOverlay = (0, _react.useMemo)(() => {
+    try {
+      // @ts-ignore - Dynamic import that may not exist
+      const {
+        ScenariosOverlay: Overlay
+      } = require("@buoy-gg/scenarios");
+      return Overlay;
+    } catch (e) {
+      (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/scenarios", e);
+      return null;
+    }
+  }, []);
+
   // Check if redux is installed and auto-mount startup instrumentation.
   // Binds the store from app mount (renders nothing) so the action log, MCP
   // getState/dispatch, and desktop sync work WITHOUT the Redux tool ever
@@ -423,6 +458,17 @@ const FloatingDevTools = ({
     isAvailable: (0, _autoExternalSync.isExternalSyncAvailable)()
   });
 
+  // The on-device action registry is published unconditionally, separately
+  // from the broker socket. They used to be the same mount: `registerToolAdapters`
+  // lived inside AutoExternalSync, so anything driving tools from INSIDE the
+  // app (the Scenarios runner, Ask Buoy) got an empty registry in exactly the
+  // builds where sync was off, and every dispatch threw `Unknown tool`.
+  // Publishing the map opens no socket and contacts nothing.
+  const toolRegistry = /*#__PURE__*/(0, _jsxRuntime.jsx)(_autoExternalSync.ToolRegistryPublisher, {
+    requiredEnvVars: requiredEnvVars,
+    customApps: syncApps
+  });
+
   // Headless (sync-only): tool adapters + route tracking + desktop sync, no
   // on-device UI. requireLicense is intentionally skipped — there's nothing
   // to gate. All hooks above already ran, so hook order is preserved, and
@@ -430,7 +476,7 @@ const FloatingDevTools = ({
   // contacted from a shipped build that didn't ask for it).
   if (headless) {
     return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
-      children: [ReduxAutoInstrument && /*#__PURE__*/(0, _jsxRuntime.jsx)(ReduxAutoInstrument, {}), ConsoleRoot && /*#__PURE__*/(0, _jsxRuntime.jsx)(ConsoleRoot, {}), RouteTracker && /*#__PURE__*/(0, _jsxRuntime.jsx)(RouteTracker, {}), syncEnabled && /*#__PURE__*/(0, _jsxRuntime.jsx)(_autoExternalSync.AutoExternalSync, {
+      children: [ReduxAutoInstrument && /*#__PURE__*/(0, _jsxRuntime.jsx)(ReduxAutoInstrument, {}), ConsoleRoot && /*#__PURE__*/(0, _jsxRuntime.jsx)(ConsoleRoot, {}), RouteTracker && /*#__PURE__*/(0, _jsxRuntime.jsx)(RouteTracker, {}), ReactQueryTracker && /*#__PURE__*/(0, _jsxRuntime.jsx)(ReactQueryTracker, {}), toolRegistry, syncEnabled && /*#__PURE__*/(0, _jsxRuntime.jsx)(_autoExternalSync.AutoExternalSync, {
         options: (0, _externalSyncGate.externalSyncOptions)(externalSync),
         requiredEnvVars: requiredEnvVars,
         isPro: isLicensed,
@@ -461,7 +507,10 @@ const FloatingDevTools = ({
       disableHints: disableHints,
       children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
         style: styles.container,
-        pointerEvents: "box-none",
+        pointerEvents: "box-none"
+        // @ts-expect-error — deliberate marker prop, not part of ViewProps.
+        ,
+        __buoyDevToolsRoot: true,
         children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_DevToolsVisibilityContext.DevToolsVisibilityProvider, {
           children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_AppHost.AppHostProvider, {
             children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_MinimizedToolsContext.MinimizedToolsProvider, {
@@ -470,9 +519,9 @@ const FloatingDevTools = ({
                 ...props,
                 apps: finalApps,
                 environment: resolvedEnvironment
-              }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_AppHost.AppOverlay, {})]
+              }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_AppHost.AppOverlay, {}), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ToolOpenerBridge.ToolOpenerBridge, {})]
             })
-          }), children, DebugBordersOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(DebugBordersOverlay, {}), HighlightUpdatesOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(HighlightUpdatesOverlay, {}), ImageOverlayOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(ImageOverlayOverlay, {}), PerfMonitorOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(PerfMonitorOverlay, {}), JsTopOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(JsTopOverlay, {}), ImpersonateOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(ImpersonateOverlay, {}), ReduxAutoInstrument && /*#__PURE__*/(0, _jsxRuntime.jsx)(ReduxAutoInstrument, {}), ConsoleRoot && /*#__PURE__*/(0, _jsxRuntime.jsx)(ConsoleRoot, {}), RouteTracker && /*#__PURE__*/(0, _jsxRuntime.jsx)(RouteTracker, {}), syncEnabled && /*#__PURE__*/(0, _jsxRuntime.jsx)(_autoExternalSync.AutoExternalSync, {
+          }), children, DebugBordersOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(DebugBordersOverlay, {}), HighlightUpdatesOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(HighlightUpdatesOverlay, {}), ImageOverlayOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(ImageOverlayOverlay, {}), PerfMonitorOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(PerfMonitorOverlay, {}), JsTopOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(JsTopOverlay, {}), ImpersonateOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(ImpersonateOverlay, {}), ScenariosOverlay && /*#__PURE__*/(0, _jsxRuntime.jsx)(ScenariosOverlay, {}), ReduxAutoInstrument && /*#__PURE__*/(0, _jsxRuntime.jsx)(ReduxAutoInstrument, {}), ConsoleRoot && /*#__PURE__*/(0, _jsxRuntime.jsx)(ConsoleRoot, {}), RouteTracker && /*#__PURE__*/(0, _jsxRuntime.jsx)(RouteTracker, {}), ReactQueryTracker && /*#__PURE__*/(0, _jsxRuntime.jsx)(ReactQueryTracker, {}), toolRegistry, syncEnabled && /*#__PURE__*/(0, _jsxRuntime.jsx)(_autoExternalSync.AutoExternalSync, {
             options: (0, _externalSyncGate.externalSyncOptions)(externalSync),
             requiredEnvVars: requiredEnvVars,
             isPro: isLicensed,

package/lib/commonjs/floatingMenu/MinimizedToolsContext.js

@@ -101,6 +101,16 @@ function MinimizedToolsProvider({
   getToolIcon
 }) {
   const [minimizedTools, setMinimizedTools] = (0, _react.useState)([]);
+  /**
+   * A mirror of the list that can be read SYNCHRONOUSLY.
+   *
+   * `restore()` has to return the tool it removed, in the same tick, because
+   * its caller uses that return value to un-minimize the tool in AppHost. It
+   * cannot get that from `minimizedTools` (the callback is memoized with no
+   * deps, so it would close over a stale list) and it cannot get it from
+   * inside a state updater either — see the note on `restore`.
+   */
+  const minimizedToolsRef = (0, _react.useRef)([]);
   const [isRestored, setIsRestored] = (0, _react.useState)(false);
   const persistenceTimeoutRef = (0, _react.useRef)(null);
   const getToolIconRef = (0, _react.useRef)(getToolIcon);
@@ -132,6 +142,9 @@ function MinimizedToolsProvider({
     restoreMinimizedTools();
   }, []);
 
+  // One assignment, every render, so the ref never lags the state it mirrors.
+  minimizedToolsRef.current = minimizedTools;
+
   // Persist minimized tools to storage with debounce
   (0, _react.useEffect)(() => {
     if (!isRestored) return;
@@ -170,14 +183,29 @@ function MinimizedToolsProvider({
       }];
     });
   }, []);
+
+  /**
+   * Take a tool out of the minimized list and hand it back to the caller.
+   *
+   * THE RETURN VALUE IS LOAD-BEARING. `MinimizedToolsStack` only calls
+   * `onRestore` — which is what actually un-minimizes the tool in AppHost —
+   * when this returns non-null. This used to assign the tool inside the
+   * `setMinimizedTools` updater and read it back on the next line, which
+   * assumes React runs updaters synchronously at the call site. Under React
+   * 18's automatic batching it does not: the updater runs in the render
+   * phase, so the caller always saw `null`, `onRestore` never fired, and
+   * AppHost kept the tool flagged `minimized: true`. The tool then sat in the
+   * rail with no way back — tapping it did nothing, and neither did opening
+   * it again from the dial, because AppHost already had it open. It survived
+   * reloads, because both stores are persisted.
+   *
+   * Reading the ref instead keeps the lookup synchronous and leaves the
+   * updater doing only what an updater should: deriving the next state.
+   */
   const restore = (0, _react.useCallback)(instanceId => {
-    let restoredTool = null;
-    setMinimizedTools(current => {
-      const index = current.findIndex(t => t.instanceId === instanceId);
-      if (index === -1) return current;
-      restoredTool = current[index];
-      return current.filter(t => t.instanceId !== instanceId);
-    });
+    const restoredTool = minimizedToolsRef.current.find(t => t.instanceId === instanceId) ?? null;
+    if (!restoredTool) return null;
+    setMinimizedTools(current => current.filter(t => t.instanceId !== instanceId));
     return restoredTool;
   }, []);
   const isMinimized = (0, _react.useCallback)(id => {

package/lib/commonjs/floatingMenu/MinimizedToolsStack.js

@@ -32,7 +32,7 @@ const MAX_GLITCH_DELAY = 6000;
 
 function GlitchToolButton({
   tool,
-  onPress,
+  onSelect,
   index
 }) {
   const glitchX = (0, _react.useRef)(new _reactNative.Animated.Value(0)).current;
@@ -127,7 +127,7 @@ function GlitchToolButton({
     };
   }, [glitchX, glitchOpacity, glitchScale, index]);
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
-    onPress: () => onPress(tool),
+    onPress: () => onSelect(tool),
     activeOpacity: 0.7,
     style: styles.toolButton,
     accessibilityLabel: `Restore ${tool.title}`,
@@ -185,7 +185,7 @@ function MinimizedToolsStack({
     collapsedLabel: `Show ${minimizedTools.length} minimized tools`,
     children: [...minimizedTools].reverse().map((tool, index) => /*#__PURE__*/(0, _jsxRuntime.jsx)(GlitchToolButton, {
       tool: tool,
-      onPress: handleToolPress,
+      onSelect: handleToolPress,
       index: index
     }, tool.instanceId))
   });

package/lib/commonjs/floatingMenu/ToolOpenerBridge.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ToolOpenerBridge = ToolOpenerBridge;
+var _react = require("react");
+var _sharedUi = require("@buoy-gg/shared-ui");
+var _AppHost = require("./AppHost");
+/**
+ * ToolOpenerBridge — publishes "bring a tool back on screen" to the overlays.
+ *
+ * Renders nothing. It exists only to sit INSIDE `AppHostProvider` (where the
+ * open-tool state lives) and hand that capability out through the global seam
+ * in `@buoy-gg/shared-ui`, so an overlay rendered as a sibling of the provider
+ * can still offer a button that opens a tool. See `toolUiBridge.ts` for why the
+ * overlays can't just be moved inside the provider.
+ *
+ * It only RESTORES a tool that is already open — including one that has been
+ * minimized, which is the case that matters (the macro recorder minimizes
+ * Scenarios so the tester can drive the app, then needs it back). It
+ * deliberately does not construct and open a tool from scratch: an opener that
+ * guesses at an instance is a worse failure than reporting that it couldn't,
+ * and every caller already has to handle `false`.
+ */
+
+function ToolOpenerBridge() {
+  const {
+    openApps,
+    restore
+  } = (0, _AppHost.useAppHost)();
+  (0, _react.useEffect)(() => {
+    return (0, _sharedUi.registerToolOpener)(toolId => {
+      const instance = openApps.find(app => app.id === toolId);
+      if (!instance) return false;
+      restore(instance.instanceId);
+      return true;
+    });
+  }, [openApps, restore]);
+  return null;
+}

package/lib/commonjs/floatingMenu/allToolsRegistry.js

@@ -120,6 +120,20 @@ const ALL_TOOLS_REGISTRY = exports.ALL_TOOLS_REGISTRY = [{
   renderIcon: size => /*#__PURE__*/(0, _jsxRuntime.jsx)(_floatingToolsCore.TimeMachineIcon, {
     size: size
   })
+}, {
+  id: "scenarios",
+  name: "SCENARIOS",
+  color: _floatingToolsCore.SCENARIOS_ICON_COLOR,
+  renderIcon: size => /*#__PURE__*/(0, _jsxRuntime.jsx)(_floatingToolsCore.ScenariosIcon, {
+    size: size
+  })
+}, {
+  id: "copilot",
+  name: "ASK BUOY",
+  color: _floatingToolsCore.COPILOT_ICON_COLOR,
+  renderIcon: size => /*#__PURE__*/(0, _jsxRuntime.jsx)(_floatingToolsCore.CopilotIcon, {
+    size: size
+  })
 }, {
   id: "jotai",
   name: "JOTAI",

package/lib/commonjs/floatingMenu/autoDiscoverPresets.js

@@ -205,6 +205,38 @@ function autoDiscoverPresets() {
       }
     }
   },
+  // Scenarios
+  {
+    name: "@buoy-gg/scenarios",
+    loader: () => {
+      try {
+        // @ts-ignore - Dynamic import that may not exist
+        const {
+          scenariosToolPreset
+        } = require("@buoy-gg/scenarios");
+        return scenariosToolPreset;
+      } catch (e) {
+        (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/scenarios", e);
+        return null;
+      }
+    }
+  },
+  // Ask Buoy (AI chat)
+  {
+    name: "@buoy-gg/copilot",
+    loader: () => {
+      try {
+        // @ts-ignore - Dynamic import that may not exist
+        const {
+          copilotToolPreset
+        } = require("@buoy-gg/copilot");
+        return copilotToolPreset;
+      } catch (e) {
+        (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/copilot", e);
+        return null;
+      }
+    }
+  },
   // Redux DevTools
   {
     name: "@buoy-gg/redux",

package/lib/commonjs/floatingMenu/autoExternalSync.js

@@ -4,11 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AutoExternalSync = AutoExternalSync;
+exports.ToolRegistryPublisher = ToolRegistryPublisher;
 exports.isExternalSyncAvailable = isExternalSyncAvailable;
+exports.useToolAdapterMap = useToolAdapterMap;
 var _react = require("react");
 var _reactNative = require("react-native");
 var _optionalRequire = require("./optionalRequire.js");
 var _appSyncAdapter = require("./sync/appSyncAdapter.js");
+var _sharedUi = require("@buoy-gg/shared-ui");
 /**
  * Zero-config device→desktop sync for FloatingDevTools.
  *
@@ -53,6 +56,8 @@ let perfMonitorModule = null;
 let jsTopModule = null;
 let imagesModule = null;
 let assetsModule = null;
+let tvRemoteModule = null;
+let focusInspectorModule = null;
 let expoConstantsModule = null;
 
 // Catch bodies report through reportOptionalRequireError: silent for a
@@ -148,6 +153,16 @@ try {
 } catch (e) {
   (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/assets", e);
 }
+try {
+  tvRemoteModule = require("@buoy-gg/tv-remote");
+} catch (e) {
+  (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/tv-remote", e);
+}
+try {
+  focusInspectorModule = require("@buoy-gg/focus-inspector");
+} catch (e) {
+  (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/focus-inspector", e);
+}
 try {
   expoConstantsModule = require("expo-constants");
 } catch (e) {
@@ -171,6 +186,52 @@ function defaultIdentity() {
     deviceId: `${slug || "buoy"}-${_reactNative.Platform.OS}`
   };
 }
+/**
+ * Build the `toolId -> sync adapter` map from whatever tool packages the app
+ * installed.
+ *
+ * Extracted out of AutoExternalSync so the map can be published on-device
+ * WITHOUT opening a broker socket. It used to be inline, which quietly welded
+ * the two together: `registerToolAdapters` had exactly one caller, inside a
+ * component that only mounts when the sync gate passes, so in any build where
+ * the broker path was closed the on-device registry was empty too and every
+ * `dispatchToolAction` threw `Unknown tool`. Anything that drives tools from
+ * inside the app — the Scenarios runner, Ask Buoy — needs the map without the
+ * socket.
+ */
+function useToolAdapterMap({
+  requiredEnvVars,
+  customApps
+}) {
+  // Context-based query adapter; null when there is no QueryClientProvider
+  // above FloatingDevTools (or the installed @buoy-gg/react-query predates
+  // the hook).
+  const queryAdapter = reactQueryModule?.useReactQuerySyncAdapter ? reactQueryModule.useReactQuerySyncAdapter() : null;
+  return useToolAdapterMapInner(queryAdapter, requiredEnvVars, customApps);
+}
+
+/**
+ * Publish the adapter map on-device, with no socket and no external-sync
+ * dependency.
+ *
+ * Mounted unconditionally by FloatingDevTools. A getter is registered rather
+ * than a snapshot for the same reason `attachDeviceSync` does it: the memo is
+ * rebuilt whenever its inputs change, and a captured copy would keep
+ * dispatching into adapters the tree has already replaced.
+ */
+function ToolRegistryPublisher({
+  requiredEnvVars,
+  customApps
+}) {
+  const tools = useToolAdapterMap({
+    requiredEnvVars,
+    customApps
+  });
+  const toolsRef = (0, _react.useRef)(tools);
+  toolsRef.current = tools;
+  (0, _react.useEffect)(() => (0, _sharedUi.registerToolAdapters)(() => toolsRef.current), []);
+  return null;
+}
 function AutoExternalSync({
   options,
   requiredEnvVars,
@@ -183,11 +244,10 @@ function AutoExternalSync({
     useExternalSyncSocket,
     useExternalSync
   } = externalSyncModule;
-
-  // Context-based query adapter; null when there is no QueryClientProvider
-  // above FloatingDevTools (or the installed @buoy-gg/react-query predates
-  // the hook).
-  const queryAdapter = reactQueryModule?.useReactQuerySyncAdapter ? reactQueryModule.useReactQuerySyncAdapter() : null;
+  const tools = useToolAdapterMap({
+    requiredEnvVars,
+    customApps
+  });
   const identity = (0, _react.useMemo)(defaultIdentity, []);
   const deviceId = options?.deviceId ?? identity.deviceId;
   const {
@@ -233,7 +293,22 @@ function AutoExternalSync({
       socket.off("connect", emitLicense);
     };
   }, [socket, isPro, tier, licenseKey]);
-  const tools = (0, _react.useMemo)(() => {
+  useExternalSync({
+    tools,
+    socket,
+    deviceId,
+    enableLogs: options?.enableLogs
+  });
+  return null;
+}
+
+/**
+ * The map itself. Split from `useToolAdapterMap` only so the react-query hook
+ * is called at a stable position while the memo takes its result as a plain
+ * dependency.
+ */
+function useToolAdapterMapInner(queryAdapter, requiredEnvVars, customApps) {
+  return (0, _react.useMemo)(() => {
     // Core's own adapter — device-level capabilities (JS-bundle reload) that
     // don't belong to any tool package. Registered unconditionally so remote
     // drivers can rely on it for every app, whatever tools are installed.
@@ -279,6 +354,26 @@ function AutoExternalSync({
     } catch (e) {
       (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/time-machine", e);
     }
+    // Lazy for the same reason as time-machine: scenarios imports
+    // `@buoy-gg/core` for useToolHost/useToolHeader.
+    try {
+      const scenariosModule = require("@buoy-gg/scenarios");
+      if (scenariosModule?.scenariosSyncAdapter) {
+        map.scenarios = scenariosModule.scenariosSyncAdapter;
+      }
+    } catch (e) {
+      (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/scenarios", e);
+    }
+    // Lazy, same require-cycle reason as time-machine and scenarios: the
+    // copilot package imports `@buoy-gg/core` for the tool-host hooks.
+    try {
+      const copilotModule = require("@buoy-gg/copilot");
+      if (copilotModule?.copilotSyncAdapter) {
+        map.copilot = copilotModule.copilotSyncAdapter;
+      }
+    } catch (e) {
+      (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/copilot", e);
+    }
     if (envModule?.createEnvSyncAdapter) {
       map.env = envModule.createEnvSyncAdapter(requiredEnvVars ?? []);
     }
@@ -303,6 +398,12 @@ function AutoExternalSync({
     if (assetsModule?.assetsSyncAdapter) {
       map.assets = assetsModule.assetsSyncAdapter;
     }
+    if (tvRemoteModule?.tvRemoteSyncAdapter) {
+      map["tv-remote"] = tvRemoteModule.tvRemoteSyncAdapter;
+    }
+    if (focusInspectorModule?.focusInspectorSyncAdapter) {
+      map["focus-inspector"] = focusInspectorModule.focusInspectorSyncAdapter;
+    }
 
     // Third-party custom tools that declared InstalledApp.sync. Namespaced so
     // a custom tool named "network" can't shadow the first-party adapter on
@@ -314,11 +415,4 @@ function AutoExternalSync({
     }
     return map;
   }, [queryAdapter, requiredEnvVars, customApps]);
-  useExternalSync({
-    tools,
-    socket,
-    deviceId,
-    enableLogs: options?.enableLogs
-  });
-  return null;
 }

package/lib/commonjs/floatingMenu/sync/appSyncAdapter.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.appSyncAdapter = void 0;
+var _reactNative = require("react-native");
 var _sharedUi = require("@buoy-gg/shared-ui");
 /**
  * Sync adapter for the "app" pseudo-tool — device-level capabilities that
@@ -15,10 +16,10 @@ var _sharedUi = require("@buoy-gg/shared-ui");
  * Desktop, the MCP server) can count on it for every connected app — no tool
  * package, and no native peer deps, required.
  *
- * Today that's one thing: reloading the JS bundle. The snapshot is static
- * (there is nothing to stream), it just advertises whether a reload would
- * work and which mechanism would run, so a driver can say so up front instead
- * of discovering it by failing.
+ * Two things today: reloading the JS bundle, and what KIND of device this is.
+ * The snapshot is static (there is nothing to stream), it just advertises
+ * whether a reload would work and which mechanism would run, so a driver can
+ * say so up front instead of discovering it by failing.
  */
 /**
  * When THIS JS realm booted. A reload replaces the realm, so a driver that
@@ -38,13 +39,33 @@ const REALM_STARTED_AT = Date.now();
  * that learned this origin while the app was healthy.
  */
 const DEV_SERVER_ORIGIN = (0, _sharedUi.getDevServerOrigin)();
+
+/**
+ * What kind of device this is, resolved once at module load.
+ *
+ * A dashboard cannot infer this from `platform` alone: an Apple TV and an
+ * iPhone both report "ios", and an Android TV and a phone both report
+ * "android". Without it Buoy Desktop has to show every tool for every device —
+ * including TV-only tools on a phone, where they can never do anything.
+ *
+ * `Platform.isTVOS` is `undefined` (not `false`) on Android TV, so it is only
+ * ever compared against `true`.
+ */
+const DEVICE = {
+  platform: _reactNative.Platform.OS,
+  isTV: _reactNative.Platform.isTV === true,
+  isTVOS: _reactNative.Platform.isTVOS === true
+};
 const appSyncAdapter = exports.appSyncAdapter = {
-  version: 2,
+  // v3 adds `device`. Consumers must tolerate its absence — an older app on a
+  // newer dashboard simply reports an unknown device kind.
+  version: 3,
   getSnapshot: () => {
     const strategy = (0, _sharedUi.resolveReloadStrategy)("auto");
     return {
       startedAt: REALM_STARTED_AT,
       devServerOrigin: DEV_SERVER_ORIGIN,
+      device: DEVICE,
       reload: {
         available: strategy !== null,
         strategy

package/lib/commonjs/version.js

@@ -15,4 +15,4 @@ exports.SDK_VERSION = void 0;
  * Drift is prevented by a test that fails when this disagrees with
  * package.json, so a version bump that forgets this file cannot ship.
  */
-const SDK_VERSION = exports.SDK_VERSION = "7.0.30";
+const SDK_VERSION = exports.SDK_VERSION = "7.0.31";

package/lib/module/floatingMenu/AppHost.js

@@ -339,6 +339,7 @@ export const AppOverlay = () => {
   } = useAppHost();
   const {
     minimize: addToMinimizedStack,
+    restore: removeFromMinimizedStack,
     getNextIconPosition,
     minimizedTools
   } = useMinimizedTools();
@@ -371,7 +372,30 @@ export const AppOverlay = () => {
         }
       }
     });
-  }, [openApps, minimizedTools, addToMinimizedStack]);
+
+    // ...and take out anything the rail is still showing that is no longer
+    // minimized, or no longer open at all.
+    //
+    // WHY THIS HALF EXISTS. `openApps` and the rail are two separate stores
+    // for one fact, and only the ADD side was reliable. Minimizing goes
+    // through an event handler; un-minimizing happens inside `open`, which
+    // schedules the rail removal with a `setTimeout` from INSIDE a
+    // `setOpenApps` updater. Updaters are not a safe place for side effects —
+    // React may double-invoke or discard them — so the removal could be
+    // skipped while `minimized: false` still landed. The rail then kept an
+    // icon for an already-open tool, and tapping it did nothing except delete
+    // the icon: the tool looked like it vanished, with no way back to it, and
+    // both stores are persisted so it survived every reload.
+    //
+    // Reconciling here makes the rail eventually consistent with `openApps`
+    // whichever way the state moved, without moving the side effect.
+    minimizedTools.forEach(tool => {
+      const app = openApps.find(a => a.instanceId === tool.instanceId);
+      if (!app || !app.minimized) {
+        removeFromMinimizedStack(tool.instanceId);
+      }
+    });
+  }, [openApps, minimizedTools, addToMinimizedStack, removeFromMinimizedStack]);
 
   // Filter to renderable apps (exclude toggle-only)
   const renderableApps = openApps.filter(app => app.launchMode !== "toggle-only");