@kabmo-labs/kabmo 0.7.0 → 0.8.0

package/src/client/hooks/chat/timeline/send-execute.test.ts

@@ -160,6 +160,7 @@ function makeSendHarness(options: {
   const params: string[] = [];
   const seeds: SessionSeed[] = [];
   const spawnSelectionRef = { current: { plan: true, goal: false } };
+  const spawnWorktreeRef = { current: null as string | null };
   const adoptedSessionIdRef = { current: null };
   const deps: ChatTimelineSendDeps = {
     folders: options.folders ?? [],
@@ -190,6 +191,7 @@ function makeSendHarness(options: {
     deferredComposerPickRef: options.deferredPick ?? { current: null },
     accessModeRef: { current: 'always-ask' },
     spawnSelectionRef,
+    spawnWorktreeRef,
     abortControllerRef: { current: null },
     setInputValue: (v) => {
       drafts.push(v);

package/src/client/hooks/chat/timeline/send-steer.test.ts

@@ -151,6 +151,7 @@ function makeSendHarness(options: {
   const params: string[] = [];
   const seeds: SessionSeed[] = [];
   const spawnSelectionRef = { current: { plan: true, goal: false } };
+  const spawnWorktreeRef = { current: null as string | null };
   const adoptedSessionIdRef = { current: null };
   const deps: ChatTimelineSendDeps = {
     folders: options.folders ?? [],
@@ -181,6 +182,7 @@ function makeSendHarness(options: {
     deferredComposerPickRef: options.deferredPick ?? { current: null },
     accessModeRef: { current: 'always-ask' },
     spawnSelectionRef,
+    spawnWorktreeRef,
     abortControllerRef: { current: null },
     setInputValue: (v) => {
       drafts.push(v);

package/src/client/hooks/chat/timeline/send.test.ts

@@ -151,6 +151,7 @@ function makeSendHarness(options: {
   const params: string[] = [];
   const seeds: SessionSeed[] = [];
   const spawnSelectionRef = { current: { plan: true, goal: false } };
+  const spawnWorktreeRef = { current: null as string | null };
   const adoptedSessionIdRef = { current: null };
   const deps: ChatTimelineSendDeps = {
     folders: options.folders ?? [],
@@ -181,6 +182,7 @@ function makeSendHarness(options: {
     deferredComposerPickRef: options.deferredPick ?? { current: null },
     accessModeRef: { current: 'always-ask' },
     spawnSelectionRef,
+    spawnWorktreeRef,
     abortControllerRef: { current: null },
     setInputValue: (v) => {
       drafts.push(v);

package/src/client/hooks/chat/timeline/send.ts

@@ -58,6 +58,13 @@ export interface ChatTimelineSendDeps {
    *  outside the render that produced the pick, and it is the FIRST moment a
    *  child exists to carry the selection. */
   spawnSelectionRef: { current: { plan: boolean; goal: boolean } | null };
+  /**
+   * The worktree the pending chat picked (`chat.spawnTarget`), read through a
+   * REF because the composer is remounted by a stretch, a tab switch and a
+   * reload while this handler is created once per deps record — the same reason
+   * the waiting pick keeps one.
+   */
+  spawnWorktreeRef: { current: string | null };
   /** Picks the composer made while a turn was streaming. Pushed onto the
    *  session here, immediately before the prompt they were meant for. */
   deferredComposerPickRef: DeferredModelStore;
@@ -104,6 +111,7 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
     deferredComposerPickRef,
     accessModeRef,
     spawnSelectionRef,
+    spawnWorktreeRef,
     abortControllerRef,
     setInputValue,
     setSearchParams,
@@ -234,7 +242,9 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
     // when the spawn fails (e.g. MOCK=true or no workspace context).
     if (!isOmpSession) {
       const currentFolder = folders.find(f => String(f.id) === String(selectedFolderId));
-      const cwd = currentFolder?.project_path || currentFolder?.name;
+      // A worktree pick wins: the chat is BORN there, so no relocation is ever
+      // needed and the child's cwd is right for its whole life.
+      const cwd = spawnWorktreeRef.current || currentFolder?.project_path || currentFolder?.name;
       if (cwd) {
         const images = collectImages(attachments);
         const promptText = await buildPromptText(text, textFiles);

package/src/client/hooks/chat/timeline/spawn-target.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The worktree a pending chat picked, as a ref the SEND path can read.
+ *
+ * The composer is remounted by a stretch, a tab switch and a reload, while the
+ * send handler is created once per deps record — so a pick read from render
+ * state there would be missed, which is the one outcome the pick exists to
+ * prevent. The persisted copy is `chat.spawnTarget` (it survives a reload, and
+ * a second tab sees it); the ref is its render-visible mirror.
+ *
+ * Same shape as the waiting pick's ref (`waiting/choice.ts`), for the same
+ * reason: a value written before the send and read at send time cannot travel
+ * through props that rebuild.
+ */
+
+import { useEffect, useRef } from 'preact/hooks';
+import { useSessionState } from '@/client/hooks/workspace/session-state/index';
+
+/** Where the chat that has not started will run. */
+export interface SpawnTarget {
+  folderId: number | null;
+  /** Absolute worktree path, or null for the folder's own checkout. */
+  worktreePath: string | null;
+}
+
+/** `chat.spawnTarget` — the persisted pick, shared by both layouts' composers. */
+export const SPAWN_TARGET_KEY = 'chat.spawnTarget';
+
+export interface SpawnTargetBinding {
+  /** The pick, for a control that draws it (the composer's target picker). */
+  target: SpawnTarget | null;
+  setTarget: (next: SpawnTarget | null) => void;
+  /** The send path's view: set before the request goes out. */
+  worktreePathRef: { current: string | null };
+}
+
+export function useSpawnTarget(sessionId: string | null): SpawnTargetBinding {
+  const [target, setTarget] = useSessionState<SpawnTarget | null>(SPAWN_TARGET_KEY, null);
+  const worktreePathRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    // A pick for ANOTHER session must not leak into this one: the store is keyed
+    // by session, so a change of session id re-reads and this effect re-mirrors.
+    worktreePathRef.current = target?.worktreePath ?? null;
+  }, [target, sessionId]);
+
+  return { target, setTarget, worktreePathRef };
+}

package/src/client/hooks/chat/timeline/tool-open.test.ts

@@ -20,6 +20,7 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
 import { Window } from 'happy-dom';
 import { h, render } from 'preact';
+import { useState } from 'preact/hooks';
 import { act } from 'preact/test-utils';
 import { useToolOpenState, TOOL_OPEN_STATE_KEY, type ToolOpenState } from '@/client/hooks/chat/timeline/tool-open';
 import { SessionStateProvider } from '@/client/components/common/session-state-provider';
@@ -139,3 +140,76 @@ describe('useToolOpenState', () => {
     expect(remounted.current?.openMap.a).toBe(true);
   });
 });
+
+describe('useToolOpenState — a streaming eval opens itself', () => {
+  /**
+   * Mount a probe whose tools can be REPLACED, so a status transition is
+   * observable: the reported bug is about a card that was open for the run and
+   * must not snap shut when the call returns.
+   */
+  async function mountMutable(initial: ToolCallData[]) {
+    const api: { current: ToolOpenState | null; setTools: (next: ToolCallData[]) => void } = {
+      current: null,
+      setTools: () => {},
+    };
+    function Probe() {
+      const [tools, setTools] = useState(initial);
+      api.setTools = setTools;
+      api.current = useToolOpenState(tools, false);
+      return null;
+    }
+    container = document.createElement('div');
+    document.body.appendChild(container);
+    await act(async () => {
+      render(h(SessionStateProvider, { sessionId: SESSION, children: h(Probe, {}) }), container);
+    });
+    await act(async () => {
+      for (let i = 0; i < 8; i++) await Promise.resolve();
+    });
+    return api;
+  }
+
+  const evalTool = (partial: Partial<ToolCallData> = {}) =>
+    tool('e1', { type: 'eval', name: 'eval', title: 'Counting lines', ...partial });
+
+  test('a running eval is open, so its streamed output is visible', async () => {
+    const api = await mountMutable([evalTool({ status: 'running' })]);
+    expect(api.current?.openMap.e1).toBe(true);
+  });
+
+  test('it STAYS open once the call settles', async () => {
+    const api = await mountMutable([evalTool({ status: 'running' })]);
+    await act(async () => {
+      api.setTools([evalTool({ status: 'success', output: 'line 1' })]);
+    });
+    // Re-deriving from `status` alone closed the card at the exact moment the
+    // reader wants the result — the `wait` lesson, restated for eval.
+    expect(api.current?.openMap.e1).toBe(true);
+  });
+
+  test('a settled eval from a reloaded transcript stays closed', async () => {
+    // History is not a live run: opening every past eval would bury the
+    // conversation under scripts nobody asked to see again.
+    const api = await mountMutable([evalTool({ status: 'success', output: 'line 1' })]);
+    expect(api.current?.openMap.e1).toBe(false);
+  });
+
+  test('a running bash is still folded', async () => {
+    // The auto-open is for the card whose body IS the answer, not for every
+    // streaming call — a bash log belongs folded.
+    const api = await mountMutable([tool('b1', { status: 'running' })]);
+    expect(api.current?.openMap.b1).toBe(false);
+  });
+
+  test('the reader can still close a running eval, and it stays closed', async () => {
+    const api = await mountMutable([evalTool({ status: 'running' })]);
+    await act(async () => {
+      api.current?.toggle('e1');
+    });
+    expect(api.current?.openMap.e1).toBe(false);
+    await act(async () => {
+      api.setTools([evalTool({ status: 'success', output: 'line 1' })]);
+    });
+    expect(api.current?.openMap.e1).toBe(false);
+  });
+});

package/src/client/hooks/chat/timeline/tool-open.ts

@@ -18,7 +18,7 @@
  * session blob.
  */
 
-import { useCallback, useMemo } from 'preact/hooks';
+import { useCallback, useEffect, useMemo, useRef } from 'preact/hooks';
 import { useSessionState } from '@/client/hooks/workspace/session-state';
 import { isSkippedTool } from '@/shared/lib/chat/tool-status';
 import type { ToolCallData } from '@/shared/types/chat';
@@ -42,6 +42,22 @@ export const TOOL_OPEN_STATE_KEY = 'chat.toolOpen';
  * belongs folded, while a wait's is three short rows.
  *
  * A stored choice still wins, so closing it stays closed.
+ *
+ * An `eval` is the second such card, and it is the one a reader reported: a
+ * script cell streams its stdout as it runs, and a collapsed card showed
+ * `Running` with the output invisible for the whole call — the panel had drawn
+ * it all along, folded away, and only expanding by hand (or waiting for the
+ * call to return) revealed it. It differs from `bash` the same way `wait` does:
+ * an eval's output IS the answer, not a log to consult afterwards, and the
+ * reader is watching it arrive.
+ *
+ * A card that was OPENED because it was running stays open once it settles —
+ * `watchedIds` records that, in memory only. Collapsing at the settle would
+ * take the output away at the exact moment the reader wants to read it (the
+ * `wait` lesson above), while re-deriving from `status` alone would do exactly
+ * that. The record is deliberately not persisted: a reloaded transcript is
+ * history, and every historical eval reopening itself would bury the
+ * conversation under scripts nobody asked to see again.
  */
 function defaultOpen(tool: ToolCallData, autoOpenFirst: boolean, index: number): boolean {
   if (isSkippedTool(tool)) return false;
@@ -50,6 +66,12 @@ function defaultOpen(tool: ToolCallData, autoOpenFirst: boolean, index: number):
   return autoOpenFirst && index === 0;
 }
 
+/** True while this call is a script cell that is still producing output. */
+function isStreamingEval(tool: ToolCallData): boolean {
+  if (tool.status !== 'running') return false;
+  return (tool.name || tool.type) === 'eval';
+}
+
 export interface ToolOpenState {
   /** Resolved openness per tool id — stored choice first, default second. */
   openMap: Record<string, boolean>;
@@ -59,28 +81,50 @@ export interface ToolOpenState {
 
 export function useToolOpenState(tools: ToolCallData[], autoOpenFirst: boolean): ToolOpenState {
   const [stored, setStored] = useSessionState<Record<string, boolean>>(TOOL_OPEN_STATE_KEY, {});
+  /** Ids opened BECAUSE they were streaming; see `defaultOpen`'s eval note. */
+  const watchedRef = useRef<Set<string>>(new Set());
+
+  const streamingEvalIds = useMemo(
+    () => tools.filter(isStreamingEval).map((tool) => tool.id),
+    [tools],
+  );
+  // Recorded after the render that opened them, so the open survives the call
+  // settling. In memory only: a reloaded transcript is history.
+  useEffect(() => {
+    for (const id of streamingEvalIds) watchedRef.current.add(id);
+  }, [streamingEvalIds]);
+
+  /**
+   * The default a card is RENDERING, before any stored choice. One function for
+   * the map and for `toggle`, because a toggle that flips a different default
+   * than the one on screen takes two clicks to close an auto-opened card — the
+   * streaming eval made that reachable, since its default now depends on more
+   * than `status`.
+   */
+  const renderedDefault = useCallback(
+    (tool: ToolCallData, index: number): boolean =>
+      isStreamingEval(tool) || watchedRef.current.has(tool.id) || defaultOpen(tool, autoOpenFirst, index),
+    [autoOpenFirst],
+  );
 
   const openMap = useMemo(() => {
     const map: Record<string, boolean> = {};
     tools.forEach((tool, index) => {
       const explicit = stored[tool.id];
-      map[tool.id] = explicit === undefined ? defaultOpen(tool, autoOpenFirst, index) : explicit;
+      map[tool.id] = explicit === undefined ? renderedDefault(tool, index) : explicit;
     });
     return map;
-  }, [tools, stored, autoOpenFirst]);
+  }, [tools, stored, renderedDefault]);
 
   const toggle = useCallback(
     (toolId: string) => {
       setStored((prev) => {
         const tool = tools.find((entry) => entry.id === toolId);
-        // The first toggle of an untouched call has to flip its DERIVED default,
-        // not an absent key — otherwise an auto-opened error would need two
-        // clicks to close.
-        const current = prev[toolId] ?? (tool ? defaultOpen(tool, autoOpenFirst, tools.indexOf(tool)) : false);
+        const current = prev[toolId] ?? (tool ? renderedDefault(tool, tools.indexOf(tool)) : false);
         return { ...prev, [toolId]: !current };
       });
     },
-    [setStored, tools, autoOpenFirst],
+    [setStored, tools, renderedDefault],
   );
 
   return { openMap, toggle };

package/src/client/hooks/ui/long-press.test.ts

@@ -0,0 +1,174 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Long press: the only way a finger reaches a Files-panel row's menu.
+ *
+ * Three rules are load-bearing and each was a way the gesture would misbehave
+ * on a phone:
+ *
+ * 1. **A press that MOVES is a scroll.** The tree is a scroller, and a hold that
+ *    begins a flick must cancel — otherwise every scroll that starts on a row
+ *    opens a menu.
+ * 2. **The click the same gesture produces is swallowed.** Lifting the finger
+ *    after the menu opened would otherwise also toggle the folder it opened for;
+ *    the platform raises both events for one gesture and marks neither.
+ * 3. **It is inert without a finger.** A desktop holding its primary button down
+ *    is a drag, and a mouse already has a right button.
+ *
+ * Time is driven, never slept through: a 450 ms hold is a real wait, and the
+ * hook's decisions are all about WHICH event arrives, never about how long the
+ * test took.
+ */
+
+import { afterEach, beforeEach, describe, expect, test, vi } from 'bun:test';
+import { Window } from 'happy-dom';
+import { h, render } from 'preact';
+import { act } from 'preact/test-utils';
+import { installDomGlobals, restoreDomGlobals } from '@/test-support/pristine-globals';
+import { useLongPress, type LongPressHandlers } from '@/client/hooks/ui/long-press';
+
+let win: Window;
+let container: HTMLElement;
+let handlers: LongPressHandlers | null = null;
+const fired: Array<{ x: number; y: number }> = [];
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  win = new Window({ url: 'http://localhost' });
+  installDomGlobals(win);
+  container = document.createElement('div');
+  document.body.appendChild(container);
+  fired.length = 0;
+  handlers = null;
+});
+
+afterEach(() => {
+  render(null, container);
+  container.remove();
+  restoreDomGlobals();
+  vi.useRealTimers();
+});
+
+/** Mount the hook; `enabled` is what a touch device decides. */
+async function mount(enabled: boolean): Promise<void> {
+  const Probe = () => {
+    handlers = useLongPress({ enabled, onLongPress: (x, y) => fired.push({ x, y }) });
+    return null;
+  };
+  await act(async () => {
+    render(h(Probe, {}), container);
+  });
+}
+
+/** A touch event carrying one finger at `(x, y)`. */
+function touch(type: string, x: number, y: number): globalThis.TouchEvent {
+  const event = new win.Event(type, { bubbles: true, cancelable: true }) as unknown as globalThis.TouchEvent;
+  Object.defineProperty(event, 'touches', { value: type === 'touchend' || type === 'touchcancel' ? [] : [{ clientX: x, clientY: y }] });
+  return event;
+}
+
+/** Advance the hook's own timer, without waiting on a real clock. */
+async function holdFor(ms: number): Promise<void> {
+  await act(async () => {
+    vi.advanceTimersByTime(ms);
+  });
+}
+
+describe('useLongPress', () => {
+  test('a hold fires at the press point', async () => {
+    await mount(true);
+
+    await act(async () => {
+      handlers!.onTouchStart(touch('touchstart', 40, 80));
+    });
+    await holdFor(520);
+
+    expect(fired).toEqual([{ x: 40, y: 80 }]);
+  });
+
+  test('a press released before the threshold never fires', async () => {
+    await mount(true);
+
+    await act(async () => {
+      handlers!.onTouchStart(touch('touchstart', 40, 80));
+    });
+    await act(async () => {
+      handlers!.onTouchEnd();
+    });
+    await holdFor(520);
+
+    expect(fired).toEqual([]);
+  });
+
+  test('a press that MOVES is a scroll, not a press', async () => {
+    await mount(true);
+
+    await act(async () => {
+      handlers!.onTouchStart(touch('touchstart', 40, 80));
+      // Past the slop: the first few pixels of a flick arrive immediately, and
+      // a menu that opened on them would make the tree unscrollable.
+      handlers!.onTouchMove(touch('touchmove', 40, 140));
+    });
+    await holdFor(520);
+
+    expect(fired).toEqual([]);
+  });
+
+  test('a small drift inside the slop still counts as a hold', async () => {
+    await mount(true);
+
+    await act(async () => {
+      handlers!.onTouchStart(touch('touchstart', 40, 80));
+      handlers!.onTouchMove(touch('touchmove', 42, 83));
+    });
+    await holdFor(520);
+
+    expect(fired).toHaveLength(1);
+  });
+
+  test('a cancelled press never fires', async () => {
+    await mount(true);
+
+    await act(async () => {
+      handlers!.onTouchStart(touch('touchstart', 40, 80));
+      handlers!.onTouchCancel();
+    });
+    await holdFor(520);
+
+    expect(fired).toEqual([]);
+  });
+
+  test('the click after a fired press is consumed exactly once', async () => {
+    await mount(true);
+
+    await act(async () => {
+      handlers!.onTouchStart(touch('touchstart', 40, 80));
+    });
+    await holdFor(520);
+
+    // The first click belongs to the gesture that opened the menu; a second
+    // click is the user's own and must work.
+    expect(handlers!.consume()).toBe(true);
+    expect(handlers!.consume()).toBe(false);
+  });
+
+  test('no press means nothing to consume', async () => {
+    await mount(true);
+
+    expect(handlers!.consume()).toBe(false);
+  });
+
+  test('it is inert without a finger', async () => {
+    await mount(false);
+
+    await act(async () => {
+      handlers!.onTouchStart(touch('touchstart', 40, 80));
+    });
+    await holdFor(520);
+
+    expect(fired).toEqual([]);
+  });
+});

package/src/client/hooks/ui/long-press.ts

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Long press, for the surfaces that have no right-click.
+ *
+ * A phone's Files panel offered no way to reach a row's context menu: the menu
+ * opens on `contextmenu`, which a touch device only raises after a press that
+ * the browser has already claimed for something else — a native drag (the row
+ * is a drag source) or a text selection of the whole panel. Measured on a
+ * phone: holding a file row selected the tree's text and started a drag ghost,
+ * and no menu ever appeared.
+ *
+ * Three rules make this usable rather than a second way to break the panel:
+ *
+ * - **A press that MOVES is a scroll, not a press.** The tree is a scroller, and
+ *   a hold that begins a scroll must cancel — otherwise every flick that starts
+ *   on a row opens a menu. The threshold is small (`SLOP_PX`) because the first
+ *   few pixels of a scroll arrive within the same tick.
+ * - **A fired press suppresses the CLICK it would otherwise produce.** Lifting
+ *   the finger after the menu opened would otherwise also toggle the folder the
+ *   menu was opened for. The caller asks `consume()` from its click handler,
+ *   which is the only place the two can be told apart — the platform raises both
+ *   events for one gesture and does not mark either.
+ * - **It is inert without a touch device.** A mouse already has a right button,
+ *   and a desktop holding its primary button down over a row is a drag.
+ *
+ * The handler is deliberately not `onContextMenu`-based: some Android builds DO
+ * raise `contextmenu` after a hold, and the browser's own press has already
+ * started a selection by then, so the menu would open over a half-selected tree.
+ */
+
+import { useCallback, useEffect, useRef } from 'preact/hooks';
+
+/** How long a press must be held before it counts. */
+const LONG_PRESS_MS = 450;
+/** Movement that turns a press into a scroll, in CSS pixels. */
+const SLOP_PX = 8;
+/** How long a fired press keeps suppressing the click it produces. */
+const CLICK_SUPPRESS_MS = 700;
+
+export interface LongPressOptions {
+  /** False on a device with a pointer: the right button already does this. */
+  enabled: boolean;
+  /** Where the press landed, in viewport coordinates — a menu anchor. */
+  onLongPress: (x: number, y: number) => void;
+}
+
+export interface LongPressHandlers {
+  onTouchStart: (event: globalThis.TouchEvent) => void;
+  onTouchMove: (event: globalThis.TouchEvent) => void;
+  onTouchEnd: () => void;
+  onTouchCancel: () => void;
+  /**
+   * True exactly once after a press fired, so the caller's click handler can
+   * ignore the click the same gesture produces.
+   */
+  consume: () => boolean;
+}
+
+export function useLongPress({ enabled, onLongPress }: LongPressOptions): LongPressHandlers {
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const originRef = useRef<{ x: number; y: number } | null>(null);
+  const firedAtRef = useRef(0);
+  /** The latest callback, so a re-render never leaves a stale one armed. */
+  const handlerRef = useRef(onLongPress);
+  handlerRef.current = onLongPress;
+
+  const cancel = useCallback(() => {
+    if (timerRef.current !== null) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    originRef.current = null;
+  }, []);
+
+  useEffect(() => cancel, [cancel]);
+
+  return {
+    onTouchStart: (event) => {
+      if (!enabled) return;
+      const touch = event.touches[0];
+      if (!touch) return;
+      cancel();
+      originRef.current = { x: touch.clientX, y: touch.clientY };
+      timerRef.current = setTimeout(() => {
+        timerRef.current = null;
+        const origin = originRef.current;
+        originRef.current = null;
+        if (!origin) return;
+        firedAtRef.current = Date.now();
+        handlerRef.current(origin.x, origin.y);
+      }, LONG_PRESS_MS);
+    },
+    onTouchMove: (event) => {
+      const origin = originRef.current;
+      const touch = event.touches[0];
+      if (!origin || !touch) return;
+      if (Math.abs(touch.clientX - origin.x) > SLOP_PX || Math.abs(touch.clientY - origin.y) > SLOP_PX) cancel();
+    },
+    onTouchEnd: cancel,
+    onTouchCancel: cancel,
+    consume: () => {
+      if (firedAtRef.current === 0) return false;
+      const recent = Date.now() - firedAtRef.current < CLICK_SUPPRESS_MS;
+      firedAtRef.current = 0;
+      return recent;
+    },
+  };
+}