@opengeni/react 0.34.1 → 0.34.3

package/src/components/message-timeline.tsx

@@ -32,7 +32,7 @@ import {
   type ReactNode,
 } from "react";
 import { cn } from "../lib/cn";
-import { formatRelativeTime, truncate } from "../lib/format";
+import { formatClockTime, formatRelativeTime, truncate } from "../lib/format";
 import { prefersReducedMotion } from "../lib/motion";
 import { Markdown } from "./markdown";
 import {
@@ -41,6 +41,7 @@ import {
   tipFollowCancel,
   tipFollowCompensateShrink,
   tipFollowStep,
+  supportsScrollEndEvent,
   TIP_FOLLOW_READER_UP_EPS_PX,
   TIP_FOLLOW_SHRINK_EPS_PX,
   type TipFollowState,
@@ -158,12 +159,16 @@ export type MessageTimelineProps = {
  * replaces was the "content is hidden, then pops in in batches" wobble.)
  *
  * Scroll invariant (tip-follow camera — see `./tip-follow.ts`):
- * - DOM truth mounts immediately; the camera eases down to the tip (not
+ * - Load/remount: hidden until tip is hard-snapped across a short settle; then
+ *   reveal. Live tip: DOM grows immediately; the camera eases down (not
  *   tip-glued feed-forward — that is the one-line yank).
  * - One continuous follow while hot (faster τ when behind); sleeps when cold.
  * - While pinned, tip-debt from growth/collapse must NEVER unpin — only
- *   wheel/keys/pointer-armed scroll-up. Height shrink compensates scrollTop
- *   by Δh (collapse owns motion); tip-ease pauses briefly so the two don't fight.
+ *   wheel/keys/pointer-armed scroll-up, or a settled scrollend away from the
+ *   tip while the tip-follow camera is idle (Vimium / unfocused PageUp).
+ *   Height shrink compensates scrollTop by Δh (collapse owns motion); tip-ease
+ *   pauses briefly so the two don't fight. Programmatic camera writes are
+ *   tagged so their scroll echoes never count as leave.
  * - overflow-anchor off while pinned so the browser cannot instant-correct.
  * - Scrolled up → history prepends restore via the retained group anchor
  *   (offsetTop delta); loadOlder can truncate the tip, so scrollHeight delta
@@ -288,9 +293,10 @@ export function MessageTimeline({
   const olderLoadGateRef = useRef<"armed" | "cooling">("armed");
   const resizeFollowRafRef = useRef<number | null>(null);
   const firstGroupKey = allGroups[0] ? timelineGroupKey(allGroups[0]) : null;
-  // Content stays invisible until its first bottom-anchored frame, so a flash
-  // of the window's TOP while a large timeline lays out is structurally
-  // impossible — the reader only ever sees it already at the bottom.
+  // Content stays invisible until the tip is hard-parked across a short
+  // post-commit settle (two rAFs). That absorbs sync late layout while hidden
+  // so load/remount does not ease into the tip — live tip-follow is unchanged
+  // once revealed. A flash of the window's TOP is still structurally impossible.
   const [revealed, setRevealed] = useState(false);
   // Mirror `pinned` into a ref, written ONLY by applyPinned, so the
   // ResizeObserver rAF (a stable closure) reads the live value and a snap can
@@ -325,11 +331,24 @@ export function MessageTimeline({
   const lastScrollHeightRef = useRef(0);
   const lastClientHeightRef = useRef(0);
   /**
-   * Armed by pointerdown on the scroller. Geometric scroll-up only unpins
-   * while armed — mid-turn fold+growth also drops scrollTop with a flat
-   * maxScroll and must NOT count as leave. Wheel/keys unpin directly.
+   * Armed by pointerdown on the scroller. Immediate geometric scroll-up unpins
+   * while armed (scrollbar / touch drag). Wheel/keys unpin directly. Extension
+   * jumps (Vimium) settle via scrollend while the camera is idle.
    */
   const readerIntentArmRef = useRef(false);
+  /**
+   * Count of camera/snap scrollTop writes whose scroll echoes are not yet
+   * consumed. A boolean was wrong when the browser coalesced two writes into
+   * one scroll event (or fired two) — use a count, and clear to 0 on echo.
+   */
+  const programmaticScrollRef = useRef(0);
+  /**
+   * Unarmed scroll-away observed; waiting for scrollend (or rAF fallback).
+   * Blocks layout tip-follow so a stream token cannot yank before leave settles.
+   */
+  const pendingReaderLeaveRef = useRef(false);
+  /** Fallback leave check when `scrollend` is missing (one rAF, not a timer). */
+  const leaveFallbackRafRef = useRef<number | null>(null);
   // Resting fold state per durable group id (see fold-memory.ts). Outlives the
   // deliberate chip remounts (activity→turn wrap, nested key flips) so a fold
   // that already settled closed — or that the reader closed — never reopens.
@@ -369,6 +388,27 @@ export function MessageTimeline({
     lastClientHeightRef.current = node.clientHeight;
   }, []);
 
+  const writeScrollTop = useCallback((node: HTMLElement, top: number) => {
+    const next = Math.max(0, top);
+    if (node.scrollTop === next) {
+      return;
+    }
+    programmaticScrollRef.current += 1;
+    node.scrollTop = next;
+  }, []);
+
+  const cancelLeaveFallback = useCallback(() => {
+    if (leaveFallbackRafRef.current !== null) {
+      cancelFrame(leaveFallbackRafRef.current);
+      leaveFallbackRafRef.current = null;
+    }
+  }, []);
+
+  const clearPendingReaderLeave = useCallback(() => {
+    pendingReaderLeaveRef.current = false;
+    cancelLeaveFallback();
+  }, [cancelLeaveFallback]);
+
   const stopFollow = useCallback(() => {
     followRef.current = tipFollowCancel(followRef.current);
     if (followFrameRef.current !== null) {
@@ -377,7 +417,7 @@ export function MessageTimeline({
     }
   }, []);
 
-  /** Reader left the tip — wheel, keyboard, or pointer-armed scroll-up. */
+  /** Reader left the tip — wheel, keyboard, pointer-armed scroll-up, or scrollend. */
   const releasePinFromReader = useCallback(
     (node?: HTMLElement | null) => {
       if (!autoFollow || !pinnedRef.current || hasNewerRef.current) {
@@ -388,6 +428,7 @@ export function MessageTimeline({
         return;
       }
       readerIntentArmRef.current = false;
+      clearPendingReaderLeave();
       stopFollow();
       applyPinned(false);
       if (wantPinRef.current) {
@@ -398,9 +439,51 @@ export function MessageTimeline({
         setOlderPrefetchArmed(true);
       }
     },
-    [autoFollow, applyPinned, stopFollow],
+    [autoFollow, applyPinned, clearPendingReaderLeave, stopFollow],
   );
 
+  /**
+   * Settled away from the tip while the camera is idle — Vimium / unfocused
+   * PageUp. Folds are recovered by layout tip-follow before this fires at tip.
+   */
+  const releasePinAfterScrollSettled = useCallback(
+    (node: HTMLElement) => {
+      if (!autoFollow || !pinnedRef.current || hasNewerRef.current) {
+        return;
+      }
+      if (programmaticScrollRef.current > 0) {
+        return;
+      }
+      if (followRef.current.running || followFrameRef.current !== null) {
+        return;
+      }
+      if (isNearBottom(node) || maxScrollOf(node) <= 1) {
+        clearPendingReaderLeave();
+        return;
+      }
+      releasePinFromReader(node);
+      if (olderLoadGateRef.current === "cooling" && node.scrollTop > OLDER_PREFETCH_MARGIN_PX) {
+        olderLoadGateRef.current = "armed";
+      }
+    },
+    [autoFollow, clearPendingReaderLeave, releasePinFromReader],
+  );
+
+  const scheduleLeaveFallback = useCallback(() => {
+    // Prefer scrollend when the engine supports it.
+    if (supportsScrollEndEvent()) {
+      return;
+    }
+    cancelLeaveFallback();
+    leaveFallbackRafRef.current = requestFrame(() => {
+      leaveFallbackRafRef.current = null;
+      const current = scrollRef.current;
+      if (current) {
+        releasePinAfterScrollSettled(current);
+      }
+    });
+  }, [cancelLeaveFallback, releasePinAfterScrollSettled]);
+
   const onWheel = (event: {
     deltaY: number;
     deltaX: number;
@@ -455,14 +538,15 @@ export function MessageTimeline({
   const snapToBottom = useCallback(
     (node: HTMLElement) => {
       stopFollow();
-      node.scrollTop = Math.max(0, node.scrollHeight - node.clientHeight);
+      cancelLeaveFallback();
+      writeScrollTop(node, Math.max(0, node.scrollHeight - node.clientHeight));
       syncScrollBaseline(node);
       followRef.current = {
         ...followRef.current,
         lastHeight: node.scrollHeight,
       };
     },
-    [stopFollow, syncScrollBaseline],
+    [cancelLeaveFallback, stopFollow, syncScrollBaseline, writeScrollTop],
   );
 
   const driveFollowRef = useRef<(node: HTMLElement, now?: number) => void>(() => undefined);
@@ -472,6 +556,12 @@ export function MessageTimeline({
         stopFollow();
         return;
       }
+      // Reader/extension leave in flight — do not yank back before scrollend.
+      if (pendingReaderLeaveRef.current) {
+        stopFollow();
+        return;
+      }
+      cancelLeaveFallback();
       // Prefer the rAF timestamp so ease integrates against vsync (and tests
       // can advance a synthetic clock via requestAnimationFrame callbacks).
       const now =
@@ -493,9 +583,7 @@ export function MessageTimeline({
           node.scrollHeight,
           node.clientHeight,
         );
-        if (node.scrollTop !== nextTop) {
-          node.scrollTop = nextTop;
-        }
+        writeScrollTop(node, nextTop);
         syncScrollBaseline(node);
         followRef.current = {
           ...followRef.current,
@@ -531,11 +619,10 @@ export function MessageTimeline({
         revealed: revealedRef.current,
       });
       followRef.current = result.state;
-      if (node.scrollTop !== result.scrollTop) {
-        node.scrollTop = result.scrollTop;
-      }
+      writeScrollTop(node, result.scrollTop);
       syncScrollBaseline(node);
       if (result.state.running) {
+        cancelLeaveFallback();
         if (followFrameRef.current === null) {
           followFrameRef.current = requestFrame((frameNow) => {
             followFrameRef.current = null;
@@ -550,11 +637,12 @@ export function MessageTimeline({
         followFrameRef.current = null;
       }
     },
-    [stopFollow, syncScrollBaseline],
+    [cancelLeaveFallback, stopFollow, syncScrollBaseline, writeScrollTop],
   );
   driveFollowRef.current = driveFollow;
 
   useEffect(() => stopFollow, [stopFollow]);
+  useEffect(() => () => cancelLeaveFallback(), [cancelLeaveFallback]);
 
   // The single post-commit scroll authority. Runs after EVERY commit (no dep
   // list): any commit may change content height, and the decision is cheap.
@@ -578,7 +666,7 @@ export function MessageTimeline({
       // prepend correction (it would shift the reader away from the top).
       pendingJumpToStartRef.current = false;
       stopFollow();
-      node.scrollTop = 0;
+      writeScrollTop(node, 0);
     } else if (wantPinRef.current && !hasNewer) {
       // Jump-to-latest was pressed on a history window and the tip window is
       // in THIS commit — consume pre-paint so the first tip frame is already
@@ -589,8 +677,19 @@ export function MessageTimeline({
         snapToBottom(node);
       }
     } else if (autoFollow && pinnedRef.current && !hasNewer) {
-      // Live tip: tip-follow camera eases down (snap only first paint / jumps).
-      driveFollow(node);
+      // Load/remount (still hidden): hard-park. Live tip after reveal: ease.
+      // Pending unarmed leave: tip *growth* must not yank (Vimium during stream).
+      // Flat/shrink commits (fold) still recover — height did not grow under us.
+      if (!revealedRef.current) {
+        snapToBottom(node);
+      } else if (pendingReaderLeaveRef.current) {
+        if (node.scrollHeight <= lastScrollHeightRef.current) {
+          clearPendingReaderLeave();
+          driveFollow(node);
+        }
+      } else {
+        driveFollow(node);
+      }
     } else if (prepended) {
       // Keep the reader on the same retained rows. Prefer the offsetTop delta
       // of the group that still holds the previous first item — that stays
@@ -622,7 +721,7 @@ export function MessageTimeline({
       if (delta !== null) {
         const expected = previousScrollTop + delta;
         if (Math.abs(node.scrollTop - expected) > 2) {
-          node.scrollTop = expected;
+          writeScrollTop(node, expected);
         }
       }
     }
@@ -661,11 +760,46 @@ export function MessageTimeline({
       }
       groupOffsetByKeyRef.current = nextOffsetByKey;
     }
-    if (!revealed && groups.length > 0) {
-      setRevealed(true);
-    }
   });
 
+  // First paint / session remount: keep the scroller hidden, snap to tip for
+  // two animation frames (late sync layout), then reveal. Does not change the
+  // tip-follow ease law used once `revealed` is true.
+  useLayoutEffect(() => {
+    if (revealed || allGroups.length === 0) {
+      return;
+    }
+    let cancelled = false;
+    let frame2 = 0;
+    const park = () => {
+      const node = scrollRef.current;
+      if (node && autoFollow && pinnedRef.current && !hasNewerRef.current) {
+        snapToBottom(node);
+      }
+    };
+    park();
+    const frame1 = requestFrame(() => {
+      if (cancelled) {
+        return;
+      }
+      park();
+      frame2 = requestFrame(() => {
+        if (cancelled) {
+          return;
+        }
+        park();
+        setRevealed(true);
+      });
+    });
+    return () => {
+      cancelled = true;
+      cancelFrame(frame1);
+      if (frame2 !== 0) {
+        cancelFrame(frame2);
+      }
+    };
+  }, [revealed, allGroups.length, autoFollow, snapToBottom]);
+
   // A cleared timeline (stream identity change) re-arms the reveal + prefetch
   // gate and returns to bottom-follow for the next session's first paint.
   useLayoutEffect(() => {
@@ -792,9 +926,15 @@ export function MessageTimeline({
         if (!current) {
           return;
         }
-        if (autoFollow && pinnedRef.current && !hasNewerRef.current) {
-          driveFollow(current);
+        if (!autoFollow || !pinnedRef.current || hasNewerRef.current) {
+          return;
+        }
+        // Still unveiling the first tip frame: hard-park (no ease settle).
+        if (!revealedRef.current) {
+          snapToBottom(current);
+          return;
         }
+        driveFollow(current);
       });
     });
     observer.observe(inner);
@@ -808,7 +948,7 @@ export function MessageTimeline({
         resizeFollowRafRef.current = null;
       }
     };
-  }, [autoFollow, driveFollow]);
+  }, [autoFollow, driveFollow, snapToBottom]);
 
   // Entering a non-tip history window: drop any live pin so the page bottom
   // cannot re-stick follow across loadNewer. Leaving it (the tip window
@@ -838,9 +978,9 @@ export function MessageTimeline({
     }
   }, [hasNewer, autoFollow, applyPinned, snapToBottom, stopFollow]);
 
-  // Unpin: wheel / keys always; pointer-armed geometric scroll-up only.
-  // Mid-turn fold + narration drops scrollTop while maxScroll stays flat —
-  // treating that as reader-up was the Jump-to-latest bug on soft-follow.
+  // Pinned: layout/camera recover tip debt; wheel/keys/pointer-arm unpin
+  // immediately; extension jumps settle via scrollend (or one-rAF fallback).
+  // Do not tip-follow-yank an in-flight unarmed scroll-away — that ate Vimium.
   const onScroll = () => {
     const node = scrollRef.current;
     if (!node) {
@@ -857,17 +997,34 @@ export function MessageTimeline({
     const heightShrunk =
       followRef.current.lastHeight > 0 &&
       nextHeight < followRef.current.lastHeight - TIP_FOLLOW_SHRINK_EPS_PX;
+    // Consume all pending camera-write echoes (browsers may coalesce writes).
+    const programmatic = programmaticScrollRef.current > 0;
+    if (programmatic) {
+      programmaticScrollRef.current = 0;
+    }
 
     if (autoFollow && pinnedRef.current && !hasNewer) {
       // Fold / composer shrink: compensate before baseline sync so driveFollow
       // still sees the pre-shrink scrollTop (avoid double-subtract after clamp).
       if (heightShrunk || maxFell) {
         readerIntentArmRef.current = false;
+        clearPendingReaderLeave();
         driveFollow(node);
         return;
       }
+      if (programmatic) {
+        syncScrollBaseline(node);
+        followRef.current = {
+          ...followRef.current,
+          lastHeight: nextHeight,
+        };
+        return;
+      }
       syncScrollBaseline(node);
       const nearBottomPinned = isNearBottom(node);
+      if (nearBottomPinned) {
+        clearPendingReaderLeave();
+      }
       // Pointer-dragged scroll-up away from tip. Layout churn never arms this.
       if (readerArmed && readerUp > TIP_FOLLOW_READER_UP_EPS_PX && !nearBottomPinned) {
         readerIntentArmRef.current = false;
@@ -877,9 +1034,15 @@ export function MessageTimeline({
         }
         return;
       }
-      // Growth debt / fold noise / camera echo: stay pinned and recover tip.
-      if (!nearBottomPinned || readerUp > TIP_FOLLOW_READER_UP_EPS_PX) {
-        driveFollow(node);
+      // Tip grew under a still viewport (no reader-up): ease back to the tip.
+      // Reader/extension scroll-up in progress: do not yank — scrollend decides.
+      if (!nearBottomPinned && readerUp <= TIP_FOLLOW_READER_UP_EPS_PX) {
+        if (!pendingReaderLeaveRef.current) {
+          driveFollow(node);
+        }
+      } else if (!nearBottomPinned && readerUp > TIP_FOLLOW_READER_UP_EPS_PX) {
+        pendingReaderLeaveRef.current = true;
+        scheduleLeaveFallback();
       } else {
         followRef.current = {
           ...followRef.current,
@@ -922,6 +1085,20 @@ export function MessageTimeline({
     }
   };
 
+  const onScrollEnd = () => {
+    const node = scrollRef.current;
+    if (!node) {
+      return;
+    }
+    cancelLeaveFallback();
+    if (programmaticScrollRef.current > 0) {
+      programmaticScrollRef.current = 0;
+      syncScrollBaseline(node);
+      return;
+    }
+    releasePinAfterScrollSettled(node);
+  };
+
   return (
     <LightboxProvider>
       <FoldMemoryProvider value={foldMemoryRef.current}>
@@ -935,6 +1112,7 @@ export function MessageTimeline({
                   ref={scrollRef}
                   tabIndex={-1}
                   onScroll={onScroll}
+                  onScrollEnd={onScrollEnd}
                   onWheel={onWheel}
                   onPointerDown={onPointerDown}
                   onKeyDown={onKeyDown}
@@ -1787,6 +1965,22 @@ function compactionSkipSubtitle(reason: string | null): string {
   }
 }
 
+/** Hover-reveal clock beside the copy control (sent / finished). */
+function MessageFooterTime({ occurredAt }: { occurredAt: string }) {
+  return (
+    <time
+      dateTime={occurredAt}
+      className={cn(
+        "shrink-0 tabular-nums text-og-xs text-og-fg-subtle",
+        "opacity-0 transition-opacity duration-150",
+        "group-hover/copy:opacity-100 group-focus-within/copy:opacity-100 pointer-coarse:opacity-70",
+      )}
+    >
+      {formatClockTime(occurredAt)}
+    </time>
+  );
+}
+
 function UserMessageRow({
   item,
   renderMessageText,
@@ -1804,6 +1998,7 @@ function UserMessageRow({
           copyText={item.text}
           label="Copy message"
           className="w-fit max-w-full min-w-0"
+          trailing={<MessageFooterTime occurredAt={item.occurredAt} />}
         >
           <div className="w-fit max-w-full min-w-0 rounded-og-lg rounded-br-og-xs border border-og-border bg-og-surface-2 px-4 py-2.5 text-og-md leading-6 text-og-fg">
             {renderMessageText ? (
@@ -1835,13 +2030,15 @@ function AgentMessageRow({
   ) : (
     <Markdown streaming={item.streaming}>{item.text}</Markdown>
   );
-  // While streaming, copy is still useful (current text) but keep chrome calm.
+  // While streaming, copy is still useful (current text) but keep chrome calm —
+  // stamp only after the message finishes (occurredAt tracks completion).
   return (
     <CopyHoverFrame
       copyText={item.text}
       label="Copy message"
-      align="end"
+      align="start"
       className={cn(enter && "animate-og-enter", "min-w-0 text-og-md leading-7 text-og-fg")}
+      trailing={item.streaming ? null : <MessageFooterTime occurredAt={item.occurredAt} />}
     >
       {body}
     </CopyHoverFrame>

package/src/components/tip-follow.ts

@@ -81,6 +81,21 @@ export const TIP_FOLLOW_VELOCITY_ARM_DEBT_PX = 72;
 export const TIP_FOLLOW_VELOCITY_DECAY_MS = _t(180);
 /** Reader-up pixels above clamp budget that count as leaving the tip. */
 export const TIP_FOLLOW_READER_UP_EPS_PX = 2;
+
+/** Test-only override for scrollend feature detection (`null` = probe DOM). */
+let scrollEndSupportOverride: boolean | null = null;
+
+/** @internal */ export function setScrollEndSupportForTests(value: boolean | null): void {
+  scrollEndSupportOverride = value;
+}
+
+/** True when the engine exposes element `scrollend` (prefer over rAF leave). */
+export function supportsScrollEndEvent(): boolean {
+  if (scrollEndSupportOverride !== null) {
+    return scrollEndSupportOverride;
+  }
+  return typeof HTMLElement !== "undefined" && "onscrollend" in HTMLElement.prototype;
+}
 /** @deprecated Shrink lock removed; kept so old imports do not break. */
 export const TIP_FOLLOW_SHRINK_LOCK_MS = 0;
 /** @deprecated Absorb thresholds removed — growth track is continuous. */

package/src/composer.ts

@@ -3,6 +3,7 @@
  *
  * `import * as Composer from "@opengeni/react/composer"`.
  */
+export { OPEN_WORKSTREAM_CONTROL_EVENT } from "./workstream-control-event";
 export {
   Actions,
   AttachButton,
@@ -16,7 +17,6 @@ export {
   Hint,
   Input,
   ModelPicker,
-  OPEN_WORKSTREAM_CONTROL_EVENT,
   PauseButton,
   PausedState,
   RestoredResources,

package/src/hooks/use-composer.ts

@@ -420,7 +420,13 @@ export function useComposer(
         localSignatureAtStart === null
           ? localAtStart !== 0
           : localSignatureAtStart !== lastSavedSignature.current;
-      setDraftLoading(true);
+      // Only blank the picker on first hydrate / hard reload. Reconcile and
+      // event-triggered soft reloads (loadOlder SSE reconnect) must not flicker
+      // draftLoading — stale-while-revalidate keeps the settled UI mounted.
+      const showLoading = replaceLocal || draftRef.current === null;
+      if (showLoading) {
+        setDraftLoading(true);
+      }
       try {
         const fetched = await client.getComposerDraft(workspaceId, sessionId);
         if (

package/src/hooks/use-workspace-capture.ts

@@ -315,6 +315,12 @@ export function useWorkspaceCapture(
     if (!enabled) return;
     if (visibleAnnouncedRevision === null) return;
     if (loadedRevision !== null && visibleAnnouncedRevision <= loadedRevision) return;
+    // The mount request is already resolving the latest revision. Do not abort
+    // and replace that exact identity-equivalent read merely because the event
+    // tail announced a revision before the response arrived. When the request
+    // settles, its state update re-runs this effect and a genuinely newer
+    // announcement still refreshes immediately.
+    if (requestAbortRef.current) return;
     // A newer capture exists than the one we hold (or we hold none) — pull it.
     void refresh();
   }, [enabled, visibleAnnouncedRevision, loadedRevision, refresh]);

package/src/index.ts

@@ -100,7 +100,7 @@ export type {
   SessionChromeSignalTone,
 } from "./components/session-chrome";
 export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "./components/tooltip";
-export { OPEN_WORKSTREAM_CONTROL_EVENT } from "./components/chat-composer";
+export { OPEN_WORKSTREAM_CONTROL_EVENT } from "./workstream-control-event";
 export { useGoal, isGoalEvent } from "./hooks/use-goal";
 export type { UseGoalOptions, UseGoalResult } from "./hooks/use-goal";
 export { useSessionControl } from "./hooks/use-session-control";
@@ -486,6 +486,7 @@ export { cn } from "./lib/cn";
 export {
   CREDIT_EXHAUSTION_MESSAGE,
   formatBytes,
+  formatClockTime,
   formatRelativeTime,
   humanizeFailureReason,
   isCreditExhaustion,

package/src/lib/format.ts

@@ -1,5 +1,19 @@
 import { OpenGeniApiError } from "@opengeni/sdk";
 
+/** Local finished-at stamp for message footers: "Aug 2, 3:42 PM" / locale-equivalent. */
+export function formatClockTime(iso: string): string {
+  const then = new Date(iso);
+  if (Number.isNaN(then.getTime())) {
+    return "";
+  }
+  return then.toLocaleString(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  });
+}
+
 /** Compact relative time: "now", "42s", "7m", "3h", "2d", then a date. */
 export function formatRelativeTime(iso: string, now: Date = new Date()): string {
   const then = new Date(iso).getTime();

package/src/timeline/index.ts

@@ -22,7 +22,9 @@ export {
   extractSessionRef,
   groupTimeline,
   sessionStatusFromEvents,
+  mcpToolLeaf,
   toolDisplayName,
+  toolMatchesLeaf,
 } from "./projection";
 
 // item types

package/src/timeline/parsers.ts

@@ -227,6 +227,19 @@ export function applyPatchOps(raw: unknown): ApplyPatchOperation[] {
   return r.operation ? [r.operation] : [];
 }
 
+/** Ops from provider `raw`, or from function-tool arguments when raw is empty. */
+export function applyPatchOpsFromToolItem(item: {
+  raw: unknown;
+  arguments: unknown;
+}): ApplyPatchOperation[] {
+  const fromRaw = applyPatchOps(item.raw);
+  if (fromRaw.length > 0) {
+    return fromRaw;
+  }
+  const args = parseToolArgs(item.arguments);
+  return applyPatchOps(args);
+}
+
 /**
  * True when a tool item is an `apply_patch_call` — by its provider-native
  * `raw.type` (the live-wire source of truth) or by tool `name` (first-party
@@ -235,7 +248,11 @@ export function applyPatchOps(raw: unknown): ApplyPatchOperation[] {
 export function isApplyPatch(item: { name: string; raw: unknown }): boolean {
   const type =
     item.raw && typeof item.raw === "object" ? (item.raw as { type?: unknown }).type : undefined;
-  return type === "apply_patch_call" || item.name === "apply_patch_call";
+  if (type === "apply_patch_call") {
+    return true;
+  }
+  const name = item.name;
+  return name === "apply_patch_call" || name === "apply_patch" || name.endsWith("__apply_patch");
 }
 
 /* --- secret redaction ------------------------------------------------------- */