diff --git a/apps/desktop/src/components/workpanel/SubagentPanel.tsx b/apps/desktop/src/components/workpanel/SubagentPanel.tsx
index 5dbd3ffb5..8a13fdb71 100644
--- a/apps/desktop/src/components/workpanel/SubagentPanel.tsx
+++ b/apps/desktop/src/components/workpanel/SubagentPanel.tsx
@@ -21,6 +21,7 @@ import { useFollowScroll } from "../../hooks/use-follow-scroll";
 import { useTranscriptView } from "../../hooks/use-transcript-view";
 import { useTranscriptSearchFocus } from "../../hooks/use-transcript-search-focus";
 import { IconArrowDown } from "../icons";
+import { DisclosureAnchorContext } from "../../lib/disclosure-anchor-context";
 import { TooltipButton } from "../ui";
 import { SubagentDetail } from "../ChatTranscript";
 
@@ -93,6 +94,7 @@ export function SubagentPanel({ selection }: { selection: SubagentPanelSelection
     jumpToLatest,
     scheduleFollowScroll,
     releaseFollow,
+    disclosureAnchorNotifier,
   } = useFollowScroll();
 
   useLayoutEffect(() => {
@@ -113,6 +115,7 @@ export function SubagentPanel({ selection }: { selection: SubagentPanelSelection
   });
 
   return (
+    <DisclosureAnchorContext.Provider value={disclosureAnchorNotifier}>
     <section
       id="subagent-panel"
       className="subagent-panel"
@@ -122,6 +125,7 @@ export function SubagentPanel({ selection }: { selection: SubagentPanelSelection
     >
       <div
         ref={scrollRef}
+        data-scroll-owner="follow"
         className="subagent-panel-scroll"
         onScroll={handleScroll}
         role="log"
@@ -163,5 +167,6 @@ export function SubagentPanel({ selection }: { selection: SubagentPanelSelection
           : t("panel.subagentEmpty")}
       </span>
     </section>
+    </DisclosureAnchorContext.Provider>
   );
 }
diff --git a/apps/desktop/src/features/chat/transcript/ActivityGroup.tsx b/apps/desktop/src/features/chat/transcript/ActivityGroup.tsx
index b4a20e311..f2d5f5d70 100644
--- a/apps/desktop/src/features/chat/transcript/ActivityGroup.tsx
+++ b/apps/desktop/src/features/chat/transcript/ActivityGroup.tsx
@@ -237,6 +237,7 @@ export const ActivityGroup = memo(function ActivityGroup({
     toggle: toggleDisclosure,
     collapse: collapseDisclosure,
     claim: claimDisclosure,
+    titleRef,
   } = useAutomaticDisclosure(live, revealRequest);
   const [now, setNow] = useState(Date.now);
   const [finishedAt, setFinishedAt] = useState<number | null>(null);
@@ -359,6 +360,7 @@ export const ActivityGroup = memo(function ActivityGroup({
       }`}
     >
       <button
+        ref={titleRef}
         className="tool-activity-header"
         aria-expanded={open}
         aria-controls={detailsId}
diff --git a/apps/desktop/src/features/chat/transcript/ChatTranscript.tsx b/apps/desktop/src/features/chat/transcript/ChatTranscript.tsx
index 3ad13d5c0..2080426ad 100644
--- a/apps/desktop/src/features/chat/transcript/ChatTranscript.tsx
+++ b/apps/desktop/src/features/chat/transcript/ChatTranscript.tsx
@@ -22,6 +22,7 @@ import { ResponseAnnotationOverlay } from "../../../components/ResponseAnnotatio
 import { useTranscriptScroll } from "./hooks/useTranscriptScroll";
 import type { TranscriptSearchTarget } from "../../../lib/transcript-reading";
 import { TranscriptSearchContext } from "../../../lib/transcript-search-context";
+import { DisclosureAnchorContext } from "../../../lib/disclosure-anchor-context";
 
 export const ChatTranscript = memo(function ChatTranscript({
   sessionId,
@@ -109,6 +110,7 @@ export const ChatTranscript = memo(function ChatTranscript({
     revealEarlierHistory,
     jumpToLatest,
     navigateAnnotation,
+    disclosureAnchorNotifier,
   } = useTranscriptScroll({
     sessionId,
     messages,
@@ -175,6 +177,7 @@ export const ChatTranscript = memo(function ChatTranscript({
 
   return (
     <TranscriptSearchContext.Provider value={searchTarget}>
+    <DisclosureAnchorContext.Provider value={disclosureAnchorNotifier}>
     <div
       className="thread-wrap"
       ref={wrapRef}
@@ -206,6 +209,7 @@ export const ChatTranscript = memo(function ChatTranscript({
       <div
         className="thread-scroll"
         ref={scrollRef}
+        data-scroll-owner="transcript"
         onScroll={handleScroll}
         role="log"
         aria-live="polite"
@@ -317,6 +321,7 @@ export const ChatTranscript = memo(function ChatTranscript({
         </TooltipButton>
       ) : null}
     </div>
+    </DisclosureAnchorContext.Provider>
     </TranscriptSearchContext.Provider>
   );
 });
diff --git a/apps/desktop/src/features/chat/transcript/SubagentDetail.tsx b/apps/desktop/src/features/chat/transcript/SubagentDetail.tsx
index 870e0be2b..70f298b82 100644
--- a/apps/desktop/src/features/chat/transcript/SubagentDetail.tsx
+++ b/apps/desktop/src/features/chat/transcript/SubagentDetail.tsx
@@ -29,6 +29,7 @@ import {
   IconStop,
   IconTarget,
 } from "../../../components/icons";
+import { useDisclosureAnchorNotifier } from "../../../lib/disclosure-anchor-context";
 import { CopyButton } from "./shared";
 import {
   delegateAgentName,
@@ -198,6 +199,8 @@ export function SubagentDetail({
   const taskLabelId = useId();
   const taskBodyRef = useRef<HTMLDivElement>(null);
   const [taskExpanded, setTaskExpanded] = useState(false);
+  const taskToggleRef = useRef<HTMLButtonElement | null>(null);
+  const notifyDisclosureAnchor = useDisclosureAnchorNotifier();
   const [taskOverflow, setTaskOverflow] = useState(false);
 
   useLayoutEffect(() => {
@@ -282,10 +285,17 @@ export function SubagentDetail({
           {taskOverflow ? (
             <button
               type="button"
+              ref={taskToggleRef}
               className="subagent-task-toggle"
               aria-expanded={taskExpanded}
               aria-controls={taskBodyId}
-              onClick={() => setTaskExpanded((expanded) => !expanded)}
+              onClick={() => {
+                // Expanding the brief changes the height of whichever scroller
+                // this card sits in (#324), so it holds the same reading
+                // position the tool and activity titles do.
+                notifyDisclosureAnchor?.(taskToggleRef.current);
+                setTaskExpanded((expanded) => !expanded);
+              }}
             >
               <span>
                 {taskExpanded
diff --git a/apps/desktop/src/features/chat/transcript/ToolRow.tsx b/apps/desktop/src/features/chat/transcript/ToolRow.tsx
index c848fd466..0d096c612 100644
--- a/apps/desktop/src/features/chat/transcript/ToolRow.tsx
+++ b/apps/desktop/src/features/chat/transcript/ToolRow.tsx
@@ -54,6 +54,7 @@ import {
   IconStop,
 } from "../../../components/icons";
 import { TooltipButton } from "../../../components/ui";
+import { DisclosureAnchorContext } from "../../../lib/disclosure-anchor-context";
 import {
   AssistantErrorMessage,
   DisclosureCollapseRail,
@@ -153,6 +154,7 @@ export const ToolRow = memo(function ToolRow({
   // through its status icon/label without expanding the payload automatically.
   const disclosure = useAutomaticDisclosure(false);
   const { open, toggle: toggleDisclosure, collapse: collapseDisclosure } = disclosure;
+  const titleRef = disclosure.titleRef;
   const toggleRow = useCallback(() => {
     onUserInteraction?.();
     toggleDisclosure();
@@ -377,6 +379,7 @@ export const ToolRow = memo(function ToolRow({
       ) : (
         <div className={`tool-row-head${runHead ? " is-run" : ""}`}>
           <button
+            ref={titleRef}
             className="tool-row-header"
             aria-expanded={open}
             aria-controls={hasDetails ? detailsId : undefined}
@@ -588,6 +591,7 @@ function SubagentRunFollow({
     handleScroll,
     jumpToLatest,
     scheduleFollowScroll,
+    disclosureAnchorNotifier,
   } = useFollowScroll();
 
   useLayoutEffect(() => {
@@ -596,59 +600,66 @@ function SubagentRunFollow({
   }, [items, scheduleFollowScroll, scrollable]);
 
   return (
-    <div className="subagent-run-follow">
-      {/* The rows scroll inside the run rather than growing the transcript
-        * (D271). Follow sticks to the latest output while pinned (D302).
-        * Labelled and focusable so a keyboard reader can reach the scroll
-        * area the pointer can already use. */}
-      <div
-        ref={scrollRef}
-        className={`subagent-run-rows${scrollable ? "" : " is-panel-flow"}`}
-        role="group"
-        tabIndex={scrollable ? 0 : undefined}
-        aria-labelledby={headingId}
-        onScroll={scrollable ? handleScroll : undefined}
-      >
-        <div ref={contentRef}>
-          {items.map((item) =>
-            item.kind === "tool" ? (
-              <Fragment key={item.message.id}>
-                <ToolRow message={item.message} />
-                <ReviewChangeCard message={item.message} />
-              </Fragment>
-            ) : item.kind === "thinking" ? (
-              <ThinkingRow
-                key={`thinking-${item.message.id}`}
-                message={item.message}
-                streaming={item.message.status === "streaming"}
-              />
-            ) : (
-              <div className="subagent-answer" data-message-id={item.message.id} key={`answer-${item.message.id}`}>
-                {item.message.content ? (
-                  <div className="prose-chat">
-                    <Markdown source={item.message.content} />
-                  </div>
-                ) : null}
-                {item.message.error ? (
-                  <AssistantErrorMessage message={item.message} />
-                ) : null}
-              </div>
-            ),
-          )}
+    <DisclosureAnchorContext.Provider value={disclosureAnchorNotifier}>
+      <div className="subagent-run-follow">
+        {/* The rows scroll inside the run rather than growing the transcript
+          * (D271). Follow sticks to the latest output while pinned (D302).
+          * Labelled and focusable so a keyboard reader can reach the scroll
+          * area the pointer can already use. */}
+        <div
+          ref={scrollRef}
+          data-scroll-owner="follow"
+          className={`subagent-run-rows${scrollable ? "" : " is-panel-flow"}`}
+          role="group"
+          tabIndex={scrollable ? 0 : undefined}
+          aria-labelledby={headingId}
+          onScroll={scrollable ? handleScroll : undefined}
+        >
+          <div ref={contentRef}>
+            {items.map((item) =>
+              item.kind === "tool" ? (
+                <Fragment key={item.message.id}>
+                  <ToolRow message={item.message} />
+                  <ReviewChangeCard message={item.message} />
+                </Fragment>
+              ) : item.kind === "thinking" ? (
+                <ThinkingRow
+                  key={`thinking-${item.message.id}`}
+                  message={item.message}
+                  streaming={item.message.status === "streaming"}
+                />
+              ) : (
+                <div
+                  className="subagent-answer"
+                  data-message-id={item.message.id}
+                  key={`answer-${item.message.id}`}
+                >
+                  {item.message.content ? (
+                    <div className="prose-chat">
+                      <Markdown source={item.message.content} />
+                    </div>
+                  ) : null}
+                  {item.message.error ? (
+                    <AssistantErrorMessage message={item.message} />
+                  ) : null}
+                </div>
+              ),
+            )}
+          </div>
         </div>
+        {scrollable && showJump ? (
+          <TooltipButton
+            type="button"
+            className="jump-latest-btn"
+            ariaLabel={t("chat.scrollToBottom")}
+            tooltip={t("chat.scrollToBottom")}
+            onClick={jumpToLatest}
+          >
+            <IconArrowDown size={14} />
+          </TooltipButton>
+        ) : null}
       </div>
-      {scrollable && showJump ? (
-        <TooltipButton
-          type="button"
-          className="jump-latest-btn"
-          ariaLabel={t("chat.scrollToBottom")}
-          tooltip={t("chat.scrollToBottom")}
-          onClick={jumpToLatest}
-        >
-          <IconArrowDown size={14} />
-        </TooltipButton>
-      ) : null}
-    </div>
+    </DisclosureAnchorContext.Provider>
   );
 }
 
diff --git a/apps/desktop/src/features/chat/transcript/hooks/useTranscriptScroll.ts b/apps/desktop/src/features/chat/transcript/hooks/useTranscriptScroll.ts
index 85e548b7a..c70d12281 100644
--- a/apps/desktop/src/features/chat/transcript/hooks/useTranscriptScroll.ts
+++ b/apps/desktop/src/features/chat/transcript/hooks/useTranscriptScroll.ts
@@ -32,8 +32,14 @@ import {
 } from "../../../../lib/transcript-window";
 import {
   isRecentScrollGesture,
+  isScrollGestureInput,
   reduceTranscriptScroll,
+  SCROLL_OWNER_ATTRIBUTE,
+  TRANSCRIPT_SCROLL_ROUNDING_TOLERANCE_PX,
+  type ScrollInputType,
 } from "../../../../lib/transcript-scroll";
+import { readScrollInputContext } from "../../../../lib/scroll-input";
+import { useDisclosureAnchor } from "../../../../hooks/use-disclosure-anchor";
 import type { TranscriptSearchTarget } from "../../../../lib/transcript-reading";
 import { useTranscriptSearchFocus } from "../../../../hooks/use-transcript-search-focus";
 
@@ -103,11 +109,12 @@ export function useTranscriptScroll({
     if (!el) return;
     const targetTop = Math.max(0, el.scrollHeight - el.clientHeight);
     el.scrollTo({ top: targetTop, behavior });
-    // `scrollTo({ behavior: "auto" })` is synchronous. Recording the exact
-    // target avoids the following native scroll event being mistaken for a
-    // user gesture when the composer or the new turn changes the content
-    // height in the same frame.
-    if (behavior === "auto") lastScrollTopRef.current = targetTop;
+    // `scrollTo({ behavior: "auto" })` is synchronous. Record the position the
+    // scroller actually reached, not the one that was asked for: at a
+    // fractional device pixel ratio the browser lands a fraction of a pixel
+    // away (asked 841, got 840.909), and the intended value would make the
+    // following native scroll event read as the user scrolling up.
+    if (behavior === "auto") lastScrollTopRef.current = el.scrollTop;
   }, []);
 
   const cancelFollowScroll = useCallback(() => {
@@ -115,39 +122,52 @@ export function useTranscriptScroll({
     followFrameRef.current = 0;
   }, []);
 
+  // A manual disclosure (a tool, thinking or activity title; #324) hands this
+  // scroller the very title it was toggled from, before the expansion state
+  // changes. Follow mode is left first — re-bottoming the expansion is exactly
+  // what dragged the clicked title out of view — and the held position is
+  // restored from the observer below for every frame of the height transition.
+  const enterDisclosureReading = useCallback(() => {
+    cancelFollowScroll();
+    pinnedRef.current = false;
+    setShowJump(true);
+  }, [cancelFollowScroll]);
+  const recordScrollPosition = useCallback((top: number) => {
+    lastScrollTopRef.current = top;
+  }, []);
+  const {
+    notifier: disclosureAnchorNotifier,
+    restore: restoreDisclosureAnchor,
+    release: releaseDisclosureAnchor,
+    isHeld: isDisclosureAnchorHeld,
+  } = useDisclosureAnchor(
+    scrollRef,
+    enterDisclosureReading,
+    recordScrollPosition,
+  );
+
   // A user scroll-up gesture always emits input before its scroll events;
   // programmatic follow scrolling and layout clamps (composer collapse on
   // send, indicator mount/unmount) never do. Track the last real input so
   // `handleScroll` can tell the two apart and never let a clamp between a
-  // follow `scrollTo` and its native event release follow mode.
-  const markScrollGesture = useCallback((event: Event) => {
-    if (
-      event.type === "wheel" ||
-      event.type === "touchstart" ||
-      event.type === "touchmove"
-    ) {
-      lastScrollGestureAtRef.current = performance.now();
-      return;
-    }
-    if (event.type === "pointerdown") {
+  // follow `scrollTo` and its native event release follow mode. Only input
+  // that can move *this* scroller counts: a press on a row control is an
+  // ordinary click, a field owns its own keys, and a gesture a nested dock
+  // consumes belongs to that dock.
+  const markScrollGesture = useCallback(
+    (event: Event) => {
+      const input = readScrollInputContext(
+        event,
+        scrollRef.current,
+        contentRef.current,
+      );
+      if (!isScrollGestureInput(event.type as ScrollInputType, input)) return;
       lastScrollGestureAtRef.current = performance.now();
-      return;
-    }
-    if (event.type === "keydown") {
-      const key = (event as KeyboardEvent).key;
-      if (
-        key === "ArrowUp" ||
-        key === "ArrowDown" ||
-        key === "PageUp" ||
-        key === "PageDown" ||
-        key === "Home" ||
-        key === "End" ||
-        key === " "
-      ) {
-        lastScrollGestureAtRef.current = performance.now();
-      }
-    }
-  }, []);
+      // Real input takes the viewport back from a held disclosure position.
+      releaseDisclosureAnchor();
+    },
+    [releaseDisclosureAnchor],
+  );
 
   useEffect(() => {
     const el = wrapRef.current;
@@ -170,11 +190,12 @@ export function useTranscriptScroll({
   // "activation" is its own first layout: settle at the newest turn before the
   // first paint, with no cross-session state to unwind.
   useLayoutEffect(() => {
+    releaseDisclosureAnchor();
     cancelFollowScroll();
     pinnedRef.current = true;
     setShowJump(false);
     scrollToBottom();
-  }, [cancelFollowScroll, scrollToBottom]);
+  }, [cancelFollowScroll, releaseDisclosureAnchor, scrollToBottom]);
 
   // Revisits restore this pane's own position. A hidden scroller can be clamped
   // while its content grows off screen, so the offset is captured on the way out
@@ -193,6 +214,7 @@ export function useTranscriptScroll({
     if (!el) return;
     wasPaneVisibleRef.current = paneVisible;
     if (becameHidden) {
+      releaseDisclosureAnchor();
       cancelFollowScroll();
       retainedScrollTopRef.current = el.scrollTop;
       return;
@@ -206,7 +228,7 @@ export function useTranscriptScroll({
     if (retained === null) return;
     el.scrollTop = retained;
     lastScrollTopRef.current = retained;
-  }, [cancelFollowScroll, paneVisible, scrollToBottom]);
+  }, [cancelFollowScroll, paneVisible, releaseDisclosureAnchor, scrollToBottom]);
 
   // A hidden pane must not chase its stream: its scroller has no visible
   // viewport, and the measurements a follow scroll depends on are unreliable
@@ -215,12 +237,16 @@ export function useTranscriptScroll({
   paneVisibleRef.current = paneVisible;
   const scheduleFollowScroll = useCallback(() => {
     if (!paneVisibleRef.current) return;
+    // A held disclosure position wins over a queued follow frame: re-asserting
+    // the bottom here would move the title the reader just toggled even though
+    // the observer below already refuses to.
     if (!pinnedRef.current || followFrameRef.current !== 0) return;
+    if (isDisclosureAnchorHeld()) return;
     followFrameRef.current = requestAnimationFrame(() => {
       followFrameRef.current = 0;
       if (paneVisibleRef.current && pinnedRef.current) scrollToBottom();
     });
-  }, [scrollToBottom]);
+  }, [isDisclosureAnchorHeld, scrollToBottom]);
 
   // Re-pins before the browser paints. A ResizeObserver callback runs after
   // layout and before paint, so a `requestAnimationFrame` requested from it
@@ -229,11 +255,16 @@ export function useTranscriptScroll({
   // twitching whenever a row changed height after mount (D287). Scrolling from
   // inside the callback costs nothing extra (layout is already clean) and
   // cannot resize the observed box, so it never re-triggers the observer.
+  //
+  // A manual disclosure holds the title the reader toggled (#324) and is
+  // restored first: its height can keep changing for several frames, and
+  // re-pinning on any one of them is what dragged that title out of view.
   const followScrollNow = useCallback(() => {
+    if (paneVisibleRef.current && restoreDisclosureAnchor()) return;
     if (!paneVisibleRef.current || !pinnedRef.current) return;
     cancelFollowScroll();
     scrollToBottom();
-  }, [cancelFollowScroll, scrollToBottom]);
+  }, [cancelFollowScroll, restoreDisclosureAnchor, scrollToBottom]);
 
   useEffect(() => cancelFollowScroll, [cancelFollowScroll]);
 
@@ -301,27 +332,30 @@ export function useTranscriptScroll({
       return;
     }
     const wasPinned = pinnedRef.current;
+    // Only a real gesture (wheel / trackpad / touch / scrollbar / keyboard,
+    // on this scroller) releases follow. When the composer collapses or an
+    // indicator row unmounts right after send, the browser clamps scrollTop
+    // and emits a scroll event that looks like an upward gesture; without
+    // this guard it would cancel follow and leave the transcript stuck above
+    // the new turn. The tolerance is slack for the fractions a fractional
+    // device pixel ratio leaves behind on programmatic corrections; anything a
+    // gesture produced is compared exactly, so a one-pixel scroll still
+    // unpins.
+    const gesturing = isRecentScrollGesture(
+      performance.now(),
+      lastScrollGestureAtRef.current,
+    );
     const transition = reduceTranscriptScroll({
       previousScrollTop: lastScrollTopRef.current,
       scrollTop: el.scrollTop,
       scrollHeight: el.scrollHeight,
       clientHeight: el.clientHeight,
-      wasPinned: pinnedRef.current,
+      wasPinned,
+      tolerancePx: gesturing ? 0 : TRANSCRIPT_SCROLL_ROUNDING_TOLERANCE_PX,
     });
     lastScrollTopRef.current = el.scrollTop;
     if (transition.releasedFollow) cancelFollowScroll();
-    // Only a real gesture (wheel / trackpad / touch / scrollbar / keyboard)
-    // releases follow. When the composer collapses or an indicator row
-    // unmounts right after send, the browser clamps scrollTop and emits a
-    // scroll event that looks like an upward gesture; without this guard it
-    // would cancel follow and leave the transcript stuck above the new turn.
-    const released =
-      transition.releasedFollow &&
-      isRecentScrollGesture(
-        performance.now(),
-        lastScrollGestureAtRef.current,
-      );
-    if (released) {
+    if (gesturing && transition.releasedFollow) {
       pinnedRef.current = false;
       setShowJump(true);
     } else if (transition.releasedFollow) {
@@ -347,6 +381,7 @@ export function useTranscriptScroll({
     const turnStarted = isRunning && !wasRunningRef.current;
     wasRunningRef.current = isRunning;
     if (!turnStarted || !paneVisible) return;
+    releaseDisclosureAnchor();
     cancelFollowScroll();
     pinnedRef.current = true;
     setShowJump(false);
@@ -356,6 +391,7 @@ export function useTranscriptScroll({
     cancelFollowScroll,
     isRunning,
     paneVisible,
+    releaseDisclosureAnchor,
     scheduleFollowScroll,
     scrollToBottom,
   ]);
@@ -502,13 +538,11 @@ export function useTranscriptScroll({
 
   const releaseSearchFollow = useCallback((fresh: boolean) => {
     if (fresh) prependHeightRef.current = null;
+    releaseDisclosureAnchor();
     cancelFollowScroll();
     pinnedRef.current = false;
     setShowJump(true);
-  }, [cancelFollowScroll]);
-  const recordSearchPosition = useCallback((top: number) => {
-    lastScrollTopRef.current = top;
-  }, []);
+  }, [cancelFollowScroll, releaseDisclosureAnchor]);
   useTranscriptSearchFocus({
     target: searchTarget,
     source: messages.find((message) => message.id === searchTarget?.messageId)?.content ?? "",
@@ -517,7 +551,7 @@ export function useTranscriptScroll({
     contentRef,
     contentVersion: historyEntries,
     onNavigate: releaseSearchFollow,
-    onPosition: recordSearchPosition,
+    onPosition: recordScrollPosition,
   });
 
   // Runs in the same layout phase the expansion commits in, before the browser
@@ -587,12 +621,13 @@ export function useTranscriptScroll({
   const hasEarlierHistory = transcriptWindow.hiddenAbove > 0 || hasMoreBefore;
 
   const navigateAnnotation = useCallback((annotation: ResponseAnnotation) => {
+    releaseDisclosureAnchor();
     cancelFollowScroll();
     pinnedRef.current = false;
     setShowJump(true);
     annotationPagesRef.current.clear();
     setPendingAnnotation(annotation);
-  }, [cancelFollowScroll]);
+  }, [cancelFollowScroll, releaseDisclosureAnchor]);
 
   // An annotation can precede the mounted window (or a reloaded history page).
   // Reveal its row before measuring, then scroll only this pane, not the window.
@@ -646,6 +681,7 @@ export function useTranscriptScroll({
       reachTop();
       return;
     }
+    releaseDisclosureAnchor();
     cancelFollowScroll();
     pinnedRef.current = false;
     setShowJump(true);
@@ -656,9 +692,10 @@ export function useTranscriptScroll({
       top: 0,
       behavior: reduceMotion ? "auto" : "smooth",
     });
-  }, [cancelFollowScroll, reachTop]);
+  }, [cancelFollowScroll, reachTop, releaseDisclosureAnchor]);
 
   const jumpToLatest = useCallback(() => {
+    releaseDisclosureAnchor();
     pinnedRef.current = true;
     setShowJump(false);
     scrollToBottom(
@@ -666,7 +703,7 @@ export function useTranscriptScroll({
         ? "auto"
         : "smooth",
     );
-  }, [scrollToBottom]);
+  }, [releaseDisclosureAnchor, scrollToBottom]);
 
   // D269: history progression follows the visible top boundary, not only a
   // native scroll event. A tail page can collapse to less than one viewport,
@@ -756,5 +793,6 @@ export function useTranscriptScroll({
     scrollToBottom,
     jumpToLatest,
     navigateAnnotation,
+    disclosureAnchorNotifier,
   };
 }
diff --git a/apps/desktop/src/features/chat/transcript/shared.tsx b/apps/desktop/src/features/chat/transcript/shared.tsx
index 4fe311e50..7d338f448 100644
--- a/apps/desktop/src/features/chat/transcript/shared.tsx
+++ b/apps/desktop/src/features/chat/transcript/shared.tsx
@@ -18,6 +18,7 @@ import {
   type ThinkingLevel,
 } from "@pi-desktop/shared";
 import { useOpenChatFileRef, useOpenPreviewTarget } from "../../../hooks/use-preview-target";
+import { useDisclosureAnchorNotifier } from "../../../lib/disclosure-anchor-context";
 import { messageThinking as thinkingText } from "../../../lib/assistant-turns";
 import { useReferencedImageDataUrl } from "../../../lib/use-referenced-image-data-url";
 import { isHtmlFilePath, splitChatText } from "../../../lib/chat-links";
@@ -138,6 +139,8 @@ export function MessageMeta({
 export function AssistantErrorMessage({ message }: { message: UiMessage }) {
   const { t } = useTranslation();
   const [open, setOpen] = useState(true);
+  const detailsToggleRef = useRef<HTMLButtonElement | null>(null);
+  const notifyDisclosureAnchor = useDisclosureAnchorNotifier();
   const detailsId = useId();
   const error = message.error;
   if (!error) return null;
@@ -175,10 +178,17 @@ export function AssistantErrorMessage({ message }: { message: UiMessage }) {
         <div className="message-error-actions">
           <button
             type="button"
+            ref={detailsToggleRef}
             className="message-error-toggle"
             aria-expanded={open}
             aria-controls={detailsId}
-            onClick={() => setOpen((value) => !value)}
+            onClick={() => {
+              // The raw detail block changes the row's height, so this manual
+              // disclosure holds its own reading position like the others
+              // (#324).
+              notifyDisclosureAnchor?.(detailsToggleRef.current);
+              setOpen((value) => !value);
+            }}
           >
             <IconChevronRight size={12} aria-hidden />
             {open ? t("chat.hideErrorDetails") : t("chat.showErrorDetails")}
@@ -310,9 +320,17 @@ export function ToolActionIcon({ action }: { action: ToolAction }) {
  * but one user click takes ownership for the rest of that component's lifetime.
  * Layout effects keep the automatic transition from moving the transcript for a
  * painted frame.
+ *
+ * A *manual* toggle also hands its own title to the scroller that owns it,
+ * before the state changes (#324): the height under the click may keep changing
+ * for several frames, and the reader's place in the transcript is the one thing
+ * that must not move while it does. The automatic transition below goes through
+ * `setOpen` directly and never claims a reading position.
  */
 export function useAutomaticDisclosure(automaticOpen: boolean, revealRequest?: number) {
   const [open, setOpen] = useState(automaticOpen || revealRequest !== undefined);
+  const notifyAnchor = useDisclosureAnchorNotifier();
+  const titleRef = useRef<HTMLButtonElement | null>(null);
   const userInteractedRef = useRef(false);
   const previousAutomaticOpenRef = useRef(automaticOpen);
 
@@ -335,15 +353,17 @@ export function useAutomaticDisclosure(automaticOpen: boolean, revealRequest?: n
 
   const toggle = useCallback(() => {
     claim();
+    notifyAnchor?.(titleRef.current);
     setOpen((value) => !value);
-  }, [claim]);
+  }, [claim, notifyAnchor]);
 
   const collapse = useCallback(() => {
     claim();
+    notifyAnchor?.(titleRef.current);
     setOpen(false);
-  }, [claim]);
+  }, [claim, notifyAnchor]);
 
-  return { open, toggle, collapse, claim };
+  return { open, toggle, collapse, claim, titleRef };
 }
 
 /** Actions whose path/url argument makes sense to preview in the panel. */
@@ -529,8 +549,9 @@ export const ThinkingRow = memo(function ThinkingRow({
 }) {
   const { t } = useTranslation();
   const detailsId = useId();
-  const { open, toggle: toggleDisclosure, collapse: collapseDisclosure } =
-    useAutomaticDisclosure(autoOpen);
+  const disclosure = useAutomaticDisclosure(autoOpen);
+  const { open, toggle: toggleDisclosure, collapse: collapseDisclosure } = disclosure;
+  const titleRef = disclosure.titleRef;
   const toggleRow = useCallback(() => {
     onUserInteraction?.();
     toggleDisclosure();
@@ -544,6 +565,7 @@ export const ThinkingRow = memo(function ThinkingRow({
   return (
     <div className={`tool-row thinking ${open ? "open" : ""}`}>
       <button
+        ref={titleRef}
         className="tool-row-header"
         aria-expanded={open}
         aria-controls={detailsId}
diff --git a/apps/desktop/src/hooks/use-disclosure-anchor.ts b/apps/desktop/src/hooks/use-disclosure-anchor.ts
new file mode 100644
index 000000000..3a96c605c
--- /dev/null
+++ b/apps/desktop/src/hooks/use-disclosure-anchor.ts
@@ -0,0 +1,128 @@
+import { useCallback, useRef, type RefObject } from "react";
+import {
+  adoptDisclosureAnchor,
+  resolveDisclosureAnchor,
+  type DisclosureAnchor,
+  type DisclosureAnchorFrame,
+} from "../lib/disclosure-anchor";
+import {
+  useDisclosureAnchorNotifier,
+  type DisclosureAnchorNotifier,
+} from "../lib/disclosure-anchor-context";
+
+type HeldTitle = DisclosureAnchor & { element: HTMLElement };
+
+export type DisclosureAnchorControl = {
+  /**
+   * Context value for the rows this scroller renders. Called synchronously by a
+   * manual disclosure, before its state changes, so the title is measured while
+   * the layout still matches what the user clicked.
+   */
+  notifier: DisclosureAnchorNotifier;
+  /**
+   * Puts the held title back where it was; run from the scroller's own
+   * `ResizeObserver`, so it covers every frame of a height transition. Returns
+   * `true` while a title is held, which is also the signal to skip follow
+   * scrolling for this frame.
+   */
+  restore: () => boolean;
+  /** Whether a title is held, for callers that queue follow work. */
+  isHeld: () => boolean;
+  /** Drops the hold: real input, a follow re-pin, or a departing pane. */
+  release: () => void;
+};
+
+/**
+ * Reading position held across one manual disclosure (#324).
+ *
+ * Shared by the transcript scroller and every nested follow scroller (D302) so
+ * both answer the same way: the title keeps its viewport offset for as long as
+ * the content around it keeps changing height, and the scroller stops
+ * re-bottoming until the reader takes the viewport back.
+ */
+export function useDisclosureAnchor(
+  scrollRef: RefObject<HTMLDivElement | null>,
+  /** Called once when a hold begins, to leave follow mode. */
+  onHold: () => void,
+  /** Records the scroll position a correction reached, as own scroll work. */
+  onPosition: (scrollTop: number) => void,
+): DisclosureAnchorControl {
+  const heldRef = useRef<HeldTitle | null>(null);
+  const onHoldRef = useRef(onHold);
+  const onPositionRef = useRef(onPosition);
+  onHoldRef.current = onHold;
+  onPositionRef.current = onPosition;
+  // A scroller nested in another one (the transcript's delegate dock, D302)
+  // passes its hold outward as well: growing the inner scroller grows the outer
+  // content, so an outer scroller still in follow mode would re-bottom and drag
+  // the same title away. Reading the ambient notifier here — at this
+  // component's own position in the tree — never sees this owner's own value.
+  const outerNotifier = useDisclosureAnchorNotifier();
+
+  const measure = useCallback(
+    (element: HTMLElement): DisclosureAnchorFrame | null => {
+      const scroller = scrollRef.current;
+      if (!scroller || !scroller.isConnected || !element.isConnected) {
+        return null;
+      }
+      return {
+        elementOffset:
+          element.getBoundingClientRect().top -
+          scroller.getBoundingClientRect().top,
+        scrollTop: scroller.scrollTop,
+        scrollHeight: scroller.scrollHeight,
+        clientHeight: scroller.clientHeight,
+      };
+    },
+    [scrollRef],
+  );
+
+  const notifier = useCallback<DisclosureAnchorNotifier>(
+    (title) => {
+      if (!title) return;
+      const frame = measure(title);
+      if (!frame) return;
+      heldRef.current = { element: title, offset: frame.elementOffset };
+      onHoldRef.current();
+      outerNotifier?.(title);
+    },
+    [measure, outerNotifier],
+  );
+
+  const release = useCallback(() => {
+    heldRef.current = null;
+  }, []);
+
+  const isHeld = useCallback(() => heldRef.current !== null, []);
+
+  const restore = useCallback(() => {
+    const held = heldRef.current;
+    if (!held) return false;
+    const scroller = scrollRef.current;
+    const before = measure(held.element);
+    if (!scroller || !before) {
+      // The title or the scroller is gone: there is nothing left to hold.
+      heldRef.current = null;
+      return false;
+    }
+    const target = resolveDisclosureAnchor(held, before);
+    if (target !== null) {
+      scroller.scrollTop = target;
+      // Record what the scroller actually reached, exactly as follow scrolling
+      // does, so its own native scroll event is not read as a user gesture.
+      onPositionRef.current(scroller.scrollTop);
+    }
+    // Adopt the position the title actually reached: a boundary clamp is the
+    // browser's answer, not an error to correct again on the next frame.
+    const after = measure(held.element);
+    if (after) {
+      heldRef.current = {
+        element: held.element,
+        ...adoptDisclosureAnchor(after),
+      };
+    }
+    return true;
+  }, [measure, scrollRef]);
+
+  return { notifier, restore, release, isHeld };
+}
diff --git a/apps/desktop/src/hooks/use-follow-scroll.ts b/apps/desktop/src/hooks/use-follow-scroll.ts
index 457376c35..ac2e1b95c 100644
--- a/apps/desktop/src/hooks/use-follow-scroll.ts
+++ b/apps/desktop/src/hooks/use-follow-scroll.ts
@@ -9,8 +9,14 @@ import {
 } from "react";
 import {
   isRecentScrollGesture,
+  isScrollGestureInput,
   reduceTranscriptScroll,
+  TRANSCRIPT_SCROLL_ROUNDING_TOLERANCE_PX,
+  type ScrollInputType,
 } from "../lib/transcript-scroll";
+import { readScrollInputContext } from "../lib/scroll-input";
+import type { DisclosureAnchorNotifier } from "../lib/disclosure-anchor-context";
+import { useDisclosureAnchor } from "./use-disclosure-anchor";
 
 export type FollowScroll = {
   scrollRef: RefObject<HTMLDivElement | null>;
@@ -20,6 +26,8 @@ export type FollowScroll = {
   jumpToLatest: () => void;
   scheduleFollowScroll: () => void;
   releaseFollow: () => void;
+  /** Provided around this scroller's rows so their disclosures can hold it. */
+  disclosureAnchorNotifier: DisclosureAnchorNotifier;
 };
 
 /**
@@ -28,6 +36,9 @@ export type FollowScroll = {
  * Same contract as the main transcript: pin on mount, follow while pinned,
  * release only on a real upward gesture, and re-pin from a jump control.
  * Layout clamps and programmatic `scrollTo` never count as a user gesture.
+ * A manual disclosure holds its own reading position here too (#324), and the
+ * hold also reaches the scroller this one is nested in, because growing these
+ * rows grows that one's content as well.
  */
 export function useFollowScroll(): FollowScroll {
   const scrollRef = useRef<HTMLDivElement>(null);
@@ -43,7 +54,11 @@ export function useFollowScroll(): FollowScroll {
     if (!el) return;
     const targetTop = Math.max(0, el.scrollHeight - el.clientHeight);
     el.scrollTo({ top: targetTop, behavior });
-    if (behavior === "auto") lastScrollTopRef.current = targetTop;
+    // Record the position the scroller actually reached, not the one that was
+    // asked for: a fractional device pixel ratio lands a fraction of a pixel
+    // away, and the intended value would make the following native scroll event
+    // read as the user scrolling up.
+    if (behavior === "auto") lastScrollTopRef.current = el.scrollTop;
   }, []);
 
   const cancelFollowScroll = useCallback(() => {
@@ -51,34 +66,37 @@ export function useFollowScroll(): FollowScroll {
     followFrameRef.current = 0;
   }, []);
 
-  const markScrollGesture = useCallback((event: Event) => {
-    if (
-      event.type === "wheel" ||
-      event.type === "touchstart" ||
-      event.type === "touchmove"
-    ) {
-      lastScrollGestureAtRef.current = performance.now();
-      return;
-    }
-    if (event.type === "pointerdown") {
-      lastScrollGestureAtRef.current = performance.now();
-      return;
-    }
-    if (event.type === "keydown") {
-      const key = (event as KeyboardEvent).key;
-      if (
-        key === "ArrowUp" ||
-        key === "ArrowDown" ||
-        key === "PageUp" ||
-        key === "PageDown" ||
-        key === "Home" ||
-        key === "End" ||
-        key === " "
-      ) {
-        lastScrollGestureAtRef.current = performance.now();
-      }
-    }
+  const recordScrollPosition = useCallback((top: number) => {
+    lastScrollTopRef.current = top;
   }, []);
+  const {
+    notifier: disclosureAnchorNotifier,
+    restore: restoreDisclosureAnchor,
+    release: releaseDisclosureAnchor,
+    isHeld: isDisclosureAnchorHeld,
+  } = useDisclosureAnchor(
+    scrollRef,
+    useCallback(() => {
+      cancelFollowScroll();
+      pinnedRef.current = false;
+      setShowJump(true);
+    }, [cancelFollowScroll]),
+    recordScrollPosition,
+  );
+
+  const markScrollGesture = useCallback(
+    (event: Event) => {
+      const input = readScrollInputContext(
+        event,
+        scrollRef.current,
+        contentRef.current,
+      );
+      if (!isScrollGestureInput(event.type as ScrollInputType, input)) return;
+      lastScrollGestureAtRef.current = performance.now();
+      releaseDisclosureAnchor();
+    },
+    [releaseDisclosureAnchor],
+  );
 
   useEffect(() => {
     const el = scrollRef.current;
@@ -98,50 +116,60 @@ export function useFollowScroll(): FollowScroll {
   }, [markScrollGesture]);
 
   useLayoutEffect(() => {
+    releaseDisclosureAnchor();
     cancelFollowScroll();
     pinnedRef.current = true;
     setShowJump(false);
     scrollToBottom();
-  }, [cancelFollowScroll, scrollToBottom]);
+  }, [cancelFollowScroll, releaseDisclosureAnchor, scrollToBottom]);
 
   const scheduleFollowScroll = useCallback(() => {
+    // A queued follow frame must not move the title the reader just toggled:
+    // the observer below already refuses to, and this path would undo it.
     if (!pinnedRef.current || followFrameRef.current !== 0) return;
+    if (isDisclosureAnchorHeld()) return;
     followFrameRef.current = requestAnimationFrame(() => {
       followFrameRef.current = 0;
       if (pinnedRef.current) scrollToBottom();
     });
-  }, [scrollToBottom]);
+  }, [isDisclosureAnchorHeld, scrollToBottom]);
 
   // Re-pin in the observer callback itself (D287): a rAF scheduled from
-  // ResizeObserver paints one unpinned frame before the follow lands.
+  // ResizeObserver paints one unpinned frame before the follow lands. A held
+  // disclosure position takes precedence — it is what keeps the clicked title
+  // still while the dock's rows animate. (`useDisclosureAnchor` already passes
+  // this hold outward to the scroller this one is nested in.)
   const followScrollNow = useCallback(() => {
+    if (restoreDisclosureAnchor()) return;
     if (!pinnedRef.current) return;
     cancelFollowScroll();
     scrollToBottom();
-  }, [cancelFollowScroll, scrollToBottom]);
+  }, [cancelFollowScroll, restoreDisclosureAnchor, scrollToBottom]);
 
   useEffect(() => cancelFollowScroll, [cancelFollowScroll]);
+  useEffect(() => releaseDisclosureAnchor, [releaseDisclosureAnchor]);
 
   const handleScroll = useCallback<UIEventHandler<HTMLDivElement>>(() => {
     const el = scrollRef.current;
     if (!el) return;
     const wasPinned = pinnedRef.current;
+    // Real input is compared exactly; without it, sub-pixel slack keeps a
+    // fractional device pixel ratio from reading as the user scrolling up.
+    const gesturing = isRecentScrollGesture(
+      performance.now(),
+      lastScrollGestureAtRef.current,
+    );
     const transition = reduceTranscriptScroll({
       previousScrollTop: lastScrollTopRef.current,
       scrollTop: el.scrollTop,
       scrollHeight: el.scrollHeight,
       clientHeight: el.clientHeight,
-      wasPinned: pinnedRef.current,
+      wasPinned,
+      tolerancePx: gesturing ? 0 : TRANSCRIPT_SCROLL_ROUNDING_TOLERANCE_PX,
     });
     lastScrollTopRef.current = el.scrollTop;
     if (transition.releasedFollow) cancelFollowScroll();
-    const released =
-      transition.releasedFollow &&
-      isRecentScrollGesture(
-        performance.now(),
-        lastScrollGestureAtRef.current,
-      );
-    if (released) {
+    if (gesturing && transition.releasedFollow) {
       pinnedRef.current = false;
       setShowJump(true);
     } else if (transition.releasedFollow) {
@@ -165,6 +193,7 @@ export function useFollowScroll(): FollowScroll {
   }, [followScrollNow]);
 
   const jumpToLatest = useCallback(() => {
+    releaseDisclosureAnchor();
     pinnedRef.current = true;
     setShowJump(false);
     scrollToBottom(
@@ -172,13 +201,14 @@ export function useFollowScroll(): FollowScroll {
         ? "auto"
         : "smooth",
     );
-  }, [scrollToBottom]);
+  }, [releaseDisclosureAnchor, scrollToBottom]);
 
   const releaseFollow = useCallback(() => {
+    releaseDisclosureAnchor();
     cancelFollowScroll();
     pinnedRef.current = false;
     setShowJump(true);
-  }, [cancelFollowScroll]);
+  }, [cancelFollowScroll, releaseDisclosureAnchor]);
 
   return {
     scrollRef,
@@ -188,5 +218,7 @@ export function useFollowScroll(): FollowScroll {
     jumpToLatest,
     scheduleFollowScroll,
     releaseFollow,
+    disclosureAnchorNotifier,
   };
 }
+
diff --git a/apps/desktop/src/lib/disclosure-anchor-context.ts b/apps/desktop/src/lib/disclosure-anchor-context.ts
new file mode 100644
index 000000000..041b6a3ec
--- /dev/null
+++ b/apps/desktop/src/lib/disclosure-anchor-context.ts
@@ -0,0 +1,21 @@
+import { createContext, useContext } from "react";
+
+/**
+ * Hands the title element of a manual disclosure to the scroll container that
+ * owns it, synchronously, before the expansion state changes (#324).
+ *
+ * Every scroll owner provides its own notifier — the transcript scroller and
+ * each nested follow scroller (D302) — so the innermost owner wins: a row inside
+ * a delegate's dock hands its reading position to that dock, not to the
+ * transcript behind it, and a row inside the transcript hands it to the
+ * transcript. Without a provider (a row rendered outside any scroller) the
+ * notification is simply a no-op.
+ */
+export type DisclosureAnchorNotifier = (title: HTMLElement | null) => void;
+
+export const DisclosureAnchorContext =
+  createContext<DisclosureAnchorNotifier | null>(null);
+
+export function useDisclosureAnchorNotifier(): DisclosureAnchorNotifier | null {
+  return useContext(DisclosureAnchorContext);
+}
diff --git a/apps/desktop/src/lib/disclosure-anchor.ts b/apps/desktop/src/lib/disclosure-anchor.ts
new file mode 100644
index 000000000..62aae5144
--- /dev/null
+++ b/apps/desktop/src/lib/disclosure-anchor.ts
@@ -0,0 +1,78 @@
+/**
+ * Reading position held across one manual disclosure (#324).
+ *
+ * The transcript turns native scroll anchoring off (`.thread-scroll` sets
+ * `overflow-anchor: none`), so the browser does not keep a row in place when
+ * the content around it changes height, and pinned follow cannot either: it
+ * re-bottoms on every content resize, which is exactly what dragged a clicked
+ * tool/thinking/activity title out of view. A manual disclosure therefore hands
+ * the owning scroller the title it was toggled from, and that scroller restores
+ * this anchor from its own ResizeObserver for as many frames as the height
+ * keeps changing (an activity group animates its `grid-template-rows`).
+ *
+ * The anchor is the title's top relative to the scroller's top edge, not a
+ * `scrollTop`, so a simultaneous height change *above* the title — a collapsed
+ * row, a prepended history page — is compensated as well.
+ */
+
+/** Sub-pixel slack for "the viewport already holds the anchor". */
+export const DISCLOSURE_ANCHOR_TOLERANCE_PX = 0.5;
+
+export type DisclosureAnchor = {
+  /** Title top relative to the scroller's top edge when it was toggled. */
+  offset: number;
+};
+
+export type DisclosureAnchorFrame = {
+  /** Title top relative to the scroller's top edge, measured now. */
+  elementOffset: number;
+  scrollTop: number;
+  scrollHeight: number;
+  clientHeight: number;
+};
+
+export function disclosureAnchorOffset(
+  scrollerTop: number,
+  elementTop: number,
+): number {
+  return elementTop - scrollerTop;
+}
+
+/** Where the anchored title currently sits in the scroller's own content. */
+export function disclosureContentTop(frame: DisclosureAnchorFrame): number {
+  return frame.elementOffset + frame.scrollTop;
+}
+
+/**
+ * The `scrollTop` that puts the anchored title back where it was, or `null`
+ * when the viewport already holds it: a settled frame must not write the
+ * scroller, because every write emits a scroll event.
+ *
+ * The result is clamped to the scrollable range, so a correction that cannot be
+ * reached (the content shrank under the anchor) leaves the browser's own
+ * boundary position alone.
+ */
+export function resolveDisclosureAnchor(
+  anchor: DisclosureAnchor,
+  frame: DisclosureAnchorFrame,
+): number | null {
+  const maxScrollTop = Math.max(0, frame.scrollHeight - frame.clientHeight);
+  const target = Math.min(
+    maxScrollTop,
+    Math.max(0, disclosureContentTop(frame) - anchor.offset),
+  );
+  return Math.abs(target - frame.scrollTop) < DISCLOSURE_ANCHOR_TOLERANCE_PX
+    ? null
+    : target;
+}
+
+/**
+ * The anchor to hold after a correction was applied: the position the title
+ * actually reached. A boundary clamp is the browser's answer, so adopting it
+ * stops the next frame from fighting it.
+ */
+export function adoptDisclosureAnchor(
+  frame: DisclosureAnchorFrame,
+): DisclosureAnchor {
+  return { offset: frame.elementOffset };
+}
diff --git a/apps/desktop/src/lib/scroll-input.ts b/apps/desktop/src/lib/scroll-input.ts
new file mode 100644
index 000000000..71ee82a4b
--- /dev/null
+++ b/apps/desktop/src/lib/scroll-input.ts
@@ -0,0 +1,68 @@
+import {
+  consumesVerticalScroll,
+  SCROLL_OWNER_ATTRIBUTE,
+  type ScrollInputContext,
+} from "./transcript-scroll";
+
+/** Elements that own a press: clicking one is an ordinary click. */
+const CONTROL_SELECTOR = [
+  "button",
+  "a",
+  "input",
+  "textarea",
+  "select",
+  "summary",
+  "[contenteditable='true']",
+  "[role='button']",
+  "[role='link']",
+  "[role='tab']",
+  "[role='menuitem']",
+  "[role='checkbox']",
+  "[role='switch']",
+  "[role='radio']",
+].join(", ");
+
+const EDITABLE_SELECTOR = "input, textarea, [contenteditable='true']";
+
+/**
+ * Reads what one DOM input event means for `owner`, a marked scroll container
+ * (D302 nested scrollers included).
+ *
+ * Input is attributed to the nearest scroll container that can consume it, so a
+ * wheel inside a delegate's dock never counts as the reader scrolling the
+ * transcript behind it, and a press on a row control never counts as the start
+ * of a scroll at all.
+ */
+export function readScrollInputContext(
+  event: Event,
+  owner: Element | null,
+  content: Element | null,
+): ScrollInputContext {
+  const target = event.target;
+  const nearestOwner =
+    target instanceof Element
+      ? target.closest(`[${SCROLL_OWNER_ATTRIBUTE}]`)
+      : null;
+  const context: ScrollInputContext = {
+    nestedOwner:
+      nearestOwner !== null &&
+      nearestOwner !== owner &&
+      consumesVerticalScroll(nearestOwner),
+  };
+  if (event instanceof KeyboardEvent) {
+    context.key = event.key;
+    context.editable =
+      target instanceof Element &&
+      target.closest(EDITABLE_SELECTOR) !== null;
+    return context;
+  }
+  if (event.type === "pointerdown") {
+    const inside =
+      owner !== null &&
+      (target === owner || target === content || owner.contains(target as Node));
+    context.pointerOnScrollSurface =
+      inside &&
+      !(target instanceof Element && target.closest(CONTROL_SELECTOR) !== null);
+  }
+  return context;
+}
diff --git a/apps/desktop/src/lib/transcript-scroll.ts b/apps/desktop/src/lib/transcript-scroll.ts
index f00dd410d..af85e7a5d 100644
--- a/apps/desktop/src/lib/transcript-scroll.ts
+++ b/apps/desktop/src/lib/transcript-scroll.ts
@@ -1,11 +1,25 @@
 export const TRANSCRIPT_REPIN_THRESHOLD_PX = 48;
 
+/**
+ * Sub-pixel slack for scroll events that no user input produced.
+ *
+ * A fractional device pixel ratio makes the browser report a position a
+ * fraction of a pixel away from the `scrollTop` a layout correction asked for
+ * (at DPR 1.1: asked for 841, reported 840.909). Compared strictly that
+ * fraction reads as the user scrolling up and drops follow mode. Callers pass
+ * `tolerancePx: 0` for anything a real gesture produced, so an intentional
+ * one-pixel scroll still unpins.
+ */
+export const TRANSCRIPT_SCROLL_ROUNDING_TOLERANCE_PX = 1;
+
 export type TranscriptScrollInput = {
   previousScrollTop: number;
   scrollTop: number;
   scrollHeight: number;
   clientHeight: number;
   wasPinned: boolean;
+  /** Movement under this many pixels is not movement. */
+  tolerancePx?: number;
 };
 
 export type TranscriptScrollTransition = {
@@ -24,13 +38,14 @@ export function reduceTranscriptScroll({
   scrollHeight,
   clientHeight,
   wasPinned,
+  tolerancePx = 0,
 }: TranscriptScrollInput): TranscriptScrollTransition {
   const distanceFromBottom = Math.max(
     0,
     scrollHeight - scrollTop - clientHeight,
   );
-  const movedUp = scrollTop < previousScrollTop;
-  const movedDown = scrollTop > previousScrollTop;
+  const movedUp = scrollTop < previousScrollTop - tolerancePx;
+  const movedDown = scrollTop > previousScrollTop + tolerancePx;
   const nearBottom = distanceFromBottom < TRANSCRIPT_REPIN_THRESHOLD_PX;
   const releasedFollow = movedUp && distanceFromBottom > 0;
   const pinned = releasedFollow
@@ -66,3 +81,82 @@ export function isRecentScrollGesture(
 ): boolean {
   return now - lastGestureAt <= TRANSCRIPT_SCROLL_GESTURE_WINDOW_MS;
 }
+
+/** Keys whose native default moves the scroller the focused element sits in. */
+export const SCROLL_GESTURE_KEYS: ReadonlySet<string> = new Set([
+  "ArrowUp",
+  "ArrowDown",
+  "PageUp",
+  "PageDown",
+  "Home",
+  "End",
+  " ",
+]);
+
+/** Marks a scroll container so input can be attributed to the nearest one. */
+export const SCROLL_OWNER_ATTRIBUTE = "data-scroll-owner";
+
+export type ScrollInputType =
+  | "wheel"
+  | "touchstart"
+  | "touchmove"
+  | "pointerdown"
+  | "keydown";
+
+export type ScrollInputContext = {
+  /** Pressed key, for a `keydown`. */
+  key?: string;
+  /** The key event came from a text field, which owns its own key input. */
+  editable?: boolean;
+  /**
+   * A nearer, scrollable owner sits between the event target and this one, so
+   * that owner consumes the input (`overscroll-behavior: contain` keeps it
+   * there) and this one does not scroll at all.
+   */
+  nestedOwner?: boolean;
+  /**
+   * The pointer went down on this owner's own surface — its scrollbar, its
+   * padding, or its content — rather than on one of its controls. A press on a
+   * control or an editable field is an ordinary click and cannot start a
+   * scroll.
+   */
+  pointerOnScrollSurface?: boolean;
+};
+
+/**
+ * Whether a nested scroll owner would consume a vertical wheel or touch
+ * gesture.
+ *
+ * Only the vertical axis counts. An element with horizontal overflow alone —
+ * a wide `pre` in a marked region, for instance — still lets the gesture chain
+ * to the scroller behind it, so that scroller has to own the input; treating it
+ * as consumed would leave the outer viewport unmoved but un-followed, and the
+ * next follow frame would drag the reader back to the bottom.
+ */
+export function consumesVerticalScroll(geometry: {
+  scrollHeight: number;
+  clientHeight: number;
+}): boolean {
+  return geometry.scrollHeight > geometry.clientHeight + 1;
+}
+
+/**
+ * Whether a DOM input can actually move *this* container.
+ *
+ * Only such input may release follow or a held disclosure position. A click on
+ * a control, a keystroke in a text field, and a gesture a nested scroller
+ * consumes must not: marking them lets the very next programmatic follow
+ * scroll look like the user scrolling up.
+ */
+export function isScrollGestureInput(
+  type: ScrollInputType,
+  context: ScrollInputContext = {},
+): boolean {
+  if (context.nestedOwner) return false;
+  if (type === "pointerdown") return context.pointerOnScrollSurface === true;
+  if (type === "keydown") {
+    if (context.editable) return false;
+    return context.key !== undefined && SCROLL_GESTURE_KEYS.has(context.key);
+  }
+  return true;
+}
diff --git a/apps/desktop/test/disclosure-anchor.test.mjs b/apps/desktop/test/disclosure-anchor.test.mjs
new file mode 100644
index 000000000..bc60c31d0
--- /dev/null
+++ b/apps/desktop/test/disclosure-anchor.test.mjs
@@ -0,0 +1,219 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  adoptDisclosureAnchor,
+  DISCLOSURE_ANCHOR_TOLERANCE_PX,
+  disclosureAnchorOffset,
+  disclosureContentTop,
+  resolveDisclosureAnchor,
+} from "../src/lib/disclosure-anchor.ts";
+import {
+  consumesVerticalScroll,
+  isScrollGestureInput,
+  reduceTranscriptScroll,
+  SCROLL_GESTURE_KEYS,
+  SCROLL_OWNER_ATTRIBUTE,
+  TRANSCRIPT_SCROLL_ROUNDING_TOLERANCE_PX,
+} from "../src/lib/transcript-scroll.ts";
+
+const anchor = (offset) => ({ offset });
+const frame = (overrides = {}) => ({
+  elementOffset: 0,
+  scrollTop: 0,
+  scrollHeight: 1_260,
+  clientHeight: 600,
+  ...overrides,
+});
+
+test("the anchor is measured against the scroller's own top edge", () => {
+  assert.equal(disclosureAnchorOffset(40, 160), 120);
+  assert.equal(disclosureAnchorOffset(40, 40), 0);
+});
+
+test("the anchored title's content position is independent of the scroll offset", () => {
+  assert.equal(
+    disclosureContentTop(frame({ elementOffset: 120, scrollTop: 660 })),
+    780,
+  );
+  assert.equal(
+    disclosureContentTop(frame({ elementOffset: 120, scrollTop: 0 })),
+    120,
+  );
+});
+
+test("expanding below the title needs no correction at all", () => {
+  // Issue #324's measurement: 240px of detail appears under a title that sits
+  // 120px below the scroller top. The title's content position does not move,
+  // so the viewport already holds it and the scroller must not be written.
+  const expanded = frame({
+    elementOffset: 120,
+    scrollTop: 660,
+    scrollHeight: 1_500,
+  });
+
+  assert.equal(resolveDisclosureAnchor(anchor(120), expanded), null);
+});
+
+test("content that shrinks above the title moves the viewport back to it", () => {
+  // A row above the title collapsed: the title's content position dropped by
+  // 60px, so the viewport has to move up by the same amount.
+  const shifted = frame({
+    elementOffset: 60,
+    scrollTop: 900,
+    scrollHeight: 1_600,
+  });
+
+  assert.equal(resolveDisclosureAnchor(anchor(120), shifted), 840);
+});
+
+test("a correction the content cannot reach stops at the boundary", () => {
+  const shifted = frame({
+    elementOffset: 60,
+    scrollTop: 900,
+    scrollHeight: 1_260,
+  });
+
+  assert.equal(resolveDisclosureAnchor(anchor(120), shifted), 660);
+});
+
+test("a settled frame does not write the scroller", () => {
+  const settled = frame({
+    elementOffset: 120 + DISCLOSURE_ANCHOR_TOLERANCE_PX / 2,
+    scrollTop: 660,
+    scrollHeight: 1_500,
+  });
+
+  assert.equal(resolveDisclosureAnchor(anchor(120), settled), null);
+});
+
+test("the position the browser settled on becomes the new anchor", () => {
+  // The browser clamped the correction, so the title ends up further down than
+  // asked. Adopting that position is what stops the next frame fighting it.
+  const settled = frame({
+    elementOffset: 300,
+    scrollTop: 660,
+    scrollHeight: 1_260,
+  });
+
+  assert.deepEqual(adoptDisclosureAnchor(settled), {
+    offset: 300,
+  });
+});
+
+test("a fractional device pixel ratio is not read as scrolling up", () => {
+  // At DPR 1.1 follow asked for 841 and the scroller settled on 840.909. The
+  // fraction is the browser rounding, not the reader moving.
+  const transition = reduceTranscriptScroll({
+    previousScrollTop: 841,
+    scrollTop: 840.909,
+    scrollHeight: 1_500,
+    clientHeight: 600,
+    wasPinned: true,
+    tolerancePx: TRANSCRIPT_SCROLL_ROUNDING_TOLERANCE_PX,
+  });
+
+  assert.equal(transition.movedUp, false);
+  assert.equal(transition.releasedFollow, false);
+  assert.equal(transition.pinned, true);
+});
+
+test("a real gesture still unpins on a one-pixel scroll up", () => {
+  const transition = reduceTranscriptScroll({
+    previousScrollTop: 841,
+    scrollTop: 840,
+    scrollHeight: 1_500,
+    clientHeight: 600,
+    wasPinned: true,
+    tolerancePx: 0,
+  });
+
+  assert.equal(transition.movedUp, true);
+  assert.equal(transition.releasedFollow, true);
+  assert.equal(transition.pinned, false);
+  assert.equal(transition.showJump, true);
+});
+
+test("without a tolerance the same fraction does release follow", () => {
+  // Guards the tolerance's own necessity: the product only passes it for
+  // events no gesture produced.
+  const transition = reduceTranscriptScroll({
+    previousScrollTop: 841,
+    scrollTop: 840.909,
+    scrollHeight: 1_500,
+    clientHeight: 600,
+    wasPinned: true,
+  });
+
+  assert.equal(transition.releasedFollow, true);
+});
+
+test("only vertical overflow lets a nested owner consume the gesture", () => {
+  // A wide `pre` in a marked region scrolls sideways, not down: the wheel still
+  // scrolls the transcript behind it, so the transcript has to own the input.
+  assert.equal(
+    consumesVerticalScroll({ scrollHeight: 400, clientHeight: 300 }),
+    true,
+  );
+  assert.equal(
+    consumesVerticalScroll({ scrollHeight: 300, clientHeight: 300 }),
+    false,
+  );
+  // Sub-pixel layout rounding is not overflow.
+  assert.equal(
+    consumesVerticalScroll({ scrollHeight: 300.5, clientHeight: 300 }),
+    false,
+  );
+});
+
+
+test("wheel and touch input move the scroller", () => {
+  assert.equal(isScrollGestureInput("wheel"), true);
+  assert.equal(isScrollGestureInput("touchstart"), true);
+  assert.equal(isScrollGestureInput("touchmove"), true);
+});
+
+test("a scroll key is a gesture, and Space stays a button activation", () => {
+  assert.equal(isScrollGestureInput("keydown", { key: "ArrowUp" }), true);
+  assert.equal(isScrollGestureInput("keydown", { key: "PageDown" }), true);
+  assert.equal(isScrollGestureInput("keydown", { key: "Home" }), true);
+  assert.equal(isScrollGestureInput("keydown", { key: " " }), true);
+  assert.equal(SCROLL_GESTURE_KEYS.has("ArrowDown"), true);
+  assert.equal(isScrollGestureInput("keydown", { key: "a" }), false);
+  assert.equal(isScrollGestureInput("keydown", {}), false);
+});
+
+test("a keystroke in a text field is not a scroll", () => {
+  assert.equal(
+    isScrollGestureInput("keydown", { key: "ArrowDown", editable: true }),
+    false,
+  );
+});
+
+test("only a press on the scroller's own surface starts a scroll", () => {
+  // A press on a row, a control or an editable field is an ordinary click: it
+  // must not let the next programmatic follow scroll look like a gesture.
+  assert.equal(isScrollGestureInput("pointerdown"), false);
+  assert.equal(
+    isScrollGestureInput("pointerdown", { pointerOnScrollSurface: false }),
+    false,
+  );
+  assert.equal(
+    isScrollGestureInput("pointerdown", { pointerOnScrollSurface: true }),
+    true,
+  );
+});
+
+test("input a nested scroller consumes is not this scroller's gesture", () => {
+  assert.equal(isScrollGestureInput("wheel", { nestedOwner: true }), false);
+  assert.equal(
+    isScrollGestureInput("pointerdown", {
+      nestedOwner: true,
+      pointerOnScrollSurface: true,
+    }),
+    false,
+  );
+});
+
+test("scroll owners are found by one shared attribute", () => {
+  assert.equal(SCROLL_OWNER_ATTRIBUTE, "data-scroll-owner");
+});
diff --git a/apps/desktop/test/interaction-performance.test.mjs b/apps/desktop/test/interaction-performance.test.mjs
index d70017daf..46199825d 100644
--- a/apps/desktop/test/interaction-performance.test.mjs
+++ b/apps/desktop/test/interaction-performance.test.mjs
@@ -152,22 +152,23 @@ test("send re-pins before paint instead of flashing the old transcript position"
 test("layout clamps after send cannot release transcript follow as a gesture", () => {
   assert.match(transcript, /const lastScrollGestureAtRef = useRef\(-Infinity\)/);
   assert.match(transcript, /markScrollGesture = useCallback/);
+  // Input classification lives in the shared scroll helper (#324); the rules
+  // themselves are unit-tested against `isScrollGestureInput`, so the
+  // transcript only has to route real DOM events through it.
+  assert.match(transcript, /readScrollInputContext\(/);
   assert.match(
     transcript,
-    /event\.type === "wheel" \|\|\s*event\.type === "touchstart" \|\|\s*event\.type === "touchmove"/,
+    /isScrollGestureInput\(event\.type as ScrollInputType, input\)/,
   );
-  assert.match(transcript, /event\.type === "pointerdown"/);
   assert.match(transcript, /el\.addEventListener\("wheel", markScrollGesture/);
   assert.match(transcript, /className="thread-wrap"\s+ref=\{wrapRef\}/);
-  assert.match(
-    transcript,
-    /const released =\s*transition\.releasedFollow &&\s*isRecentScrollGesture\(/,
-  );
+  assert.match(transcript, /const gesturing = isRecentScrollGesture\(/);
   assert.match(
     transcript,
     /isRecentScrollGesture\(\s*performance\.now\(\),\s*lastScrollGestureAtRef\.current,\s*\)/,
   );
   assert.match(transcript, /if \(transition\.releasedFollow\) cancelFollowScroll\(\)/);
+  assert.match(transcript, /if \(gesturing && transition\.releasedFollow\) \{/);
 });
 
 test("session activation pins the latest record before the first paint", () => {
@@ -183,7 +184,7 @@ test("session activation pins the latest record before the first paint", () => {
   // first layout: settle at the newest turn with no cross-session state to
   // unwind, before the first paint.
   const activationEffect = transcript.match(
-    /useLayoutEffect\(\(\) => \{([\s\S]*?)\n  \}, \[cancelFollowScroll, scrollToBottom\]\);/,
+    /useLayoutEffect\(\(\) => \{([\s\S]*?)\n  \}, \[cancelFollowScroll, releaseDisclosureAnchor, scrollToBottom\]\);/,
   )?.[1];
   assert.ok(activationEffect);
   assert.match(activationEffect, /cancelFollowScroll\(\)/);
@@ -198,7 +199,7 @@ test("a revealed pane restores its own scroll position in the layout phase", ()
   // scroller can be clamped while its content grows off screen, and a passive
   // effect would leave one visible frame at the wrong offset (ADR 0137).
   const revealEffect = transcript.match(
-    /useLayoutEffect\(\(\) => \{([\s\S]*?)\n  \}, \[cancelFollowScroll, paneVisible, scrollToBottom\]\);/,
+    /useLayoutEffect\(\(\) => \{([\s\S]*?)\n  \}, \[cancelFollowScroll, paneVisible, releaseDisclosureAnchor, scrollToBottom\]\);/,
   )?.[1];
   assert.ok(revealEffect, "the reveal must restore position in a layout effect");
   assert.match(revealEffect, /retainedScrollTopRef\.current = el\.scrollTop/);
diff --git a/apps/desktop/test/subagent-transcript.test.mjs b/apps/desktop/test/subagent-transcript.test.mjs
index ee7f3c46e..30cba2510 100644
--- a/apps/desktop/test/subagent-transcript.test.mjs
+++ b/apps/desktop/test/subagent-transcript.test.mjs
@@ -398,7 +398,7 @@ test("an expanded delegate run follows the latest output while pinned (D302)", (
   assert.match(followScrollSource, /isRecentScrollGesture\(/);
   assert.match(
     followScrollSource,
-    /const followScrollNow = useCallback\(\(\) => \{\s*if \(!pinnedRef\.current\) return;\s*cancelFollowScroll\(\);\s*scrollToBottom\(\);/,
+    /const followScrollNow = useCallback\(\(\) => \{[\s\S]{0,400}?if \(!pinnedRef\.current\) return;\s*cancelFollowScroll\(\);\s*scrollToBottom\(\);/,
   );
   assert.match(followScrollSource, /new ResizeObserver\(followScrollNow\)/);
   assert.doesNotMatch(
diff --git a/apps/desktop/test/transcript-disclosure-reading.test.mjs b/apps/desktop/test/transcript-disclosure-reading.test.mjs
new file mode 100644
index 000000000..2d531c281
--- /dev/null
+++ b/apps/desktop/test/transcript-disclosure-reading.test.mjs
@@ -0,0 +1,185 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import { readTranscriptSource } from "./helpers/source-contracts.mjs";
+
+const read = (path) => readFile(new URL(path, import.meta.url), "utf8");
+
+const [transcript, followScroll, anchorControl, scrollInput] = await Promise.all([
+  readTranscriptSource(),
+  read("../src/hooks/use-follow-scroll.ts"),
+  read("../src/hooks/use-disclosure-anchor.ts"),
+  read("../src/lib/scroll-input.ts"),
+]);
+
+test("a manual disclosure hands over its title before the state changes", () => {
+  // The scroller has to measure the title while the layout still matches what
+  // the reader clicked, so the notification comes before `setOpen` (#324).
+  assert.match(
+    transcript,
+    /const notifyAnchor = useDisclosureAnchorNotifier\(\);\s*const titleRef = useRef<HTMLButtonElement \| null>\(null\);/,
+  );
+  assert.match(
+    transcript,
+    /const toggle = useCallback\(\(\) => \{\s*claim\(\);\s*notifyAnchor\?\.\(titleRef\.current\);\s*setOpen\(\(value\) => !value\);/,
+  );
+  assert.match(
+    transcript,
+    /const collapse = useCallback\(\(\) => \{\s*claim\(\);\s*notifyAnchor\?\.\(titleRef\.current\);\s*setOpen\(false\);/,
+  );
+  assert.match(transcript, /return \{ open, toggle, collapse, claim, titleRef \};/);
+});
+
+test("the automatic open/close never claims a reading position", () => {
+  // Only a user click holds the viewport. The running/settled transition keeps
+  // going through `setOpen` directly, so the automatic rules are unchanged.
+  const automatic = transcript.match(
+    /useLayoutEffect\(\(\) => \{\s*if \(userInteractedRef\.current\) return;([\s\S]*?)\n  \}, \[automaticOpen\]\);/,
+  )?.[1];
+  assert.ok(automatic, "the automatic disclosure effect is missing");
+  assert.doesNotMatch(automatic, /notifyAnchor/);
+  assert.match(automatic, /setOpen\(automaticOpen\);/);
+});
+
+test("every manual title hands over the element the reader clicked", () => {
+  // The collapse rail lives inside the collapsing body, so both paths anchor on
+  // the header the reader sees, not on the control that was pressed.
+  assert.match(
+    transcript,
+    /ref=\{titleRef\}\s*className="tool-activity-header"/,
+  );
+  assert.match(transcript, /onClick=\{toggleDisclosure\}/);
+  const toolHeaders = transcript.match(
+    /ref=\{titleRef\}\s*className="tool-row-header"/g,
+  );
+  assert.equal(
+    toolHeaders?.length,
+    2,
+    "the thinking row and the tool row must both anchor their own header",
+  );
+  assert.match(transcript, /onCollapse=\{collapseDisclosure\}/);
+  const collapseWrappers = transcript.match(
+    /onUserInteraction\?\.\(\);\s*collapseDisclosure\(\);\s*\}, \[collapseDisclosure, onUserInteraction\]\);/g,
+  );
+  assert.equal(
+    collapseWrappers?.length,
+    2,
+    "the thinking row and the tool row must both anchor when their rail collapses them",
+  );
+});
+
+test("the transcript scroller provides its own anchor notifier", () => {
+  assert.match(
+    transcript,
+    /\n    disclosureAnchorNotifier,\n  \} = useTranscriptScroll\(\{/,
+  );
+  assert.match(
+    transcript,
+    /<DisclosureAnchorContext\.Provider value=\{disclosureAnchorNotifier\}>/,
+  );
+  assert.match(transcript, /data-scroll-owner="transcript"/);
+});
+
+test("the transcript restores the held title inside its resize observer", () => {
+  // The height of an animated activity group keeps changing for several frames,
+  // so the correction has to run from the observer, before follow.
+  assert.match(
+    transcript,
+    /const followScrollNow = useCallback\(\(\) => \{\s*if \(paneVisibleRef\.current && restoreDisclosureAnchor\(\)\) return;\s*if \(!paneVisibleRef\.current \|\| !pinnedRef\.current\) return;\s*cancelFollowScroll\(\);\s*scrollToBottom\(\);/,
+  );
+  assert.match(transcript, /new ResizeObserver\(followScrollNow\)/);
+  assert.match(transcript, /ro\.observe\(content, \{ box: "border-box" \}\)/);
+});
+
+test("holding a disclosure leaves follow without a delayed grab-back", () => {
+  assert.match(
+    transcript,
+    /const enterDisclosureReading = useCallback\(\(\) => \{\s*cancelFollowScroll\(\);\s*pinnedRef\.current = false;\s*setShowJump\(true\);/,
+  );
+  assert.match(
+    transcript,
+    /const recordScrollPosition = useCallback\(\(top: number\) => \{\s*lastScrollTopRef\.current = top;/,
+  );
+  // No timer, no animation frame: the hold ends on real input or on an explicit
+  // re-pin, never by taking the bottom back later.
+  assert.doesNotMatch(anchorControl, /requestAnimationFrame|setTimeout/);
+});
+
+test("real input, a new turn and every navigation drop the held position", () => {
+  assert.match(
+    transcript,
+    /lastScrollGestureAtRef\.current = performance\.now\(\);\s*\/\/ Real input takes the viewport back from a held disclosure position\.\s*releaseDisclosureAnchor\(\);/,
+  );
+  assert.match(
+    transcript,
+    /releaseDisclosureAnchor\(\);\s*cancelFollowScroll\(\);\s*pinnedRef\.current = true;\s*setShowJump\(false\);\s*scrollToBottom\(\);/,
+  );
+  assert.match(
+    transcript,
+    /const jumpToLatest = useCallback\(\(\) => \{\s*releaseDisclosureAnchor\(\);\s*pinnedRef\.current = true;/,
+  );
+  assert.match(
+    transcript,
+    /if \(becameHidden\) \{\s*releaseDisclosureAnchor\(\);/,
+  );
+});
+
+test("follow records the position the scroller actually reached", () => {
+  // The intended target minus a fractional device pixel ratio was enough to
+  // make the next scroll event look like the reader scrolling up.
+  assert.match(
+    transcript,
+    /if \(behavior === "auto"\) lastScrollTopRef\.current = el\.scrollTop;/,
+  );
+  assert.equal(
+    transcript.match(
+      /if \(behavior === "auto"\) lastScrollTopRef\.current = el\.scrollTop;/g,
+    )?.length,
+    1,
+  );
+  assert.match(
+    transcript,
+    /tolerancePx: gesturing \? 0 : TRANSCRIPT_SCROLL_ROUNDING_TOLERANCE_PX,/,
+  );
+  assert.doesNotMatch(transcript, /lastScrollTopRef\.current = targetTop/);
+});
+
+test("scroll input is attributed to the scroller that can consume it", () => {
+  assert.match(
+    transcript,
+    /const input = readScrollInputContext\(\s*event,\s*scrollRef\.current,\s*contentRef\.current,\s*\);/,
+  );
+  assert.match(
+    transcript,
+    /if \(!isScrollGestureInput\(event\.type as ScrollInputType, input\)\) return;/,
+  );
+  // A press on a control, a keystroke in a field and a nested scroller's input
+  // are read from the DOM, not guessed from the event type.
+  assert.match(scrollInput, /target\.closest\(`\[\$\{SCROLL_OWNER_ATTRIBUTE\}\]`\)/);
+  // Ownership is about the vertical axis only: an element with horizontal
+  // overflow alone lets the gesture chain to the scroller behind it, and
+  // treating it as consumed would leave the outer viewport un-followed and
+  // then re-bottomed.
+  assert.match(scrollInput, /consumesVerticalScroll\(nearestOwner\)/);
+  assert.doesNotMatch(scrollInput, /scrollWidth/);
+  assert.match(scrollInput, /target\.closest\(CONTROL_SELECTOR\)/);
+  assert.match(
+    scrollInput,
+    /context\.pointerOnScrollSurface =\s*inside &&\s*!\(target instanceof Element && target\.closest\(CONTROL_SELECTOR\) !== null\);/,
+  );
+});
+
+test("a nested owner holds its own position and passes the hold outward", () => {
+  assert.match(
+    followScroll,
+    /const followScrollNow = useCallback\(\(\) => \{\s*if \(restoreDisclosureAnchor\(\)\) return;\s*if \(!pinnedRef\.current\) return;\s*cancelFollowScroll\(\);\s*scrollToBottom\(\);/,
+  );
+  assert.match(followScroll, /disclosureAnchorNotifier,/);
+  assert.match(
+    transcript,
+    /<DisclosureAnchorContext\.Provider value=\{disclosureAnchorNotifier\}>[\s\S]{0,400}?data-scroll-owner="follow"/,
+  );
+  // Growing the dock grows the transcript's content too, so an outer scroller
+  // still in follow mode would drag the same title away.
+  assert.match(anchorControl, /outerNotifier\?\.\(title\);/);
+});
diff --git a/apps/desktop/test/transcript-settle.test.mjs b/apps/desktop/test/transcript-settle.test.mjs
index 003319e34..0ca0cbec8 100644
--- a/apps/desktop/test/transcript-settle.test.mjs
+++ b/apps/desktop/test/transcript-settle.test.mjs
@@ -134,10 +134,11 @@ test("a long transcript mounts under the settle veil and lifts it from measured
 test("pinned follow re-pins inside the resize observer, on the border box", () => {
   // A frame requested from a ResizeObserver callback lands in the next frame,
   // so the grown content painted unpinned once. Re-pinning inside the callback
-  // (after layout, before paint) removes that frame.
+  // (after layout, before paint) removes that frame. A held disclosure
+  // position (#324) is restored ahead of it, in the same callback.
   assert.match(
     transcript,
-    /const followScrollNow = useCallback\(\(\) => \{\s*if \(!paneVisibleRef\.current \|\| !pinnedRef\.current\) return;\s*cancelFollowScroll\(\);\s*scrollToBottom\(\);/,
+    /const followScrollNow = useCallback\(\(\) => \{[\s\S]{0,400}?if \(!paneVisibleRef\.current \|\| !pinnedRef\.current\) return;\s*cancelFollowScroll\(\);\s*scrollToBottom\(\);/,
   );
   assert.match(transcript, /new ResizeObserver\(followScrollNow\)/);
   assert.doesNotMatch(transcript, /new ResizeObserver\(scheduleFollowScroll\)/);
diff --git a/docs/spec/04-ux/09-interaction-patterns.md b/docs/spec/04-ux/09-interaction-patterns.md
index 74e33c23c..128fa86c2 100644
--- a/docs/spec/04-ux/09-interaction-patterns.md
+++ b/docs/spec/04-ux/09-interaction-patterns.md
@@ -1305,6 +1305,24 @@ Project drag/drop follows these patterns:
   a multi-line draft: the bottom reserve is padding on the transcript content, so
   the content is observed on its border box and the newest turn moves up with
   the composer instead of sliding behind it (D287).
+- A manual disclosure — a tool, thinking or activity title, a delegate's brief
+  toggle, or an error-detail toggle — holds the reading position of the scroller
+  that owns it (issue #324). The title is handed to that scroller before the
+  expansion state changes, follow mode is left, and the scroller restores the
+  title's viewport offset from its own resize observer for every frame of the
+  height change, so an animated activity group cannot drag the clicked title out
+  of view. A scroller nested inside another one (the delegate run dock, D302)
+  holds its own position and passes the hold outward, because growing it grows
+  the outer content too.
+- Leaving follow for a disclosure is not a re-pin: after a toggle the transcript
+  stays where the reader put it, with the jump-to-latest control visible, until
+  real scroll input, that control, a new turn or a navigation releases the hold.
+  There is no delayed "take the bottom back" correction (D430).
+- Scroll input is attributed to the scroller that can consume it. A press on a
+  row, a control or an editable field is an ordinary click rather than the start
+  of a scroll; a keystroke inside a text field belongs to that field; and input a
+  nested scroller consumes is not the outer scroller's gesture. Arrow keys still
+  scroll and Space still activates a focused title.
 - User send / retry / regenerate: re-pins, hides the jump control, and positions the latest content in the layout phase so the new turn is visible without a top-of-history flash; subsequent persisted and streamed rows continue to follow the bottom
 - Scroll-to-bottom button: position fixed at bottom-right of transcript area, offset 12px
 - Button appears as soon as upward scrolling releases follow mode
diff --git a/docs/spec/06-delivery/04-e2e-test-plan.md b/docs/spec/06-delivery/04-e2e-test-plan.md
index e7373eb04..a3890c940 100644
--- a/docs/spec/06-delivery/04-e2e-test-plan.md
+++ b/docs/spec/06-delivery/04-e2e-test-plan.md
@@ -7688,6 +7688,8 @@ identify the platform validation still needed.
 | F — Persistence (project delete) | E2E-PROJECT-delete-removes-project-and-owned-sessions |
 | Quality (project delete) | E2E-PROJECT-delete-removes-project-and-owned-sessions |
 | Security (plugin real-time capabilities) | E2E-PLUGIN-global-shortcut-owns-only-its-own-command, E2E-PLUGIN-permission-gate-for-real-time-capabilities, E2E-PLUGIN-background-audio-and-realtime-connection |
+| C — Conversation & stream (disclosure reading position) | E2E-CHAT-disclosure-toggle-keeps-reading-position |
+| E — Tools & permissions (disclosure reading position) | E2E-CHAT-disclosure-toggle-keeps-reading-position |
 
 | Milestone | Scenarios |
 |---|---|
@@ -7716,6 +7718,7 @@ identify the platform validation still needed.
 | Quality (model fallback isolation) | E2E-SUBAGENT-ordered-model-fallback-preserves-work |
 | C — Conversation & stream (legacy subagent turn limit) | E2E-SUBAGENT-legacy-turn-limit-frontmatter-is-ignored |
 | Quality (legacy subagent turn limit) | E2E-SUBAGENT-legacy-turn-limit-frontmatter-is-ignored |
+| M6+ (disclosure reading position) | E2E-CHAT-disclosure-toggle-keeps-reading-position |
 
 The `US-UI-*` visual scenarios (§UI shell visual scenarios) trace to the
 Codex parity decisions in [decisions-log §D](../08-meta/decisions-log.md)
@@ -12630,3 +12633,44 @@ session or model request. Restore availability and send; exactly one child
 is created. A child returning read-only from an in-flight fork must not be
 prompted. `test:e2e:native-side-chat` covers the rendered parent gate and its
 recovery; `side-chat-draft.test.mjs` covers action-level guards and child drift.
+
+#### E2E-CHAT-disclosure-toggle-keeps-reading-position
+
+- **Scope**: Manual disclosure of a tool, thinking or activity title in a
+  transcript or a delegate run dock while the scroller is pinned to the bottom
+  (issue #324).
+- **Preconditions**: A session longer than one screen, sitting at the bottom with
+  follow mode on, holding a tool row, a thinking row and an activity group whose
+  expanded detail is taller than its header, plus one expanded delegate run that
+  owns a nested scroller. Repeat with a finished turn (`isRunning` false) and
+  while the turn streams.
+- **Steps**: Click the title of a tool row, a thinking row and an activity group
+  while pinned at the bottom, and again after the turn has finished. Repeat with
+  the viewport parked in the middle of the transcript, with a keyboard activation
+  (Enter, then Space, on a focused title), and from the collapse rail. Expand a
+  tool row inside an expanded delegate dock. Then scroll with the wheel, press
+  ArrowUp with a title focused, click the jump-to-latest control, and send a new
+  prompt.
+- **Expected**: The clicked title keeps its on-screen position while the detail
+  animates open and closed, and the transcript never re-bottoms underneath it;
+  follow mode is left and the newest-message control appears. The held position
+  survives every frame of an animated activity group and also covers a
+  simultaneous height change above the title. A nested dock holds its own
+  position and the transcript behind it does not re-bottom either. Real scroll
+  input, the jump control, a new turn and every navigation release the hold and
+  follow the live tail again, while a reader who scrolled up keeps their place.
+  Space still activates a focused title and arrow keys still scroll.
+- **Specs linked**: `04-ux/09-interaction-patterns.md` §9.1;
+  ADR transcript-reading-ownership; D287, D302, D430
+- **Acceptance**: C (conversation & stream), E (tools & permissions), Quality
+- **Milestone**: M6+
+- **Status**: Partially automated. `pnpm test:e2e:transcript-disclosure` mounts
+  the real transcript scroll hook and a real tool row in a real 600 CSS px
+  Electron viewport and clicks the title with a real DOM click, asserting the
+  title's offset from the scroller top and the scroll offset for the transcript
+  and for a nested follow scroller; without the fix the same fixture reports the
+  title moving by the full height of the opened detail. The app stylesheet is not
+  linked, so the heights come from inline filler and the components' own
+  intrinsic size. `disclosure-anchor.test.mjs` covers the pure anchor and input
+  math, and `transcript-disclosure-reading.test.mjs` covers the wiring. Keyboard,
+  wheel and animated-activity-group paths remain additional validation.
diff --git a/docs/spec/08-meta/decisions-log.md b/docs/spec/08-meta/decisions-log.md
index afcc2a327..0c3bbe860 100644
--- a/docs/spec/08-meta/decisions-log.md
+++ b/docs/spec/08-meta/decisions-log.md
@@ -5351,6 +5351,45 @@ its menu instead of the conversation.
   `03-runtime/04-data-storage.md`, `04-ux/08-component-spec.md` (§11), and
   E2E-QUEUE-promote-orders-delivery-by-click.
 
+## 2026-09-16 — A manual disclosure keeps the reader's place (D430)
+
+- **A manual disclosure hands its own title to the scroller that owns it,
+  synchronously, before the expansion state changes.** The content
+  `ResizeObserver` still re-pins a pinned transcript on every content resize
+  (D287) and cannot tell a stream from a reader expanding a row, so the reader
+  states their intent first: the transcript leaves follow mode and the scroller
+  restores that title's viewport offset from inside the same observer, for as
+  many frames as the height keeps changing (an activity group animates its
+  `grid-template-rows`). `overflow-anchor: none` on `.thread-scroll` means this
+  has to be explicit.
+- **The anchor is the title element's offset from the scroller's top edge, not a
+  `scrollTop`, and the browser's own boundary clamping is adopted as the new
+  anchor.** A correction the content cannot reach, and a height change above the
+  title, are both handled without fighting the browser frame after frame. There
+  is no delayed "take the bottom back" compensation: the hold ends on real scroll
+  input, the jump-to-latest control, a new turn, or a navigation.
+- **Every scroll owner holds its own position and passes the hold outward.** The
+  transcript scroller and the nested delegate dock (`useFollowScroll`, D302) share
+  one controller; growing the dock grows the transcript's content, so an outer
+  scroller still in follow mode would drag the same title away.
+- **Input is attributed to the scroller that can consume it.** Only input that
+  really moves a container may release follow or a held position: a press on a
+  row, a control or an editable field is an ordinary click, a keystroke in a text
+  field belongs to the field, and input a nested scroller consumes is not the
+  outer scroller's gesture. Arrow keys still scroll and Space still activates a
+  focused title.
+- **Programmatic immediate scrolling records the `scrollTop` the scroller
+  actually reached**, and a sub-pixel tolerance is applied only to scroll events
+  no gesture produced. At DPR 1.1 follow asked for 841 and got 840.909; compared
+  strictly that fraction read as the reader scrolling up and dropped follow mode.
+  Real gestures are still compared exactly, so a one-pixel scroll unpins.
+- Renderer only: no protocol, storage, host, permission, or migration change.
+  See `04-ux/09-interaction-patterns.md` §9.1 and
+  E2E-CHAT-disclosure-toggle-keeps-reading-position.
+
+Readers reported that clicking a tool, thinking or activity title to expand it
+dragged the whole transcript up by the height of the opened detail, in a session
+that was sitting at the bottom — including after the turn had finished.
 ## 2026-09-16 — The delete dialog, not the menu, owns the running-task refusal (#360, D431)
 
 - Amends the renderer half of D421. The sidebar menu and the Projects index menu
diff --git a/docs/zh-CN/spec/06-delivery/04-e2e-test-plan.md b/docs/zh-CN/spec/06-delivery/04-e2e-test-plan.md
index bbf9b3d80..750a99ede 100644
--- a/docs/zh-CN/spec/06-delivery/04-e2e-test-plan.md
+++ b/docs/zh-CN/spec/06-delivery/04-e2e-test-plan.md
@@ -4940,6 +4940,8 @@ IPC 请求无法关闭。
 | F — 持久化（删除项目） | E2E-PROJECT-delete-removes-project-and-owned-sessions |
 | 品质（删除项目） | E2E-PROJECT-delete-removes-project-and-owned-sessions |
 | Security (plugin real-time capabilities) | E2E-PLUGIN-global-shortcut-owns-only-its-own-command、E2E-PLUGIN-permission-gate-for-real-time-capabilities、E2E-PLUGIN-background-audio-and-realtime-connection |
+| C — 对话与流式（展开详情保持阅读位置） | E2E-CHAT-disclosure-toggle-keeps-reading-position |
+| E — 工具与权限（展开详情保持阅读位置） | E2E-CHAT-disclosure-toggle-keeps-reading-position |
 
 | 里程碑 | 应用场景 |
 |---|---|
@@ -4968,6 +4970,7 @@ IPC 请求无法关闭。
 | 品质（模型回退隔离） | E2E-SUBAGENT-ordered-model-fallback-preserves-work |
 | C — 对话和直播（旧版子代理回合上限） | E2E-SUBAGENT-legacy-turn-limit-frontmatter-is-ignored |
 | 品质（旧版子代理回合上限） | E2E-SUBAGENT-legacy-turn-limit-frontmatter-is-ignored |
+| M6+（展开详情保持阅读位置） | E2E-CHAT-disclosure-toggle-keeps-reading-position |
 
 `US-UI-*` 视觉场景（§UI shell 视觉场景）追踪到
 [决策日志 §D](/zh-CN/spec/08-meta/decisions-log) 中的法典平价决策
@@ -7362,6 +7365,16 @@ runner 会在运行时的隔离临时目录中生成六个插件形态 fixture
 - **里程碑**：M6+
 - **状态**：由模块测试覆盖（`apps/desktop/test/session-turn-ended.test.mjs`、`apps/desktop/test/queued-turn-finalization.test.mjs`）；桌面旅程为草稿（该表面变更时需在具备条件的环境中运行）
 
+#### E2E-CHAT-disclosure-toggle-keeps-reading-position
+
+- **范围**：滚动器已固定在底部时，手动展开转录或委派运行停靠区里的工具、思考或活动组标题（issue #324）。
+- **先决条件**：一个超过一屏的会话，停在底部并开启跟随模式；其中包含一行工具、一行思考和一个活动组，它们的展开详情都高于自身的标题栏；另有一个已展开、拥有嵌套滚动器的委派运行。分别在一轮已结束（`isRunning` 为 false）和一轮正在流式输出时各做一遍。
+- **步骤**：在固定于底部时，依次点击工具行、思考行和活动组的标题，并在该轮结束后再点一次。把视口停在转录中部再重复一次；用键盘激活一次（先 Enter，再在获得焦点的标题上按 Space），以及从收起栏操作一次。在已展开的委派停靠区内展开一行工具。然后用滚轮滚动、在标题获得焦点时按 ArrowUp、点击“跳到最新”控件，并发送一条新提示。
+- **预期**：详情动画展开与收起期间，被点击的标题保持它在屏幕上的位置，转录不会在它下方重新触底；跟随模式被退出，并出现“回到最新消息”控件。保持的位置在活动组动画的每一帧都成立，也覆盖标题上方同时发生的高度变化。嵌套停靠区保持自己的位置，其背后的转录同样不会重新触底。真实的滚动输入、跳转控件、新一轮以及任何导航都会释放保持并重新跟随实时尾部，而已经向上滚动的阅读者保持原来的位置。Space 仍能激活获得焦点的标题，方向键仍能滚动。
+- **链接规格**：`04-ux/09-interaction-patterns.md` §9.1；ADR transcript-reading-ownership；D287、D302、D430
+- **验收**：C（对话与流式）、E（工具与权限）、品质
+- **里程碑**：M6+
+- **状态**：部分自动化。`pnpm test:e2e:transcript-disclosure` 在真实的 600 CSS px Electron 视口中挂载真实的转录滚动 hook 与真实的工具行，用真实 DOM 点击标题，并对转录以及嵌套跟随滚动器断言标题相对滚动器顶边的偏移与滚动偏移；没有该修复时，同一个夹具会报告标题移动了整个展开详情的高度。夹具未链接应用样式表，因此高度来自内联填充与组件自身的固有尺寸。`disclosure-anchor.test.mjs` 覆盖纯锚点与输入归属数学，`transcript-disclosure-reading.test.mjs` 覆盖接线。键盘、滚轮与活动组动画路径仍属补充验证。
 #### E2E-CHAT-runtime-status-keeps-row-position
 
 - **先决条件**：一个活动会话，其转录高于对话视口，且尾部由一行已完成的工具占用；窗格已构建（`pnpm build:js`）并已安装 Electron。
diff --git a/docs/zh-CN/spec/08-meta/decisions-log.md b/docs/zh-CN/spec/08-meta/decisions-log.md
index d5dcf6b29..de54ab62a 100644
--- a/docs/zh-CN/spec/08-meta/decisions-log.md
+++ b/docs/zh-CN/spec/08-meta/decisions-log.md
@@ -4186,6 +4186,16 @@ the retained upstream work-panel lifecycle. See
 - 优先区块以**相邻的用户消息**投递：第一个已优先条目在边界处启动回合，其余条目通过引导通道注入同一回合，因此整块只被回复一次，而不是每行各回一次。被注入条目自己的回合被标记为已取消；运行时拒绝接收的条目仍留在队列中，在下一个边界作为自己的回合启动。
 - 已结算的回合对队列具有权威性：终态事件可能被丢弃（Main 不会转发点名它已不再拥有的回合的终态事件），也可能根本没发出，而留在 Host 中处于活动状态的回合会永久占住该会话的队列——“点立即发送再暂停”导致的卡住正源于此。现在结算会在模块内关闭该回合，且在 drain 进行中到达的请求会被重试而不是丢弃。见 ADR 0265、`03-runtime/01-ipc-protocol.md`（§5.6）、`03-runtime/04-data-storage.md`、`04-ux/08-component-spec.md`（§11）与 E2E-QUEUE-promote-orders-delivery-by-click。
 
+## 2026-09-16 —— 手动展开详情时保持阅读位置（D430）
+
+- **手动展开会把自己的标题交给拥有它的滚动器，发生在展开状态改变之前、且是同步的。** 内容 `ResizeObserver` 仍会在每次内容尺寸变化时重新触底一个已固定的转录（D287），它无法区分「流式增长」和「读者展开一行」，所以先让读者表达意图：转录退出跟随模式，滚动器在同一个观察器回调内恢复该标题的视口偏移，持续覆盖高度仍在变化的每一帧（活动组会动画 `grid-template-rows`）。`.thread-scroll` 上的 `overflow-anchor: none` 意味着这件事必须显式做。
+- **锚点是标题元素相对滚动器顶边的偏移，而不是 `scrollTop`；浏览器自身的边界夹紧会被采纳为新的锚点。** 内容无法到达的修正量、以及标题上方同时发生的高度变化，都在不与浏览器逐帧对抗的前提下被处理。没有延时「把底部抢回来」的补偿：hold 会在真实滚动输入、跳到最新控件、新一轮或导航时结束。
+- **每个滚动所有者各持自己的位置，并把 hold 向外传递。** 转录滚动器与嵌套的委派停靠区（`useFollowScroll`，D302）共用同一个控制器；停靠区变高同时也在增大转录的内容高度，因此仍处于跟随模式的外层滚动器会把同一个标题再次拽走。
+- **输入会归属到真正能消费它的滚动器。** 只有真正能让某个容器移动的输入才可以释放跟随或已持有的位置：按在行、控件或可编辑字段上属于普通点击，文本框里的按键属于该字段，被嵌套滚动器消费的输入不算外层的手势。方向键仍能滚动，Space 仍能激活已获得焦点的标题。
+- **程序化的立即滚动记录的是滚动器实际到达的 `scrollTop`**，并且亚像素容差只作用于非手势产生的滚动事件。在 DPR 1.1 下跟随请求 841 而实际得到 840.909，严格比较时这个小数会被读成读者向上滚动并解除跟随。真实手势仍按精确值比较，所以一个像素的上滚依然会解除固定。
+- 仅渲染层：无协议、存储、宿主、权限或迁移改动。见 `04-ux/09-interaction-patterns.md` §9.1 与 E2E-CHAT-disclosure-toggle-keeps-reading-position。
+
+有读者反馈：点击工具、思考或活动标题展开时，整个转录会被拽上去整整一个展开详情的高度，即使是停在底部、甚至该轮已经结束的会话也一样。
 ## 2026-09-16 —— 运行中任务的拒绝归属删除对话框，而不是菜单（#360，D431）
 
 - 修订 D421 的渲染层一半。侧边栏菜单与项目索引菜单一旦发现该项目有任何会话在运行，就用一条转瞬即逝的 `project.deleteRunningBlocked` 警告拒绝「删除项目」，并在 `ProjectDeleteDialog` 挂载之前就返回。这条拒绝随 toast 一起消失，没有留下任何可继续的路径，于是带有一个在跑任务的项目根本无法删除 —— 这正是 #360（「项目管理中无法真正删除项目」）所描述的体感。
diff --git a/package.json b/package.json
index 77dcc6a49..8cd5c18ee 100644
--- a/package.json
+++ b/package.json
@@ -27,6 +27,7 @@
     "test:e2e:composer-autocomplete": "node scripts/e2e-composer-autocomplete.mjs",
     "test:e2e:composer-paste": "node scripts/e2e-composer-paste.mjs",
     "test:e2e:transcript": "node scripts/e2e-transcript-render.mjs",
+    "test:e2e:transcript-disclosure": "node scripts/e2e-transcript-disclosure-anchor.mjs",
     "test:e2e:provider-api-style": "node scripts/e2e-provider-api-style.mjs",
     "test:e2e:oauth-retry": "node --test apps/desktop/test/anthropic-oauth-retry.test.mjs",
     "test:e2e:native-side-chat": "node scripts/e2e-native-side-chat.mjs",
diff --git a/scripts/e2e-transcript-disclosure-anchor.mjs b/scripts/e2e-transcript-disclosure-anchor.mjs
new file mode 100644
index 000000000..b2b1838d6
--- /dev/null
+++ b/scripts/e2e-transcript-disclosure-anchor.mjs
@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * Real React/Chromium regression for issue #324: toggling a tool, thinking or
+ * activity title must not move the transcript the reader is looking at.
+ *
+ * The fixture mounts the real `useTranscriptScroll` and `useFollowScroll` in a
+ * real 600 CSS px scroller with the real `ToolRow` disclosure, and clicks the
+ * title with a real DOM click. What it proves is geometry: the clicked title's
+ * offset from the scroller's top edge, and the scroll offset, before and after
+ * the toggle. The app's stylesheet is not linked, so the heights come from
+ * inline filler and the components' own intrinsic size — the height delta is
+ * asserted to be large enough to matter, which is what the displacement was.
+ */
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveElectronBinary } from "./e2e/boot.mjs";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const require = createRequire(
+  join(root, "packages/agent-runtime/package.json"),
+);
+const { build } = require("esbuild");
+const { electronBinary } = resolveElectronBinary(root);
+const temp = await mkdtemp(join(tmpdir(), "pi-transcript-disclosure-"));
+try {
+  await build({
+    entryPoints: [join(root, "scripts/e2e/transcript-disclosure-anchor.tsx")],
+    outfile: join(temp, "renderer.js"),
+    bundle: true,
+    platform: "browser",
+    format: "iife",
+    jsx: "automatic",
+    define: { "process.env.NODE_ENV": '"production"' },
+    // The fixture measures its own geometry, so no app stylesheet is needed.
+    loader: { ".css": "empty" },
+    alias: {
+      "@pi-desktop/i18n": join(root, "packages/i18n/src/index.ts"),
+      react: join(root, "apps/desktop/node_modules/react"),
+      "react-dom": join(root, "apps/desktop/node_modules/react-dom"),
+    },
+    nodePaths: [join(root, "apps/desktop/node_modules")],
+  });
+  await writeFile(
+    join(temp, "index.html"),
+    '<!doctype html><meta charset="utf-8"><title>Transcript disclosure anchor regression</title><script src="renderer.js"></script>',
+  );
+  await writeFile(
+    join(temp, "main.cjs"),
+    `
+const { app, BrowserWindow } = require("electron");
+const path = require("node:path");
+app.setPath("userData", path.join(__dirname, "profile"));
+app.whenReady().then(async () => {
+  const window = new BrowserWindow({
+    show: false,
+    webPreferences: {
+      sandbox: true,
+      contextIsolation: true,
+      nodeIntegration: false,
+      // A hidden window still has to deliver ResizeObserver callbacks and
+      // animation frames, because that is what the product scroll logic uses.
+      backgroundThrottling: false,
+    },
+  });
+  window.webContents.on("console-message", (event) => console.error(event.message));
+  try {
+    await window.loadFile(path.join(__dirname, "index.html"));
+    const result = await window.webContents.executeJavaScript("globalThis.transcriptDisclosureProbe()");
+    console.log("TRANSCRIPT_DISCLOSURE_PROBE " + JSON.stringify(result));
+    app.quit();
+  } catch (error) {
+    console.error("TRANSCRIPT_DISCLOSURE_PROBE " + JSON.stringify({ ok: false, error: String(error) }));
+    app.exit(1);
+  }
+});
+`,
+  );
+  const env = { ...process.env };
+  delete env.ELECTRON_RUN_AS_NODE;
+  const child = spawn(electronBinary, [join(temp, "main.cjs")], {
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  let output = "";
+  for (const stream of [child.stdout, child.stderr])
+    stream.on("data", (data) => {
+      output += data;
+    });
+  const timeout = setTimeout(() => child.kill("SIGKILL"), 60_000);
+  let code;
+  try {
+    code = await new Promise((resolve, reject) => {
+      child.once("error", reject);
+      child.once("close", resolve);
+    });
+  } finally {
+    clearTimeout(timeout);
+  }
+  const line = output
+    .split(/\r?\n/)
+    .find((line) => line.startsWith("TRANSCRIPT_DISCLOSURE_PROBE "));
+  assert(
+    line,
+    `renderer returned no probe result (exit=${code}): ${output.slice(-2000)}`,
+  );
+  const result = JSON.parse(line.slice("TRANSCRIPT_DISCLOSURE_PROBE ".length));
+  console.log("TRANSCRIPT_DISCLOSURE_PROBE " + JSON.stringify(result));
+  assert.equal(code, 0, output.slice(-6000));
+  assert.equal(result.ok, true);
+} finally {
+  await rm(temp, { recursive: true, force: true });
+}
diff --git a/scripts/e2e/transcript-disclosure-anchor.tsx b/scripts/e2e/transcript-disclosure-anchor.tsx
new file mode 100644
index 000000000..d472d156b
--- /dev/null
+++ b/scripts/e2e/transcript-disclosure-anchor.tsx
@@ -0,0 +1,273 @@
+import { createRoot } from "react-dom/client";
+import { flushSync } from "react-dom";
+import { createInstance } from "i18next";
+import { I18nextProvider } from "react-i18next";
+import { en } from "@pi-desktop/i18n";
+import type { UiMessage } from "@pi-desktop/shared";
+import { DisclosureAnchorContext } from "../../apps/desktop/src/lib/disclosure-anchor-context";
+import { useTranscriptScroll } from "../../apps/desktop/src/features/chat/transcript/hooks/useTranscriptScroll";
+import { ToolRow } from "../../apps/desktop/src/features/chat/transcript/ToolRow";
+import { useFollowScroll } from "../../apps/desktop/src/hooks/use-follow-scroll";
+
+declare global {
+  var transcriptDisclosureProbe: () => Promise<unknown>;
+}
+
+function assert(value: unknown, message: string): asserts value {
+  if (!value) throw new Error(message);
+}
+
+const createdAt = "2026-09-16T00:00:00.000Z";
+
+function message(
+  id: string,
+  role: UiMessage["role"],
+  content: string,
+  extra: Partial<UiMessage> = {},
+): UiMessage {
+  return { id, role, content, createdAt, ...extra };
+}
+
+/** A tool row whose opened body is far taller than its own header. */
+function toolRowMessage(id: string): UiMessage {
+  return message(id, "tool", "done", {
+    toolName: "Bash",
+    toolCallId: `call-${id}`,
+    toolStatus: "success",
+    toolArgs: { command: "printf 'step'" },
+    toolResult: {
+      details: {
+        stdout: Array.from({ length: 80 }, (_value, index) => `step ${index}`).join(
+          "\n",
+        ),
+        exitCode: 0,
+      },
+    },
+  });
+}
+
+type Geometry = {
+  scrollTop: number;
+  scrollHeight: number;
+  clientHeight: number;
+  /** The clicked title's top, relative to the scroller's own top edge. */
+  titleTop: number;
+  distanceFromBottom: number;
+};
+
+function geometry(scroller: HTMLElement, title: HTMLElement): Geometry {
+  const scrollerTop = scroller.getBoundingClientRect().top;
+  return {
+    scrollTop: scroller.scrollTop,
+    scrollHeight: scroller.scrollHeight,
+    clientHeight: scroller.clientHeight,
+    titleTop: title.getBoundingClientRect().top - scrollerTop,
+    distanceFromBottom:
+      scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight,
+  };
+}
+
+/** Two ticks: one for the observer-driven layout, one for the follow frame. */
+async function settle() {
+  for (let tick = 0; tick < 3; tick += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 40));
+  }
+}
+
+/**
+ * The transcript scroller's own DOM, with the real hook driving it: the real
+ * ResizeObserver, follow mode and disclosure hold, in a real 600 CSS px
+ * viewport. Only the app's stylesheet is left out, so the geometry comes from
+ * inline sizes and the real components' intrinsic height.
+ */
+function TranscriptFixture({ messages }: { messages: UiMessage[] }) {
+  const {
+    scrollRef,
+    wrapRef,
+    contentRef,
+    handleScroll,
+    disclosureAnchorNotifier,
+  } = useTranscriptScroll({
+    sessionId: "fixture",
+    messages,
+    hasMoreBefore: false,
+    isRunning: false,
+    askPending: false,
+    approvalPending: false,
+    paneVisible: true,
+    searchTarget: null,
+    readingWindow: false,
+  });
+  return (
+    <DisclosureAnchorContext.Provider value={disclosureAnchorNotifier}>
+      <div
+        ref={wrapRef}
+        className="thread-wrap"
+        style={{ height: "100%", position: "relative" }}
+      >
+        <div
+          ref={scrollRef}
+          className="thread-scroll"
+          data-scroll-owner="transcript"
+          onScroll={handleScroll}
+          style={{ height: "100%", overflowY: "auto" }}
+        >
+          <div ref={contentRef} className="thread-content">
+            <div style={{ height: 700 }} />
+            <ToolRow message={messages[1]} />
+            <div style={{ height: 300 }} />
+          </div>
+        </div>
+      </div>
+    </DisclosureAnchorContext.Provider>
+  );
+}
+
+/** The nested dock scroller (D302), driven by its own follow hook. */
+function FollowFixture({ tool }: { tool: UiMessage }) {
+  const { scrollRef, contentRef, handleScroll, disclosureAnchorNotifier } =
+    useFollowScroll();
+  return (
+    <DisclosureAnchorContext.Provider value={disclosureAnchorNotifier}>
+      <div
+        ref={scrollRef}
+        className="subagent-run-rows"
+        data-scroll-owner="follow"
+        onScroll={handleScroll}
+        style={{ height: "300px", overflowY: "auto" }}
+      >
+        <div ref={contentRef}>
+          <div style={{ height: 320 }} />
+          <ToolRow message={tool} />
+          <div style={{ height: 200 }} />
+        </div>
+      </div>
+    </DisclosureAnchorContext.Provider>
+  );
+}
+
+globalThis.transcriptDisclosureProbe = async () => {
+  const i18n = createInstance();
+  await i18n.init({
+    lng: "en",
+    resources: { en: { translation: en } },
+    interpolation: { escapeValue: false },
+  });
+  const host = document.createElement("div");
+  host.style.width = "700px";
+  document.body.append(host);
+  const renderErrors: unknown[] = [];
+  const roots: Array<{ unmount: () => void }> = [];
+
+  const mount = (node: Parameters<typeof I18nextProvider>[0]["children"]) => {
+    const container = document.createElement("div");
+    container.style.height = "600px";
+    container.style.width = "640px";
+    host.append(container);
+    const root = createRoot(container, {
+      onUncaughtError: (error) => {
+        renderErrors.push(error);
+      },
+    });
+    flushSync(() =>
+      root.render(<I18nextProvider i18n={i18n}>{node}</I18nextProvider>),
+    );
+    roots.push(root);
+    return container;
+  };
+
+  try {
+    const tool = toolRowMessage("tool");
+    const container = mount(
+      <TranscriptFixture
+        messages={[
+          message("user", "user", "Inspect the workspace"),
+          tool,
+        ]}
+      />,
+    );
+    const scroller = container.querySelector<HTMLElement>(".thread-scroll");
+    const title = container.querySelector<HTMLElement>(".tool-row-header");
+    assert(scroller, "the transcript scroller did not render");
+    assert(title, "the tool title did not render");
+
+    await settle();
+    const before = geometry(scroller, title);
+    assert(
+      Math.abs(before.distanceFromBottom) < 1,
+      `the transcript did not start pinned to the bottom: ${JSON.stringify(before)}`,
+    );
+    assert(
+      before.scrollTop > 0 && before.titleTop >= 0 && before.titleTop < 600,
+      `the clicked title is not on screen: ${JSON.stringify(before)}`,
+    );
+
+    // A plain click on the title, exactly as a reader expands a tool row.
+    title.click();
+    await settle();
+    const expanded = geometry(scroller, title);
+    assert(
+      expanded.scrollHeight > before.scrollHeight + 100,
+      `the disclosure did not change the height, so nothing was measured: ${JSON.stringify({ before, expanded })}`,
+    );
+    assert(
+      Math.abs(expanded.titleTop - before.titleTop) < 2,
+      `expanding the tool moved the clicked title by ${expanded.titleTop - before.titleTop}px: ${JSON.stringify({ before, expanded })}`,
+    );
+    assert(
+      expanded.scrollTop <= before.scrollTop + 2,
+      `expanding the tool re-bottomed the transcript: ${JSON.stringify({ before, expanded })}`,
+    );
+
+    title.click();
+    await settle();
+    const collapsed = geometry(scroller, title);
+    assert(
+      Math.abs(collapsed.titleTop - before.titleTop) < 2,
+      `collapsing the tool moved the clicked title by ${collapsed.titleTop - before.titleTop}px: ${JSON.stringify({ before, collapsed })}`,
+    );
+    assert(
+      Math.abs(collapsed.scrollTop - before.scrollTop) < 2,
+      `collapsing the tool moved the transcript by ${collapsed.scrollTop - before.scrollTop}px: ${JSON.stringify({ before, collapsed })}`,
+    );
+
+    const dockContainer = mount(<FollowFixture tool={toolRowMessage("dock")} />);
+    const dockScroller = dockContainer.querySelector<HTMLElement>(
+      ".subagent-run-rows",
+    );
+    const dockTitle = dockContainer.querySelector<HTMLElement>(
+      ".tool-row-header",
+    );
+    assert(dockScroller, "the dock scroller did not render");
+    assert(dockTitle, "the dock tool title did not render");
+    await settle();
+    const dockBefore = geometry(dockScroller, dockTitle);
+    assert(
+      Math.abs(dockBefore.distanceFromBottom) < 1,
+      `the dock did not start pinned to the bottom: ${JSON.stringify(dockBefore)}`,
+    );
+    dockTitle.click();
+    await settle();
+    const dockExpanded = geometry(dockScroller, dockTitle);
+    assert(
+      dockExpanded.scrollHeight > dockBefore.scrollHeight + 100,
+      "the dock disclosure did not change the height",
+    );
+    assert(
+      Math.abs(dockExpanded.titleTop - dockBefore.titleTop) < 2,
+      `expanding the dock moved its own title by ${dockExpanded.titleTop - dockBefore.titleTop}px: ${JSON.stringify({ dockBefore, dockExpanded })}`,
+    );
+    assert(
+      dockExpanded.scrollTop <= dockBefore.scrollTop + 2,
+      "expanding the dock re-bottomed the dock scroller",
+    );
+    return {
+      ok: true,
+      transcript: { before, expanded, collapsed },
+      dock: { before: dockBefore, expanded: dockExpanded },
+    };
+  } finally {
+    for (const root of roots) flushSync(() => root.unmount());
+    host.remove();
+  }
+};