@@ -130,20 +130,18 @@ export function createSessionRows(
       onCleanup(() => abort(controller))
       rebuild()
       void data.session.pending.sync(id).catch(() => undefined)
-      void retrySessionSync(async () => {
-        await data.session.message.sync(id)
-        if (controller.signal.aborted) return
-        rebuild()
-        // Restoration waits for complete boundary groups so saved group IDs resolve.
-        await completeGroupBoundary({
-          rows,
-          messages: () => data.session.message.list(id).length,
-          more: () => data.session.message.more(id),
-          loadMore: () => data.session.message.loadMore(id),
-          active: () => !controller.signal.aborted && sessionID() === id,
-        })
-      }, controller.signal)
-        .then(() => {
+      void retrySessionSync(() => data.session.message.sync(id), controller.signal)
+        .then(async () => {
+          if (controller.signal.aborted) return
+          rebuild()
+          // Restoration waits for complete boundary groups so saved group IDs resolve.
+          await completeGroupBoundary({
+            rows,
+            messages: () => data.session.message.list(id).length,
+            more: () => data.session.message.more(id),
+            loadMore: () => data.session.message.loadMore(id),
+            active: () => !controller.signal.aborted && sessionID() === id,
+          }).catch(() => undefined)
           if (!controller.signal.aborted) onSynced?.(id)
         })
         .catch((error) => {
 
@@ -16,25 +16,25 @@ const session = {
   time: { created: 0, updated: 0 },
 }
 const location = { directory, project: { id: "project", directory, canonical: directory } }
+const assistant = {
+  id: "message-2",
+  type: "assistant",
+  agent: "build",
+  model: { providerID: "demo", id: "demo-model" },
+  content: [{ type: "text", text: "History recovered" }],
+  finish: "stop",
+  time: { created: 2, completed: 3 },
+}
 const messages = [
   { id: "message-1", type: "user", text: "Restore this history", time: { created: 1 } },
-  {
-    id: "message-2",
-    type: "assistant",
-    agent: "build",
-    model: { providerID: "demo", id: "demo-model" },
-    content: [{ type: "text", text: "History recovered" }],
-    finish: "stop",
-    time: { created: 2, completed: 3 },
-  },
+  assistant,
 ]
 
-async function launch(options: { target: Read; failures?: number; status?: number; block?: boolean }) {
+async function launch(options: { target: Read; failures?: number; status?: number; boundary?: boolean }) {
   const reads = { session: 0, message: 0 }
-  const release = Promise.withResolvers<void>()
   const setup = await createAppFixture({
     args: { sessionID: session.id },
-    config: { animations: false, tabs: { mode: "off" }, keybinds: { "session.new": "f6" } },
+    config: { animations: false, tabs: { mode: "off" } },
     fetch: async (url) => {
       if (url.pathname === "/api/agent")
         return json({ location, data: [{ id: "build", mode: "primary", hidden: false, permissions: [] }] })
@@ -51,32 +51,31 @@ async function launch(options: { target: Read; failures?: number; status?: numbe
             : undefined
       if (read) {
         reads[read]++
-        if (options.block && read === options.target) await release.promise
+        if (read === "message" && url.searchParams.has("cursor"))
+          return json({ message: "older page unavailable" }, { status: 401 })
         if (read === options.target && reads[read] <= (options.failures ?? 2)) {
           const status = options.status ?? 503
           return json(
             status === 404
               ? { _tag: "SessionNotFoundError", sessionID: session.id, message: `Session not found: ${session.id}` }
-              : { message: "temporarily unavailable" },
+              : { message: status === 401 ? "history access denied" : "temporarily unavailable" },
             { status },
           )
         }
-        return json(read === "session" ? { data: session } : { data: messages.toReversed(), cursor: {} })
+        if (read === "session") return json({ data: session })
+        return json({
+          data: options.boundary
+            ? [{ ...assistant, content: [{ type: "reasoning", text: "Existing thought" }, ...assistant.content] }]
+            : messages.toReversed(),
+          cursor: options.boundary ? { next: "older" } : {},
+        })
       }
       if (url.pathname === `/api/session/${session.id}/inbox`) return json({ data: [] })
       return undefined
     },
   })
   await setup.ready
-  return {
-    ...setup,
-    reads,
-    release: release.resolve,
-    async [Symbol.asyncDispose]() {
-      release.resolve()
-      await setup[Symbol.asyncDispose]()
-    },
-  }
+  return { ...setup, reads }
 }
 
 async function wait(condition: () => boolean) {
@@ -108,32 +107,22 @@ test("a missing session reports the error and returns to the actual home screen
   expect(setup.captureCharFrame()).not.toContain("Restore this history")
 })
 
-// The shared retry tests control time and verify each delay. This case exercises the complete
-// app's real 7.5-second retry budget and the user-visible error after all five reads fail.
-test("exhausted history reads report an error instead of silently leaving an empty transcript", async () => {
-  await using setup = await launch({ target: "message", failures: Infinity })
-  await wait(() => setup.captureCharFrame().includes("Failed to load session history"))
-  expect(setup.reads.message).toBe(5)
-  expect(setup.captureCharFrame()).toContain("UnexpectedStatus: 503")
+test("a terminal history error is reported without retrying", async () => {
+  await using setup = await launch({ target: "message", failures: Infinity, status: 401 })
+  await setup.waitForFrame(
+    (frame) => frame.includes("Failed to load session history") && frame.includes("history access denied"),
+  )
+  expect(setup.reads.message).toBe(1)
   expect(setup.captureCharFrame()).not.toContain(logo.left[1])
 })
 
-test.each(["session", "message"] satisfies Read[])(
-  "leaving during an in-flight %s read cancels stale recovery",
-  async (target) => {
-    await using setup = await launch({ target, block: true, failures: Infinity })
-    await wait(() => setup.reads[target] === 1)
-    setup.mockInput.pressKey("F6")
-    await setup.waitForFrame((frame) => frame.includes(logo.left[1]))
-    setup.release()
-    // Cross the first retry boundary to catch an obsolete read starting after the route was left.
-    await Bun.sleep(600)
-    expect(setup.reads[target]).toBe(1)
-    expect(setup.captureCharFrame()).toContain(logo.left[1])
-    expect(setup.captureCharFrame()).not.toContain("UnexpectedStatus")
-    expect(setup.captureCharFrame()).not.toContain("Failed to load session history")
-  },
-)
+test("an older-page failure does not report an initial history error", async () => {
+  await using setup = await launch({ target: "message", failures: 0, boundary: true })
+  await wait(() => setup.reads.message === 2)
+  await waitForHighlightedFrame(setup, (frame) => frame.includes("History recovered"))
+  expect(setup.captureCharFrame()).not.toContain("Failed to load session history")
+  expect(setup.captureCharFrame()).not.toContain("UnexpectedStatus")
+})
 
 test("reconnecting restarts a failed history read without stale retries or errors", async () => {
   await using setup = await launch({ target: "message", failures: 1 })
 
@@ -64,3 +64,76 @@ test.each([
     jest.useRealTimers()
   }
 })
+
+test("exhausts five reads after four delays without a final backoff", async () => {
+  jest.useFakeTimers()
+  const controller = new AbortController()
+  const error = new ClientError("UnexpectedStatus", { cause: { status: 503 } })
+  const attempts: number[] = []
+  try {
+    const task = retrySessionSync(async () => {
+      attempts.push(Date.now())
+      throw error
+    }, controller.signal).catch((error) => error)
+    await Promise.resolve()
+    await Promise.resolve()
+    for (const delay of [500, 1000, 2000, 4000]) {
+      jest.advanceTimersByTime(delay)
+      await Promise.resolve()
+      await Promise.resolve()
+    }
+    expect(await task).toBe(error)
+    expect(attempts.map((time) => time - attempts[0])).toEqual([0, 500, 1500, 3500, 7500])
+    expect(jest.getTimerCount()).toBe(0)
+  } finally {
+    controller.abort()
+    jest.useRealTimers()
+  }
+})
+
+test("cancelling a read clears its pending retry", async () => {
+  jest.useFakeTimers()
+  const controller = new AbortController()
+  const reason = new Error("session left")
+  let calls = 0
+  try {
+    const task = retrySessionSync(async () => {
+      calls++
+      throw new ClientError("UnexpectedStatus", { cause: { status: 503 } })
+    }, controller.signal).catch((error) => error)
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(jest.getTimerCount()).toBe(1)
+    controller.abort(reason)
+    expect(await task).toBe(reason)
+    expect(jest.getTimerCount()).toBe(0)
+    jest.runAllTimers()
+    expect(calls).toBe(1)
+  } finally {
+    controller.abort()
+    jest.useRealTimers()
+  }
+})
+
+test("leaving during an in-flight read prevents a stale retry", async () => {
+  jest.useFakeTimers()
+  const controller = new AbortController()
+  const response = Promise.withResolvers<void>()
+  const reason = new Error("session left")
+  let calls = 0
+  try {
+    const task = retrySessionSync(() => {
+      calls++
+      return response.promise
+    }, controller.signal).catch((error) => error)
+    controller.abort(reason)
+    response.reject(new ClientError("UnexpectedStatus", { cause: { status: 503 } }))
+    expect(await task).toBe(reason)
+    expect(jest.getTimerCount()).toBe(0)
+    jest.runAllTimers()
+    expect(calls).toBe(1)
+  } finally {
+    controller.abort()
+    jest.useRealTimers()
+  }
+})