@xelauvas/xela-cli 0.1.0

package/src/hooks/useArrowKeyHistory.tsx

@@ -0,0 +1,229 @@
+import React, { useCallback, useRef, useState } from 'react';
+import { getModeFromInput } from 'src/components/PromptInput/inputModes.js';
+import { useNotifications } from 'src/context/notifications.js';
+import { ConfigurableShortcutHint } from '../components/ConfigurableShortcutHint.js';
+import { FOOTER_TEMPORARY_STATUS_TIMEOUT } from '../components/PromptInput/Notifications.js';
+import { getHistory } from '../history.js';
+import { Text } from '../ink.js';
+import type { PromptInputMode } from '../types/textInputTypes.js';
+import type { HistoryEntry, PastedContent } from '../utils/config.js';
+export type HistoryMode = PromptInputMode;
+
+// Load history entries in chunks to reduce disk reads on rapid keypresses
+const HISTORY_CHUNK_SIZE = 10;
+
+// Shared state for batching concurrent load requests into a single disk read
+// Mode filter is included to ensure we don't mix filtered and unfiltered caches
+let pendingLoad: Promise<HistoryEntry[]> | null = null;
+let pendingLoadTarget = 0;
+let pendingLoadModeFilter: HistoryMode | undefined = undefined;
+async function loadHistoryEntries(minCount: number, modeFilter?: HistoryMode): Promise<HistoryEntry[]> {
+  // Round up to next chunk to avoid repeated small reads
+  const target = Math.ceil(minCount / HISTORY_CHUNK_SIZE) * HISTORY_CHUNK_SIZE;
+
+  // If a load is already pending with the same mode filter and will satisfy our needs, wait for it
+  if (pendingLoad && pendingLoadTarget >= target && pendingLoadModeFilter === modeFilter) {
+    return pendingLoad;
+  }
+
+  // If a load is pending but won't satisfy our needs or has different filter, we need to wait for it
+  // to complete first, then start a new one (can't interrupt an ongoing read)
+  if (pendingLoad) {
+    await pendingLoad;
+  }
+
+  // Start a new load
+  pendingLoadTarget = target;
+  pendingLoadModeFilter = modeFilter;
+  pendingLoad = (async () => {
+    const entries: HistoryEntry[] = [];
+    let loaded = 0;
+    for await (const entry of getHistory()) {
+      // If mode filter is specified, only include entries that match the mode
+      if (modeFilter) {
+        const entryMode = getModeFromInput(entry.display);
+        if (entryMode !== modeFilter) {
+          continue;
+        }
+      }
+      entries.push(entry);
+      loaded++;
+      if (loaded >= pendingLoadTarget) break;
+    }
+    return entries;
+  })();
+  try {
+    return await pendingLoad;
+  } finally {
+    pendingLoad = null;
+    pendingLoadTarget = 0;
+    pendingLoadModeFilter = undefined;
+  }
+}
+export function useArrowKeyHistory(onSetInput: (value: string, mode: HistoryMode, pastedContents: Record<number, PastedContent>) => void, currentInput: string, pastedContents: Record<number, PastedContent>, setCursorOffset?: (offset: number) => void, currentMode?: HistoryMode): {
+  historyIndex: number;
+  setHistoryIndex: (index: number) => void;
+  onHistoryUp: () => void;
+  onHistoryDown: () => boolean;
+  resetHistory: () => void;
+  dismissSearchHint: () => void;
+} {
+  const [historyIndex, setHistoryIndex] = useState(0);
+  const [lastShownHistoryEntry, setLastShownHistoryEntry] = useState<(HistoryEntry & {
+    mode?: HistoryMode;
+  }) | undefined>(undefined);
+  const hasShownSearchHintRef = useRef(false);
+  const {
+    addNotification,
+    removeNotification
+  } = useNotifications();
+
+  // Cache loaded history entries
+  const historyCache = useRef<HistoryEntry[]>([]);
+  // Track which mode filter the cache was loaded with
+  const historyCacheModeFilter = useRef<HistoryMode | undefined>(undefined);
+
+  // Synchronous tracker for history index to avoid stale closure issues
+  // React state updates are async, so rapid keypresses can see stale values
+  const historyIndexRef = useRef(0);
+
+  // Track the mode filter that was active when history navigation started
+  // This is set on the first arrow press and stays fixed until reset
+  const initialModeFilterRef = useRef<HistoryMode | undefined>(undefined);
+
+  // Refs to track current input values for draft preservation
+  // These ensure we capture the draft with the latest values, not stale closure values
+  const currentInputRef = useRef(currentInput);
+  const pastedContentsRef = useRef(pastedContents);
+  const currentModeRef = useRef(currentMode);
+
+  // Keep refs in sync with props (synchronous update on each render)
+  currentInputRef.current = currentInput;
+  pastedContentsRef.current = pastedContents;
+  currentModeRef.current = currentMode;
+  const setInputWithCursor = useCallback((value: string, mode: HistoryMode, contents: Record<number, PastedContent>, cursorToStart = false): void => {
+    onSetInput(value, mode, contents);
+    setCursorOffset?.(cursorToStart ? 0 : value.length);
+  }, [onSetInput, setCursorOffset]);
+  const updateInput = useCallback((input: HistoryEntry | undefined, cursorToStart_0 = false): void => {
+    if (!input || !input.display) return;
+    const mode_0 = getModeFromInput(input.display);
+    const value_0 = mode_0 === 'bash' ? input.display.slice(1) : input.display;
+    setInputWithCursor(value_0, mode_0, input.pastedContents ?? {}, cursorToStart_0);
+  }, [setInputWithCursor]);
+  const showSearchHint = useCallback((): void => {
+    addNotification({
+      key: 'search-history-hint',
+      jsx: <Text dimColor>
+          <ConfigurableShortcutHint action="history:search" context="Global" fallback="ctrl+r" description="search history" />
+        </Text>,
+      priority: 'immediate',
+      timeoutMs: FOOTER_TEMPORARY_STATUS_TIMEOUT
+    });
+  }, [addNotification]);
+  const onHistoryUp = useCallback((): void => {
+    // Capture and increment synchronously to handle rapid keypresses
+    const targetIndex = historyIndexRef.current;
+    historyIndexRef.current++;
+    const inputAtPress = currentInputRef.current;
+    const pastedContentsAtPress = pastedContentsRef.current;
+    const modeAtPress = currentModeRef.current;
+    if (targetIndex === 0) {
+      initialModeFilterRef.current = modeAtPress === 'bash' ? modeAtPress : undefined;
+
+      // Save draft synchronously using refs for the latest values
+      // This ensures we capture the draft before any async operations or re-renders
+      const hasInput = inputAtPress.trim() !== '';
+      setLastShownHistoryEntry(hasInput ? {
+        display: inputAtPress,
+        pastedContents: pastedContentsAtPress,
+        mode: modeAtPress
+      } : undefined);
+    }
+    const modeFilter = initialModeFilterRef.current;
+    void (async () => {
+      const neededCount = targetIndex + 1; // How many entries we need
+
+      // If mode filter changed, invalidate cache
+      if (historyCacheModeFilter.current !== modeFilter) {
+        historyCache.current = [];
+        historyCacheModeFilter.current = modeFilter;
+        historyIndexRef.current = 0;
+      }
+
+      // Load more entries if needed
+      if (historyCache.current.length < neededCount) {
+        // Batches concurrent requests - rapid keypresses share a single disk read
+        const entries = await loadHistoryEntries(neededCount, modeFilter);
+        // Only update cache if we loaded more than currently cached
+        // (handles race condition where multiple loads complete out of order)
+        if (entries.length > historyCache.current.length) {
+          historyCache.current = entries;
+        }
+      }
+
+      // Check if we can navigate
+      if (targetIndex >= historyCache.current.length) {
+        // Rollback the ref since we can't navigate
+        historyIndexRef.current--;
+        // Keep the draft intact - user stays on their current input
+        return;
+      }
+      const newIndex = targetIndex + 1;
+      setHistoryIndex(newIndex);
+      updateInput(historyCache.current[targetIndex], true);
+
+      // Show hint once per session after navigating through 2 history entries
+      if (newIndex >= 2 && !hasShownSearchHintRef.current) {
+        hasShownSearchHintRef.current = true;
+        showSearchHint();
+      }
+    })();
+  }, [updateInput, showSearchHint]);
+  const onHistoryDown = useCallback((): boolean => {
+    // Use the ref for consistent reads
+    const currentIndex = historyIndexRef.current;
+    if (currentIndex > 1) {
+      historyIndexRef.current--;
+      setHistoryIndex(currentIndex - 1);
+      updateInput(historyCache.current[currentIndex - 2]);
+    } else if (currentIndex === 1) {
+      historyIndexRef.current = 0;
+      setHistoryIndex(0);
+      if (lastShownHistoryEntry) {
+        // Restore the draft with its saved mode if available
+        const savedMode = lastShownHistoryEntry.mode;
+        if (savedMode) {
+          setInputWithCursor(lastShownHistoryEntry.display, savedMode, lastShownHistoryEntry.pastedContents ?? {});
+        } else {
+          updateInput(lastShownHistoryEntry);
+        }
+      } else {
+        // When in filtered mode, stay in that mode when clearing input
+        setInputWithCursor('', initialModeFilterRef.current ?? 'prompt', {});
+      }
+    }
+    return currentIndex <= 0;
+  }, [lastShownHistoryEntry, updateInput, setInputWithCursor]);
+  const resetHistory = useCallback((): void => {
+    setLastShownHistoryEntry(undefined);
+    setHistoryIndex(0);
+    historyIndexRef.current = 0;
+    initialModeFilterRef.current = undefined;
+    removeNotification('search-history-hint');
+    historyCache.current = [];
+    historyCacheModeFilter.current = undefined;
+  }, [removeNotification]);
+  const dismissSearchHint = useCallback((): void => {
+    removeNotification('search-history-hint');
+  }, [removeNotification]);
+  return {
+    historyIndex,
+    setHistoryIndex,
+    onHistoryUp,
+    onHistoryDown,
+    resetHistory,
+    dismissSearchHint
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useRef","useState","getModeFromInput","useNotifications","ConfigurableShortcutHint","FOOTER_TEMPORARY_STATUS_TIMEOUT","getHistory","Text","PromptInputMode","HistoryEntry","PastedContent","HistoryMode","HISTORY_CHUNK_SIZE","pendingLoad","Promise","pendingLoadTarget","pendingLoadModeFilter","undefined","loadHistoryEntries","minCount","modeFilter","target","Math","ceil","entries","loaded","entry","entryMode","display","push","useArrowKeyHistory","onSetInput","value","mode","pastedContents","Record","currentInput","setCursorOffset","offset","currentMode","historyIndex","setHistoryIndex","index","onHistoryUp","onHistoryDown","resetHistory","dismissSearchHint","lastShownHistoryEntry","setLastShownHistoryEntry","hasShownSearchHintRef","addNotification","removeNotification","historyCache","historyCacheModeFilter","historyIndexRef","initialModeFilterRef","currentInputRef","pastedContentsRef","currentModeRef","current","setInputWithCursor","contents","cursorToStart","length","updateInput","input","slice","showSearchHint","key","jsx","priority","timeoutMs","targetIndex","inputAtPress","pastedContentsAtPress","modeAtPress","hasInput","trim","neededCount","newIndex","currentIndex","savedMode"],"sources":["useArrowKeyHistory.tsx"],"sourcesContent":["import React, { useCallback, useRef, useState } from 'react'\nimport { getModeFromInput } from 'src/components/PromptInput/inputModes.js'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { ConfigurableShortcutHint } from '../components/ConfigurableShortcutHint.js'\nimport { FOOTER_TEMPORARY_STATUS_TIMEOUT } from '../components/PromptInput/Notifications.js'\nimport { getHistory } from '../history.js'\nimport { Text } from '../ink.js'\nimport type { PromptInputMode } from '../types/textInputTypes.js'\nimport type { HistoryEntry, PastedContent } from '../utils/config.js'\n\nexport type HistoryMode = PromptInputMode\n\n// Load history entries in chunks to reduce disk reads on rapid keypresses\nconst HISTORY_CHUNK_SIZE = 10\n\n// Shared state for batching concurrent load requests into a single disk read\n// Mode filter is included to ensure we don't mix filtered and unfiltered caches\nlet pendingLoad: Promise<HistoryEntry[]> | null = null\nlet pendingLoadTarget = 0\nlet pendingLoadModeFilter: HistoryMode | undefined = undefined\n\nasync function loadHistoryEntries(\n  minCount: number,\n  modeFilter?: HistoryMode,\n): Promise<HistoryEntry[]> {\n  // Round up to next chunk to avoid repeated small reads\n  const target = Math.ceil(minCount / HISTORY_CHUNK_SIZE) * HISTORY_CHUNK_SIZE\n\n  // If a load is already pending with the same mode filter and will satisfy our needs, wait for it\n  if (\n    pendingLoad &&\n    pendingLoadTarget >= target &&\n    pendingLoadModeFilter === modeFilter\n  ) {\n    return pendingLoad\n  }\n\n  // If a load is pending but won't satisfy our needs or has different filter, we need to wait for it\n  // to complete first, then start a new one (can't interrupt an ongoing read)\n  if (pendingLoad) {\n    await pendingLoad\n  }\n\n  // Start a new load\n  pendingLoadTarget = target\n  pendingLoadModeFilter = modeFilter\n  pendingLoad = (async () => {\n    const entries: HistoryEntry[] = []\n    let loaded = 0\n    for await (const entry of getHistory()) {\n      // If mode filter is specified, only include entries that match the mode\n      if (modeFilter) {\n        const entryMode = getModeFromInput(entry.display)\n        if (entryMode !== modeFilter) {\n          continue\n        }\n      }\n      entries.push(entry)\n      loaded++\n      if (loaded >= pendingLoadTarget) break\n    }\n    return entries\n  })()\n\n  try {\n    return await pendingLoad\n  } finally {\n    pendingLoad = null\n    pendingLoadTarget = 0\n    pendingLoadModeFilter = undefined\n  }\n}\n\nexport function useArrowKeyHistory(\n  onSetInput: (\n    value: string,\n    mode: HistoryMode,\n    pastedContents: Record<number, PastedContent>,\n  ) => void,\n  currentInput: string,\n  pastedContents: Record<number, PastedContent>,\n  setCursorOffset?: (offset: number) => void,\n  currentMode?: HistoryMode,\n): {\n  historyIndex: number\n  setHistoryIndex: (index: number) => void\n  onHistoryUp: () => void\n  onHistoryDown: () => boolean\n  resetHistory: () => void\n  dismissSearchHint: () => void\n} {\n  const [historyIndex, setHistoryIndex] = useState(0)\n  const [lastShownHistoryEntry, setLastShownHistoryEntry] = useState<\n    (HistoryEntry & { mode?: HistoryMode }) | undefined\n  >(undefined)\n  const hasShownSearchHintRef = useRef(false)\n  const { addNotification, removeNotification } = useNotifications()\n\n  // Cache loaded history entries\n  const historyCache = useRef<HistoryEntry[]>([])\n  // Track which mode filter the cache was loaded with\n  const historyCacheModeFilter = useRef<HistoryMode | undefined>(undefined)\n\n  // Synchronous tracker for history index to avoid stale closure issues\n  // React state updates are async, so rapid keypresses can see stale values\n  const historyIndexRef = useRef(0)\n\n  // Track the mode filter that was active when history navigation started\n  // This is set on the first arrow press and stays fixed until reset\n  const initialModeFilterRef = useRef<HistoryMode | undefined>(undefined)\n\n  // Refs to track current input values for draft preservation\n  // These ensure we capture the draft with the latest values, not stale closure values\n  const currentInputRef = useRef(currentInput)\n  const pastedContentsRef = useRef(pastedContents)\n  const currentModeRef = useRef(currentMode)\n\n  // Keep refs in sync with props (synchronous update on each render)\n  currentInputRef.current = currentInput\n  pastedContentsRef.current = pastedContents\n  currentModeRef.current = currentMode\n\n  const setInputWithCursor = useCallback(\n    (\n      value: string,\n      mode: HistoryMode,\n      contents: Record<number, PastedContent>,\n      cursorToStart = false,\n    ): void => {\n      onSetInput(value, mode, contents)\n      setCursorOffset?.(cursorToStart ? 0 : value.length)\n    },\n    [onSetInput, setCursorOffset],\n  )\n\n  const updateInput = useCallback(\n    (input: HistoryEntry | undefined, cursorToStart = false): void => {\n      if (!input || !input.display) return\n\n      const mode = getModeFromInput(input.display)\n      const value = mode === 'bash' ? input.display.slice(1) : input.display\n\n      setInputWithCursor(value, mode, input.pastedContents ?? {}, cursorToStart)\n    },\n    [setInputWithCursor],\n  )\n\n  const showSearchHint = useCallback((): void => {\n    addNotification({\n      key: 'search-history-hint',\n      jsx: (\n        <Text dimColor>\n          <ConfigurableShortcutHint\n            action=\"history:search\"\n            context=\"Global\"\n            fallback=\"ctrl+r\"\n            description=\"search history\"\n          />\n        </Text>\n      ),\n      priority: 'immediate',\n      timeoutMs: FOOTER_TEMPORARY_STATUS_TIMEOUT,\n    })\n  }, [addNotification])\n\n  const onHistoryUp = useCallback((): void => {\n    // Capture and increment synchronously to handle rapid keypresses\n    const targetIndex = historyIndexRef.current\n    historyIndexRef.current++\n\n    const inputAtPress = currentInputRef.current\n    const pastedContentsAtPress = pastedContentsRef.current\n    const modeAtPress = currentModeRef.current\n\n    if (targetIndex === 0) {\n      initialModeFilterRef.current =\n        modeAtPress === 'bash' ? modeAtPress : undefined\n\n      // Save draft synchronously using refs for the latest values\n      // This ensures we capture the draft before any async operations or re-renders\n      const hasInput = inputAtPress.trim() !== ''\n      setLastShownHistoryEntry(\n        hasInput\n          ? {\n              display: inputAtPress,\n              pastedContents: pastedContentsAtPress,\n              mode: modeAtPress,\n            }\n          : undefined,\n      )\n    }\n\n    const modeFilter = initialModeFilterRef.current\n\n    void (async () => {\n      const neededCount = targetIndex + 1 // How many entries we need\n\n      // If mode filter changed, invalidate cache\n      if (historyCacheModeFilter.current !== modeFilter) {\n        historyCache.current = []\n        historyCacheModeFilter.current = modeFilter\n        historyIndexRef.current = 0\n      }\n\n      // Load more entries if needed\n      if (historyCache.current.length < neededCount) {\n        // Batches concurrent requests - rapid keypresses share a single disk read\n        const entries = await loadHistoryEntries(neededCount, modeFilter)\n        // Only update cache if we loaded more than currently cached\n        // (handles race condition where multiple loads complete out of order)\n        if (entries.length > historyCache.current.length) {\n          historyCache.current = entries\n        }\n      }\n\n      // Check if we can navigate\n      if (targetIndex >= historyCache.current.length) {\n        // Rollback the ref since we can't navigate\n        historyIndexRef.current--\n        // Keep the draft intact - user stays on their current input\n        return\n      }\n\n      const newIndex = targetIndex + 1\n      setHistoryIndex(newIndex)\n      updateInput(historyCache.current[targetIndex], true)\n\n      // Show hint once per session after navigating through 2 history entries\n      if (newIndex >= 2 && !hasShownSearchHintRef.current) {\n        hasShownSearchHintRef.current = true\n        showSearchHint()\n      }\n    })()\n  }, [updateInput, showSearchHint])\n\n  const onHistoryDown = useCallback((): boolean => {\n    // Use the ref for consistent reads\n    const currentIndex = historyIndexRef.current\n    if (currentIndex > 1) {\n      historyIndexRef.current--\n      setHistoryIndex(currentIndex - 1)\n      updateInput(historyCache.current[currentIndex - 2])\n    } else if (currentIndex === 1) {\n      historyIndexRef.current = 0\n      setHistoryIndex(0)\n      if (lastShownHistoryEntry) {\n        // Restore the draft with its saved mode if available\n        const savedMode = lastShownHistoryEntry.mode\n        if (savedMode) {\n          setInputWithCursor(\n            lastShownHistoryEntry.display,\n            savedMode,\n            lastShownHistoryEntry.pastedContents ?? {},\n          )\n        } else {\n          updateInput(lastShownHistoryEntry)\n        }\n      } else {\n        // When in filtered mode, stay in that mode when clearing input\n        setInputWithCursor('', initialModeFilterRef.current ?? 'prompt', {})\n      }\n    }\n    return currentIndex <= 0\n  }, [lastShownHistoryEntry, updateInput, setInputWithCursor])\n\n  const resetHistory = useCallback((): void => {\n    setLastShownHistoryEntry(undefined)\n    setHistoryIndex(0)\n    historyIndexRef.current = 0\n    initialModeFilterRef.current = undefined\n    removeNotification('search-history-hint')\n    historyCache.current = []\n    historyCacheModeFilter.current = undefined\n  }, [removeNotification])\n\n  const dismissSearchHint = useCallback((): void => {\n    removeNotification('search-history-hint')\n  }, [removeNotification])\n\n  return {\n    historyIndex,\n    setHistoryIndex,\n    onHistoryUp,\n    onHistoryDown,\n    resetHistory,\n    dismissSearchHint,\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/src/hooks/useAssistantHistory.ts

@@ -0,0 +1,250 @@
+import { randomUUID } from 'crypto'
+import {
+  type RefObject,
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+} from 'react'
+import {
+  createHistoryAuthCtx,
+  fetchLatestEvents,
+  fetchOlderEvents,
+  type HistoryAuthCtx,
+  type HistoryPage,
+} from '../assistant/sessionHistory.js'
+import type { ScrollBoxHandle } from '../ink/components/ScrollBox.js'
+import type { RemoteSessionConfig } from '../remote/RemoteSessionManager.js'
+import { convertSDKMessage } from '../remote/sdkMessageAdapter.js'
+import type { Message, SystemInformationalMessage } from '../types/message.js'
+import { logForDebugging } from '../utils/debug.js'
+
+type Props = {
+  /** Gated on viewerOnly — non-viewer sessions have no remote history to page. */
+  config: RemoteSessionConfig | undefined
+  setMessages: React.Dispatch<React.SetStateAction<Message[]>>
+  scrollRef: RefObject<ScrollBoxHandle | null>
+  /** Called after prepend from the layout effect with message count + height
+   *  delta. Lets useUnseenDivider shift dividerIndex + dividerYRef. */
+  onPrepend?: (indexDelta: number, heightDelta: number) => void
+}
+
+type Result = {
+  /** Trigger for ScrollKeybindingHandler's onScroll composition. */
+  maybeLoadOlder: (handle: ScrollBoxHandle) => void
+}
+
+/** Fire loadOlder when scrolled within this many rows of the top. */
+const PREFETCH_THRESHOLD_ROWS = 40
+
+/** Max chained page loads to fill the viewport on mount. Bounds the loop if
+ *  events convert to zero visible messages (everything filtered). */
+const MAX_FILL_PAGES = 10
+
+const SENTINEL_LOADING = 'loading older messages…'
+const SENTINEL_LOADING_FAILED =
+  'failed to load older messages — scroll up to retry'
+const SENTINEL_START = 'start of session'
+
+/** Convert a HistoryPage to REPL Message[] using the same opts as viewer mode. */
+function pageToMessages(page: HistoryPage): Message[] {
+  const out: Message[] = []
+  for (const ev of page.events) {
+    const c = convertSDKMessage(ev, {
+      convertUserTextMessages: true,
+      convertToolResults: true,
+    })
+    if (c.type === 'message') out.push(c.message)
+  }
+  return out
+}
+
+/**
+ * Lazy-load `claude assistant` history on scroll-up.
+ *
+ * On mount: fetch newest page via anchor_to_latest, prepend to messages.
+ * On scroll-up near top: fetch next-older page via before_id, prepend with
+ * scroll anchoring (viewport stays put).
+ *
+ * No-op unless config.viewerOnly. REPL only calls this hook inside a
+ * feature('KAIROS') gate, so build-time elimination is handled there.
+ */
+export function useAssistantHistory({
+  config,
+  setMessages,
+  scrollRef,
+  onPrepend,
+}: Props): Result {
+  const enabled = config?.viewerOnly === true
+
+  // Cursor state: ref-only (no re-render on cursor change). `null` = no
+  // older pages. `undefined` = initial page not fetched yet.
+  const cursorRef = useRef<string | null | undefined>(undefined)
+  const ctxRef = useRef<HistoryAuthCtx | null>(null)
+  const inflightRef = useRef(false)
+
+  // Scroll-anchor: snapshot height + prepended count before setMessages;
+  // compensate in useLayoutEffect after React commits. getFreshScrollHeight
+  // reads Yoga directly so the value is correct post-commit.
+  const anchorRef = useRef<{ beforeHeight: number; count: number } | null>(null)
+
+  // Fill-viewport chaining: after the initial page commits, if content doesn't
+  // fill the viewport yet, load another page. Self-chains via the layout effect
+  // until filled or the budget runs out. Budget set once on initial load; user
+  // scroll-ups don't need it (maybeLoadOlder re-fires on next wheel event).
+  const fillBudgetRef = useRef(0)
+
+  // Stable sentinel UUID — reused across swaps so virtual-scroll treats it
+  // as one item (text-only mutation, not remove+insert).
+  const sentinelUuidRef = useRef(randomUUID())
+
+  function mkSentinel(text: string): SystemInformationalMessage {
+    return {
+      type: 'system',
+      subtype: 'informational',
+      content: text,
+      isMeta: false,
+      timestamp: new Date().toISOString(),
+      uuid: sentinelUuidRef.current,
+      level: 'info',
+    }
+  }
+
+  /** Prepend a page at the front, with scroll-anchor snapshot for non-initial.
+   *  Replaces the sentinel (always at index 0 when present) in-place. */
+  const prepend = useCallback(
+    (page: HistoryPage, isInitial: boolean) => {
+      const msgs = pageToMessages(page)
+      cursorRef.current = page.hasMore ? page.firstId : null
+
+      if (!isInitial) {
+        const s = scrollRef.current
+        anchorRef.current = s
+          ? { beforeHeight: s.getFreshScrollHeight(), count: msgs.length }
+          : null
+      }
+
+      const sentinel = page.hasMore ? null : mkSentinel(SENTINEL_START)
+      setMessages(prev => {
+        // Drop existing sentinel (index 0, known stable UUID — O(1)).
+        const base =
+          prev[0]?.uuid === sentinelUuidRef.current ? prev.slice(1) : prev
+        return sentinel ? [sentinel, ...msgs, ...base] : [...msgs, ...base]
+      })
+
+      logForDebugging(
+        `[useAssistantHistory] ${isInitial ? 'initial' : 'older'} page: ${msgs.length} msgs (raw ${page.events.length}), hasMore=${page.hasMore}`,
+      )
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- scrollRef is a stable ref; mkSentinel reads refs only
+    [setMessages],
+  )
+
+  // Initial fetch on mount — best-effort.
+  useEffect(() => {
+    if (!enabled || !config) return
+    let cancelled = false
+    void (async () => {
+      const ctx = await createHistoryAuthCtx(config.sessionId).catch(() => null)
+      if (!ctx || cancelled) return
+      ctxRef.current = ctx
+      const page = await fetchLatestEvents(ctx)
+      if (cancelled || !page) return
+      fillBudgetRef.current = MAX_FILL_PAGES
+      prepend(page, true)
+    })()
+    return () => {
+      cancelled = true
+    }
+    // config identity is stable (created once in main.tsx, never recreated)
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [enabled])
+
+  const loadOlder = useCallback(async () => {
+    if (!enabled || inflightRef.current) return
+    const cursor = cursorRef.current
+    const ctx = ctxRef.current
+    if (!cursor || !ctx) return // null=exhausted, undefined=initial pending
+    inflightRef.current = true
+    // Swap sentinel to "loading…" — O(1) slice since sentinel is at index 0.
+    setMessages(prev => {
+      const base =
+        prev[0]?.uuid === sentinelUuidRef.current ? prev.slice(1) : prev
+      return [mkSentinel(SENTINEL_LOADING), ...base]
+    })
+    try {
+      const page = await fetchOlderEvents(ctx, cursor)
+      if (!page) {
+        // Fetch failed — revert sentinel back to "start" placeholder so the user
+        // can retry on next scroll-up. Cursor is preserved (not nulled out).
+        setMessages(prev => {
+          const base =
+            prev[0]?.uuid === sentinelUuidRef.current ? prev.slice(1) : prev
+          return [mkSentinel(SENTINEL_LOADING_FAILED), ...base]
+        })
+        return
+      }
+      prepend(page, false)
+    } finally {
+      inflightRef.current = false
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- mkSentinel reads refs only
+  }, [enabled, prepend, setMessages])
+
+  // Scroll-anchor compensation — after React commits the prepended items,
+  // shift scrollTop by the height delta so the viewport stays put. Also
+  // fire onPrepend here (not in prepend()) so dividerIndex + baseline ref
+  // are shifted with the ACTUAL height delta, not an estimate.
+  // No deps: runs every render; cheap no-op when anchorRef is null.
+  useLayoutEffect(() => {
+    const anchor = anchorRef.current
+    if (anchor === null) return
+    anchorRef.current = null
+    const s = scrollRef.current
+    if (!s || s.isSticky()) return // sticky = pinned bottom; prepend is invisible
+    const delta = s.getFreshScrollHeight() - anchor.beforeHeight
+    if (delta > 0) s.scrollBy(delta)
+    onPrepend?.(anchor.count, delta)
+  })
+
+  // Fill-viewport chain: after paint, if content doesn't exceed the viewport,
+  // load another page. Runs as useEffect (not layout effect) so Ink has
+  // painted and scrollViewportHeight is populated. Self-chains via next
+  // render's effect; budget caps the chain.
+  //
+  // The ScrollBox content wrapper has flexGrow:1 flexShrink:0 — it's clamped
+  // to ≥ viewport. So `content < viewport` is never true; `<=` detects "no
+  // overflow yet" correctly. Stops once there's at least something to scroll.
+  useEffect(() => {
+    if (
+      fillBudgetRef.current <= 0 ||
+      !cursorRef.current ||
+      inflightRef.current
+    ) {
+      return
+    }
+    const s = scrollRef.current
+    if (!s) return
+    const contentH = s.getFreshScrollHeight()
+    const viewH = s.getViewportHeight()
+    logForDebugging(
+      `[useAssistantHistory] fill-check: content=${contentH} viewport=${viewH} budget=${fillBudgetRef.current}`,
+    )
+    if (contentH <= viewH) {
+      fillBudgetRef.current--
+      void loadOlder()
+    } else {
+      fillBudgetRef.current = 0
+    }
+  })
+
+  // Trigger wrapper for onScroll composition in REPL.
+  const maybeLoadOlder = useCallback(
+    (handle: ScrollBoxHandle) => {
+      if (handle.getScrollTop() < PREFETCH_THRESHOLD_ROWS) void loadOlder()
+    },
+    [loadOlder],
+  )
+
+  return { maybeLoadOlder }
+}

package/src/hooks/useAwaySummary.ts

@@ -0,0 +1,125 @@
+import { feature } from 'bun:bundle'
+import { useEffect, useRef } from 'react'
+import {
+  getTerminalFocusState,
+  subscribeTerminalFocus,
+} from '../ink/terminal-focus-state.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
+import { generateAwaySummary } from '../services/awaySummary.js'
+import type { Message } from '../types/message.js'
+import { createAwaySummaryMessage } from '../utils/messages.js'
+
+const BLUR_DELAY_MS = 5 * 60_000
+
+type SetMessages = (updater: (prev: Message[]) => Message[]) => void
+
+function hasSummarySinceLastUserTurn(messages: readonly Message[]): boolean {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i]!
+    if (m.type === 'user' && !m.isMeta && !m.isCompactSummary) return false
+    if (m.type === 'system' && m.subtype === 'away_summary') return true
+  }
+  return false
+}
+
+/**
+ * Appends a "while you were away" summary message after the terminal has been
+ * blurred for 5 minutes. Fires only when (a) 5min since blur, (b) no turn in
+ * progress, and (c) no existing away_summary since the last user message.
+ *
+ * Focus state 'unknown' (terminal doesn't support DECSET 1004) is a no-op.
+ */
+export function useAwaySummary(
+  messages: readonly Message[],
+  setMessages: SetMessages,
+  isLoading: boolean,
+): void {
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const abortRef = useRef<AbortController | null>(null)
+  const messagesRef = useRef(messages)
+  const isLoadingRef = useRef(isLoading)
+  const pendingRef = useRef(false)
+  const generateRef = useRef<(() => Promise<void>) | null>(null)
+
+  messagesRef.current = messages
+  isLoadingRef.current = isLoading
+
+  // 3P default: false
+  const gbEnabled = getFeatureValue_CACHED_MAY_BE_STALE(
+    'tengu_sedge_lantern',
+    false,
+  )
+
+  useEffect(() => {
+    if (!feature('AWAY_SUMMARY')) return
+    if (!gbEnabled) return
+
+    function clearTimer(): void {
+      if (timerRef.current !== null) {
+        clearTimeout(timerRef.current)
+        timerRef.current = null
+      }
+    }
+
+    function abortInFlight(): void {
+      abortRef.current?.abort()
+      abortRef.current = null
+    }
+
+    async function generate(): Promise<void> {
+      pendingRef.current = false
+      if (hasSummarySinceLastUserTurn(messagesRef.current)) return
+      abortInFlight()
+      const controller = new AbortController()
+      abortRef.current = controller
+      const text = await generateAwaySummary(
+        messagesRef.current,
+        controller.signal,
+      )
+      if (controller.signal.aborted || text === null) return
+      setMessages(prev => [...prev, createAwaySummaryMessage(text)])
+    }
+
+    function onBlurTimerFire(): void {
+      timerRef.current = null
+      if (isLoadingRef.current) {
+        pendingRef.current = true
+        return
+      }
+      void generate()
+    }
+
+    function onFocusChange(): void {
+      const state = getTerminalFocusState()
+      if (state === 'blurred') {
+        clearTimer()
+        timerRef.current = setTimeout(onBlurTimerFire, BLUR_DELAY_MS)
+      } else if (state === 'focused') {
+        clearTimer()
+        abortInFlight()
+        pendingRef.current = false
+      }
+      // 'unknown' → no-op
+    }
+
+    const unsubscribe = subscribeTerminalFocus(onFocusChange)
+    // Handle the case where we're already blurred when the effect mounts
+    onFocusChange()
+    generateRef.current = generate
+
+    return () => {
+      unsubscribe()
+      clearTimer()
+      abortInFlight()
+      generateRef.current = null
+    }
+  }, [gbEnabled, setMessages])
+
+  // Timer fired mid-turn → fire when turn ends (if still blurred)
+  useEffect(() => {
+    if (isLoading) return
+    if (!pendingRef.current) return
+    if (getTerminalFocusState() !== 'blurred') return
+    void generateRef.current?.()
+  }, [isLoading])
+}