@kabmo-labs/kabmo 0.0.1 → 0.2.0

package/src/client/hooks/chat/timeline/ask-frames-grouped.test.ts

@@ -63,7 +63,7 @@ describe('splitAskFrames with a grouped ask frame', () => {
     expect(split.modalRequest).toBeNull();
   });
 
-  test('an unowned grouped frame stays for the modal', () => {
+  test('an unowned grouped frame becomes an inline orphan, never a modal', () => {
     const stranger: ExtensionUiDialogRequest = {
       ...grouped,
       id: 'frame-2',
@@ -71,6 +71,50 @@ describe('splitAskFrames with a grouped ask frame', () => {
     };
     const split = splitAskFrames([message()], [stranger], true);
     expect(split.framesByTool.get('call-ask')).toBeUndefined();
-    expect(split.modalRequest).toBe(stranger);
+    // The timeline draws it (`OrphanAsks`); the modal has no `ask` body, so a
+    // grouped frame handed to it rendered an empty panel.
+    expect(split.orphanAsks).toEqual([stranger]);
+    expect(split.modalRequest).toBeNull();
+  });
+
+  test('a grouped frame whose questions carry no ids still claims its card', () => {
+    // Measured on 2 of 161 real `ask` calls: omp's schema requires an id, but
+    // a call written by an older build carried none. The id walk then matched
+    // nothing and the frame fell through to the MODAL.
+    const tool = askTool();
+    tool.input = {
+      questions: [
+        { id: '', question: 'Pick colors', options: [{ label: 'red' }], multi: true },
+        { id: '', question: 'Pick a size', options: [{ label: 's' }] },
+      ],
+    };
+    const unkeyed: ExtensionUiDialogRequest = {
+      ...grouped,
+      id: 'frame-3',
+      questions: [
+        { id: '', question: 'Pick colors', options: [{ label: 'red' }], multi: true },
+        { id: '', question: 'Pick a size', options: [{ label: 's' }] },
+      ],
+    };
+    const history = { id: 'm1', role: 'ai', content: '', toolCalls: [tool] } as unknown as ChatMessageData;
+
+    const split = splitAskFrames([history], [unkeyed], true);
+    expect(split.framesByTool.get('call-ask')?.length).toBe(2);
+    expect(split.orphanAsks).toEqual([]);
+    expect(split.modalRequest).toBeNull();
+  });
+
+  test('a grouped frame matches its card by question text when ids differ', () => {
+    const retitled: ExtensionUiDialogRequest = {
+      ...grouped,
+      id: 'frame-4',
+      questions: [
+        { id: 'omp-a', question: 'Pick colors', options: [{ label: 'red' }], multi: true },
+        { id: 'omp-b', question: 'Pick a size', options: [{ label: 's' }] },
+      ],
+    };
+    const split = splitAskFrames([message()], [retitled], true);
+    expect(split.framesByTool.get('call-ask')?.length).toBe(2);
+    expect(split.orphanAsks).toEqual([]);
   });
 });

package/src/client/hooks/chat/timeline/ask-frames.test.ts

@@ -65,7 +65,7 @@ describe('splitAskFrames', () => {
     const gate = confirmFrame('g1', 'Run bash?');
 
     // The regression: the frame has been replayed, its tool call has not.
-    expect(splitAskFrames([], [question], false)).toEqual({ framesByTool: new Map(), modalRequest: null });
+    expect(splitAskFrames([], [question], false)).toEqual({ framesByTool: new Map(), orphanAsks: [], modalRequest: null });
     // The hold is uniform — a gate cannot be told from an ask before history
     // either, and it is re-decided the moment the history settles.
     expect(splitAskFrames([], [gate], false).modalRequest).toBeNull();

package/src/client/hooks/chat/timeline/ask-frames.ts

@@ -12,23 +12,31 @@
  * (approval gates under `always-ask`, extension pickers) has no card of its own
  * and keeps the modal.
  *
- * The two are told apart by the running ask tool calls: a frame whose title
- * names one of their questions is theirs, and a frame that follows such a frame
- * (the `editor` omp opens after "Other (type your own)") belongs with it too.
- * Any frame left over is modal material — including an ask-shaped frame whose
- * tool call the timeline has not seen, which must stay answerable rather than
- * silently vanish.
+ * An `ask` frame is therefore NEVER modal material, in any state. It is either
+ * claimed by the card that raised it, or returned as an ORPHAN the timeline
+ * draws inline: a question whose tool call this client never saw (a subagent's,
+ * an extension's own `askDialog`, a tool call outside the loaded window) still
+ * blocks the agent, and the one place it must not appear is a dialog over the
+ * conversation. That is what an empty modal was — `ExtensionDialog` has no
+ * `ask` body, so an orphaned frame painted a panel with no question in it and a
+ * single button whose click omp rejected ("Ask dialog response must carry N
+ * answers"), leaving the run parked.
  *
- * That fallback must wait for the session's own history, though. Ownership is
- * decided against the ask tool calls in `messages`, and on session open the
+ * The claim walks two keys, because omp gives the frame less than the tool call
+ * does: the question IDS when both carry them, and the question TEXT (what
+ * omp's own per-question loop matches on). A frame that matches neither is an
+ * orphan, not a modal — and deliberately not "the only open ask", which would
+ * steal a ratchet approval or an extension's own `askDialog` into a tool card
+ * that did not raise it.
+ *
+ * The modal is also held until the session's own history has loaded. Ownership
+ * is decided against the ask tool calls in `messages`, and on session open the
  * pending dialogs are replayed from the agent-state probe — which answers out
- * of the wrapper's local flags — long before the JSONL fetch lands. Every
- * replayed frame therefore looks unowned for that window, and rendering one as
- * a modal painted the question on screen and yanked it away the instant the
- * timeline arrived and its card claimed it: the flash seen when switching to a
- * session parked on an ask. `historyLoaded` holds the modal — never the card
- * claim — until there is a timeline to decide against; a frame no card claims
- * after that still gets its modal.
+ * of the wrapper's local flags — long before the JSONL fetch lands. Rendering a
+ * replayed APPROVAL as a modal in that window painted it on screen and yanked
+ * it away the instant the timeline arrived and its card claimed it: the flash
+ * seen when switching to a session parked on an ask. `historyLoaded` holds the
+ * modal — never the card claim — until there is a timeline to decide against.
  */
 
 import { createContext, useContext } from 'preact/compat';
@@ -40,17 +48,21 @@ import type { ExtensionDialogResponse } from '@/client/components/workspace/chat
 export interface AskFramesSplit {
   /** The ask's dialogs, bucketed per question, keyed by ask tool-call id. */
   framesByTool: Map<string, ExtensionUiDialogRequest[][]>;
-  /** Oldest request no ask card owns — the one the modal renders, if any. */
+  /** Ask dialogs no card can own — the timeline draws them inline. */
+  orphanAsks: ExtensionUiDialogRequest[];
+  /** Oldest non-ask request nothing claimed — the one the modal renders. */
   modalRequest: ExtensionUiDialogRequest | null;
 }
 
 export interface AskFramesHandle {
   framesByTool: AskFramesSplit['framesByTool'];
+  /** Ask dialogs with no tool card to render them (see `orphanAsks`). */
+  orphanAsks: AskFramesSplit['orphanAsks'];
   /** Answer one ask dialog and drop it from the pending queue. */
   respond: (request: ExtensionUiDialogRequest, response: ExtensionDialogResponse) => void;
 }
 
-const EMPTY: AskFramesHandle = { framesByTool: new Map(), respond: () => {} };
+const EMPTY: AskFramesHandle = { framesByTool: new Map(), orphanAsks: [], respond: () => {} };
 
 export const AskFramesContext = createContext<AskFramesHandle>(EMPTY);
 
@@ -67,7 +79,7 @@ export function splitAskFrames(
   historyLoaded: boolean,
 ): AskFramesSplit {
   const framesByTool = new Map<string, ExtensionUiDialogRequest[][]>();
-  if (pending.length === 0) return { framesByTool, modalRequest: null };
+  if (pending.length === 0) return { framesByTool, orphanAsks: [], modalRequest: null };
 
   // Match against the asks that can still own a dialog: a reloaded session
   // reads its tool calls back from the JSONL, where a call still parked on a
@@ -95,25 +107,61 @@ export function splitAskFrames(
 
   const owned = new Map<string, ExtensionUiDialogRequest[]>();
   const claimed = new Set<ExtensionUiDialogRequest>();
+  const orphanAsks: ExtensionUiDialogRequest[] = [];
   let lastOwner: string | null = null;
 
   for (const request of pending) {
+    // An `ask` frame is never modal material, whatever it carries. A malformed
+    // one (no `questions`) has nothing for a card to draw either, but handing it
+    // to the title/lastOwner walk below would file it under an unrelated ask's
+    // question — so it is orphaned like any other cardless ask.
+    const isAskFrame = request.method === 'ask';
     // A GROUPED ask frame (`method:"ask"`, sent after `set_ask_dialog`) carries
     // every question of one call and no `title` at all, so the title walk below
     // can never place it. Its questions carry omp's own ids, which is the
     // exact key the tool call's arguments use — match on those.
-    const grouped = Array.isArray(request.questions) && request.questions.length > 0 ? request.questions : null;
+    const grouped = isAskFrame && Array.isArray(request.questions) && request.questions.length > 0
+      ? request.questions
+      : null;
+    if (isAskFrame && !grouped) {
+      if (historyLoaded) orphanAsks.push(request);
+      continue;
+    }
     if (grouped) {
       const ids = new Set(grouped.map((question) => question.id).filter(Boolean));
-      const owner = [...openAsks].reverse().find((candidate) =>
+      let groupedOwner = [...openAsks].reverse().find((candidate) =>
         candidate.questions.some((question) => question.id && ids.has(question.id)),
       );
-      if (owner) {
+      // The id walk is the exact key, but it is not the only one omp gives us:
+      // a call whose questions carry no `id` (measured on 2 of 161 real `ask`
+      // calls) yields an empty id set, and the frame then matched nothing and
+      // fell through to the MODAL — an ask dialog shown outside the timeline,
+      // which is the one place it must never be. The question TEXT is what
+      // omp's own per-question loop matches on, so it is the fallback here.
+      if (!groupedOwner) {
+        const titles = new Set(grouped.map((question) => normalizeAskText(question.question)).filter(Boolean));
+        groupedOwner = [...openAsks].reverse().find((candidate) =>
+          candidate.questions.some((question) => titles.has(normalizeAskText(question.question))),
+        );
+      }
+      if (groupedOwner) {
         claimed.add(request);
-        lastOwner = owner.toolId;
-        owned.set(owner.toolId, [...(owned.get(owner.toolId) ?? []), request]);
-        continue;
+        lastOwner = groupedOwner.toolId;
+        owned.set(groupedOwner.toolId, [...(owned.get(groupedOwner.toolId) ?? []), request]);
       }
+      // A grouped ask is NEVER modal material: with no card to claim it, it is
+      // an orphan the timeline draws inline (see the module note). It must not
+      // fall through to the title/lastOwner walk either — that walk exists for
+      // the per-question `select` loop, and handing a grouped frame to it would
+      // file one dialog under a single question.
+      //
+      // The orphan row waits for the history for the same reason the modal
+      // does: a frame replayed on session open looks cardless until the JSONL
+      // lands, so drawing it now would paint the question at the tail of the
+      // timeline and then move it onto its card. The frame stays queued, so
+      // nothing is lost — the split simply re-runs.
+      if (!groupedOwner && historyLoaded) orphanAsks.push(request);
+      continue;
     }
 
     const title = typeof request.title === 'string' ? normalizeAskText(request.title) : '';
@@ -164,9 +212,11 @@ export function splitAskFrames(
   }
 
   // The frame stays queued either way — only the modal waits for the history,
-  // so nothing is dropped and nothing flashes.
-  return {
-    framesByTool,
-    modalRequest: historyLoaded ? pending.find((request) => !claimed.has(request)) ?? null : null,
-  };
+  // so nothing is dropped and nothing flashes. An `ask` frame is excluded here
+  // in BOTH states: it is answered by a card or by the orphan row, and the
+  // modal has no body for it.
+  const modalRequest = historyLoaded
+    ? pending.find((request) => !claimed.has(request) && request.method !== 'ask') ?? null
+    : null;
+  return { framesByTool, orphanAsks, modalRequest };
 }

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

@@ -49,7 +49,7 @@ export function useChatTimeline({
   // without re-creating it (useSessionLoad is defined below the scroll hook).
   const loadOlderRef = useRef<() => void>(() => {});
 
-  const { scrollRef, contentRef, showScrollBottom, handleScroll, scrollToBottom, jumpToBottom, followRef, jumpActiveRef, jumpCountRef } = useChatTimelineScroll({
+  const { scrollRef, contentRef, showScrollBottom, readingBack, handleScroll, scrollToBottom, jumpToBottom, followRef, jumpActiveRef, jumpCountRef } = useChatTimelineScroll({
     onScrollTop: () => loadOlderRef.current(),
   });
 
@@ -324,6 +324,7 @@ export function useChatTimeline({
     scrollRef,
     contentRef,
     showScrollBottom,
+    readingBack,
     handleScroll,
     scrollToBottom,
     jumpToBottom,

package/src/client/hooks/chat/timeline/scroll-probe.test-util.ts

@@ -0,0 +1,227 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Harness for the timeline-scroll specs, shared by `scroll.test.ts` and
+ * `scroll-reading-back.test.ts`.
+ *
+ * Runs against a real DOM (happy-dom) because these are Preact hooks; geometry
+ * is faked on the container, since happy-dom does no layout. Preact binds its
+ * environment at module evaluation time, so every Preact/hook module is loaded
+ * DYNAMICALLY after the DOM globals exist — a static import would evaluate
+ * against the real (or missing) DOM and the hooks would observe nothing.
+ *
+ * The harness is a factory rather than module-level setup because two spec
+ * files share one `bun test` process: each installs its own globals in
+ * `beforeAll` and removes them in `afterAll`.
+ */
+
+import { Window } from 'happy-dom';
+import type { h as PreactH, render as PreactRender } from 'preact';
+import type { act as PreactAct } from 'preact/test-utils';
+import type {
+  useChatTimelineScroll as UseScroll,
+  ChatTimelineScrollResult,
+} from '@/client/hooks/chat/timeline/scroll';
+import type { useTimelineAutoScroll as UseAuto } from '@/client/hooks/chat/timeline/auto-scroll';
+import type { ChatMessageData } from '@/shared/types';
+
+export interface ScrollGeometry {
+  top: number;
+  height: number;
+  viewport: number;
+}
+
+export interface ScrollRecord {
+  top: number;
+  behavior?: ScrollBehavior;
+}
+
+export interface ProbeHandle {
+  holder: { current: ChatTimelineScrollResult | null };
+  node: HTMLDivElement;
+  el: HTMLDivElement;
+}
+
+interface ProbeProps {
+  sessionId: string;
+  messages: ChatMessageData[];
+  /** Holder owned by ONE test: a stale tree can only write its own hook result. */
+  holder: { current: ChatTimelineScrollResult | null };
+}
+
+/** ResizeObserver the tests drive by hand — the hook rebuilds one per content
+ *  node, so the last instance of the current mount is the live one. */
+export class StubResizeObserver {
+  static instances: StubResizeObserver[] = [];
+  static latest(): StubResizeObserver {
+    return StubResizeObserver.instances[StubResizeObserver.instances.length - 1];
+  }
+  constructor(private readonly callback: () => void) {
+    StubResizeObserver.instances.push(this);
+  }
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+  fire() {
+    this.callback();
+  }
+}
+
+export interface ScrollProbe {
+  /** Live geometry the fake scroller reports. */
+  geometry: ScrollGeometry;
+  /** Every scroll the hook asked for, in order. */
+  scrolled: ScrollRecord[];
+  StubResizeObserver: typeof StubResizeObserver;
+  /** Preact's test-utils `act`, loaded after the DOM globals exist. */
+  act: typeof PreactAct;
+  /** Drain the deferred frames the hook scheduled. */
+  flushFrames(): Promise<void>;
+  message(id: string): ChatMessageData;
+  mountProbe(sessionId: string, messages: ChatMessageData[]): Promise<ProbeHandle>;
+  updateProbe(probe: ProbeHandle, sessionId: string, messages: ChatMessageData[]): Promise<void>;
+  unmountProbe(probe: ProbeHandle): Promise<void>;
+  /** Remove the DOM globals this harness installed. */
+  teardown(): void;
+}
+
+export async function setupScrollProbe(): Promise<ScrollProbe> {
+  const win = new Window({ url: 'http://localhost' });
+  const keys = [
+    'window', 'document', 'navigator', 'Node', 'Element', 'HTMLElement', 'Event',
+  ] as const;
+  for (const key of keys) {
+    (globalThis as Record<string, unknown>)[key] = (win as unknown as Record<string, unknown>)[key];
+  }
+
+  StubResizeObserver.instances = [];
+  (globalThis as Record<string, unknown>).ResizeObserver = StubResizeObserver;
+
+  const geometry: ScrollGeometry = { top: 0, height: 5000, viewport: 500 };
+  const scrolled: ScrollRecord[] = [];
+  /** Frame callbacks the hook's observer deferred; index 0 is handle 1. */
+  const pendingFrames: Array<(() => void) | null> = [];
+
+  // The hook defers its resize-driven pin by one frame, and happy-dom's own rAF
+  // never runs without a real event loop, so the queue is drained by hand:
+  // `flushFrames()` runs whatever a delivery scheduled.
+  (globalThis as Record<string, unknown>).requestAnimationFrame = (cb: () => void) => pendingFrames.push(cb);
+  (globalThis as Record<string, unknown>).cancelAnimationFrame = (handle: number) => {
+    pendingFrames[handle - 1] = null;
+  };
+
+  /** Observe what the hook asks for; 'instant' also lands (a smooth scroll would
+   *  animate in a browser, so the fake keeps it as a recorded intent only). */
+  function applyTop(el: HTMLDivElement, value: number) {
+    geometry.top = Math.max(0, Math.min(value, geometry.height - geometry.viewport));
+    // The global `Event` the hook's listener expects: happy-dom's, installed
+    // into globalThis above.
+    el.dispatchEvent(new Event('scroll'));
+  }
+
+  function installScroller(el: HTMLDivElement) {
+    Object.defineProperty(el, 'scrollHeight', { get: () => geometry.height, configurable: true });
+    Object.defineProperty(el, 'clientHeight', { get: () => geometry.viewport, configurable: true });
+    Object.defineProperty(el, 'scrollTop', {
+      get: () => geometry.top,
+      set: (value: number) => applyTop(el, value),
+      configurable: true,
+    });
+    Object.defineProperty(el, 'scrollTo', {
+      value: (options: ScrollRecord) => {
+        scrolled.push(options);
+        if (options.behavior !== 'smooth') applyTop(el, options.top);
+      },
+      configurable: true,
+    });
+  }
+
+  // Static imports cannot work here: the modules below must load after the DOM
+  // globals are installed (see the module header).
+  const { useChatTimelineScroll }: { useChatTimelineScroll: typeof UseScroll } =
+    await import('@/client/hooks/chat/timeline/scroll');
+  const { useTimelineAutoScroll }: { useTimelineAutoScroll: typeof UseAuto } =
+    await import('@/client/hooks/chat/timeline/auto-scroll');
+  const { h, render }: { h: typeof PreactH; render: typeof PreactRender } = await import('preact');
+  const { act }: { act: typeof PreactAct } = await import('preact/test-utils');
+
+  function Probe(props: ProbeProps) {
+    const scroll = useChatTimelineScroll({});
+    useTimelineAutoScroll({
+      sessionId: props.sessionId,
+      messages: props.messages,
+      scrollRef: scroll.scrollRef,
+      jumpToBottom: scroll.jumpToBottom,
+      enabled: true,
+    });
+    props.holder.current = scroll;
+    return h('div', { ref: scroll.scrollRef, onScroll: scroll.handleScroll },
+      h('div', { ref: scroll.contentRef }));
+  }
+
+  const message = (id: string) => ({ id, role: 'user', content: id } as unknown as ChatMessageData);
+
+  /** Fresh mount, own container: `follow`, the jump counter and the observers
+   *  are per-hook state, so sharing them across tests would hide the behaviour. */
+  async function mountProbe(sessionId: string, messages: ChatMessageData[]): Promise<ProbeHandle> {
+    const holder: ProbeHandle['holder'] = { current: null };
+    const node = document.createElement('div');
+    document.body.appendChild(node);
+    await act(async () => { render(h(Probe, { sessionId, messages, holder }), node); });
+    const el = holder.current!.scrollRef.current!;
+    installScroller(el);
+    return { holder, node, el };
+  }
+
+  /** Re-render with new props: a session switch, then that session's history. */
+  async function updateProbe(probe: ProbeHandle, sessionId: string, messages: ChatMessageData[]) {
+    await act(async () => {
+      render(h(Probe, { sessionId, messages, holder: probe.holder }), probe.node);
+    });
+  }
+
+  async function unmountProbe(probe: ProbeHandle) {
+    await act(async () => { render(null, probe.node); });
+    probe.node.remove();
+  }
+
+  /**
+   * Drain the deferred frames. The resize-driven pin is deliberately NOT applied
+   * inside the ResizeObserver delivery — a layout write there makes the browser
+   * re-run its observers in the same frame, and past its depth limit it reports
+   * "ResizeObserver loop completed with undelivered notifications." — so a test
+   * that fires an observer has to let the frame it scheduled run before the
+   * geometry it asserts on has been applied.
+   */
+  async function flushFrames() {
+    for (let i = 0; i < pendingFrames.length; i++) {
+      const callback = pendingFrames[i];
+      pendingFrames[i] = null;
+      if (!callback) continue;
+      await act(async () => { callback(); });
+    }
+    pendingFrames.length = 0;
+  }
+
+  function teardown() {
+    for (const key of [...keys, 'ResizeObserver', 'requestAnimationFrame', 'cancelAnimationFrame']) {
+      delete (globalThis as Record<string, unknown>)[key];
+    }
+  }
+
+  return {
+    geometry,
+    scrolled,
+    StubResizeObserver,
+    act,
+    flushFrames,
+    message,
+    mountProbe,
+    updateProbe,
+    unmountProbe,
+    teardown,
+  };
+}

package/src/client/hooks/chat/timeline/scroll-reading-back.test.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The timeline's reading-back hysteresis, which is what a phone composer
+ * shrinks on.
+ *
+ * It is hysteretic for a reason the geometry makes unavoidable: compacting the
+ * composer GROWS the scroller's viewport by the height it gave back, which
+ * moves the reader CLOSER to the tail. A single threshold would then release
+ * the flag, restore the box, and push the reader back out — a render loop.
+ *
+ * The follow gate and the deferred re-pin live in `scroll.test.ts`; both files
+ * share `scroll-probe.test-util.ts`.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import type { ScrollProbe } from '@/client/hooks/chat/timeline/scroll-probe.test-util';
+
+let p: ScrollProbe;
+
+beforeAll(async () => {
+  // Dynamic: the harness installs the DOM globals BEFORE Preact and the hooks
+  // evaluate, which a static import would pre-empt (see the harness header).
+  const { setupScrollProbe } = await import('@/client/hooks/chat/timeline/scroll-probe.test-util');
+  p = await setupScrollProbe();
+});
+
+afterAll(() => {
+  p.teardown();
+});
+
+describe('timeline reading back', () => {
+  test('readingBack engages further back than the jump button and releases at the tail', async () => {
+    p.scrolled.length = 0;
+    p.geometry.top = 0;
+    p.geometry.height = 5000;
+    const probe = await p.mountProbe('a', [p.message('a1')]);
+    const scroll = () => probe.holder.current!;
+    /** Both flags are state, so the commit that carries them is a render. */
+    const readAt = async (top: number) => {
+      await p.act(() => { probe.el.scrollTop = top; });
+      return { jump: scroll().showScrollBottom, compact: scroll().readingBack };
+    };
+    const tail = p.geometry.height - p.geometry.viewport;
+
+    // At the tail: neither flag.
+    expect(await readAt(tail)).toEqual({ jump: false, compact: false });
+
+    // Past the jump-button threshold but short of the compaction one: the
+    // button is offered, the composer is NOT shrunk.
+    expect(await readAt(tail - 150)).toEqual({ jump: true, compact: false });
+
+    // Further back: both.
+    expect(await readAt(tail - 400)).toEqual({ jump: true, compact: true });
+
+    // Coming back: the composer stays shrunk through the jump-button window,
+    // so the 24px a compaction gives back cannot release it.
+    expect(await readAt(tail - 150)).toEqual({ jump: true, compact: true });
+
+    // The tail releases it.
+    expect(await readAt(tail)).toEqual({ jump: false, compact: false });
+    await p.unmountProbe(probe);
+  });
+});