@@ -394,6 +394,7 @@ describe("load-older cursor advance logic", () => {
 import {
   createArchivePagingState,
   applyChannelReset,
+  runHydrationLoop,
 } from "@/features/agents/ui/archivePagingState.ts";
 
 describe("archive paging state reset on channel change", () => {
@@ -415,6 +416,7 @@ describe("archive paging state reset on channel change", () => {
       false,
       "initialHydrationDone starts false",
     );
+    assert.equal(ps.activeChannelId, null, "activeChannelId starts null");
   });
 
   it("test_channel_switch_resets_cursor_exhaustion_and_fetch_lock", () => {
@@ -425,11 +427,12 @@ describe("archive paging state reset on channel change", () => {
     ps.hasOlderArchived = false; // channel A exhausted
     ps.isFetching = true; // mid-flight request (edge case)
     ps.initialHydrationDone = true; // hydration ran for channel A
+    ps.activeChannelId = "chan-a";
     ps.backfillStatus = "done"; // backfill ran once already
     const originalPromise = ps.backfillPromise; // must survive reset
 
     // Channel switch — this is what the useEffect([channelId]) calls.
-    applyChannelReset(ps);
+    applyChannelReset(ps, "chan-b");
 
     assert.equal(ps.cursor, null, "cursor resets to null on channel switch");
     assert.equal(
@@ -447,6 +450,11 @@ describe("archive paging state reset on channel change", () => {
       false,
       "initialHydrationDone resets to false on channel switch so the new channel hydrates",
     );
+    assert.equal(
+      ps.activeChannelId,
+      "chan-b",
+      "activeChannelId updates to new channel on switch",
+    );
 
     // Backfill state must NOT be touched — it is identity-level and should
     // survive channel switches so the backfill only runs once per identity mount.
@@ -474,7 +482,7 @@ describe("archive paging state reset on channel change", () => {
     ps.cursor = { createdAt: 500, id: "a-oldest" };
     ps.hasOlderArchived = false;
     ps.initialHydrationDone = true;
-    applyChannelReset(ps);
+    applyChannelReset(ps, "chan-b");
 
     assert.equal(ps.cursor, null, "switch A→B: cursor reset");
     assert.equal(
@@ -487,12 +495,17 @@ describe("archive paging state reset on channel change", () => {
       false,
       "switch A→B: initialHydrationDone reset",
     );
+    assert.equal(
+      ps.activeChannelId,
+      "chan-b",
+      "switch A→B: activeChannelId updated",
+    );
 
     // Simulate channel B also being paged and hydrated.
     ps.cursor = { createdAt: 200, id: "b-oldest" };
     ps.hasOlderArchived = false;
     ps.initialHydrationDone = true;
-    applyChannelReset(ps);
+    applyChannelReset(ps, "chan-c");
 
     assert.equal(ps.cursor, null, "switch B→C: cursor reset again");
     assert.equal(
@@ -505,6 +518,11 @@ describe("archive paging state reset on channel change", () => {
       false,
       "switch B→C: initialHydrationDone reset again",
     );
+    assert.equal(
+      ps.activeChannelId,
+      "chan-c",
+      "switch B→C: activeChannelId updated",
+    );
   });
 });
 
@@ -514,127 +532,144 @@ describe("archive paging state reset on channel change", () => {
 // fetchOlderArchived up to INITIAL_HYDRATION_BUDGET_PAGES times. The loop must:
 //   - Stop at budget (10 pages) even if more archive exists.
 //   - Stop early when the archive is exhausted (ps.hasOlderArchived → false).
-//   - Respect channel-switch cancellation (cancelled flag).
-//   - Set ps.initialHydrationDone immediately to prevent duplicate loops.
+//   - Respect channel-switch cancellation (signal.cancelled).
 //
-// We test the loop's control flow as pure logic using mock fetchOlderArchived
-// functions and ArchivePagingState directly — no React runtime needed.
+// These tests call the PRODUCTION runHydrationLoop from archivePagingState.ts
+// with mock fetchOnePage functions — so they fail if the production loop logic
+// is deleted or misrouted, not just if a reimplemented copy breaks.
 
-describe("eager initial hydration loop control flow", () => {
+describe("eager initial hydration loop control flow (production runHydrationLoop)", () => {
   const BUDGET = 10; // mirrors INITIAL_HYDRATION_BUDGET_PAGES
 
-  // Simulate the hydration loop from the hook with injectable fetch + ps.
-  async function runHydrationLoop(
-    ps,
-    fetchOlderArchived,
-    cancelled = { value: false },
-  ) {
-    ps.initialHydrationDone = true;
-    for (let page = 0; page < BUDGET; page++) {
-      if (cancelled.value || !ps.hasOlderArchived) {
-        break;
-      }
-      await fetchOlderArchived();
-    }
-  }
-
   it("test_hydration_stops_at_budget_when_archive_never_exhausted", async () => {
     const ps = createArchivePagingState();
+    applyChannelReset(ps, "chan-1");
     let fetchCount = 0;
-    // fetchOlderArchived that never exhausts the archive
-    const fetchOlderArchived = async () => {
+    const fetchOnePage = async () => {
       fetchCount++;
-      // archive remains non-empty
+      // archive remains non-empty — ps.hasOlderArchived stays true
     };
-    await runHydrationLoop(ps, fetchOlderArchived);
+    const signal = { cancelled: false };
+    await runHydrationLoop(ps, fetchOnePage, BUDGET, signal);
     assert.equal(
       fetchCount,
       BUDGET,
-      `hydration loop must stop after exactly ${BUDGET} pages (budget limit)`,
-    );
-    assert.equal(
-      ps.initialHydrationDone,
-      true,
-      "initialHydrationDone must be true after budget reached",
+      `production runHydrationLoop must stop after exactly ${BUDGET} pages (budget limit)`,
     );
   });
 
   it("test_hydration_stops_early_when_archive_exhausted", async () => {
     const ps = createArchivePagingState();
+    applyChannelReset(ps, "chan-1");
     let fetchCount = 0;
-    // fetchOlderArchived that exhausts archive on page 3
-    const fetchOlderArchived = async () => {
+    const fetchOnePage = async () => {
       fetchCount++;
       if (fetchCount >= 3) {
-        ps.hasOlderArchived = false;
+        ps.hasOlderArchived = false; // mock: archive exhausted on page 3
       }
     };
-    await runHydrationLoop(ps, fetchOlderArchived);
+    const signal = { cancelled: false };
+    await runHydrationLoop(ps, fetchOnePage, BUDGET, signal);
     assert.equal(
       fetchCount,
       3,
-      "hydration loop must stop as soon as archive is exhausted (before budget)",
-    );
-    assert.equal(
-      ps.initialHydrationDone,
-      true,
-      "initialHydrationDone must be true after exhaustion",
-    );
-    assert.equal(
-      ps.hasOlderArchived,
-      false,
-      "hasOlderArchived must be false after exhaustion",
+      "production runHydrationLoop must stop as soon as ps.hasOlderArchived is false (before budget)",
     );
   });
 
   it("test_hydration_respects_cancellation_on_channel_switch", async () => {
     const ps = createArchivePagingState();
-    const cancelled = { value: false };
+    applyChannelReset(ps, "chan-1");
+    const signal = { cancelled: false };
     let fetchCount = 0;
-    // fetchOlderArchived that sets cancelled on page 2 (simulates channel switch mid-loop)
-    const fetchOlderArchived = async () => {
+    const fetchOnePage = async () => {
       fetchCount++;
       if (fetchCount >= 2) {
-        cancelled.value = true;
+        signal.cancelled = true; // mock: channel switched mid-loop
       }
     };
-    await runHydrationLoop(ps, fetchOlderArchived, cancelled);
+    await runHydrationLoop(ps, fetchOnePage, BUDGET, signal);
     assert.equal(
       fetchCount,
       2,
-      "hydration loop must stop when cancelled (channel switch)",
+      "production runHydrationLoop must stop when signal.cancelled is true (channel switch)",
     );
-    // initialHydrationDone is true because it was set before the loop;
-    // applyChannelReset will reset it for the new channel.
+  });
+
+  it("test_hydration_zero_iterations_when_already_exhausted", async () => {
+    // If ps.hasOlderArchived is already false before the loop starts (e.g.
+    // channel A was exhausted and reset did not run yet), the loop must not
+    // call fetchOnePage at all.
+    const ps = createArchivePagingState();
+    applyChannelReset(ps, "chan-1");
+    ps.hasOlderArchived = false; // already exhausted
+    let fetchCount = 0;
+    const fetchOnePage = async () => {
+      fetchCount++;
+    };
+    const signal = { cancelled: false };
+    await runHydrationLoop(ps, fetchOnePage, BUDGET, signal);
     assert.equal(
-      ps.initialHydrationDone,
-      true,
-      "initialHydrationDone stays true (applyChannelReset will reset it for new channel)",
+      fetchCount,
+      0,
+      "must not fetch when archive is already exhausted",
     );
   });
 
-  it("test_initialHydrationDone_set_before_loop_prevents_duplicate_loops", () => {
+  // Regression: stale React closure — the original fetchOlderArchived captured
+  // hasOlderArchived from React state, which was false (exhausted) for channel A
+  // while ps.hasOlderArchived had already been reset to true by applyChannelReset.
+  // The production loop uses ps.hasOlderArchived (the ref) to guard iterations,
+  // so the switch-then-hydrate path must call fetchOnePage for the new channel.
+  it("test_exhausted_channel_A_then_switch_to_B_hydrates_B", async () => {
     const ps = createArchivePagingState();
-    assert.equal(ps.initialHydrationDone, false, "starts false");
-    // Simulate the synchronous guard at the top of the effect.
-    ps.initialHydrationDone = true;
-    // A second effect invocation would see initialHydrationDone=true and bail immediately.
-    // Verify the guard value is set before any async work starts.
+
+    // Simulate exhausting channel A.
+    applyChannelReset(ps, "chan-a");
+    ps.hasOlderArchived = false; // channel A exhausted
+
+    // Switch to channel B — resets hasOlderArchived and activeChannelId.
+    applyChannelReset(ps, "chan-b");
+
+    // ps.hasOlderArchived is now true; the loop should call fetchOnePage.
+    let fetchCount = 0;
+    const fetchOnePage = async () => {
+      fetchCount++;
+      ps.hasOlderArchived = false; // B also exhausted after 1 page
+    };
+    const signal = { cancelled: false };
+    await runHydrationLoop(ps, fetchOnePage, BUDGET, signal);
+
     assert.equal(
-      ps.initialHydrationDone,
-      true,
-      "initialHydrationDone must be true immediately after loop starts (prevents re-entry)",
+      fetchCount,
+      1,
+      "after switch from exhausted channel A to B, runHydrationLoop must call fetchOnePage for B (not skip due to stale exhaustion)",
     );
   });
 
-  it("test_channel_reset_clears_hydration_flag_for_new_channel", () => {
+  // Regression: stale cursor write — an in-flight read from channel A should
+  // not write A's cursor into ps.cursor after the switch to B. The activeChannelId
+  // token (set by applyChannelReset) is what lets fetchOlderArchived detect and
+  // discard the stale result. This test verifies that applyChannelReset correctly
+  // advances the token so a pre-switch requestChannelId !== ps.activeChannelId.
+  it("test_activeChannelId_token_detects_stale_read_from_prior_channel", () => {
     const ps = createArchivePagingState();
-    ps.initialHydrationDone = true; // hydration ran for channel A
-    applyChannelReset(ps);
+    applyChannelReset(ps, "chan-a");
+    const requestChannelId = ps.activeChannelId; // captured at request start = "chan-a"
+
+    // Simulate channel switch before the Tauri read resolves.
+    applyChannelReset(ps, "chan-b");
+
+    // The in-flight A read checks requestChannelId !== ps.activeChannelId.
+    assert.notEqual(
+      requestChannelId,
+      ps.activeChannelId,
+      "requestChannelId from channel A must not match activeChannelId after switching to B — stale read must be discarded",
+    );
     assert.equal(
-      ps.initialHydrationDone,
-      false,
-      "applyChannelReset must clear initialHydrationDone so new channel gets fresh hydration pass",
+      ps.activeChannelId,
+      "chan-b",
+      "activeChannelId must reflect the current channel after switch",
     );
   });
 });
 
@@ -32,6 +32,11 @@ export interface ArchivePagingState {
    *  completed (budget reached or archive exhausted). Resets on channel change
    *  so switching channels triggers a fresh hydration pass. */
   initialHydrationDone: boolean;
+  /** The channelId that this paging state is currently scoped to.
+   *  Captured by fetchOlderArchived at request start; compared on resolution
+   *  to detect and discard cursor/exhaustion writes from in-flight reads that
+   *  completed after a channel switch. */
+  activeChannelId: string | null;
 }
 
 /**
@@ -48,6 +53,7 @@ export function createArchivePagingState(): ArchivePagingState {
     backfillResolve: null,
     cursor: null,
     initialHydrationDone: false,
+    activeChannelId: null,
   };
   state.backfillPromise = new Promise<void>((resolve) => {
     state.backfillResolve = resolve;
@@ -58,16 +64,50 @@ export function createArchivePagingState(): ArchivePagingState {
 /**
  * Reset per-channel paging state when the viewed channel changes.
  *
- * Only cursor, exhaustion flag, and fetch lock are channel-scoped. Backfill
- * state is identity-level (the index covers ALL channels and needs to run only
- * once per identity mount), so it is intentionally NOT touched here.
+ * Only cursor, exhaustion flag, fetch lock, and channel token are
+ * channel-scoped. Backfill state is identity-level (the index covers ALL
+ * channels and needs to run only once per identity mount), so it is
+ * intentionally NOT touched here.
  *
  * Called by the useEffect([channelId]) in useLoadArchivedObserverEvents.
  * Exported so tests can verify the reset semantics without a React runtime.
  */
-export function applyChannelReset(state: ArchivePagingState): void {
+export function applyChannelReset(
+  state: ArchivePagingState,
+  newChannelId: string | null,
+): void {
   state.cursor = null;
   state.isFetching = false;
   state.hasOlderArchived = true;
   state.initialHydrationDone = false;
+  state.activeChannelId = newChannelId;
+}
+
+/**
+ * Run the eager initial-hydration paging loop.
+ *
+ * Calls `fetchOnePage()` up to `budget` times. Stops early when:
+ *   - `ps.hasOlderArchived` is false (archive exhausted for this channel), OR
+ *   - `signal.cancelled` is true (channel switched away mid-loop).
+ *
+ * `fetchOnePage` is the per-page read unit: it must respect `ps.isFetching`
+ * (lock), await backfill, perform the Tauri read, ingest results, advance
+ * the cursor, and set `ps.hasOlderArchived = false` when the page is short.
+ * The hook wires the real implementation; tests supply a mock.
+ *
+ * Exported so tests can call the production loop logic directly — passing a
+ * mock `fetchOnePage` — without reimplementing the control flow.
+ */
+export async function runHydrationLoop(
+  ps: ArchivePagingState,
+  fetchOnePage: () => Promise<void>,
+  budget: number,
+  signal: { cancelled: boolean },
+): Promise<void> {
+  for (let page = 0; page < budget; page++) {
+    if (signal.cancelled || !ps.hasOlderArchived) {
+      break;
+    }
+    await fetchOnePage();
+  }
 }