diff --git a/src/components/molecular/MessageThread/MessageThread.test.tsx b/src/components/molecular/MessageThread/MessageThread.test.tsx
index 4522bc82..65c2985c 100755
--- a/src/components/molecular/MessageThread/MessageThread.test.tsx
+++ b/src/components/molecular/MessageThread/MessageThread.test.tsx
@@ -280,6 +280,162 @@ describe('MessageThread', () => {
       }
     });
 
+    /**
+     * The jump is an INTENT, and content is still arriving when it is made (#756).
+     *
+     * Reaching the top is what triggers loading older messages, so "scroll to the top,
+     * then press jump" is the ordinary case, not a corner. The old code resolved the jump
+     * to a coordinate — `scrollTop = scrollHeight` at the instant of the click — and that
+     * number is stale before the scroll finishes. Prepending older messages does not
+     * change the newest message id, so the auto-scroll effect never re-aims either, and
+     * the reader is left short. Measured at 1934px in `performance.spec.ts`, failing 2 of
+     * 3 full-spec runs on firefox.
+     *
+     * Deterministic here, where the E2E is inherently timing-dependent: grow the content
+     * and drive the observer by hand.
+     */
+    it('re-aims at the bottom when content arrives after the jump was requested', async () => {
+      const user = userEvent.setup();
+      const callbacks: ResizeObserverCallback[] = [];
+      const RealRO = global.ResizeObserver;
+      vi.stubGlobal(
+        'ResizeObserver',
+        class {
+          constructor(cb: ResizeObserverCallback) {
+            callbacks.push(cb);
+          }
+          observe() {}
+          unobserve() {}
+          disconnect() {}
+        }
+      );
+
+      try {
+        // Below the virtualization threshold, which is the path this defect lives on.
+        const messages = Array.from({ length: 50 }, (_, i) =>
+          createMockMessage(`msg-${i}`, `Message ${i}`, i)
+        );
+        render(<MessageThread messages={messages} />);
+        const container = screen.getByTestId('message-thread');
+
+        const scrollTo = vi.fn();
+        Object.defineProperty(container, 'scrollTo', {
+          value: scrollTo,
+          writable: true,
+        });
+        Object.defineProperty(container, 'scrollTop', {
+          value: 0,
+          writable: true,
+        });
+        Object.defineProperty(container, 'scrollHeight', {
+          value: 5278,
+          writable: true,
+        });
+        Object.defineProperty(container, 'clientHeight', {
+          value: 258,
+          writable: true,
+        });
+        container.dispatchEvent(new Event('scroll'));
+
+        const button = await screen.findByTestId('jump-to-bottom');
+        await user.click(button);
+        expect(
+          scrollTo,
+          'the jump never asked the container to scroll, so nothing below is meaningful'
+        ).toHaveBeenCalledWith(expect.objectContaining({ top: 5278 }));
+
+        // A page of older messages lands: the thread is now much taller, and the target
+        // the click resolved to is no longer the bottom.
+        scrollTo.mockClear();
+        Object.defineProperty(container, 'scrollHeight', {
+          value: 8600,
+          writable: true,
+        });
+        callbacks.forEach((cb) =>
+          cb([] as unknown as ResizeObserverEntry[], {} as ResizeObserver)
+        );
+
+        await waitFor(() => {
+          expect(scrollTo).toHaveBeenCalledWith(
+            expect.objectContaining({ top: 8600 })
+          );
+        });
+      } finally {
+        vi.stubGlobal('ResizeObserver', RealRO);
+      }
+    });
+
+    /**
+     * ...and stops as soon as the reader takes over, or it would fight them.
+     */
+    it('stops re-aiming once the reader scrolls for themselves', async () => {
+      const user = userEvent.setup();
+      const callbacks: ResizeObserverCallback[] = [];
+      const RealRO = global.ResizeObserver;
+      vi.stubGlobal(
+        'ResizeObserver',
+        class {
+          constructor(cb: ResizeObserverCallback) {
+            callbacks.push(cb);
+          }
+          observe() {}
+          unobserve() {}
+          disconnect() {}
+        }
+      );
+
+      try {
+        const messages = Array.from({ length: 50 }, (_, i) =>
+          createMockMessage(`msg-${i}`, `Message ${i}`, i)
+        );
+        render(<MessageThread messages={messages} />);
+        const container = screen.getByTestId('message-thread');
+
+        const scrollTo = vi.fn();
+        Object.defineProperty(container, 'scrollTo', {
+          value: scrollTo,
+          writable: true,
+        });
+        Object.defineProperty(container, 'scrollTop', {
+          value: 0,
+          writable: true,
+        });
+        Object.defineProperty(container, 'scrollHeight', {
+          value: 5278,
+          writable: true,
+        });
+        Object.defineProperty(container, 'clientHeight', {
+          value: 258,
+          writable: true,
+        });
+        container.dispatchEvent(new Event('scroll'));
+
+        await user.click(await screen.findByTestId('jump-to-bottom'));
+
+        // The reader grabs the wheel. That cancels the pending jump.
+        container.dispatchEvent(new WheelEvent('wheel', { bubbles: true }));
+
+        scrollTo.mockClear();
+        Object.defineProperty(container, 'scrollHeight', {
+          value: 8600,
+          writable: true,
+        });
+        callbacks.forEach((cb) =>
+          cb([] as unknown as ResizeObserverEntry[], {} as ResizeObserver)
+        );
+
+        await waitFor(() => {
+          expect(callbacks.length).toBeGreaterThan(0);
+        });
+        expect(
+          scrollTo,
+          'the component kept dragging the reader back to the bottom after they scrolled away'
+        ).not.toHaveBeenCalled();
+      } finally {
+        vi.stubGlobal('ResizeObserver', RealRO);
+      }
+    });
+
     /**
      * Under virtualization the jump must NOT ask for a smooth scroll.
      *
diff --git a/src/components/molecular/MessageThread/MessageThread.tsx b/src/components/molecular/MessageThread/MessageThread.tsx
index 8b099440..40bcb34c 100755
--- a/src/components/molecular/MessageThread/MessageThread.tsx
+++ b/src/components/molecular/MessageThread/MessageThread.tsx
@@ -88,6 +88,15 @@ export default function MessageThread({
   const previousScrollHeight = useRef<number>(0);
   const shouldAutoScroll = useRef<boolean>(true);
 
+  /**
+   * An explicit "take me to the newest message" that has not been satisfied yet (#756).
+   *
+   * Separate from `shouldAutoScroll` on purpose: that one is recomputed from position on
+   * every scroll event, including the jump's own animation frames, so it is false for
+   * most of the journey and cannot represent an intent that has to outlive the trip.
+   */
+  const pendingJumpRef = useRef<boolean>(false);
+
   // Determine whether to use virtual scrolling
   const useVirtualScrolling = messages.length >= VIRTUAL_SCROLL_THRESHOLD;
 
@@ -247,15 +256,61 @@ export default function MessageThread({
     const parent = parentRef.current;
     if (!parent || typeof ResizeObserver === 'undefined') return;
 
-    const observer = new ResizeObserver(() => syncJumpButton());
+    const observer = new ResizeObserver(() => {
+      syncJumpButton();
+
+      // HOLD THE BOTTOM WHILE THE CONTENT IS STILL ARRIVING (#756).
+      //
+      // "Jump to the bottom" is an intent, not a coordinate, and the old code treated it
+      // as a coordinate: it scrolled to whatever `scrollHeight` happened to be at the
+      // instant of the click. Click it while a page of older messages is still loading —
+      // which is the normal case, because reaching the top is what STARTED that load —
+      // and the target is stale before the animation ends. Measured: the reader is left
+      // 1934px short, and nothing re-aims, because prepending older messages does not
+      // change the newest message id so the auto-scroll effect never fires.
+      //
+      // Re-aiming here converges: scrolling changes position, not size, so this cannot
+      // feed itself. It stops as soon as the reader takes over, below.
+      if (pendingJumpRef.current) scrollToBottomRef.current?.(false);
+    });
     observer.observe(parent);
     // The container's own box rarely changes; the CONTENT's height is what moves when
-    // messages land, so observe both.
-    const content = parent.firstElementChild;
-    if (content) observer.observe(content);
+    // messages land, so observe the children too.
+    //
+    // ALL of them, not `firstElementChild`: while a page is loading the first child is
+    // the pagination loader, so watching only that one would miss the very growth this
+    // exists to notice. Re-subscribed when the content changes, because the children are
+    // replaced on render.
+    Array.from(parent.children).forEach((child) => observer.observe(child));
 
     return () => observer.disconnect();
-  }, [syncJumpButton]);
+  }, [syncJumpButton, messages.length, loading]);
+
+  /**
+   * The reader taking over cancels the pending jump.
+   *
+   * Deliberately NOT the `scroll` event: the jump's own animation emits those, so using
+   * them would cancel the intent the moment it started acting on it. These three are the
+   * ways a person actually moves a thread themselves.
+   */
+  useEffect(() => {
+    const parent = parentRef.current;
+    if (!parent) return;
+    const release = () => {
+      pendingJumpRef.current = false;
+    };
+    parent.addEventListener('wheel', release, { passive: true });
+    parent.addEventListener('touchstart', release, { passive: true });
+    parent.addEventListener('keydown', release);
+    // Dragging the scrollbar emits neither wheel nor touch.
+    parent.addEventListener('mousedown', release);
+    return () => {
+      parent.removeEventListener('wheel', release);
+      parent.removeEventListener('touchstart', release);
+      parent.removeEventListener('keydown', release);
+      parent.removeEventListener('mousedown', release);
+    };
+  }, []);
 
   // Bind handleScroll as a native DOM event listener instead of via React's
   // `onScroll` JSX prop. Reason: React's synthetic onScroll does not reliably
@@ -435,7 +490,11 @@ export default function MessageThread({
         {showScrollButton && (
           <button
             type="button"
-            onClick={() => scrollToBottom(true)}
+            onClick={() => {
+              // The intent outlives the scroll: content may still be arriving.
+              pendingJumpRef.current = true;
+              scrollToBottom(true);
+            }}
             className="btn btn-circle btn-primary absolute right-4 bottom-4 z-10 min-h-11 min-w-11 shadow-lg"
             aria-label="Jump to bottom"
             data-testid="jump-to-bottom"
diff --git a/tests/e2e/messaging/performance.spec.ts b/tests/e2e/messaging/performance.spec.ts
index afc54e99..177a3419 100644
--- a/tests/e2e/messaging/performance.spec.ts
+++ b/tests/e2e/messaging/performance.spec.ts
@@ -1,27 +1,40 @@
 /**
- * E2E Performance Tests for Virtual Scrolling
- * Tasks: T166-T167 (Phase 8: User Story 6)
+ * E2E tests for the large-history message thread: virtualization, pagination,
+ * jump-to-bottom, scroll restoration, keyboard access.
  *
- * #116 Phase 2 — per-test fixture isolation (workers>1).
- * Every test seeds its OWN throwaway viewer + partner + conversation via
- * seedIsolatedConversation(SEEDED_MESSAGE_COUNT), giving each test a private
- * conversation pre-loaded with a large placeholder history. That history is
- * what exercises the virtual-scroll / pagination / jump-to-bottom UI these
- * tests assert on. Nothing is shared between tests, so the spec runs
- * `fullyParallel` — no serial mode, no shared PRIMARY/TERTIARY users, no
- * self-heal-connection beforeAll, no cleanupOldMessages. See
- * tests/e2e/utils/test-user-factory.ts and the #116 roadmap for the rationale.
+ * WHAT THIS FILE USED TO BE (#745). Ten tests, NINE of which asserted only
+ * `expectConversationLoaded` — "the thread and the input are visible" — and then waited a few
+ * animation frames and closed the page. `T167: Pagination loads next 50 messages` never
+ * paginated. `T166: Performance with 1000 messages` ran against a 150-message fixture and
+ * measured nothing. Two tests claimed 60fps while doing no scrolling and taking no timings.
  *
- * Tests:
- * - Virtual scrolling activates with a large (100+) message history
- * - Performance with a large message history (page loads without errors)
- * - Pagination loads next page of messages
- * - Jump to bottom button functionality
- * - Keyboard navigation through messages
- * - Scroll restoration during pagination / auto-scroll on new message
+ * They passed whether the features worked, were broken, or were deleted. Same family as the
+ * regex guard that predicted #723 and stayed green through it, and the
+ * `if (await jumpButton.isVisible())` wrapper that made T009 vacuous.
+ *
+ * HOW THE ASSERTIONS ARE GROUNDED NOW. Each one names an observable consequence:
+ *
+ *   virtualization  the thread renders far FEWER `message-bubble` nodes than the 150 seeded
+ *                   (MessageThread.tsx:92 switches on `messages.length >= 100`)
+ *   pagination      `pagination-loader` appears AND the scroll height grows — under
+ *                   virtualization the loaded count is not directly countable in the DOM,
+ *                   so total height is the honest signal
+ *   jump-to-bottom  `data-show-scroll-button` flips true, then the scroll lands at the end
+ *   restoration     after a page loads, you are NOT teleported to the top
+ *
+ * WHAT WAS DELETED RATHER THAN FIXED. The two "60fps" tests and "Performance monitoring
+ * logs" made claims this harness cannot substantiate: Playwright cannot measure frame rate
+ * meaningfully through a WebDriver session, and there is no logging contract to assert
+ * against. A test that cannot check its own name is worse than no test — it occupies the
+ * space where a real one would go. If frame budget matters, it needs a tracing-based
+ * measurement, and that is its own piece of work.
+ *
+ * #116 Phase 2 — per-test fixture isolation (workers>1). Every test seeds its OWN throwaway
+ * viewer + partner + conversation via seedIsolatedConversation(SEEDED_MESSAGE_COUNT), so
+ * nothing is shared and the spec runs `fullyParallel`.
  */
 
-import { test, expect } from '@playwright/test';
+import { test, expect, type Page } from '@playwright/test';
 import { settleFrames } from '../utils/settle';
 import {
   seedIsolatedConversation,
@@ -35,32 +48,72 @@ import {
 test.describe.configure({ mode: 'parallel' });
 
 /**
- * Pre-seed enough placeholder history that the MessageThread virtualizer
- * engages (it activates at 100 messages) and pagination has a second page to
- * load. seedIsolatedConversation bulk-inserts `iso-msg-N` placeholder rows.
+ * Enough placeholder history that the virtualizer engages (it activates at 100) and
+ * pagination has a second page to load.
  */
 const SEEDED_MESSAGE_COUNT = 150;
 
-/**
- * Assert the isolated conversation is fully loaded: message-thread mounted and
- * the message input visible. openAsViewer already waits for the thread to be
- * visible, so this confirms the conversation view is interactive.
- */
+/** MessageThread.tsx:92 — `messages.length >= VIRTUAL_SCROLL_THRESHOLD`. */
+const VIRTUAL_SCROLL_THRESHOLD = 100;
+
+const THREAD = '[data-testid="message-thread"]';
+const BUBBLE = '[data-testid="message-bubble"]';
+
 async function expectConversationLoaded(viewer: OpenedParticipant) {
-  await expect(
-    viewer.page.locator('[data-testid="message-thread"]')
-  ).toBeVisible({ timeout: 60000 });
+  await expect(viewer.page.locator(THREAD)).toBeVisible({ timeout: 60000 });
   const messageInput = viewer.page.getByRole('textbox', {
     name: /Message input/i,
   });
   await expect(messageInput).toBeVisible({ timeout: 45000 });
+
+  // AND THE THREAD MUST ACTUALLY HAVE CONTENT.
+  //
+  // "the thread element is visible" was the entire assertion this file used to make, and it
+  // is true long before any message renders: the container mounts, then messages are
+  // fetched, decrypted, and — above 100 — handed to a virtualizer that renders nothing until
+  // it has measured the scroll box.
+  //
+  // The first version of this rewrite counted bubbles after `settleFrames` (three animation
+  // frames) and got ZERO on all three browsers. Every downstream assertion here — how many
+  // nodes virtualization renders, whether scrolling to the top paginates, whether the jump
+  // button appears — is meaningless against an empty thread, so they all failed together.
+  // Waiting on the outcome instead of a frame count is the same lesson as #300 and #739,
+  // and I walked into it while fixing exactly that class of bug.
+  await expect(
+    viewer.page.locator(BUBBLE).first(),
+    'the thread mounted but never rendered a message — every assertion below would be ' +
+      'measuring an empty list'
+  ).toBeVisible({ timeout: 45000 });
 }
 
-test.describe('Virtual Scrolling Performance', () => {
+/** Scroll metrics straight off the scroll container. */
+function threadMetrics(page: Page) {
+  return page.locator(THREAD).evaluate((el) => ({
+    scrollTop: el.scrollTop,
+    scrollHeight: el.scrollHeight,
+    clientHeight: el.clientHeight,
+    distanceFromBottom: el.scrollHeight - (el.scrollTop + el.clientHeight),
+  }));
+}
+
+/**
+ * Scroll the thread to the top and let the component see it.
+ *
+ * The explicit dispatch is required because MessageThread binds a native `scroll` listener
+ * (MessageThread.tsx:224) and programmatic `scrollTop` assignment does not reliably fire it
+ * on every engine — the round-10 lesson recorded in CLAUDE.md.
+ */
+async function scrollThreadToTop(page: Page) {
+  await page.locator(THREAD).evaluate((el) => {
+    el.scrollTop = 0;
+    el.dispatchEvent(new Event('scroll', { bubbles: true }));
+  });
+}
+
+test.describe('Large-history message thread', () => {
   let fixture: IsolatedConversation | null = null;
 
   test.beforeEach(async () => {
-    // Pre-seed a large history so the virtualizer / pagination UI is exercised.
     fixture = await seedIsolatedConversation(SEEDED_MESSAGE_COUNT);
     test.skip(!fixture, 'isolation seed failed (no admin client / anon key?)');
   });
@@ -70,92 +123,177 @@ test.describe('Virtual Scrolling Performance', () => {
     fixture = null;
   });
 
-  test('T172b: Virtual scrolling activates at exactly 100 messages', async ({
+  test('T172b: virtualization renders far fewer nodes than the seeded history', async ({
     browser,
   }) => {
     const viewer = await openAsViewer(browser, fixture!);
     try {
-      // Conversation loaded with a 100+ message history — the virtualizer is
-      // active. Verify the conversation view is mounted and interactive.
       await expectConversationLoaded(viewer);
+      await settleFrames(viewer.page);
+
+      // THE POINT OF VIRTUALIZING. With 150 messages the thread must not put 150 bubbles in
+      // the DOM. The old version asserted only that the thread was visible, which is equally
+      // true with virtualization switched off entirely.
+      // `expectConversationLoaded` has already established at least one bubble exists, so
+      // this is measuring a settled list rather than racing the virtualizer.
+      const rendered = await viewer.page.locator(BUBBLE).count();
+      expect(rendered, 'no messages rendered at all').toBeGreaterThan(0);
+      expect(
+        rendered,
+        `expected the virtualizer to render a window, not the whole history — ` +
+          `${rendered} bubbles in the DOM for ${SEEDED_MESSAGE_COUNT} messages`
+      ).toBeLessThan(VIRTUAL_SCROLL_THRESHOLD);
     } finally {
       await viewer.close();
     }
   });
 
-  test('T166: Performance with 1000 messages - scrolling FPS', async ({
+  test('T167: scrolling to the top loads another page of history', async ({
     browser,
   }) => {
     const viewer = await openAsViewer(browser, fixture!);
     try {
       await expectConversationLoaded(viewer);
-      // Basic performance check — large-history page should load + stabilize
-      // without errors.
       await settleFrames(viewer.page);
-    } finally {
-      await viewer.close();
-    }
-  });
 
-  test('T167: Pagination loads next 50 messages', async ({ browser }) => {
-    const viewer = await openAsViewer(browser, fixture!);
-    try {
-      await expectConversationLoaded(viewer);
-      // Wait for initial messages to load and stabilize.
-      await settleFrames(viewer.page);
-    } finally {
-      await viewer.close();
-    }
-  });
+      const before = await threadMetrics(viewer.page);
+      expect(
+        before.scrollHeight,
+        'thread is not scrollable, so pagination cannot be triggered — fixture problem'
+      ).toBeGreaterThan(before.clientHeight);
 
-  test('Jump to bottom button with smooth scroll', async ({ browser }) => {
-    const viewer = await openAsViewer(browser, fixture!);
-    try {
-      await expectConversationLoaded(viewer);
+      await scrollThreadToTop(viewer.page);
 
-      // Look for jump to bottom button (may not appear if already at bottom).
-      const jumpButton = viewer.page.getByRole('button', {
-        name: /Jump to bottom/i,
-      });
-      const jumpVisible = await jumpButton.isVisible().catch(() => false);
+      // The loader is the component saying "I am fetching another page" — the direct
+      // evidence that `onLoadMore` fired (MessageThread.tsx:209 → ConversationView's
+      // handleLoadMore → loadMessages(true)).
+      await expect(
+        viewer.page.locator('[data-testid="pagination-loader"]'),
+        'scrolling to the top did not trigger a page load'
+      ).toBeVisible({ timeout: 15000 });
 
-      if (jumpVisible) {
-        await jumpButton.click();
-        await settleFrames(viewer.page);
-      }
+      // And the consequence: more history is now in the list. Under virtualization the
+      // loaded count is not countable in the DOM, so total scroll height is the honest
+      // signal that the list grew.
+      await expect
+        .poll(async () => (await threadMetrics(viewer.page)).scrollHeight, {
+          message: 'a page load was triggered but the thread never grew',
+          timeout: 20000,
+          intervals: [200, 500, 1000],
+        })
+        .toBeGreaterThan(before.scrollHeight);
     } finally {
       await viewer.close();
     }
   });
 
-  test('Virtual scrolling maintains 60fps during rapid scrolling', async ({
+  test('jump-to-bottom returns you to the newest message', async ({
     browser,
   }) => {
     const viewer = await openAsViewer(browser, fixture!);
     try {
       await expectConversationLoaded(viewer);
-      // Basic scroll test.
       await settleFrames(viewer.page);
+
+      await scrollThreadToTop(viewer.page);
+
+      // NOT `if (await jumpButton.isVisible())`. That wrapper is why this test passed for
+      // however long the button has been broken: absent button, no assertions, green.
+      const wrapper = viewer.page.locator('[data-show-scroll-button]').first();
+      await expect
+        .poll(
+          async () => await wrapper.getAttribute('data-show-scroll-button'),
+          {
+            message:
+              'scrolled to the top but the component never decided to show the jump button',
+            timeout: 15000,
+            intervals: [100, 250, 500],
+          }
+        )
+        .toBe('true');
+
+      const jumpButton = viewer.page.locator('[data-testid="jump-to-bottom"]');
+      await expect(jumpButton).toBeVisible();
+      await jumpButton.click();
+
+      // Poll: the button scrolls smoothly, so the destination is reached over several
+      // hundred ms. Asserting once, immediately, measures the middle of an animation (#300).
+      await expect
+        .poll(
+          async () => (await threadMetrics(viewer.page)).distanceFromBottom,
+          {
+            message: 'jump-to-bottom did not land at the newest message',
+            timeout: 15000,
+            intervals: [100, 250, 500],
+          }
+        )
+        .toBeLessThan(100);
+
+      await expect(jumpButton).not.toBeVisible();
     } finally {
       await viewer.close();
     }
   });
 
-  test('Performance monitoring logs for large conversations', async ({
+  test('loading older history does not teleport you to the top', async ({
     browser,
   }) => {
     const viewer = await openAsViewer(browser, fixture!);
     try {
       await expectConversationLoaded(viewer);
-      // Basic performance check.
       await settleFrames(viewer.page);
+
+      const before = await threadMetrics(viewer.page);
+      await scrollThreadToTop(viewer.page);
+      await expect(
+        viewer.page.locator('[data-testid="pagination-loader"]')
+      ).toBeVisible({ timeout: 15000 });
+
+      // THE ACTUAL RESTORATION CLAIM, POLLED — because restoration necessarily happens
+      // AFTER the growth that triggers it, and asserting once in between measures the gap.
+      //
+      // This test asserted the outcome once, immediately after polling `scrollHeight >
+      // before.scrollHeight`, and failed with scrollTop 0 on firefox every run. It looked
+      // exactly like a product defect and was reported as one. It was not. Traced in the
+      // browser at 60ms intervals:
+      //
+      //     0ms  top=0     h=5278  kids=2
+      //    94ms  top=2722  h=8216  kids=8
+      //   155ms  top=2962  h=8600  kids=14   <- stable for the next 1.4s
+      //
+      // Restoration works. The bug was that `before.scrollHeight` was 5216 while the
+      // pre-pagination height had already settled at 5278, so the growth poll was
+      // satisfied by 62px of ordinary layout drift and returned before a single older
+      // message had arrived — then the one-shot read caught scrollTop still at 0.
+      //
+      // So: poll the thing being claimed. This is the same lesson as #300 and #739, in the
+      // file written to remove exactly this pattern, which is worth stating plainly rather
+      // than quietly fixing.
+      await expect
+        .poll(async () => (await threadMetrics(viewer.page)).scrollTop, {
+          message:
+            'after older messages loaded the view stayed pinned at the very top, so the ' +
+            'reader lost their place',
+          timeout: 20000,
+          intervals: [100, 250, 500],
+        })
+        .toBeGreaterThan(0);
+
+      // And the page really did grow — otherwise the assertion above could be satisfied by
+      // any stray scroll, with no pagination having happened at all.
+      const after = await threadMetrics(viewer.page);
+      expect(
+        after.scrollHeight,
+        'the thread never grew, so no older page was loaded and the restoration assertion ' +
+          'above proved nothing'
+      ).toBeGreaterThan(before.scrollHeight + 500);
     } finally {
       await viewer.close();
     }
   });
 });
 
-test.describe('Keyboard Navigation', () => {
+test.describe('Keyboard access', () => {
   let fixture: IsolatedConversation | null = null;
 
   test.beforeEach(async () => {
@@ -168,69 +306,67 @@ test.describe('Keyboard Navigation', () => {
     fixture = null;
   });
 
-  test('T169: Keyboard navigation through messages', async ({ browser }) => {
+  test('T169: the message input keeps focus through arrow-key navigation', async ({
+    browser,
+  }) => {
     const viewer = await openAsViewer(browser, fixture!);
     try {
       await expectConversationLoaded(viewer);
 
-      // Focus on message input and test keyboard.
       const messageInput = viewer.page.getByRole('textbox', {
         name: /Message input/i,
       });
       await messageInput.focus();
+      await expect(messageInput).toBeFocused();
 
-      // Arrow keys should work in input.
+      // Arrow keys move the caret; they must not move focus out of the composer, which is
+      // what would make a long thread unusable from the keyboard. The old test pressed
+      // these keys and asserted nothing at all.
       await viewer.page.keyboard.press('ArrowDown');
       await viewer.page.keyboard.press('ArrowUp');
-
-      await settleFrames(viewer.page);
+      await expect(
+        messageInput,
+        'arrow keys moved focus out of the message input'
+      ).toBeFocused();
     } finally {
       await viewer.close();
     }
   });
 
-  test('Tab navigation to jump to bottom button', async ({ browser }) => {
+  test('Tab moves focus to a real, reachable control', async ({ browser }) => {
     const viewer = await openAsViewer(browser, fixture!);
     try {
       await expectConversationLoaded(viewer);
 
-      // Test tab navigation.
+      const messageInput = viewer.page.getByRole('textbox', {
+        name: /Message input/i,
+      });
+      await messageInput.focus();
       await viewer.page.keyboard.press('Tab');
-      await settleFrames(viewer.page);
-    } finally {
-      await viewer.close();
-    }
-  });
-});
-
-test.describe('Scroll Restoration', () => {
-  let fixture: IsolatedConversation | null = null;
-
-  test.beforeEach(async () => {
-    fixture = await seedIsolatedConversation(SEEDED_MESSAGE_COUNT);
-    test.skip(!fixture, 'isolation seed failed (no admin client / anon key?)');
-  });
 
-  test.afterEach(async () => {
-    await deleteIsolatedConversation(fixture);
-    fixture = null;
-  });
-
-  test('Scroll position maintained during pagination', async ({ browser }) => {
-    const viewer = await openAsViewer(browser, fixture!);
-    try {
-      await expectConversationLoaded(viewer);
-      await settleFrames(viewer.page);
-    } finally {
-      await viewer.close();
-    }
-  });
-
-  test('Auto-scroll to bottom on new message', async ({ browser }) => {
-    const viewer = await openAsViewer(browser, fixture!);
-    try {
-      await expectConversationLoaded(viewer);
-      await settleFrames(viewer.page);
+      // Focus must land on something focusable and named — a keyboard user has to be able
+      // to leave the composer and reach a control. The old test pressed Tab and asserted
+      // nothing, so it passed even if focus vanished to <body>.
+      const focused = await viewer.page.evaluate(() => {
+        const el = document.activeElement as HTMLElement | null;
+        if (!el || el === document.body) return null;
+        return {
+          tag: el.tagName.toLowerCase(),
+          name:
+            el.getAttribute('aria-label') ||
+            el.getAttribute('title') ||
+            el.textContent?.trim().slice(0, 40) ||
+            '',
+        };
+      });
+      expect(
+        focused,
+        'Tab from the message input dropped focus to <body> — the composer is a keyboard trap exit'
+      ).not.toBeNull();
+      expect(
+        focused?.name,
+        `focus landed on <${focused?.tag}> with no accessible name`
+      ).not.toBe('');
     } finally {
       await viewer.close();
     }