@buoy-gg/core 7.0.31 → 7.0.33

package/lib/commonjs/floatingMenu/FloatingDevTools.js

@@ -46,6 +46,13 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
  * Storage key configuration for monitoring
  */
 
+/**
+ * Ask Buoy's config, mirrored structurally so core never depends on the
+ * optional `@buoy-gg/ask-buoy` package (it is required lazily, like every other
+ * tool). The object is handed to `createAskBuoyTool` untouched, so any field
+ * that package accepts passes through — the index signature is the seam.
+ */
+
 /**
  * Props for FloatingDevTools component.
  *
@@ -112,6 +119,7 @@ const FloatingDevTools = ({
   apps,
   requiredEnvVars,
   requiredStorageKeys,
+  askBuoy,
   children,
   disableHints = false,
   defaultFloatingTools,
@@ -232,8 +240,23 @@ const FloatingDevTools = ({
         (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/storage", error);
       }
     }
+
+    // The documented one-prop Ask Buoy setup. Same lazy-require shape as env
+    // and storage above: the configured tool replaces the bare auto-discovered
+    // preset by id, and an app without @buoy-gg/ask-buoy installed gets the
+    // usual optional-require report instead of a crash.
+    if (askBuoy) {
+      try {
+        const {
+          createAskBuoyTool
+        } = require("@buoy-gg/ask-buoy");
+        overrides.push(createAskBuoyTool(askBuoy));
+      } catch (error) {
+        (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/ask-buoy", error);
+      }
+    }
     return overrides;
-  }, [requiredEnvVars, requiredStorageKeys]);
+  }, [requiredEnvVars, requiredStorageKeys, askBuoy]);
 
   // Combine user apps with config overrides
   const userApps = (0, _react.useMemo)(() => {

package/lib/commonjs/floatingMenu/autoDiscoverPresets.js

@@ -189,6 +189,22 @@ function autoDiscoverPresets() {
       }
     }
   },
+  // Sentry
+  {
+    name: "@buoy-gg/sentry",
+    loader: () => {
+      try {
+        // @ts-ignore - Dynamic import that may not exist
+        const {
+          sentryToolPreset
+        } = require("@buoy-gg/sentry");
+        return sentryToolPreset;
+      } catch (e) {
+        (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/sentry", e);
+        return null;
+      }
+    }
+  },
   // Time Machine
   {
     name: "@buoy-gg/time-machine",
@@ -223,16 +239,16 @@ function autoDiscoverPresets() {
   },
   // Ask Buoy (AI chat)
   {
-    name: "@buoy-gg/copilot",
+    name: "@buoy-gg/ask-buoy",
     loader: () => {
       try {
         // @ts-ignore - Dynamic import that may not exist
         const {
-          copilotToolPreset
-        } = require("@buoy-gg/copilot");
-        return copilotToolPreset;
+          askBuoyToolPreset
+        } = require("@buoy-gg/ask-buoy");
+        return askBuoyToolPreset;
       } catch (e) {
-        (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/copilot", e);
+        (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/ask-buoy", e);
         return null;
       }
     }

package/lib/commonjs/floatingMenu/autoExternalSync.js

@@ -11,6 +11,7 @@ var _react = require("react");
 var _reactNative = require("react-native");
 var _optionalRequire = require("./optionalRequire.js");
 var _appSyncAdapter = require("./sync/appSyncAdapter.js");
+var _deviceIdentity = require("./deviceIdentity.js");
 var _sharedUi = require("@buoy-gg/shared-ui");
 /**
  * Zero-config device→desktop sync for FloatingDevTools.
@@ -24,8 +25,10 @@ var _sharedUi = require("@buoy-gg/shared-ui");
  * package, discovered with the same guarded-require pattern as
  * autoDiscoverPresets. No <DevToolsSync> wiring needed in the app.
  *
- * Identity defaults come from expo-constants when available (app name →
- * "MyApp (ios)" / "myapp-ios"), overridable via the `externalSync` prop.
+ * Identity defaults come from deviceIdentity.ts: the app name (expo-constants)
+ * plus a persisted per-install tail, so two devices on one build register as
+ * two devices — "MyApp (iPhone 17 Pro · 2c1d)" / "myapp-ios-3f9a2c1d".
+ * Overridable via the `externalSync` prop.
  */
 
 /* eslint-disable @typescript-eslint/no-var-requires */
@@ -48,6 +51,7 @@ let zustandModule = null;
 let jotaiModule = null;
 let eventsModule = null;
 let consoleModule = null;
+let sentryModule = null;
 let envModule = null;
 let highlightUpdatesModule = null;
 let debugBordersModule = null;
@@ -113,6 +117,11 @@ try {
 } catch (e) {
   (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/console", e);
 }
+try {
+  sentryModule = require("@buoy-gg/sentry");
+} catch (e) {
+  (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/sentry", e);
+}
 try {
   envModule = require("@buoy-gg/env");
 } catch (e) {
@@ -178,13 +187,12 @@ function getAppName() {
   const constants = expoConstantsModule?.default ?? expoConstantsModule;
   return constants?.expoConfig?.name ?? constants?.manifest2?.extra?.expoClient?.name ?? null;
 }
-function defaultIdentity() {
-  const appName = getAppName();
-  const slug = (appName ?? "buoy").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
-  return {
-    deviceName: `${appName ?? "Buoy Device"} (${_reactNative.Platform.OS})`,
-    deviceId: `${slug || "buoy"}-${_reactNative.Platform.OS}`
-  };
+
+/** expo-constants' `deviceName`: the simulator's name on a sim, the model on Android. */
+function getHardwareName() {
+  const constants = expoConstantsModule?.default ?? expoConstantsModule;
+  const name = constants?.deviceName;
+  return typeof name === "string" && name.length > 0 ? name : null;
 }
 /**
  * Build the `toolId -> sync adapter` map from whatever tool packages the app
@@ -248,12 +256,16 @@ function AutoExternalSync({
     requiredEnvVars,
     customApps
   });
-  const identity = (0, _react.useMemo)(defaultIdentity, []);
-  const deviceId = options?.deviceId ?? identity.deviceId;
+  const identity = (0, _deviceIdentity.useDeviceIdentity)(options, {
+    appName: getAppName(),
+    hardwareName: getHardwareName(),
+    platform: _reactNative.Platform.OS
+  });
+  const deviceId = identity?.deviceId ?? null;
   const {
     socket
   } = useExternalSyncSocket({
-    deviceName: options?.deviceName ?? identity.deviceName,
+    deviceName: identity?.deviceName ?? "Buoy Device",
     // Older external-sync versions predate getDefaultSocketURL and require
     // an explicit URL — keep the literal fallback for them.
     socketURL: options?.socketURL ?? externalSyncModule.getDefaultSocketURL?.() ?? "http://localhost:42831",
@@ -342,6 +354,9 @@ function useToolAdapterMapInner(queryAdapter, requiredEnvVars, customApps) {
     if (consoleModule?.consoleSyncAdapter) {
       map.console = consoleModule.consoleSyncAdapter;
     }
+    if (sentryModule?.sentrySyncAdapter) {
+      map.sentry = sentryModule.sentrySyncAdapter;
+    }
     // Lazy: time-machine imports `@buoy-gg/core` (useToolHost), and this file
     // is loaded from core's index. Requiring it at module top-level is a
     // require cycle (LogBox on every reload). Waiting until first render
@@ -365,14 +380,14 @@ function useToolAdapterMapInner(queryAdapter, requiredEnvVars, customApps) {
       (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.
+    // ask-buoy package imports `@buoy-gg/core` for the tool-host hooks.
     try {
-      const copilotModule = require("@buoy-gg/copilot");
-      if (copilotModule?.copilotSyncAdapter) {
-        map.copilot = copilotModule.copilotSyncAdapter;
+      const askBuoyModule = require("@buoy-gg/ask-buoy");
+      if (askBuoyModule?.askBuoySyncAdapter) {
+        map["ask-buoy"] = askBuoyModule.askBuoySyncAdapter;
       }
     } catch (e) {
-      (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/copilot", e);
+      (0, _optionalRequire.reportOptionalRequireError)("@buoy-gg/ask-buoy", e);
     }
     if (envModule?.createEnvSyncAdapter) {
       map.env = envModule.createEnvSyncAdapter(requiredEnvVars ?? []);

package/lib/commonjs/floatingMenu/deviceIdentity.js

@@ -0,0 +1,173 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.INSTALL_ID_LENGTH = void 0;
+exports.buildDeviceIdentity = buildDeviceIdentity;
+exports.generateInstallId = generateInstallId;
+exports.getInstallId = getInstallId;
+exports.loadInstallId = loadInstallId;
+exports.resetInstallIdForTests = resetInstallIdForTests;
+exports.useDeviceIdentity = useDeviceIdentity;
+var _react = require("react");
+var _reactNative = require("react-native");
+var _sharedUi = require("@buoy-gg/shared-ui");
+/**
+ * How a device introduces itself to the Buoy Desktop broker.
+ *
+ * The id used to be `<app-slug>-<platform>` — a BUILD identity, not a device
+ * identity. Every phone and simulator running the same app registered under
+ * the same id, and the broker (which deliberately lets one device hold
+ * several sockets for Fast Refresh) treated each newcomer as a reconnect and
+ * handed it the identity. Actions then landed on whichever device connected
+ * most recently, silently. See DEVICE_IDENTITY_COLLISION.md.
+ *
+ * Now the id carries a per-install tail minted once and persisted:
+ *
+ *   deviceId   = "<app-slug>-<platform>-<8 hex>"      e.g. acme-app-ios-3f9a2c1d
+ *   deviceName = "<App Name> (<hardware> · <last 4>)" e.g. Acme App (iPhone 17 Pro · 2c1d)
+ *
+ * The tail is what makes two devices on one build two devices. The name's
+ * hardware label comes from expo-constants' `deviceName` when available (the
+ * simulator's own name on a sim, "iPhone" on iOS 16+ hardware, the model on
+ * Android) and falls back to the platform; the 4-char tail is always on so
+ * two identical simulators never share a label.
+ *
+ * Persistence: native goes through shared's `persistentStorage` (file system
+ * → AsyncStorage → memory); web uses `sessionStorage` so every browser TAB
+ * is its own device — `localStorage` is shared across tabs and would collide
+ * exactly the way the old default did. The id does not survive a reinstall
+ * on purpose: it crosses an unauthenticated LAN socket, and deleting the app
+ * should reset it.
+ *
+ * An explicit `externalSync.deviceId` bypasses all of this; whoever pins an
+ * id owns its uniqueness.
+ */
+
+/** Minimal getItem/setItem surface, so storage can be injected in tests. */
+
+const INSTALL_ID_LENGTH = exports.INSTALL_ID_LENGTH = 8;
+
+/** 8 lowercase hex chars — short enough to read, random enough for a LAN. */
+function generateInstallId() {
+  let out = "";
+  while (out.length < INSTALL_ID_LENGTH) {
+    out += (Math.random() * 16 | 0).toString(16);
+  }
+  return out;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+/** Pure: turns the inputs into the id/name pair the broker sees. */
+function buildDeviceIdentity({
+  appName,
+  hardwareName,
+  platform,
+  installId,
+  deviceId
+}) {
+  const slug = slugify(appName ?? "buoy") || "buoy";
+  const label = appName ?? "Buoy Device";
+  const hardware = hardwareName?.trim() || platform;
+  if (deviceId) {
+    // The app pinned its own id: it can also pin its own name, so keep the
+    // default name free of a tail that would refer to an id nobody sees.
+    return {
+      deviceId,
+      deviceName: `${label} (${hardware})`
+    };
+  }
+  const id = `${slug}-${platform}-${installId}`;
+  return {
+    deviceId: id,
+    deviceName: `${label} (${hardware} · ${installId.slice(-4)})`
+  };
+}
+
+// Web: every tab is a device, so the id lives in the tab's sessionStorage.
+function sessionStore() {
+  const g = globalThis;
+  try {
+    return g.sessionStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+/**
+ * The persisted per-install tail: read it, or mint and store it on the first
+ * dial. Storage failures degrade to a fresh in-memory id rather than blocking
+ * the socket — a per-launch id still beats the old colliding one.
+ */
+async function loadInstallId({
+  platform = _reactNative.Platform.OS,
+  store,
+  mint = generateInstallId
+} = {}) {
+  const key = _sharedUi.devToolsStorageKeys.sync.deviceId();
+  const target = store === undefined ? platform === "web" ? sessionStore() : _sharedUi.persistentStorage : store;
+  if (!target) return mint();
+  try {
+    const existing = await target.getItem(key);
+    if (existing && existing.length > 0) return existing;
+    const fresh = mint();
+    await target.setItem(key, fresh);
+    return fresh;
+  } catch {
+    return mint();
+  }
+}
+let installIdPromise = null;
+
+/**
+ * Process-wide memo so every mount (and every Fast Refresh of the component
+ * that calls it) shares one storage round-trip and one id.
+ */
+function getInstallId() {
+  if (!installIdPromise) installIdPromise = loadInstallId();
+  return installIdPromise;
+}
+
+/** Tests only. */
+function resetInstallIdForTests() {
+  installIdPromise = null;
+}
+/**
+ * The identity to dial with. Null until the per-install id is read from
+ * storage (one round-trip on first mount; memoized process-wide after) —
+ * both sync hooks no-op on a null id, so the socket simply dials a beat
+ * later. An explicit `deviceId` skips the read entirely; an explicit
+ * `deviceName` is used verbatim.
+ */
+function useDeviceIdentity(options, env) {
+  const pinnedId = options?.deviceId;
+  const pinnedName = options?.deviceName;
+  const loadId = env.loadId ?? getInstallId;
+  const platform = env.platform ?? _reactNative.Platform.OS;
+  const [installId, setInstallId] = (0, _react.useState)(null);
+  (0, _react.useEffect)(() => {
+    if (pinnedId) return;
+    let cancelled = false;
+    loadId().then(id => {
+      if (!cancelled) setInstallId(id);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [pinnedId, loadId]);
+  return (0, _react.useMemo)(() => {
+    if (!pinnedId && !installId) return null;
+    const identity = buildDeviceIdentity({
+      appName: env.appName,
+      hardwareName: env.hardwareName,
+      platform,
+      installId: installId ?? "",
+      deviceId: pinnedId
+    });
+    return pinnedName ? {
+      ...identity,
+      deviceName: pinnedName
+    } : identity;
+  }, [pinnedId, pinnedName, installId, env.appName, env.hardwareName, platform]);
+}

package/lib/commonjs/floatingMenu/dial/DialDevTools.js

@@ -9,7 +9,6 @@ var _reactNative = require("react-native");
 var _sharedUi = require("@buoy-gg/shared-ui");
 var _DialIcon = require("./DialIcon.js");
 var _DialHyperspace = require("./DialHyperspace.js");
-var _allToolsRegistry = require("../allToolsRegistry.js");
 var _DialPagination = require("./DialPagination.js");
 var _dialUsageStore = require("./dialUsageStore.js");
 var _DevToolsSettingsModal = require("../DevToolsSettingsModal");
@@ -261,38 +260,6 @@ const DialDevTools = ({
     return map;
   }, [dialApps, actions, open, onClose]);
 
-  // Tools from the global registry that are NOT installed in this app.
-  // These are appended after all available tools so paging "next" eventually
-  // reveals them. They are display-only (real icon + real name + "Unavailable").
-  const unavailableTools = (0, _react.useMemo)(() => {
-    const installedIds = new Set(dialApps.map(a => a.id));
-    return _allToolsRegistry.ALL_TOOLS_REGISTRY.filter(t => !installedIds.has(t.id));
-  }, [dialApps]);
-
-  // Build stable IconType entries for each unavailable tool.
-  const unavailableIconsById = (0, _react.useMemo)(() => {
-    const map = new Map();
-    for (const tool of unavailableTools) {
-      map.set(tool.id, {
-        id: tool.id,
-        name: tool.name,
-        // Pre-render the icon at the standard GLYPH size (not the slot size —
-        // the slot also holds the label + "Unavailable" caption, so a glyph
-        // rendered at DIAL_ICON_SIZE overflows the slot and looks ~2x bigger
-        // than installed tools' icons).
-        icon: tool.renderIcon(_floatingToolsCore.DIAL_ICON_GLYPH_SIZE),
-        iconComponent: undefined,
-        color: tool.color,
-        unavailable: true,
-        // Tapping an unavailable tool is intentionally a no-op: the dial stays
-        // open and no modal launches, signalling the tool is not installed.
-        // Future: add a brief Toast with an install link here.
-        onPress: () => {}
-      });
-    }
-    return map;
-  }, [unavailableTools]);
-
   // Snapshot the usage-ranked order when the dial opens. It stays stable while
   // open so icons don't jump positions mid-interaction.
   const [rankedIds, setRankedIds] = (0, _react.useState)(() => (0, _dialUsageStore.getRankedToolIds)(dialApps.map(a => a.id)));
@@ -312,8 +279,9 @@ const DialDevTools = ({
     };
   }, [dialApps]);
 
-  // Page count spans available tools (usage-ranked) + unavailable tools (appended).
-  const pageCount = Math.max(1, Math.ceil((rankedIds.length + unavailableTools.length) / _floatingToolsCore.MAX_DIAL_SLOTS));
+  // Page count spans the installed tools (usage-ranked). Only tools the app
+  // actually has appear in the dial — nothing is shown for uninstalled ones.
+  const pageCount = Math.max(1, Math.ceil(rankedIds.length / _floatingToolsCore.MAX_DIAL_SLOTS));
   const [currentPage, setCurrentPage] = (0, _react.useState)(0);
   const safePage = Math.min(currentPage, pageCount - 1);
 
@@ -321,18 +289,13 @@ const DialDevTools = ({
   // snapshotted on open, so each icon's page and slot are fixed for the
   // session — which lets us mount all icons once and paginate purely by
   // toggling visibility (no remounts on page change).
-  //
-  // Order: usage-ranked available tools first, unavailable tools appended at
-  // the very end. This guarantees unavailable items always appear on the last
-  // pages and never displace available tools.
   const allDialIcons = (0, _react.useMemo)(() => {
-    const allIds = [...rankedIds, ...unavailableTools.map(t => t.id)];
-    return allIds.map(id => iconsById.get(id) ?? unavailableIconsById.get(id)).filter(icon => Boolean(icon)).map((icon, i) => ({
+    return rankedIds.map(id => iconsById.get(id)).filter(icon => Boolean(icon)).map((icon, i) => ({
       icon,
       page: Math.floor(i / _floatingToolsCore.MAX_DIAL_SLOTS),
       slot: i % _floatingToolsCore.MAX_DIAL_SLOTS
     }));
-  }, [rankedIds, iconsById, unavailableTools, unavailableIconsById]);
+  }, [rankedIds, iconsById]);
 
   // Empty slot indices for the current page (only the last page can be
   // partial). These are cheap placeholder dots.
@@ -535,10 +498,6 @@ const DialDevTools = ({
     });
   };
   const handleIconPress = icon => {
-    // Unavailable tools are display-only. Return early so the dial stays open
-    // and no modal or animation is triggered. The dimmed appearance already
-    // communicates that the tool is not installed.
-    if (icon.unavailable) return;
     setSelectedIcon(1);
     const interaction = _floatingToolsCore.dialAnimationConfig?.interaction ?? {
       iconSelect: {

package/lib/commonjs/floatingMenu/dial/DialIcon.js

@@ -185,35 +185,6 @@ const DialIcon = ({
       children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
         style: styles.emptyDot
       })
-    }) : icon.unavailable ?
-    /*#__PURE__*/
-    // ── Unavailable tool ──────────────────────────────────────────────────
-    // Renders the real icon + real name at NORMAL styling (visually identical
-    // to an installed tool). The ONLY signal that it's unavailable is the small
-    // muted "Unavailable" caption under the name. It's non-interactive: no
-    // Pressable, and the dial stays open when tapped because
-    // DialDevTools.handleIconPress returns early for unavailable icons.
-    (0, _jsxRuntime.jsxs)(_reactNative.View, {
-      style: styles.pressable,
-      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
-        style: styles.iconWrapper,
-        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
-          style: styles.iconClamp,
-          children: icon.icon
-        })
-      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
-        style: styles.label,
-        numberOfLines: 1,
-        adjustsFontSizeToFit: true,
-        minimumFontScale: 0.7,
-        children: icon.name.toUpperCase()
-      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
-        style: styles.unavailableCaption,
-        numberOfLines: 1,
-        adjustsFontSizeToFit: true,
-        minimumFontScale: 0.6,
-        children: "Unavailable"
-      })]
     }) : /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.Pressable, {
       onPress: () => onPress(icon),
       onPressIn: handlePressIn,
@@ -292,8 +263,8 @@ const styles = _reactNative.StyleSheet.create({
   },
   /**
    * Hard clamp for PRE-RENDERED icon nodes (icon.icon) — the path where the
-   * glyph's size is baked in by whoever created the node (unavailable-tool
-   * registry entries, consumer custom tools) rather than controlled here. The
+   * glyph's size is baked in by whoever created the node (consumer custom
+   * tools) rather than controlled here. The
    * fixed overflow-hidden box guarantees an oversized node can never blow past
    * its slot and dwarf neighboring icons — worst case it center-crops. The
    * iconComponent path stays unclipped: we render it at DIAL_ICON_GLYPH_SIZE
@@ -327,20 +298,5 @@ const styles = _reactNative.StyleSheet.create({
     backgroundColor: _floatingToolsCore.dialColors.emptyDotBackground,
     borderWidth: _floatingToolsCore.dialStyles.emptySlot.borderWidth,
     borderColor: _floatingToolsCore.dialColors.emptyDotBorder
-  },
-  // ── Unavailable tool styles ────────────────────────────────────────────────
-  /**
-   * Small muted caption shown under the (normal-styled) tool name — the only
-   * signal that the tool is not installed. Kept compact (smaller than the label)
-   * so the extra line doesn't disturb the arc layout. Uses the shared muted
-   * theme token rather than a hardcoded color.
-   */
-  unavailableCaption: {
-    fontSize: _floatingToolsCore.dialStyles.icon.label.fontSize - 1,
-    fontWeight: _floatingToolsCore.dialStyles.icon.label.fontWeight,
-    letterSpacing: _floatingToolsCore.dialStyles.icon.label.letterSpacing,
-    fontFamily: _floatingToolsCore.dialStyles.icon.label.fontFamily,
-    color: _floatingToolsCore.dialColors.iconLabelMuted,
-    textTransform: "uppercase"
   }
 });

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.31";
+const SDK_VERSION = exports.SDK_VERSION = "7.0.33";

package/lib/module/floatingMenu/FloatingDevTools.js

@@ -42,6 +42,13 @@ import { externalSyncOptions, shouldMountExternalSync } from "./externalSyncGate
  * Storage key configuration for monitoring
  */
 
+/**
+ * Ask Buoy's config, mirrored structurally so core never depends on the
+ * optional `@buoy-gg/ask-buoy` package (it is required lazily, like every other
+ * tool). The object is handed to `createAskBuoyTool` untouched, so any field
+ * that package accepts passes through — the index signature is the seam.
+ */
+
 /**
  * Props for FloatingDevTools component.
  *
@@ -108,6 +115,7 @@ export const FloatingDevTools = ({
   apps,
   requiredEnvVars,
   requiredStorageKeys,
+  askBuoy,
   children,
   disableHints = false,
   defaultFloatingTools,
@@ -228,8 +236,23 @@ export const FloatingDevTools = ({
         reportOptionalRequireError("@buoy-gg/storage", error);
       }
     }
+
+    // The documented one-prop Ask Buoy setup. Same lazy-require shape as env
+    // and storage above: the configured tool replaces the bare auto-discovered
+    // preset by id, and an app without @buoy-gg/ask-buoy installed gets the
+    // usual optional-require report instead of a crash.
+    if (askBuoy) {
+      try {
+        const {
+          createAskBuoyTool
+        } = require("@buoy-gg/ask-buoy");
+        overrides.push(createAskBuoyTool(askBuoy));
+      } catch (error) {
+        reportOptionalRequireError("@buoy-gg/ask-buoy", error);
+      }
+    }
     return overrides;
-  }, [requiredEnvVars, requiredStorageKeys]);
+  }, [requiredEnvVars, requiredStorageKeys, askBuoy]);
 
   // Combine user apps with config overrides
   const userApps = useMemo(() => {

package/lib/module/floatingMenu/autoDiscoverPresets.js

@@ -185,6 +185,22 @@ export function autoDiscoverPresets() {
       }
     }
   },
+  // Sentry
+  {
+    name: "@buoy-gg/sentry",
+    loader: () => {
+      try {
+        // @ts-ignore - Dynamic import that may not exist
+        const {
+          sentryToolPreset
+        } = require("@buoy-gg/sentry");
+        return sentryToolPreset;
+      } catch (e) {
+        reportOptionalRequireError("@buoy-gg/sentry", e);
+        return null;
+      }
+    }
+  },
   // Time Machine
   {
     name: "@buoy-gg/time-machine",
@@ -219,16 +235,16 @@ export function autoDiscoverPresets() {
   },
   // Ask Buoy (AI chat)
   {
-    name: "@buoy-gg/copilot",
+    name: "@buoy-gg/ask-buoy",
     loader: () => {
       try {
         // @ts-ignore - Dynamic import that may not exist
         const {
-          copilotToolPreset
-        } = require("@buoy-gg/copilot");
-        return copilotToolPreset;
+          askBuoyToolPreset
+        } = require("@buoy-gg/ask-buoy");
+        return askBuoyToolPreset;
       } catch (e) {
-        reportOptionalRequireError("@buoy-gg/copilot", e);
+        reportOptionalRequireError("@buoy-gg/ask-buoy", e);
         return null;
       }
     }