Skip to content

Your lightweight open-source personal agent.

52.6 KB
Raw Blame
import {
  forwardRef,
  type ReactNode,
  useCallback,
  useEffect,
  useImperativeHandle,
  useLayoutEffect,
  useMemo,
  useRef,
  useState,
} from "react";
import { ArrowDown } from "lucide-react";
import { useTranslation } from "react-i18next";

import { PromptRail } from "@/components/thread/PromptRail";
import { SubagentThreadMessages, useHasSubagentResults } from "@/components/thread/SubagentTaskResults";
import { DiagramScope } from "@/components/markdown-diagrams/context";
import { DiffViewportContext } from "./activity/DiffViewportContext";
import { ThreadHistoryStatus } from "@/components/thread/ThreadHistoryStatus";
import { isAgentActivityMember } from "@/components/thread/AgentActivityCluster";
import { ThreadCameraController } from "@/components/thread/thread-camera";
import { HISTORY_HOLD_PX, ThreadHistorySpring, type HistoryRevealPhase } from "@/components/thread/thread-history-spring";
import {
  ThreadMotionCoordinator,
  type ThreadMotionGeometry,
} from "@/components/thread/thread-motion";
import { Button } from "@/components/ui/button";
import {
  findPromptElement,
  promptTop,
} from "@/components/thread/promptNavigation";
import { cn } from "@/lib/utils";
import type { PromptHistoryNavigation } from "@/hooks/usePromptHistory";
import type { CliAppInfo, McpPresetInfo, RetryStatus, SlashCommand, UIMessage } from "@/lib/types";

export interface ThreadViewportHandle {
  jumpToUserPrompt: (promptId: string) => void;
  cancelAutoScroll: () => void;
}

interface ThreadViewportProps {
  messages: UIMessage[];
  navigation?: PromptHistoryNavigation;
  temporary?: boolean;
  isStreaming: boolean;
  /** Optimistic or canonical start time for the active turn, in unix seconds. */
  runStartedAt?: number | null;
  retryStatus?: RetryStatus | null;
  composer?: ReactNode;
  onComposerLayoutChange?: () => void;
  navigationFrame?: HTMLElement | null;
  emptyState?: ReactNode;
  initialLoading?: boolean;
  initialError?: string | null;
  onRetryInitial?: () => void;
  scrollToBottomSignal?: number;
  activeTurnId?: string | null;
  activeTurnStartedHere?: boolean;
  conversationKey?: string | null;
  /** Override when message ownership changes after the selected conversation. */
  messagesKey?: string | null;
  conversationReady?: boolean;
  showScrollToBottomButton?: boolean;
  cliApps?: CliAppInfo[];
  mcpPresets?: McpPresetInfo[];
  slashCommands?: SlashCommand[];
  forkBoundaryMessageCount?: number | null;
  hasMoreBefore?: boolean | null;
  loadingOlder?: boolean;
  olderError?: string | null;
  userMessageOffset?: number;
  onLoadOlder?: () => Promise<void> | void;
  traceDetailScope?: string | null;
  onLoadTraceDetails?: (refs: string[]) => void | Promise<void>;
  onOpenFilePreview?: (path: string) => void;
  onForkFromMessage?: (beforeUserIndex: number) => void;
  onQuoteSelection?: (text: string) => void;
}

const NEAR_BOTTOM_PX = 48;
const PROMPT_TOP_INSET_PX = 48;
const HISTORY_PREFETCH_MIN_PX = 160;
const HISTORY_PREFETCH_MAX_PX = 480;
const DEFAULT_SCROLL_BUTTON_BOTTOM_PX = 192;
const EXTERNAL_COMPOSER_SCROLL_BUTTON_BOTTOM_PX = 16;
const SCROLL_BUTTON_COMPOSER_GAP_PX = 16;
const SOFT_KEYBOARD_MIN_INSET_PX = 80;
const SESSION_HANDOFF_EXIT_DURATION_MS = 80;
const SESSION_HANDOFF_ENTER_DURATION_MS = 140;
const SESSION_HANDOFF_OPACITY = 0.82;
export const INITIAL_HISTORY_WINDOW = 120;
export const HISTORY_WINDOW_INCREMENT = 120;

interface HistoryScrollAnchor {
  key: string;
  offsetTop: number;
  scrollTop: number;
}

const THREAD_DISPLAY_UNIT_SELECTOR = "[data-thread-display-unit]";

function promptTopInset(scroller: HTMLElement): number {
  const padding = Number.parseFloat(getComputedStyle(scroller).scrollPaddingTop);
  return Number.isFinite(padding) ? padding : PROMPT_TOP_INSET_PX;
}

function historyPrefetchDistance(scroller: HTMLElement): number {
  return Math.min(
    HISTORY_PREFETCH_MAX_PX,
    Math.max(HISTORY_PREFETCH_MIN_PX, scroller.clientHeight / 2),
  );
}

function visibleHistoryUnit(
  content: HTMLElement,
  viewport: DOMRect,
): HTMLElement | null {
  // Scroll is a hot path. Hit-testing keeps the common case O(1) instead of
  // forcing layout for every mounted message while the trackpad is moving.
  if (typeof document.elementsFromPoint === "function" && viewport.height > 0) {
    const contentBounds = content.getBoundingClientRect();
    const left = Math.max(viewport.left, contentBounds.left);
    const right = Math.min(viewport.right, contentBounds.right);
    const x = left + Math.max(0, right - left) / 2;
    const offsets = [1, Math.min(32, viewport.height / 3), viewport.height / 2];
    for (const offset of offsets) {
      for (const target of document.elementsFromPoint(x, viewport.top + offset)) {
        const unit = target instanceof Element
          ? target.closest<HTMLElement>(THREAD_DISPLAY_UNIT_SELECTOR)
          : null;
        if (unit && content.contains(unit)) return unit;
      }
    }
  }

  // Deterministic fallback for pre-layout states, tests, and older browsers.
  const units = Array.from(
    content.querySelectorAll<HTMLElement>(THREAD_DISPLAY_UNIT_SELECTOR),
  );
  return units.find((unit) => {
    const bounds = unit.getBoundingClientRect();
    return bounds.bottom > viewport.top && bounds.top < viewport.bottom;
  }) ?? units[0] ?? null;
}

export function windowMessages(messages: UIMessage[], visibleCount: number): UIMessage[] {
  if (messages.length <= visibleCount) return messages;
  let start = Math.max(0, messages.length - visibleCount);
  while (
    start > 0
    && isAgentActivityMember(messages[start])
    && isAgentActivityMember(messages[start - 1])
  ) {
    start -= 1;
  }
  return messages.slice(start);
}

function isKeyboardEditableElement(element: Element | null): element is HTMLElement {
  if (!(element instanceof HTMLElement)) return false;
  if (element.isContentEditable) return true;
  if (element instanceof HTMLTextAreaElement) return true;
  if (!(element instanceof HTMLInputElement)) return false;
  return ![
    "button",
    "checkbox",
    "color",
    "file",
    "hidden",
    "image",
    "radio",
    "range",
    "reset",
    "submit",
  ].includes(element.type);
}

function isThreadDisclosureTarget(target: EventTarget | null): boolean {
  return target instanceof Element
    && target.closest("[data-thread-disclosure]") !== null;
}

function isKeyboardControl(element: Element | null): boolean {
  return element instanceof HTMLElement
    && element.closest(
      "button, a[href], select, [role='button'], [role='menuitem'], [role='option']",
    ) !== null;
}

type ThreadScrollDirection = "backward" | "forward";

const KEYBOARD_SCROLL_DIRECTIONS: Readonly<
  Partial<Record<string, ThreadScrollDirection>>
> = {
  ArrowUp: "backward",
  PageUp: "backward",
  Home: "backward",
  ArrowDown: "forward",
  PageDown: "forward",
  End: "forward",
};

function directionFromDelta(deltaY: number): ThreadScrollDirection | null {
  return deltaY < 0 ? "backward" : deltaY > 0 ? "forward" : null;
}

function keyboardScrollDirection(
  event: KeyboardEvent,
): ThreadScrollDirection | null {
  if (event.key === " ") {
    return event.shiftKey ? "backward" : "forward";
  }
  return KEYBOARD_SCROLL_DIRECTIONS[event.key] ?? null;
}

function canScrollInDirection(
  element: HTMLElement,
  direction: ThreadScrollDirection | null,
): boolean {
  switch (direction) {
    case "backward":
      return element.scrollTop > 0;
    case "forward":
      return (
        element.scrollTop
        < Math.max(0, element.scrollHeight - element.clientHeight)
      );
    default:
      return false;
  }
}

function readSoftKeyboardInsetBottom(container: HTMLElement | null): number {
  // The touch App shell already fits the visual viewport, including portaled
  // composers. Keep the existing local inset only for unfitted/native layouts.
  if (container?.closest("#root.visual-viewport")) return 0;
  const viewport = window.visualViewport;
  if (!viewport) return 0;
  const active = document.activeElement;
  if (!isKeyboardEditableElement(active) || !container?.contains(active)) return 0;
  const layoutHeight = window.innerHeight || document.documentElement.clientHeight;
  const inset = layoutHeight - viewport.height - viewport.offsetTop;
  return inset >= SOFT_KEYBOARD_MIN_INSET_PX ? Math.ceil(inset) : 0;
}

function setHistoryPresentation(
  scroller: HTMLDivElement | null,
  status: HTMLDivElement | null,
  slot: HTMLDivElement | null,
  distance: number,
): void {
  // A retained inline slot replaces the same amount of presentation travel.
  const travel = distance - (slot ? HISTORY_HOLD_PX : 0);
  if (scroller) scroller.style.transform = travel ? `translateY(${travel}px)` : "";
  status?.style.setProperty("--history-pull", `${distance}px`);
}

export const ThreadViewport = forwardRef<ThreadViewportHandle, ThreadViewportProps>(function ThreadViewport({
  messages: latestMessages,
  navigation,
  temporary = false,
  isStreaming: liveStreaming,
  runStartedAt = null,
  retryStatus = null,
  composer,
  onComposerLayoutChange,
  navigationFrame,
  emptyState,
  initialLoading = false,
  initialError = null,
  onRetryInitial,
  scrollToBottomSignal = 0,
  activeTurnId: liveTurnId = null,
  activeTurnStartedHere = false,
  conversationKey = null,
  messagesKey = conversationKey,
  conversationReady = true,
  showScrollToBottomButton = true,
  cliApps = [],
  mcpPresets = [],
  slashCommands = [],
  forkBoundaryMessageCount: latestForkBoundary = null,
  hasMoreBefore: latestHasMoreBefore = false,
  loadingOlder: latestLoadingOlder = false,
  olderError: latestOlderError = null,
  userMessageOffset: latestUserOffset = 0,
  onLoadOlder: loadLatestOlder,
  traceDetailScope = null,
  onLoadTraceDetails,
  onOpenFilePreview,
  onForkFromMessage,
  onQuoteSelection,
}, ref) {
  const { t } = useTranslation();
  const historyWindow = navigation?.window;
  const messages = historyWindow?.messages ?? latestMessages;
  const isStreaming = !historyWindow && liveStreaming;
  const activeTurnId = historyWindow ? null : liveTurnId;
  const forkBoundaryMessageCount = historyWindow ? historyWindow.forkBoundaryMessageCount : latestForkBoundary;
  const hasMoreBefore = historyWindow?.hasMoreBefore ?? latestHasMoreBefore;
  const loadingOlder = historyWindow ? navigation!.operation === "older" && navigation!.loading : latestLoadingOlder;
  const olderError = historyWindow ? navigation!.operation === "older" ? navigation!.error : null : latestOlderError;
  const userMessageOffset = historyWindow?.userMessageOffset ?? latestUserOffset;
  const onLoadOlder = historyWindow ? navigation!.older : loadLatestOlder;
  const scrollRef = useRef<HTMLDivElement | null>(null);
  const viewportFrameRef = useRef<HTMLDivElement>(null);
  const contentRef = useRef<HTMLDivElement>(null);
  const messageRegionRef = useRef<HTMLDivElement | null>(null);
  const messageContentRef = useRef<HTMLDivElement>(null);
  const diffViewport = useMemo(() => ({ scroller: messageRegionRef, content: messageContentRef }), []);
  const emptyStateRef = useRef<HTMLDivElement>(null);
  const composerDockRef = useRef<HTMLDivElement>(null);
  const composerLayoutChangeRef = useRef(onComposerLayoutChange);
  composerLayoutChangeRef.current = onComposerLayoutChange;
  const bottomRef = useRef<HTMLDivElement>(null);
  const lastConversationKeyRef = useRef<string | null>(conversationKey);
  const conversationHandoffPendingRef = useRef(false);
  const conversationHandoffAnimationRef = useRef<Animation | null>(null);
  const pendingConversationScrollRef = useRef(true);
  const pendingPromptJumpRef = useRef<string | null>(null);
  const restoreScrollAfterPrependRef =
    useRef<{ height: number; top: number } | null>(null);
  const historyScrollAnchorRef = useRef<HistoryScrollAnchor | null>(null);
  const previousLoadingOlderRef = useRef(loadingOlder);
  const composerDockHeightRef = useRef(0);
  const [atBottom, setAtBottom] = useState(true);
  const [atHistoryTop, setAtHistoryTop] = useState(false);
  const [historyPhase, setHistoryPhase] = useState<HistoryRevealPhase>("hidden");
  const historyPhaseRef = useRef(historyPhase);
  const [historySlotKey, setHistorySlotKey] = useState<string | null>(null);
  const historySlotCompleted = previousLoadingOlderRef.current && !loadingOlder && !olderError && historySlotKey !== null;
  const retainedHistorySlotKey = historySlotCompleted ? null : historySlotKey;
  const [showHistoryExhausted, setShowHistoryExhausted] = useState(false);
  const historySlotRef = useRef<HTMLDivElement | null>(null);
  const historyInputRef = useRef<"touch" | "other">("other");
  const historyTouchRef = useRef<{
    target: Node; lastY: number; startX: number; startY: number; pulling: boolean; horizontal: boolean;
  } | null>(null);
  const historyTouchTargetCleanupRef = useRef<(() => void) | null>(null);
  const clearHistoryTouchTarget = useCallback(() => {
    historyTouchTargetCleanupRef.current?.();
    historyTouchTargetCleanupRef.current = null;
  }, []);
  const historyDistanceRef = useRef(0);
  const historyStatusRef = useRef<HTMLDivElement | null>(null);
  const historySpringRef = useRef<ThreadHistorySpring | null>(null);
  if (historySpringRef.current === null) {
    historySpringRef.current = new ThreadHistorySpring({
      onPhaseChange: (phase) => {
        const previous = historyPhaseRef.current;
        historyPhaseRef.current = phase;
        setHistoryPhase(phase);
        if (phase === "hidden" && previous === "feedback") setShowHistoryExhausted(false);
      },
      onUpdate: (distance) => {
        historyDistanceRef.current = distance;
        setHistoryPresentation(messageRegionRef.current, historyStatusRef.current, historySlotRef.current, distance);
      },
    });
  }

  const setMessageRegion = useCallback((element: HTMLDivElement | null) => {
    // React can reuse this div for the empty state; release imperative styles with the ref.
    messageRegionRef.current?.style.removeProperty("transform");
    messageRegionRef.current = element;
    setHistoryPresentation(element, historyStatusRef.current, historySlotRef.current, historyDistanceRef.current);
  }, []);
  const setHistoryStatus = useCallback((element: HTMLDivElement | null) => {
    historyStatusRef.current = element;
    setHistoryPresentation(messageRegionRef.current, element, historySlotRef.current, historyDistanceRef.current);
  }, []);
  const setHistorySlot = useCallback((element: HTMLDivElement | null) => {
    historySlotRef.current = element;
    setHistoryPresentation(messageRegionRef.current, historyStatusRef.current, element, historyDistanceRef.current);
  }, []);
  const [composerDockHeight, setComposerDockHeight] = useState(0);
  const [keyboardInsetBottom, setKeyboardInsetBottom] = useState(0);
  const [hasVerticalOverflow, setHasVerticalOverflow] = useState(false);
  const [visibleMessageCount, setVisibleMessageCount] =
    useState(INITIAL_HISTORY_WINDOW);
  const threadMotionRef = useRef<ThreadMotionCoordinator | null>(null);
  if (threadMotionRef.current === null) {
    const camera = new ThreadCameraController(() => scrollRef.current);
    threadMotionRef.current = new ThreadMotionCoordinator({
      camera,
      measure: (promptId) => {
        const scrollEl = scrollRef.current;
        const composerDock = composerDockRef.current;
        if (!scrollEl) return null;
        const composerHeight = composerDock
          ? composerDock.getBoundingClientRect().height || composerDock.offsetHeight
          : 0;
        const prompt = promptId ? findPromptElement(scrollEl, promptId) : null;
        const scrollHeight = scrollEl.scrollHeight;
        const clientHeight = scrollEl.clientHeight;
        const maxScrollTop = Math.max(0, scrollHeight - clientHeight);
        return {
          scrollTop: scrollEl.scrollTop,
          scrollHeight,
          clientHeight,
          maxScrollTop,
          composerHeight,
          promptTop: prompt
            ? Math.min(
                maxScrollTop,
                Math.max(0, promptTop(scrollEl, prompt) - promptTopInset(scrollEl)),
              )
            : null,
        };
      },
      onGeometry: (geometry: ThreadMotionGeometry) => {
        composerLayoutChangeRef.current?.();
        if (Math.abs(composerDockHeightRef.current - geometry.composerHeight) >= 1) {
          composerDockHeightRef.current = geometry.composerHeight;
          setComposerDockHeight(geometry.composerHeight);
        }
        const nextOverflow = geometry.scrollHeight > geometry.clientHeight + 1;
        setHasVerticalOverflow((current) =>
          current === nextOverflow ? current : nextOverflow,
        );
      },
      onAutoFollow: () => setAtBottom(true),
    });
  }
  const hasTaskResults = useHasSubagentResults();
  const hasMessages = messages.length > 0 || (hasTaskResults && conversationReady);
  const hasThreadLayout = hasMessages || initialLoading;
  useLayoutEffect(() => {
    scrollRef.current = hasMessages
      ? messageRegionRef.current
      : viewportFrameRef.current;
  }, [hasMessages]);
  const visibleMessages = useMemo(
    () => windowMessages(messages, visibleMessageCount),
    [messages, visibleMessageCount],
  );
  const hiddenMessageCount = messages.length - visibleMessages.length;
  const historyUnknown = hasMoreBefore === null;
  const historyExhausted = hasMoreBefore === false && hiddenMessageCount === 0;
  const hiddenUserMessageCount =
    userMessageOffset
    + (hiddenMessageCount > 0
      ? messages.slice(0, hiddenMessageCount).filter(
        (message) => message.role === "user" && message.deliveryStatus !== "failed",
      ).length
      : 0);
  const visibleForkBoundaryMessageCount =
    forkBoundaryMessageCount !== null && forkBoundaryMessageCount > hiddenMessageCount
      ? forkBoundaryMessageCount - hiddenMessageCount
      : null;
  const hasComposer = composer !== null && composer !== undefined;
  const scrollButtonBottom =
    keyboardInsetBottom
    + (composerDockHeight > 0
      ? composerDockHeight + SCROLL_BUTTON_COMPOSER_GAP_PX
      : hasComposer
        ? DEFAULT_SCROLL_BUTTON_BOTTOM_PX
        : EXTERNAL_COMPOSER_SCROLL_BUTTON_BOTTOM_PX);
  const scrollViewportStyle =
    keyboardInsetBottom > 0 ? { bottom: keyboardInsetBottom } : undefined;

  const yieldCameraToUser = useCallback(() => {
    threadMotionRef.current?.takeUserControl();
  }, []);

  const captureHistoryScrollAnchor = useCallback(() => {
    const scroller = scrollRef.current;
    const content = messageContentRef.current;
    if (!scroller || !content) {
      historyScrollAnchorRef.current = null;
      return false;
    }
    const viewport = scroller.getBoundingClientRect();
    const element = visibleHistoryUnit(content, viewport);
    const key = element?.dataset.threadDisplayUnit;
    if (!element || !key) {
      historyScrollAnchorRef.current = null;
      return false;
    }
    historyScrollAnchorRef.current = {
      key,
      scrollTop: scroller.scrollTop,
      // Normalize out the reveal lease, even when reading above its inline slot.
      offsetTop: element.getBoundingClientRect().top - viewport.top
        - (historySlotRef.current ? HISTORY_HOLD_PX : 0),
    };
    return true;
  }, []);

  const reconcileHistoryScrollAnchor = useCallback(() => {
    const scroller = scrollRef.current;
    const content = messageContentRef.current;
    const anchor = historyScrollAnchorRef.current;
    if (!scroller || !content || !anchor) return false;
    const element = Array.from(
      content.querySelectorAll<HTMLElement>("[data-thread-display-unit]"),
    ).find((candidate) => candidate.dataset.threadDisplayUnit === anchor.key);
    if (!element) {
      historyScrollAnchorRef.current = null;
      return false;
    }

    const nextOffset =
      element.getBoundingClientRect().top
      - scroller.getBoundingClientRect().top
      - (historySlotRef.current ? HISTORY_HOLD_PX : 0);
    const delta = nextOffset - anchor.offsetTop;
    if (Math.abs(delta) < 0.5) return true;
    const maxScrollTop = Math.max(0, scroller.scrollHeight - scroller.clientHeight);
    const nextTop = Math.min(maxScrollTop, Math.max(0, scroller.scrollTop + delta));
    threadMotionRef.current?.jumpTo(nextTop);
    anchor.scrollTop = scroller.scrollTop;
    return true;
  }, []);

  const resetHistoryHeader = useCallback(() => {
    setHistorySlotKey(null);
    historySpringRef.current?.reset();
  }, []);

  const holdHistoryHeader = useCallback(() => {
    // A request at a new boundary supersedes the old slot. Mid-page retry
    // keeps its original boundary, never a hit-tested answer or activity row.
    if (!historySlotRef.current || (scrollRef.current && scrollRef.current.scrollTop <= 1)) {
      const unit = messageContentRef.current?.querySelector<HTMLElement>(THREAD_DISPLAY_UNIT_SELECTOR);
      if (unit?.dataset.threadDisplayUnit) setHistorySlotKey(unit.dataset.threadDisplayUnit);
    }
    historySpringRef.current?.hold();
  }, []);

  useLayoutEffect(() => {
    // Replaced history windows cannot retain a slot for an unmounted boundary.
    if (retainedHistorySlotKey && !historySlotRef.current) resetHistoryHeader();
  }, [retainedHistorySlotKey, resetHistoryHeader, visibleMessages]);

  const scrollToBottomNow = useCallback((smooth = false) => {
    historyScrollAnchorRef.current = null;
    resetHistoryHeader();
    const el = scrollRef.current;
    const marker = bottomRef.current;
    const behavior: ScrollBehavior = smooth ? "smooth" : "auto";
    if (el) {
      const top = Math.max(0, el.scrollHeight - el.clientHeight);
      if (smooth) {
        threadMotionRef.current?.navigateLatestTo(top);
      } else {
        threadMotionRef.current?.jumpTo(top);
      }
    } else if (marker) {
      marker.scrollIntoView({ block: "end", behavior });
    }
    setAtBottom(true);
  }, [resetHistoryHeader]);

  const scrollToBottom = useCallback(
    (smooth = false, options?: { force?: boolean }) => {
      const force = options?.force ?? false;
      if (!force && threadMotionRef.current?.isAutoFollowPaused()) return;
      if (!smooth) threadMotionRef.current?.resumeAutoFollow();
      scrollToBottomNow(smooth);
    },
    [scrollToBottomNow],
  );

  const loadEarlierMessages = useCallback(() => {
    if (loadingOlder || navigation?.loading) return;
    const el = scrollRef.current;
    if (el) {
      if (captureHistoryScrollAnchor()) {
        restoreScrollAfterPrependRef.current = null;
      } else {
        restoreScrollAfterPrependRef.current = {
          height: el.scrollHeight,
          top: el.scrollTop,
        };
      }
    }
    threadMotionRef.current?.takeUserControl();
    setAtBottom(false);
    if (hiddenMessageCount > 0) {
      setVisibleMessageCount((count) =>
        Math.min(messages.length, count + HISTORY_WINDOW_INCREMENT),
      );
      return;
    }
    if (hasMoreBefore && onLoadOlder) {
      holdHistoryHeader();
      setVisibleMessageCount((count) => count + HISTORY_WINDOW_INCREMENT);
      void onLoadOlder();
    }
  }, [
    captureHistoryScrollAnchor,
    hasMoreBefore,
    hiddenMessageCount,
    holdHistoryHeader,
    loadingOlder,
    messages.length,
    navigation?.loading,
    onLoadOlder,
  ]);

  const maybeLoadEarlierFromScroll = useCallback(() => {
    const el = scrollRef.current;
    if (!el || !hasMessages || pendingConversationScrollRef.current) return;
    if (!threadMotionRef.current?.isBrowsingHistory()) return;
    if (el.scrollTop > historyPrefetchDistance(el)) return;
    if (hiddenMessageCount <= 0 && (historyInputRef.current === "touch" || el.scrollTop > 1)) return;
    if (hiddenMessageCount <= 0 && (!hasMoreBefore || olderError)) return;
    loadEarlierMessages();
  }, [hasMessages, hasMoreBefore, hiddenMessageCount, loadEarlierMessages, olderError]);

  const navigateToVisiblePrompt = useCallback((promptId: string) => {
    const scrollEl = scrollRef.current;
    const prompt = scrollEl ? findPromptElement(scrollEl, promptId) : null;
    if (!scrollEl || !prompt) return false;
    historyScrollAnchorRef.current = null;
    resetHistoryHeader();
    setAtBottom(false);
    threadMotionRef.current?.navigateHistoryToPrompt(promptId);
    return true;
  }, [resetHistoryHeader]);

  const jumpToUserPrompt = useCallback((promptId: string) => {
    // A local destination also supersedes an in-flight remote jump.
    navigation?.cancel();
    pendingPromptJumpRef.current = null;
    if (navigateToVisiblePrompt(promptId)) return;
    if (navigation?.prompts.some((prompt) => prompt.id === promptId && prompt.cursor)) {
      threadMotionRef.current?.takeUserControl();
      navigation.jump(promptId);
      return;
    }
    const localMessages = historyWindow ? latestMessages : messages;
    const index = localMessages.findIndex((message) => message.id === promptId);
    if (index < 0) return;
    if (historyWindow) navigation?.latest();
    threadMotionRef.current?.takeUserControl();
    pendingPromptJumpRef.current = promptId;
    setAtBottom(false);
    setVisibleMessageCount((count) => Math.max(count, localMessages.length - index));
  }, [historyWindow, latestMessages, messages, navigateToVisiblePrompt, navigation]);

  useLayoutEffect(() => {
    if (!navigation?.target) return;
    historyScrollAnchorRef.current = null;
    restoreScrollAfterPrependRef.current = null;
    pendingConversationScrollRef.current = false;
    pendingPromptJumpRef.current = navigation.target.id;
    threadMotionRef.current?.takeUserControl();
    setAtBottom(false);
    const index = messages.findIndex((message) => message.id === navigation.target!.id);
    setVisibleMessageCount(Math.max(INITIAL_HISTORY_WINDOW, messages.length - Math.max(0, index)));
  }, [navigation?.target]);

  useEffect(() => {
    if (activeTurnStartedHere && liveTurnId) navigation?.latest();
  }, [activeTurnStartedHere, liveTurnId, navigation?.latest]);

  const cancelAutoScroll = useCallback(() => {
    threadMotionRef.current?.takeUserControl();
  }, []);

  useImperativeHandle(
    ref,
    () => ({
      jumpToUserPrompt,
      cancelAutoScroll,
    }),
    [cancelAutoScroll, jumpToUserPrompt],
  );

  useLayoutEffect(() => {
    const updateKeyboardInset = () => {
      const composerDock = composerDockRef.current;
      const next = readSoftKeyboardInsetBottom(composerDock);
      const active = document.activeElement;
      const composerFocused =
        hasMessages
        && isKeyboardEditableElement(active)
        && Boolean(composerDock?.contains(active));
      setKeyboardInsetBottom((current) =>
        Math.abs(current - next) < 1 ? current : next,
      );
      if (composerFocused) {
        // Focusing the composer establishes a new reference frame at the
        // latest message. This is one immediate positioning command; viewport
        // events may issue a fresh command, but no command survives into a
        // later render as a train of retry frames.
        scrollToBottom(false, { force: true });
      }
    };
    updateKeyboardInset();
    const viewport = window.visualViewport;
    viewport?.addEventListener("resize", updateKeyboardInset);
    viewport?.addEventListener("scroll", updateKeyboardInset);
    window.addEventListener("resize", updateKeyboardInset);
    document.addEventListener("focusin", updateKeyboardInset);
    document.addEventListener("focusout", updateKeyboardInset);
    return () => {
      viewport?.removeEventListener("resize", updateKeyboardInset);
      viewport?.removeEventListener("scroll", updateKeyboardInset);
      window.removeEventListener("resize", updateKeyboardInset);
      document.removeEventListener("focusin", updateKeyboardInset);
      document.removeEventListener("focusout", updateKeyboardInset);
    };
  }, [hasMessages, scrollToBottom]);

  useEffect(() => {
    if (scrollToBottomSignal <= 0) return;
    scrollToBottom(false, { force: true });
  }, [scrollToBottomSignal, scrollToBottom]);

  useLayoutEffect(() => {
    if (lastConversationKeyRef.current === conversationKey) return;
    lastConversationKeyRef.current = conversationKey;
    clearHistoryTouchTarget();
    historyTouchRef.current = null;
    historyInputRef.current = "other";
    resetHistoryHeader();
    conversationHandoffAnimationRef.current?.cancel();
    conversationHandoffAnimationRef.current = null;
    conversationHandoffPendingRef.current = true;
    pendingConversationScrollRef.current = true;
    historyScrollAnchorRef.current = null;
    restoreScrollAfterPrependRef.current = null;
    threadMotionRef.current?.reset();
    setAtBottom(true);
    setShowHistoryExhausted(false);
    setVisibleMessageCount(INITIAL_HISTORY_WINDOW);

    const surface = hasMessages ? messageRegionRef.current : emptyStateRef.current;
    const reduceMotion = typeof window.matchMedia === "function"
      && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
    if (!surface || reduceMotion || typeof surface.animate !== "function") return;
    conversationHandoffAnimationRef.current = surface.animate(
      [{ opacity: 1 }, { opacity: SESSION_HANDOFF_OPACITY }],
      {
        duration: SESSION_HANDOFF_EXIT_DURATION_MS,
        easing: "cubic-bezier(0.2, 0, 0, 1)",
        fill: "forwards",
      },
    );
  }, [clearHistoryTouchTarget, conversationKey, hasMessages, resetHistoryHeader]);

  useLayoutEffect(() => {
    if (!conversationReady) {
      threadMotionRef.current?.reset();
      return;
    }
    if (!activeTurnId) {
      threadMotionRef.current?.completeTurn();
      return;
    }

    const promptIndex = messages.findIndex(
      (message) => message.role === "user" && message.turnId === activeTurnId,
    );
    if (
      activeTurnStartedHere
      && promptIndex >= 0
      && threadMotionRef.current?.snapshot().turnId !== activeTurnId
    ) {
      // A turn submitted in this mounted viewport establishes a new prompt
      // origin. A restored turn must first complete open-at-bottom instead.
      pendingConversationScrollRef.current = false;
    }
    const prompt = promptIndex >= 0 ? messages[promptIndex] : null;
    const hasOutput = promptIndex >= 0
      ? messages
          .slice(promptIndex + 1)
          .some(
            (message) =>
              message.role !== "user"
              && (!message.turnId || message.turnId === activeTurnId),
          )
      : !activeTurnStartedHere && messages.some(
          (message) =>
            message.role !== "user" && message.turnId === activeTurnId,
        );
    threadMotionRef.current?.updateTurn({
      id: activeTurnId,
      promptId: prompt?.id ?? null,
      hasOutput,
      entry: activeTurnStartedHere ? "submitted" : "restored",
    });
  }, [activeTurnId, activeTurnStartedHere, conversationReady, messages]);

  useLayoutEffect(() => {
    const wasLoading = previousLoadingOlderRef.current;
    previousLoadingOlderRef.current = loadingOlder;
    if (!wasLoading || loadingOlder || olderError || !historySlotKey) return;
    // The completed render already removed the slot. Rebase the saved anchor
    // by its live presentation travel before the single final-geometry read.
    const anchor = historyScrollAnchorRef.current;
    if (anchor) anchor.offsetTop += historyDistanceRef.current;
    setShowHistoryExhausted(historyExhausted);
    resetHistoryHeader();
  }, [loadingOlder, olderError, historySlotKey, historyExhausted, resetHistoryHeader]);

  useLayoutEffect(() => {
    const pending = restoreScrollAfterPrependRef.current;
    const el = scrollRef.current;
    restoreScrollAfterPrependRef.current = null;
    if (!el) return;
    if (reconcileHistoryScrollAnchor()) return;
    if (!pending) return;
    const delta = el.scrollHeight - pending.height;
    const nextTop = Math.min(
      Math.max(0, el.scrollHeight - el.clientHeight),
      Math.max(0, pending.top + delta),
    );
    threadMotionRef.current?.jumpTo(nextTop);
  }, [reconcileHistoryScrollAnchor, visibleMessages.length, messages, loadingOlder]);

  useLayoutEffect(() => {
    const promptId = pendingPromptJumpRef.current;
    const scrollEl = scrollRef.current;
    if (!promptId || !scrollEl || !findPromptElement(scrollEl, promptId)) return;
    const frame = window.requestAnimationFrame(() => {
      if (pendingPromptJumpRef.current === promptId && navigateToVisiblePrompt(promptId)) {
        pendingPromptJumpRef.current = null;
      }
    });
    return () => window.cancelAnimationFrame(frame);
  }, [navigateToVisiblePrompt, visibleMessages, navigation?.target]);

  useLayoutEffect(() => {
    if (!pendingConversationScrollRef.current) return;
    if (!conversationReady) return;
    if (!conversationKey) {
      pendingConversationScrollRef.current = false;
      scrollToBottom(false, { force: true });
      return;
    }
    scrollToBottom(false, { force: true });
    if (!hasMessages) return;
    pendingConversationScrollRef.current = false;
  }, [
    conversationKey,
    conversationReady,
    hasMessages,
    messages,
    scrollToBottom,
  ]);

  useLayoutEffect(() => {
    // A request commits temporary space; successful completion reclaims it below.
    if (conversationReady && loadingOlder && scrollRef.current?.scrollTop === 0 && !historySlotRef.current) {
      holdHistoryHeader();
    }
  }, [conversationReady, loadingOlder, holdHistoryHeader]);

  useLayoutEffect(() => {
    if (!conversationReady || !conversationHandoffPendingRef.current) return;
    conversationHandoffPendingRef.current = false;
    conversationHandoffAnimationRef.current?.cancel();
    conversationHandoffAnimationRef.current = null;
    const surface = hasMessages ? messageRegionRef.current : emptyStateRef.current;
    const reduceMotion = typeof window.matchMedia === "function"
      && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
    if (!surface || reduceMotion || typeof surface.animate !== "function") return;

    const animation = surface.animate(
      [{ opacity: SESSION_HANDOFF_OPACITY }, { opacity: 1 }],
      {
        duration: SESSION_HANDOFF_ENTER_DURATION_MS,
        easing: "cubic-bezier(0.2, 0, 0, 1)",
      },
    );
    conversationHandoffAnimationRef.current = animation;
    const clearAnimation = () => {
      if (conversationHandoffAnimationRef.current === animation) {
        conversationHandoffAnimationRef.current = null;
      }
    };
    animation.onfinish = clearAnimation;
    animation.oncancel = clearAnimation;
  }, [conversationReady, hasMessages]);

  useLayoutEffect(() => {
    threadMotionRef.current?.invalidateGeometry();
  }, [composer, hasMessages, visibleMessages.length]);

  useEffect(() => () => {
    conversationHandoffAnimationRef.current?.cancel();
    historySpringRef.current?.reset();
    threadMotionRef.current?.dispose();
  }, []);

  useLayoutEffect(() => {
    const el = scrollRef.current;
    const content = contentRef.current;
    // The flexible first grid row moves the composer during hero/thread transitions.
    const contentRegion = messageRegionRef.current ?? emptyStateRef.current;
    const messageContent = messageContentRef.current;
    const composerDock = composerDockRef.current;
    if (!el) return;

    const invalidateGeometry = () => {
      threadMotionRef.current?.invalidateGeometry();
    };
    const reconcileObservedGeometry = () => {
      reconcileHistoryScrollAnchor();
      threadMotionRef.current?.reconcileObservedGeometry();
    };
    reconcileObservedGeometry();
    const observer = typeof ResizeObserver === "undefined"
      ? null
      : new ResizeObserver(reconcileObservedGeometry);
    observer?.observe(el);
    if (content) observer?.observe(content);
    if (contentRegion) observer?.observe(contentRegion);
    if (messageContent) observer?.observe(messageContent);
    if (composerDock) observer?.observe(composerDock);
    window.addEventListener("resize", invalidateGeometry);
    return () => {
      observer?.disconnect();
      window.removeEventListener("resize", invalidateGeometry);
    };
  }, [hasMessages, reconcileHistoryScrollAnchor]);

  useEffect(() => {
    const el = scrollRef.current;
    if (!el) return;

    const onScroll = (allowHistoryLoad = true) => {
      setAtHistoryTop(el.scrollTop <= 1);
      if (el.scrollTop > 1) historySpringRef.current?.leaveBoundary();
      const distance = el.scrollHeight - el.scrollTop - el.clientHeight;
      const near = distance < NEAR_BOTTOM_PX;
      // A detached history page's bottom is not the live tail.
      const owner = threadMotionRef.current?.observeScroll(near && !historyWindow) ?? "automatic";
      const logicallyAtBottom = !historyWindow && (owner === "automatic" || (owner === "navigation" && near));
      setAtBottom((current) =>
        current === logicallyAtBottom ? current : logicallyAtBottom,
      );
      if (owner === "user") {
        // Restoring the anchor also emits scroll. Keep that reading position
        // through lazy content resizing instead of selecting a prepended row.
        const anchor = historyScrollAnchorRef.current;
        if (!anchor || el.scrollTop !== anchor.scrollTop) captureHistoryScrollAnchor();
        if (allowHistoryLoad) maybeLoadEarlierFromScroll();
        if (allowHistoryLoad && distance < HISTORY_PREFETCH_MIN_PX
          && historyWindow?.hasMoreAfter && !navigation?.loading && !navigation?.error) navigation?.newer();
      } else if (near) {
        historyScrollAnchorRef.current = null;
      }
    };

    onScroll(false);
    const handleScroll = () => onScroll(true);
    const atHistoryBoundary = () => el.scrollTop <= 1 && messages.length > 0 && conversationReady
      && !pendingConversationScrollRef.current;
    const canLoadAtTop = () => atHistoryBoundary() && !loadingOlder && !navigation?.loading
      && (hiddenMessageCount > 0 || hasMoreBefore);
    const handleDirectionalInput = (
      direction: ThreadScrollDirection | null,
    ) => {
      if (!direction) return;
      if (direction === "backward" && atHistoryBoundary() && hasMoreBefore === null && hiddenMessageCount === 0) {
        captureHistoryScrollAnchor();
        yieldCameraToUser();
        return;
      }
      if (direction === "forward" && historyWindow?.hasMoreAfter
        && el.scrollHeight - el.scrollTop - el.clientHeight < HISTORY_PREFETCH_MIN_PX
        && !navigation?.loading) {
        captureHistoryScrollAnchor();
        navigation?.newer();
      }
      // At the top (including a page too short to scroll), backward intent
      // produces no scroll event. It must still be able to reveal history.
      if (direction === "backward" && canLoadAtTop()) {
        loadEarlierMessages();
        return;
      }
      threadMotionRef.current?.handleUserScrollIntent(
        canScrollInDirection(el, direction),
        direction === "forward" && !historyWindow,
      );
    };
    const prepareHistoryPull = () => {
      if (loadingOlder || navigation?.loading) return;
      const first = messageContentRef.current?.querySelector<HTMLElement>(THREAD_DISPLAY_UNIT_SELECTOR);
      // A retained header belongs to the page boundary where it was opened,
      // not to a newer boundary reached by scrolling through prepended history.
      if (historySlotKey && first?.dataset.threadDisplayUnit !== historySlotKey) resetHistoryHeader();
    };
    const handleWheel = (event: WheelEvent) => {
      if (
        event.defaultPrevented
        || event.ctrlKey
        || Math.abs(event.deltaY) <= Math.abs(event.deltaX)
      ) {
        return;
      }
      historyInputRef.current = "other";
      if (atHistoryBoundary() && hasMoreBefore !== null) {
        const unit = event.deltaMode === WheelEvent.DOM_DELTA_LINE ? 16
          : event.deltaMode === WheelEvent.DOM_DELTA_PAGE ? el.clientHeight : 1;
        if (event.deltaY < 0) {
          prepareHistoryPull();
          yieldCameraToUser();
          setAtHistoryTop(true);
          const first = historySpringRef.current?.wheel(-event.deltaY * unit);
          if ((first || olderError) && canLoadAtTop()) loadEarlierMessages();
          return;
        }
      }
      handleDirectionalInput(directionFromDelta(event.deltaY));
    };
    const handlePointerDown = (event: PointerEvent) => {
      if (
        event.button === 0
        && (event.target === el || isThreadDisclosureTarget(event.target))
      ) {
        yieldCameraToUser();
      }
    };
    const handleTouchCancel = () => {
      clearHistoryTouchTarget();
      historyTouchRef.current = null;
      historySpringRef.current?.endTouch(true);
    };
    const handleTouchStart = (event: TouchEvent) => {
      historyInputRef.current = "touch";
      const touch = event.touches[0];
      if (event.touches.length !== 1 || !touch) {
        handleTouchCancel();
        return;
      }
      clearHistoryTouchTarget();
      const target = event.target as Node;
      historyTouchRef.current = {
        target,
        lastY: touch.clientY,
        startX: touch.clientX,
        startY: touch.clientY,
        pulling: false,
        horizontal: false,
      };
      observeHistoryTouchTarget(target);
    };
    const handleTouchMove = (event: TouchEvent) => {
      const gesture = historyTouchRef.current;
      const touch = event.touches[0];
      if (event.touches.length !== 1) {
        handleTouchCancel();
        return;
      }
      if (!gesture || !touch || event.defaultPrevented) return;
      const delta = gesture.lastY - touch.clientY;
      gesture.lastY = touch.clientY;
      const horizontalTravel = Math.abs(touch.clientX - gesture.startX);
      const verticalTravel = Math.abs(touch.clientY - gesture.startY);
      if (!gesture.pulling && horizontalTravel > verticalTravel) gesture.horizontal = true;
      if (gesture.horizontal) return;
      if (gesture.pulling || (atHistoryBoundary() && hasMoreBefore !== null && delta < 0 && hiddenMessageCount === 0)) {
        if (!gesture.pulling) {
          prepareHistoryPull();
          historySpringRef.current?.startTouch();
          gesture.pulling = true;
        }
        if (event.cancelable) event.preventDefault();
        yieldCameraToUser();
        historySpringRef.current?.moveTouch(-delta);
        setAtHistoryTop(true);
        return;
      }
      handleDirectionalInput(directionFromDelta(delta));
    };
    const handleTouchEnd = () => {
      const pulling = historyTouchRef.current?.pulling;
      clearHistoryTouchTarget();
      historyTouchRef.current = null;
      if (historySpringRef.current?.endTouch() && pulling && canLoadAtTop()) loadEarlierMessages();
    };
    const observeHistoryTouchTarget = (target: Node) => {
      if (target === el) return;
      // Touch events remain targeted at the original node even after React replaces it.
      // Keep ordinary connected events on the existing viewport path and only forward
      // events that can no longer reach it through DOM propagation.
      const detached = (handler: (event: TouchEvent) => void) => (event: Event) => {
        if (historyTouchRef.current?.target === target && !event.composedPath().includes(el)) handler(event as TouchEvent);
      };
      const move = detached(handleTouchMove);
      const end = detached(handleTouchEnd);
      const cancel = detached(handleTouchCancel);
      target.addEventListener("touchmove", move, { passive: false });
      target.addEventListener("touchend", end, { passive: true });
      target.addEventListener("touchcancel", cancel, { passive: true });
      historyTouchTargetCleanupRef.current = () => {
        target.removeEventListener("touchmove", move);
        target.removeEventListener("touchend", end);
        target.removeEventListener("touchcancel", cancel);
      };
    };
    const handleKeyDown = (event: KeyboardEvent) => {
      if (
        event.defaultPrevented
        || event.altKey
        || event.ctrlKey
        || event.metaKey
        || isKeyboardEditableElement(event.target as Element | null)
      ) {
        return;
      }
      if (
        (event.key === "Enter" || event.key === " ")
        && isThreadDisclosureTarget(event.target)
      ) {
        yieldCameraToUser();
        return;
      }
      if (isKeyboardControl(event.target as Element | null)) return;
      historyInputRef.current = "other";
      handleDirectionalInput(keyboardScrollDirection(event));
    };
    if (historyTouchRef.current) observeHistoryTouchTarget(historyTouchRef.current.target);
    el.addEventListener("scroll", handleScroll, { passive: true });
    el.addEventListener("wheel", handleWheel, { passive: true });
    el.addEventListener("touchstart", handleTouchStart, { passive: true });
    el.addEventListener("touchmove", handleTouchMove, { passive: false });
    el.addEventListener("touchend", handleTouchEnd, { passive: true });
    el.addEventListener("touchcancel", handleTouchCancel, { passive: true });
    el.addEventListener("pointerdown", handlePointerDown);
    el.addEventListener("keydown", handleKeyDown);
    return () => {
      clearHistoryTouchTarget();
      el.removeEventListener("scroll", handleScroll);
      el.removeEventListener("wheel", handleWheel);
      el.removeEventListener("touchstart", handleTouchStart);
      el.removeEventListener("touchmove", handleTouchMove);
      el.removeEventListener("touchend", handleTouchEnd);
      el.removeEventListener("touchcancel", handleTouchCancel);
      el.removeEventListener("pointerdown", handlePointerDown);
      el.removeEventListener("keydown", handleKeyDown);
    };
  }, [
    captureHistoryScrollAnchor,
    clearHistoryTouchTarget,
    conversationReady,
    hasMessages,
    hasMoreBefore,
    hiddenMessageCount,
    loadingOlder,
    loadEarlierMessages,
    maybeLoadEarlierFromScroll,
    messages.length,
    olderError,
    yieldCameraToUser,
    historySlotKey,
    historyWindow,
    navigation,
    resetHistoryHeader,
  ]);

  const navigationStatus = navigation?.operation !== "older" && Boolean(navigation?.loading || navigation?.error);
  const showInitialHistoryStatus = !navigationStatus && historyUnknown && hasMessages && conversationReady
    && atHistoryTop && Boolean(initialLoading || initialError);
  const showHistoryStatus = !historyUnknown && !historySlotCompleted && !navigationStatus && messages.length > 0 && conversationReady
    && (atHistoryTop && (!historyExhausted || showHistoryExhausted) || historyPhase !== "hidden" || loadingOlder);
  const historyStatus = showHistoryStatus ? (
    <ThreadHistoryStatus
      ref={setHistoryStatus}
      loading={loadingOlder}
      error={olderError}
      exhausted={historyExhausted}
      preview={historyPhase === "feedback"}
      onRetry={loadEarlierMessages}
      className={!retainedHistorySlotKey && !(historyExhausted && showHistoryExhausted) ? cn("thread-history-reveal", historyPhase === "feedback" && "thread-history-feedback") : undefined}
    />
  ) : null;

  return (
    <div className="thread-viewport relative flex min-h-0 flex-1 overflow-hidden">
      <div
        ref={viewportFrameRef}
        className={cn(
          "thread-viewport-frame absolute inset-0",
          hasMessages
            ? "overflow-hidden"
            : cn(
                "thread-viewport-scrollbar scroll-auto",
                "[overflow-anchor:none] [scrollbar-width:none]",
                "[&::-webkit-scrollbar]:hidden",
                hasVerticalOverflow ? "overflow-y-auto" : "overflow-hidden",
              ),
        )}
        style={scrollViewportStyle}
      >
        <div
          ref={contentRef}
          data-testid={!hasThreadLayout ? "thread-welcome-layout" : undefined}
          data-layout={hasComposer ? (hasThreadLayout ? "thread" : "hero") : "external"}
          className={cn(
            "thread-layout mx-auto grid min-h-full w-full",
            hasThreadLayout
              ? "h-full"
              : "max-w-[72rem] px-3 pb-[calc(0.75rem+env(safe-area-inset-bottom))] pt-6 sm:px-4 sm:py-12",
          )}
        >
          {hasMessages ? (
            <div
              ref={setMessageRegion}
              data-testid="thread-message-region"
              className={cn(
                "thread-message-viewport thread-viewport-scrollbar row-start-1 flex min-h-0 min-w-0 flex-col",
                "scroll-auto justify-start overflow-x-hidden overscroll-y-none pb-0 scroll-pt-12",
                "[overflow-anchor:none] [scrollbar-width:none]",
                "[&::-webkit-scrollbar]:hidden",
                hasVerticalOverflow ? "overflow-y-auto" : "overflow-hidden",
              )}
            >
              <div ref={messageContentRef} className="w-full">
                <DiffViewportContext.Provider value={diffViewport}>
                <DiagramScope identity={conversationKey}>
                <SubagentThreadMessages
                  key={messagesKey}
                  messages={visibleMessages}
                  topInset={PROMPT_TOP_INSET_PX}
                  beforeUnit={retainedHistorySlotKey ? { key: retainedHistorySlotKey, content: (
                    <div ref={setHistorySlot} className="thread-history-slot relative" style={{ height: HISTORY_HOLD_PX }}>
                      {historyStatus}
                    </div>
                  ) } : undefined}
                  temporary={temporary}
                  isStreaming={isStreaming}
                  activeTurnId={activeTurnId}
                  runStartedAt={runStartedAt}
                  retryStatus={retryStatus}
                  hiddenUserMessageCount={hiddenUserMessageCount}
                  cliApps={cliApps}
                  mcpPresets={mcpPresets}
                  slashCommands={slashCommands}
                  forkBoundaryMessageCount={visibleForkBoundaryMessageCount}
                  traceDetailScope={traceDetailScope}
                  onLoadTraceDetails={onLoadTraceDetails}
                  onOpenFilePreview={onOpenFilePreview}
                  onForkFromMessage={onForkFromMessage}
                  onQuoteSelection={onQuoteSelection}
                  onActivityToggle={yieldCameraToUser}
                />
                </DiagramScope>
                </DiffViewportContext.Provider>
              </div>
              <div aria-hidden className="thread-message-end-gap shrink-0" />
              <div ref={bottomRef} aria-hidden className="h-px shrink-0" />
            </div>
          ) : (
            <div
              ref={emptyStateRef}
              data-testid="thread-empty-region"
              className={cn(
                "row-start-1 min-h-0 min-w-0 w-full",
                initialLoading
                  ? "overflow-hidden"
                  : cn("flex items-center justify-center", hasComposer && "sm:items-end sm:pb-8"),
              )}
            >
              {emptyState}
            </div>
          )}

          {hasComposer ? (
            <div
              ref={composerDockRef}
              data-testid="thread-composer-dock"
              data-theme-surface
              onInputCapture={(event) => {
                if (event.target instanceof HTMLTextAreaElement) {
                  threadMotionRef.current?.handleComposerInput();
                }
              }}
              className={cn(
                "row-start-2 z-10 w-full",
                hasThreadLayout ? "thread-composer-dock relative" : "relative self-center",
              )}
            >
              <div
                className={cn(
                  hasThreadLayout
                    ? "px-3 pb-[calc(0.5rem+env(safe-area-inset-bottom))] sm:px-4 sm:pb-[calc(0.75rem+env(safe-area-inset-bottom))]"
                    : "",
                )}
              >
                <div
                  data-testid="thread-composer-motion"
                  className="mx-auto w-full max-w-[58rem]"
                >
                  {composer}
                </div>
              </div>
            </div>
          ) : null}

          {hasComposer ? (
            <div
              aria-hidden
              className="thread-layout-spacer row-start-3 min-h-0 overflow-hidden"
            />
          ) : null}
        </div>
        {!retainedHistorySlotKey ? historyStatus : null}
        {showInitialHistoryStatus ? <ThreadHistoryStatus loading={initialLoading}
          error={initialError} onRetry={() => onRetryInitial?.()} /> : null}
        {navigationStatus && navigation ? <ThreadHistoryStatus loading={navigation.loading}
          error={navigation.error} onRetry={navigation.retry} /> : null}
        {!hasMessages ? <div ref={bottomRef} aria-hidden className="h-px" /> : null}
      </div>

      {hasMessages ? (
        <PromptRail
          messages={messages}
          prompts={navigation?.prompts}
          scrollRef={scrollRef}
          navigationFrame={navigationFrame}
          onJumpToPrompt={jumpToUserPrompt}
        />
      ) : null}

      {showScrollToBottomButton && (!atBottom || historyWindow) && (
        <div
          className="absolute left-1/2 z-20 -translate-x-1/2"
          style={{ bottom: scrollButtonBottom }}
        >
          <Button
            variant="outline"
            size="icon"
            onClick={() => {
              navigation?.latest();
              if (historyWindow) {
                pendingConversationScrollRef.current = true;
                setVisibleMessageCount(INITIAL_HISTORY_WINDOW);
              } else scrollToBottom(true, { force: true });
            }}
            className={cn(
              "h-8 w-8 rounded-full",
              "bg-background/90 backdrop-blur",
              "animate-in fade-in-0 zoom-in-95",
            )}
            aria-label={t("thread.scrollToBottom")}
          >
            <ArrowDown className="h-4 w-4" />
          </Button>
        </div>
      )}
    </div>
  );
});