diff --git a/packages/app/src/context/global-sync/event-reducer.ts b/packages/app/src/context/global-sync/event-reducer.ts
index 5f43c341bc0b..4a6f7e644254 100644
--- a/packages/app/src/context/global-sync/event-reducer.ts
+++ b/packages/app/src/context/global-sync/event-reducer.ts
@@ -15,8 +15,14 @@ import type { State, VcsCache } from "./types"
 import { trimSessions } from "./session-trim"
 import { dropSessionCaches } from "./session-cache"
 import { diffs as list, message as clean } from "@/utils/diffs"
+import { compareMessages } from "@/context/revert-page"
 
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
+const messageIndex = (messages: readonly Message[], id: string) => messages.findIndex((message) => message.id === id)
+const messageInsertIndex = (messages: readonly Message[], message: Message) => {
+  const index = messages.findIndex((item) => compareMessages(message, item) < 0)
+  return index === -1 ? messages.length : index
+}
 
 export function applyGlobalEvent(input: {
   event: { type: string; properties?: unknown }
@@ -188,16 +194,16 @@ export function applyDirectoryEvent(input: {
         input.setStore("message", info.sessionID, [info])
         break
       }
-      const result = Binary.search(messages, info.id, (m) => m.id)
-      if (result.found) {
-        input.setStore("message", info.sessionID, result.index, reconcile(info))
+      const index = messageIndex(messages, info.id)
+      if (index !== -1) {
+        input.setStore("message", info.sessionID, index, reconcile(info))
         break
       }
       input.setStore(
         "message",
         info.sessionID,
         produce((draft) => {
-          draft.splice(result.index, 0, info)
+          draft.splice(messageInsertIndex(draft, info), 0, info)
         }),
       )
       break
@@ -208,8 +214,8 @@ export function applyDirectoryEvent(input: {
         produce((draft) => {
           const messages = draft.message[props.sessionID]
           if (messages) {
-            const result = Binary.search(messages, props.messageID, (m) => m.id)
-            if (result.found) messages.splice(result.index, 1)
+            const index = messageIndex(messages, props.messageID)
+            if (index !== -1) messages.splice(index, 1)
           }
           delete draft.part[props.messageID]
         }),
diff --git a/packages/app/src/context/revert-page.test.ts b/packages/app/src/context/revert-page.test.ts
new file mode 100644
index 000000000000..4245dbd90924
--- /dev/null
+++ b/packages/app/src/context/revert-page.test.ts
@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test"
+import type { Message, Part } from "@opencode-ai/sdk/v2/client"
+import { hasVisibleUserBeforeRevert, loadRevertAwareLatestPage } from "./revert-page"
+
+const message = (id: string, role: Message["role"]): Message =>
+  role === "assistant"
+    ? ({
+        id,
+        sessionID: "ses_1",
+        role: "assistant",
+        agent: "default",
+        model: { providerID: "openai", modelID: "gpt-4" },
+        time: { created: Number(id.slice(2)) },
+      } as unknown as Message)
+    : ({
+        id,
+        sessionID: "ses_1",
+        role: "user",
+        agent: "default",
+        model: { providerID: "openai", modelID: "gpt-4" },
+        time: { created: Number(id.slice(2)) },
+      } as unknown as Message)
+
+const textPart = (id: string, messageID: string): Extract<Part, { type: "text" }> => ({
+  id,
+  sessionID: "ses_1",
+  messageID,
+  type: "text",
+  text: id,
+})
+
+describe("revert page helpers", () => {
+  test("detects when the loaded page has no visible user before revert", () => {
+    expect(hasVisibleUserBeforeRevert([message("m6", "user"), message("m7", "assistant")], "m6")).toBe(false)
+    expect(hasVisibleUserBeforeRevert([message("m5", "user"), message("m6", "user")], "m6")).toBe(true)
+  })
+
+  test("loads and merges an older boundary window when latest page is fully reverted", async () => {
+    const olderPart = textPart("p5", "m5")
+    const boundaryPart = textPart("p6", "m6")
+
+    const result = await loadRevertAwareLatestPage({
+      current: {
+        session: [message("m6", "user"), message("m7", "assistant"), message("m8", "user")],
+        part: [
+          { id: "m6", part: [boundaryPart] },
+          { id: "m7", part: [] },
+          { id: "m8", part: [] },
+        ],
+        cursor: undefined,
+        complete: true,
+      },
+      revertMessageID: "m6",
+      fetchMessage: async () => ({ info: message("m6", "user"), parts: [boundaryPart], cursor: "boundary" }),
+      fetchPage: async (before) => {
+        expect(before).toBe("boundary")
+        return {
+          session: [message("m4", "assistant"), message("m5", "user")],
+          part: [
+            { id: "m4", part: [] },
+            { id: "m5", part: [olderPart] },
+          ],
+          cursor: "older",
+          complete: false,
+        }
+      },
+    })
+
+    expect(result.session.map((item) => item.id)).toEqual(["m4", "m5", "m6", "m7", "m8"])
+    expect(result.part.find((item) => item.id === "m5")?.part).toEqual([olderPart])
+    expect(result.part.find((item) => item.id === "m6")?.part).toEqual([boundaryPart])
+    expect(result.cursor).toBe("older")
+    expect(result.complete).toBe(false)
+  })
+
+  test("keeps loading older pages until a visible user exists before revert", async () => {
+    const boundaryPart = textPart("p6", "m6")
+    const olderPart = textPart("p3", "m3")
+    let call = 0
+
+    const result = await loadRevertAwareLatestPage({
+      current: {
+        session: [message("m6", "user"), message("m7", "assistant"), message("m8", "user")],
+        part: [
+          { id: "m6", part: [boundaryPart] },
+          { id: "m7", part: [] },
+          { id: "m8", part: [] },
+        ],
+        cursor: undefined,
+        complete: true,
+      },
+      revertMessageID: "m6",
+      fetchMessage: async () => ({ info: message("m6", "user"), parts: [boundaryPart], cursor: "boundary" }),
+      fetchPage: async () => {
+        call += 1
+        if (call === 1) {
+          return {
+            session: [message("m4", "assistant"), message("m5", "assistant")],
+            part: [
+              { id: "m4", part: [] },
+              { id: "m5", part: [] },
+            ],
+            cursor: "older-2",
+            complete: false,
+          }
+        }
+        return {
+          session: [message("m3", "user")],
+          part: [{ id: "m3", part: [olderPart] }],
+          cursor: undefined,
+          complete: true,
+        }
+      },
+    })
+
+    expect(call).toBe(2)
+    expect(result.session.map((item) => item.id)).toEqual(["m3", "m4", "m5", "m6", "m7", "m8"])
+    expect(result.part.find((item) => item.id === "m3")?.part).toEqual([olderPart])
+    expect(result.cursor).toBeUndefined()
+    expect(result.complete).toBe(true)
+  })
+
+  test("marks stale revert boundaries for clearing when the boundary message is missing", async () => {
+    const result = await loadRevertAwareLatestPage({
+      current: {
+        session: [message("m7", "assistant"), message("m8", "user")],
+        part: [
+          { id: "m7", part: [] },
+          { id: "m8", part: [] },
+        ],
+        cursor: undefined,
+        complete: true,
+      },
+      revertMessageID: "m6",
+      fetchMessage: async () => undefined,
+      fetchPage: async () => ({
+        session: [],
+        part: [],
+        cursor: undefined,
+        complete: true,
+      }),
+    })
+
+    expect(result.clearedRevert).toBe(true)
+    expect(result.session.map((item) => item.id)).toEqual(["m7", "m8"])
+  })
+})
diff --git a/packages/app/src/context/revert-page.ts b/packages/app/src/context/revert-page.ts
new file mode 100644
index 000000000000..6c84c00d8b94
--- /dev/null
+++ b/packages/app/src/context/revert-page.ts
@@ -0,0 +1,77 @@
+import type { Message, Part } from "@opencode-ai/sdk/v2/client"
+
+type MessagePage = {
+  session: Message[]
+  part: { id: string; part: Part[] }[]
+  cursor?: string
+  complete: boolean
+  clearedRevert?: boolean
+}
+
+type MessageWithParts = {
+  info: Message
+  parts: Part[]
+  cursor?: string
+}
+
+const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
+export const compareMessages = (a: Message, b: Message) => a.time.created - b.time.created || cmp(a.id, b.id)
+export const messageBefore = (message: Message, boundary: Message) => compareMessages(message, boundary) < 0
+
+const sortParts = (parts: Part[]) => parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id))
+
+export function hasVisibleUserBeforeRevert(messages: Message[], revertMessageID?: string, boundary?: Message) {
+  if (!revertMessageID) return true
+  const revert = boundary ?? messages.find((message) => message.id === revertMessageID)
+  if (!revert) return messages.some((message) => message.role === "user" && message.id < revertMessageID)
+  return messages.some((message) => message.role === "user" && messageBefore(message, revert))
+}
+
+function mergeMessages(current: Message[], older: Message[], boundary: Message) {
+  const merged = new Map(current.filter((message) => !!message?.id).map((message) => [message.id, message] as const))
+  for (const message of older) {
+    if (!message?.id) continue
+    merged.set(message.id, message)
+  }
+  merged.set(boundary.id, boundary)
+  return [...merged.values()].sort(compareMessages)
+}
+
+function mergeParts(current: MessagePage["part"], older: MessagePage["part"], boundary: MessageWithParts) {
+  const merged = new Map(current.filter((item) => !!item?.id).map((item) => [item.id, sortParts(item.part)] as const))
+  for (const item of older) {
+    if (!item?.id) continue
+    merged.set(item.id, sortParts(item.part))
+  }
+  merged.set(boundary.info.id, sortParts(boundary.parts))
+  return [...merged.entries()].sort((a, b) => cmp(a[0], b[0])).map(([id, part]) => ({ id, part }))
+}
+
+export async function loadRevertAwareLatestPage(input: {
+  current: MessagePage
+  revertMessageID?: string
+  fetchMessage: (messageID: string) => Promise<MessageWithParts | undefined>
+  fetchPage: (before: string) => Promise<MessagePage>
+}) {
+  if (!input.revertMessageID) return input.current
+
+  const boundary = await input.fetchMessage(input.revertMessageID)
+  if (!boundary) return { ...input.current, clearedRevert: true }
+  if (hasVisibleUserBeforeRevert(input.current.session, input.revertMessageID, boundary.info)) return input.current
+  if (!boundary.cursor) return input.current
+
+  let older = await input.fetchPage(boundary.cursor)
+  let session = mergeMessages(input.current.session, older.session, boundary.info)
+  let part = mergeParts(input.current.part, older.part, boundary)
+  while (!hasVisibleUserBeforeRevert(session, input.revertMessageID) && older.cursor) {
+    older = await input.fetchPage(older.cursor)
+    session = mergeMessages(session, older.session, boundary.info)
+    part = mergeParts(part, older.part, boundary)
+  }
+  return {
+    session,
+    part,
+    cursor: older.cursor,
+    complete: older.complete,
+  }
+}
diff --git a/packages/app/src/context/sync.tsx b/packages/app/src/context/sync.tsx
index 34b597b6bb52..0e2e76f57a17 100644
--- a/packages/app/src/context/sync.tsx
+++ b/packages/app/src/context/sync.tsx
@@ -3,6 +3,7 @@ import { createStore, produce, reconcile } from "solid-js/store"
 import { Binary } from "@opencode-ai/core/util/binary"
 import { retry } from "@opencode-ai/core/util/retry"
 import { createSimpleContext } from "@opencode-ai/ui/context"
+import { compareMessages, hasVisibleUserBeforeRevert, loadRevertAwareLatestPage } from "./revert-page"
 import {
   clearSessionPrefetch,
   getSessionPrefetch,
@@ -17,6 +18,17 @@ import { diffs as list, message as clean } from "@/utils/diffs"
 
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
 
+function nextBefore(link: string | null) {
+  if (!link) return undefined
+  const match = /<([^>]+)>;\s*rel="prev"/.exec(link)
+  if (!match) return undefined
+  try {
+    return new URL(match[1]).searchParams.get("before") ?? undefined
+  } catch {
+    return undefined
+  }
+}
+
 function sortParts(parts: Part[]) {
   return parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id))
 }
@@ -35,10 +47,16 @@ const keyFor = (directory: string, id: string) => `${directory}\n${id}`
 
 const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
 
-function merge<T extends { id: string }>(a: readonly T[], b: readonly T[]) {
+function merge(a: readonly Message[], b: readonly Message[]) {
   const map = new Map(a.map((item) => [item.id, item] as const))
   for (const item of b) map.set(item.id, item)
-  return [...map.values()].sort((x, y) => cmp(x.id, y.id))
+  return [...map.values()].sort(compareMessages)
+}
+
+const messageIndex = (messages: readonly Message[], id: string) => messages.findIndex((message) => message.id === id)
+const messageInsertIndex = (messages: readonly Message[], message: Message) => {
+  const index = messages.findIndex((item) => compareMessages(message, item) < 0)
+  return index === -1 ? messages.length : index
 }
 
 type OptimisticStore = {
@@ -67,6 +85,7 @@ type MessagePage = {
   part: { id: string; part: Part[] }[]
   cursor?: string
   complete: boolean
+  clearedRevert?: boolean
 }
 
 const hasParts = (parts: Part[] | undefined, want: Part[]) => {
@@ -96,9 +115,9 @@ export function mergeOptimisticPage(page: MessagePage, items: OptimisticItem[])
   const confirmed: string[] = []
 
   for (const item of items) {
-    const result = Binary.search(session, item.message.id, (message) => message.id)
-    const found = result.found
-    if (!found) session.splice(result.index, 0, item.message)
+    const index = messageIndex(session, item.message.id)
+    const found = index !== -1
+    if (!found) session.splice(messageInsertIndex(session, item.message), 0, item.message)
 
     const current = part.get(item.message.id)
     if (found && hasParts(current, item.parts)) {
@@ -112,6 +131,7 @@ export function mergeOptimisticPage(page: MessagePage, items: OptimisticItem[])
   return {
     cursor: page.cursor,
     complete: page.complete,
+    clearedRevert: page.clearedRevert,
     session,
     part: [...part.entries()].sort((a, b) => cmp(a[0], b[0])).map(([id, part]) => ({ id, part })),
     confirmed,
@@ -121,8 +141,8 @@ export function mergeOptimisticPage(page: MessagePage, items: OptimisticItem[])
 export function applyOptimisticAdd(draft: OptimisticStore, input: OptimisticAddInput) {
   const messages = draft.message[input.sessionID]
   if (messages) {
-    const result = Binary.search(messages, input.message.id, (m) => m.id)
-    messages.splice(result.index, 0, input.message)
+    const index = messageIndex(messages, input.message.id)
+    if (index === -1) messages.splice(messageInsertIndex(messages, input.message), 0, input.message)
   } else {
     draft.message[input.sessionID] = [input.message]
   }
@@ -132,8 +152,8 @@ export function applyOptimisticAdd(draft: OptimisticStore, input: OptimisticAddI
 export function applyOptimisticRemove(draft: OptimisticStore, input: OptimisticRemoveInput) {
   const messages = draft.message[input.sessionID]
   if (messages) {
-    const result = Binary.search(messages, input.messageID, (m) => m.id)
-    if (result.found) messages.splice(result.index, 1)
+    const index = messageIndex(messages, input.messageID)
+    if (index !== -1) messages.splice(index, 1)
   }
   delete draft.part[input.messageID]
 }
@@ -141,9 +161,10 @@ export function applyOptimisticRemove(draft: OptimisticStore, input: OptimisticR
 function setOptimisticAdd(setStore: (...args: unknown[]) => void, input: OptimisticAddInput) {
   setStore("message", input.sessionID, (messages: Message[] | undefined) => {
     if (!messages) return [input.message]
-    const result = Binary.search(messages, input.message.id, (m) => m.id)
+    const index = messageIndex(messages, input.message.id)
+    if (index !== -1) return messages
     const next = [...messages]
-    next.splice(result.index, 0, input.message)
+    next.splice(messageInsertIndex(next, input.message), 0, input.message)
     return next
   })
   setStore("part", input.message.id, sortParts(input.parts))
@@ -152,10 +173,10 @@ function setOptimisticAdd(setStore: (...args: unknown[]) => void, input: Optimis
 function setOptimisticRemove(setStore: (...args: unknown[]) => void, input: OptimisticRemoveInput) {
   setStore("message", input.sessionID, (messages: Message[] | undefined) => {
     if (!messages) return messages
-    const result = Binary.search(messages, input.messageID, (m) => m.id)
-    if (!result.found) return messages
+    const index = messageIndex(messages, input.messageID)
+    if (index === -1) return messages
     const next = [...messages]
-    next.splice(result.index, 1)
+    next.splice(index, 1)
     return next
   })
   setStore("part", (part: Record<string, Part[] | undefined>) => {
@@ -296,20 +317,39 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       sessionID: string
       limit: number
       before?: string
+      revertMessageID?: string
     }) => {
+      const toPage = (messages: Awaited<ReturnType<typeof input.client.session.messages>>) => {
+        const items = (messages.data ?? []).filter((x) => !!x?.info?.id)
+        const session = items.map((x) => clean(x.info)).sort(compareMessages)
+        const part = items.map((message) => ({ id: message.info.id, part: sortParts(message.parts) }))
+        const cursor = nextBefore(messages.response.headers.get("Link"))
+        return {
+          session,
+          part,
+          cursor,
+          complete: !cursor,
+        }
+      }
+
       const messages = await retry(() =>
         input.client.session.messages({ sessionID: input.sessionID, limit: input.limit, before: input.before }),
       )
-      const items = (messages.data ?? []).filter((x) => !!x?.info?.id)
-      const session = items.map((x) => clean(x.info)).sort((a, b) => cmp(a.id, b.id))
-      const part = items.map((message) => ({ id: message.info.id, part: sortParts(message.parts) }))
-      const cursor = messages.response.headers.get("x-next-cursor") ?? undefined
-      return {
-        session,
-        part,
-        cursor,
-        complete: !cursor,
-      }
+      const page = toPage(messages)
+      if (input.before) return page
+      return loadRevertAwareLatestPage({
+        current: page,
+        revertMessageID: input.revertMessageID,
+        fetchMessage: (messageID) =>
+          retry(() => input.client.session.message({ sessionID: input.sessionID, messageID })).then((result) => {
+            if (!result.data?.info?.id) return undefined
+            return { info: clean(result.data.info), parts: sortParts(result.data.parts), cursor: result.data.cursor }
+          }),
+        fetchPage: (before) =>
+          retry(() => input.client.session.messages({ sessionID: input.sessionID, limit: input.limit, before })).then(
+            toPage,
+          ),
+      })
     }
 
     const tracked = (directory: string, sessionID: string) => seen.get(directory)?.has(sessionID) ?? false
@@ -321,6 +361,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       sessionID: string
       limit: number
       before?: string
+      revertMessageID?: string
       mode?: "replace" | "prepend"
     }) => {
       const key = keyFor(input.directory, input.sessionID)
@@ -343,6 +384,16 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
               const filtered = p.part.filter((x) => !SKIP_PARTS.has(x.type))
               if (filtered.length) input.setStore("part", p.id, filtered)
             }
+            if (next.clearedRevert) {
+              input.setStore(
+                "session",
+                produce((draft) => {
+                  const match = Binary.search(draft, input.sessionID, (s) => s.id)
+                  if (!match.found) return
+                  draft[match.index] = { ...draft[match.index], revert: undefined }
+                }),
+              )
+            }
             setMeta("limit", key, message.length)
             setMeta("cursor", key, next.cursor)
             setMeta("complete", key, next.complete)
@@ -460,18 +511,24 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
               }
             }
 
-            const hasSession = Binary.search(store.session, sessionID, (s) => s.id).found
+            const sessionMatch = Binary.search(store.session, sessionID, (s) => s.id)
+            const sessionInfo = sessionMatch.found ? store.session[sessionMatch.index] : undefined
             const cached = store.message[sessionID] !== undefined && meta.limit[key] !== undefined
-            if (cached && hasSession && !opts?.force) return
+            const canReuseCached = !!(
+              cached &&
+              sessionInfo &&
+              hasVisibleUserBeforeRevert(store.message[sessionID] ?? [], sessionInfo.revert?.messageID)
+            )
+            if (canReuseCached && !opts?.force) return
 
             const limit = meta.limit[key] ?? initialMessagePageSize
-            const sessionReq =
-              hasSession && !opts?.force
-                ? Promise.resolve()
-                : retry(() => client.session.get({ sessionID })).then((session) => {
-                    if (!tracked(directory, sessionID)) return
+            const nextSession =
+              sessionInfo && !opts?.force
+                ? sessionInfo
+                : await retry(() => client.session.get({ sessionID })).then((session) => {
+                    if (!tracked(directory, sessionID)) return undefined
                     const data = session.data
-                    if (!data) return
+                    if (!data) return undefined
                     setStore(
                       "session",
                       produce((draft) => {
@@ -483,10 +540,11 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
                         draft.splice(match.index, 0, data)
                       }),
                     )
+                    return data
                   })
 
             const messagesReq =
-              cached && !opts?.force
+              canReuseCached && !opts?.force
                 ? Promise.resolve()
                 : loadMessages({
                     directory,
@@ -494,9 +552,10 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
                     setStore,
                     sessionID,
                     limit,
+                    revertMessageID: nextSession?.revert?.messageID,
                   })
 
-            await Promise.all([sessionReq, messagesReq])
+            await messagesReq
           })
         },
         async diff(sessionID: string, opts?: { force?: boolean }) {
diff --git a/packages/app/src/pages/layout.tsx b/packages/app/src/pages/layout.tsx
index 7e9e2d32aaba..46fcaa345d1f 100644
--- a/packages/app/src/pages/layout.tsx
+++ b/packages/app/src/pages/layout.tsx
@@ -16,6 +16,7 @@ import { makeEventListener } from "@solid-primitives/event-listener"
 import { useLocation, useNavigate, useParams } from "@solidjs/router"
 import { useLayout, LocalProject } from "@/context/layout"
 import { useGlobalSync } from "@/context/global-sync"
+import { compareMessages } from "@/context/revert-page"
 import { Persist, persisted } from "@/utils/persist"
 import { base64Encode } from "@opencode-ai/core/util/encode"
 import { decode64 } from "@/utils/base64"
@@ -675,6 +676,17 @@ export default function Layout(props: ParentProps) {
     running: number
   }
 
+  function nextBefore(link: string | null) {
+    if (!link) return undefined
+    const match = /<([^>]+)>;\s*rel="prev"/.exec(link)
+    if (!match) return undefined
+    try {
+      return new URL(match[1]).searchParams.get("before") ?? undefined
+    } catch {
+      return undefined
+    }
+  }
+
   const prefetchChunk = 200
   const prefetchConcurrency = 2
   const prefetchPendingLimit = 10
@@ -759,6 +771,15 @@ export default function Layout(props: ParentProps) {
     return [...map.values()].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
   }
 
+  const mergeMessages = (current: Message[], incoming: Message[]) => {
+    if (current.length === 0) return incoming.slice().sort(compareMessages)
+
+    const map = new Map<string, Message>()
+    for (const item of current) map.set(item.id, item)
+    for (const item of incoming) map.set(item.id, item)
+    return [...map.values()].sort(compareMessages)
+  }
+
   async function prefetchMessages(directory: string, sessionID: string, token: number) {
     const [store, setStore] = globalSync.child(directory, { bootstrap: false })
 
@@ -773,9 +794,9 @@ export default function Layout(props: ParentProps) {
 
             const items = (messages.data ?? []).filter((x) => !!x?.info?.id)
             const next = items.map((x) => x.info).filter((m): m is Message => !!m?.id)
-            const sorted = mergeByID([], next)
+            const sorted = mergeMessages([], next)
             const stale = markPrefetched(directory, sessionID)
-            const cursor = messages.response.headers.get("x-next-cursor") ?? undefined
+            const cursor = nextBefore(messages.response.headers.get("Link"))
             const meta = {
               limit: sorted.length,
               cursor,
@@ -791,7 +812,7 @@ export default function Layout(props: ParentProps) {
             }
 
             const current = store.message[sessionID] ?? []
-            const merged = mergeByID(
+            const merged = mergeMessages(
               current.filter((item): item is Message => !!item?.id),
               sorted,
             )
diff --git a/packages/app/src/pages/session.tsx b/packages/app/src/pages/session.tsx
index 1345e355eb25..7d93e27ed30c 100644
--- a/packages/app/src/pages/session.tsx
+++ b/packages/app/src/pages/session.tsx
@@ -10,10 +10,11 @@ import {
   createMemo,
   createEffect,
   createComputed,
+  createSignal,
+  createResource,
   on,
   onMount,
   untrack,
-  createResource,
 } from "solid-js"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { createMediaQuery } from "@solid-primitives/media"
@@ -40,6 +41,7 @@ import { usePrompt } from "@/context/prompt"
 import { useSDK } from "@/context/sdk"
 import { useSettings } from "@/context/settings"
 import { useSync } from "@/context/sync"
+import { messageBefore } from "@/context/revert-page"
 import { useTerminal } from "@/context/terminal"
 import { type FollowupDraft, sendFollowupDraft } from "@/components/prompt-input/submit"
 import { createSessionComposerState, SessionComposerRegion } from "@/pages/session/composer"
@@ -68,6 +70,11 @@ import { formatServerError } from "@/utils/server-errors"
 const emptyUserMessages: UserMessage[] = []
 type FollowupItem = FollowupDraft & { id: string }
 type FollowupEdit = Pick<FollowupItem, "id" | "prompt" | "context">
+type RevertPreview = {
+  userCount: number
+  nextMessageID?: string
+  items: { id: string; text: string }[]
+}
 const emptyFollowups: FollowupItem[] = []
 
 type ChangeMode = "git" | "branch" | "turn"
@@ -471,7 +478,9 @@ export default function Page() {
     () => {
       const revert = revertMessageID()
       if (!revert) return userMessages()
-      return userMessages().filter((m) => m.id < revert)
+      const boundary = messages().find((m) => m.id === revert)
+      if (!boundary) return userMessages().filter((m) => m.id < revert)
+      return userMessages().filter((m) => messageBefore(m, boundary))
     },
     emptyUserMessages,
     {
@@ -511,6 +520,19 @@ export default function Page() {
     ),
   )
 
+  createEffect(
+    on(
+      () => [params.id, revertMessageID()] as const,
+      ([id, revert], prev) => {
+        if (!id) return
+        if (prev && prev[0] === id && prev[1] === revert) return
+        if (!prev) return
+        void sync.session.sync(id, { force: true })
+      },
+      { defer: true },
+    ),
+  )
+
   const [store, setStore] = createStore({
     messageId: undefined as string | undefined,
     mobileTab: "session" as "session" | "changes",
@@ -788,6 +810,24 @@ export default function Page() {
     },
   )
 
+  const [revertPreview, setRevertPreview] = createSignal<RevertPreview>()
+  let revertPreviewEpoch = 0
+  createEffect(
+    on(
+      () => [params.id, revertMessageID()] as const,
+      ([sessionID, revert]) => {
+        const epoch = ++revertPreviewEpoch
+        setRevertPreview(undefined)
+        if (!sessionID || !revert) return
+        void sdk.client.session.revertPreview({ sessionID }).then((result) => {
+          if (epoch !== revertPreviewEpoch) return
+          setRevertPreview(result.data ?? undefined)
+        })
+      },
+      { defer: true },
+    ),
+  )
+
   createEffect(
     on(
       () => {
@@ -1037,6 +1077,7 @@ export default function Page() {
     setActiveMessage,
     focusInput,
     review: reviewTab,
+    nextRevertMessageID: () => revertPreview()?.nextMessageID,
   })
 
   const openReviewFile = createOpenReviewFile({
@@ -1460,6 +1501,21 @@ export default function Page() {
       attachmentName: language.t("common.attachment"),
     })
 
+  const loadPromptDraft = async (sessionID: string, id: string) => {
+    const parts = sync.data.part[id]
+    if (parts) {
+      return extractPromptFromParts(parts, {
+        directory: sdk.directory,
+        attachmentName: language.t("common.attachment"),
+      })
+    }
+    const result = await sdk.client.session.message({ sessionID, messageID: id })
+    return extractPromptFromParts(result.data?.parts ?? [], {
+      directory: sdk.directory,
+      attachmentName: language.t("common.attachment"),
+    })
+  }
+
   const line = (id: string) => {
     const text = draft(id)
       .map((part) => (part.type === "image" ? `[image:${part.filename}]` : part.content))
@@ -1487,15 +1543,6 @@ export default function Page() {
       return out
     })
 
-  const roll = (sessionID: string, next: NonNullable<ReturnType<typeof info>>["revert"]) =>
-    sync.set("session", (list) => {
-      const idx = list.findIndex((item) => item.id === sessionID)
-      if (idx < 0) return list
-      const out = list.slice()
-      out[idx] = { ...out[idx], revert: next }
-      return out
-    })
-
   const busy = (sessionID: string) => {
     if ((sync.data.session_status[sessionID] ?? { type: "idle" as const }).type !== "idle") return true
     return (sync.data.message[sessionID] ?? []).some(
@@ -1623,22 +1670,15 @@ export default function Page() {
   const revertMutation = useMutation(() => ({
     mutationFn: async (input: { sessionID: string; messageID: string }) => {
       const prev = prompt.current().slice()
-      const last = info()?.revert
       const value = draft(input.messageID)
-      batch(() => {
-        roll(input.sessionID, { messageID: input.messageID })
-        prompt.set(value)
-      })
+      prompt.set(value)
       await halt(input.sessionID)
         .then(() => sdk.client.session.revert(input))
         .then((result) => {
           if (result.data) merge(result.data)
         })
         .catch((err) => {
-          batch(() => {
-            roll(input.sessionID, last)
-            prompt.set(prev)
-          })
+          prompt.set(prev)
           fail(err)
         })
     },
@@ -1649,25 +1689,31 @@ export default function Page() {
       const sessionID = params.id
       if (!sessionID) return
 
-      const next = userMessages().find((item) => item.id > id)
+      const preview =
+        revertPreview() ??
+        (await sdk.client.session.revertPreview({ sessionID }).then((result) => result.data ?? undefined))
+      if (info()?.revert?.messageID && !preview) throw new Error("Failed to load revert preview")
+
+      const next = (() => {
+        const items = preview?.items
+        if (!items) return undefined
+        const index = items.findIndex((item) => item.id === id)
+        if (index === -1) throw new Error("Restore target missing from revert preview")
+        return items[index + 1]?.id
+      })()
       const prev = prompt.current().slice()
-      const last = info()?.revert
+      const nextDraft = next ? await loadPromptDraft(sessionID, next).catch(() => undefined) : undefined
+      if (next && !nextDraft) throw new Error("Failed to load next restore draft")
 
-      batch(() => {
-        roll(sessionID, next ? { messageID: next.id } : undefined)
-        if (next) {
-          prompt.set(draft(next.id))
-          return
-        }
-        prompt.reset()
-      })
+      if (next) prompt.set(nextDraft ?? [])
+      else prompt.reset()
 
       const task = !next
         ? halt(sessionID).then(() => sdk.client.session.unrevert({ sessionID }))
         : halt(sessionID).then(() =>
             sdk.client.session.revert({
               sessionID,
-              messageID: next.id,
+              messageID: next,
             }),
           )
 
@@ -1676,10 +1722,7 @@ export default function Page() {
           if (result.data) merge(result.data)
         })
         .catch((err) => {
-          batch(() => {
-            roll(sessionID, last)
-            prompt.set(prev)
-          })
+          prompt.set(prev)
           fail(err)
         })
     },
@@ -1699,10 +1742,13 @@ export default function Page() {
   }
 
   const rolled = createMemo(() => {
+    const items = revertPreview()?.items
+    if (items) return items
     const id = revertMessageID()
     if (!id) return []
+    const boundary = messages().find((item) => item.id === id)
     return userMessages()
-      .filter((item) => item.id >= id)
+      .filter((item) => (boundary ? !messageBefore(item, boundary) : item.id >= id))
       .map((item) => ({ id: item.id, text: line(item.id) }))
   })
 
diff --git a/packages/app/src/pages/session/use-session-commands.tsx b/packages/app/src/pages/session/use-session-commands.tsx
index 922299bec198..b848083be5eb 100644
--- a/packages/app/src/pages/session/use-session-commands.tsx
+++ b/packages/app/src/pages/session/use-session-commands.tsx
@@ -12,6 +12,7 @@ import { usePrompt } from "@/context/prompt"
 import { useSDK } from "@/context/sdk"
 import { useSettings } from "@/context/settings"
 import { useSync } from "@/context/sync"
+import { messageBefore } from "@/context/revert-page"
 import { useTerminal } from "@/context/terminal"
 import { showToast } from "@opencode-ai/ui/toast"
 import { findLast } from "@opencode-ai/core/util/array"
@@ -25,6 +26,7 @@ export type SessionCommandContext = {
   setActiveMessage: (message: UserMessage | undefined) => void
   focusInput: () => void
   review?: () => boolean
+  nextRevertMessageID: () => string | undefined
 }
 
 const withCategory = (category: string) => {
@@ -83,10 +85,15 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     return sync.data.message[id] ?? []
   }
   const userMessages = () => messages().filter((m) => m.role === "user") as UserMessage[]
+  const beforeMessage = (message: UserMessage, boundaryID: string) => {
+    const boundary = messages().find((item) => item.id === boundaryID)
+    if (!boundary) return message.id < boundaryID
+    return messageBefore(message, boundary)
+  }
   const visibleUserMessages = () => {
     const revert = info()?.revert?.messageID
     if (!revert) return userMessages()
-    return userMessages().filter((m) => m.id < revert)
+    return userMessages().filter((m) => beforeMessage(m, revert))
   }
 
   const showAllFiles = () => {
@@ -295,7 +302,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     }
 
     const revert = info()?.revert?.messageID
-    const message = findLast(userMessages(), (x) => !revert || x.id < revert)
+    const message = findLast(userMessages(), (x) => !revert || beforeMessage(x, revert))
     if (!message) return
 
     await sdk.client.session.revert({ sessionID, messageID: message.id })
@@ -305,7 +312,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
       prompt.set(restored)
     }
 
-    const prev = findLast(userMessages(), (x) => x.id < message.id)
+    const prev = findLast(userMessages(), (x) => beforeMessage(x, message.id))
     setActiveMessage(prev)
   }
 
@@ -316,17 +323,22 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     const revertMessageID = info()?.revert?.messageID
     if (!revertMessageID) return
 
-    const next = userMessages().find((x) => x.id > revertMessageID)
-    if (!next) {
+    const preview =
+      actions.nextRevertMessageID() !== undefined
+        ? { nextMessageID: actions.nextRevertMessageID() }
+        : await sdk.client.session.revertPreview({ sessionID }).then((result) => result.data ?? undefined)
+    const nextMessageID = preview?.nextMessageID
+    if (!preview && revertMessageID) return
+    if (!nextMessageID) {
       await sdk.client.session.unrevert({ sessionID })
       prompt.reset()
-      const last = findLast(userMessages(), (x) => x.id >= revertMessageID)
+      const last = findLast(userMessages(), (x) => !beforeMessage(x, revertMessageID))
       setActiveMessage(last)
       return
     }
 
-    await sdk.client.session.revert({ sessionID, messageID: next.id })
-    const prev = findLast(userMessages(), (x) => x.id < next.id)
+    await sdk.client.session.revert({ sessionID, messageID: nextMessageID })
+    const prev = findLast(userMessages(), (x) => beforeMessage(x, nextMessageID))
     setActiveMessage(prev)
   }
 
diff --git a/packages/opencode/src/cli/cmd/tui/context/keybind.tsx b/packages/opencode/src/cli/cmd/tui/context/keybind.tsx
index 2c1ab245a50c..08614727a456 100644
--- a/packages/opencode/src/cli/cmd/tui/context/keybind.tsx
+++ b/packages/opencode/src/cli/cmd/tui/context/keybind.tsx
@@ -16,8 +16,8 @@ export const { use: useKeybind, provider: KeybindProvider } = createSimpleContex
     const config = useTuiConfig()
     const keybinds = createMemo<Record<string, Keybind.Info[]>>(() => {
       return pipe(
-        (config.keybinds ?? {}) as Record<string, string>,
-        mapValues((value) => Keybind.parse(value)),
+        config.keybinds ?? {},
+        mapValues((value) => (typeof value === "string" ? Keybind.parse(value) : [])),
       )
     })
     const [store, setStore] = createStore({
diff --git a/packages/opencode/src/cli/cmd/tui/context/sync.tsx b/packages/opencode/src/cli/cmd/tui/context/sync.tsx
index 24609dd81e4f..52f949f8707f 100644
--- a/packages/opencode/src/cli/cmd/tui/context/sync.tsx
+++ b/packages/opencode/src/cli/cmd/tui/context/sync.tsx
@@ -27,11 +27,27 @@ import { createSimpleContext } from "./helper"
 import type { Snapshot } from "@/snapshot"
 import { useExit } from "./exit"
 import { useArgs } from "./args"
-import { batch, onMount } from "solid-js"
+import { batch, createEffect, on, onMount } from "solid-js"
 import * as Log from "@opencode-ai/core/util/log"
+import type { Path } from "@opencode-ai/sdk"
+import type { Workspace } from "@opencode-ai/sdk/v2"
 import { emptyConsoleState, type ConsoleState } from "@/config/console-state"
 import path from "path"
 import { useKV } from "./kv"
+import { linkParam, parseLinkHeader } from "@/util/link-header"
+import {
+  evictFromEnd,
+  evictFromStart,
+  hasUserBeforeBoundary,
+  messageBefore,
+  messageInsert,
+  paginationError,
+  windowNewest,
+  windowOldest,
+} from "@tui/util/pagination"
+
+/** Maximum messages kept in memory per session */
+const MAX_LOADED_MESSAGES = 500
 
 export const { use: useSync, provider: SyncProvider } = createSimpleContext({
   name: "Sync",
@@ -53,6 +69,19 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       }
       config: Config
       session: Session[]
+      message_page: {
+        [sessionID: string]: {
+          hasOlder: boolean
+          hasNewer: boolean
+          loading: boolean
+          loadingDirection?: "older" | "newer"
+          oldest?: string
+          newest?: string
+          olderCursor?: string
+          newerCursor?: string
+          error?: string
+        }
+      }
       session_status: {
         [sessionID: string]: SessionStatus
       }
@@ -65,6 +94,9 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       message: {
         [sessionID: string]: Message[]
       }
+      message_cursor: {
+        [messageID: string]: string | undefined
+      }
       part: {
         [messageID: string]: Part[]
       }
@@ -94,10 +126,12 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       provider: [],
       provider_default: {},
       session: [],
+      message_page: {},
       session_status: {},
       session_diff: {},
       todo: {},
       message: {},
+      message_cursor: {},
       part: {},
       lsp: [],
       mcp: {},
@@ -111,7 +145,181 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
     const sdk = useSDK()
     const kv = useKV()
 
+    const getRevertMarker = (sessionID: string) => {
+      const match = Binary.search(store.session, sessionID, (s) => s.id)
+      if (!match.found) return undefined
+      return store.session[match.index].revert?.messageID
+    }
+
+    const pageInfo = (link: string) => {
+      const links = parseLinkHeader(link)
+      return {
+        hasOlder: links.prev !== undefined,
+        hasNewer: links.next !== undefined,
+        olderCursor: linkParam(links.prev, "before"),
+        newerCursor: linkParam(links.next, "after"),
+      }
+    }
+
+    const edgeCursor = (cursors: Record<string, string | undefined>, id: string | undefined) =>
+      id ? cursors[id] : undefined
+
+    const errorStatus = (error: unknown) => {
+      if (!error || typeof error !== "object") return undefined
+      const status = Reflect.get(error, "status")
+      return typeof status === "number" ? status : undefined
+    }
+
+    const clearRevert = (sessionID: string) => {
+      setStore(
+        "session",
+        produce((draft) => {
+          const match = Binary.search(draft, sessionID, (s) => s.id)
+          if (!match.found) return
+          draft[match.index] = { ...draft[match.index], revert: undefined }
+        }),
+      )
+    }
+
+    const messageIndex = (messages: Message[] | undefined, id: string) =>
+      messages?.findIndex((item) => item.id === id) ?? -1
+
+    type LoadedMessage = {
+      info: Message
+      parts: Part[]
+      cursor?: string
+    }
+
+    type LoadedPage = ReturnType<typeof pageInfo> & {
+      items: LoadedMessage[]
+      oldest?: string
+      newest?: string
+      clearedRevert?: boolean
+    }
+
+    const insertLoadedMessage = (items: LoadedMessage[], message: LoadedMessage) => {
+      const result = messageInsert(
+        items.map((item) => item.info),
+        message.info,
+      )
+      if (!result.found) items.splice(result.index, 0, message)
+    }
+
+    const loadLatestPage = async (sessionID: string, revertMessageID?: string): Promise<LoadedPage> => {
+      const latest = await sdk.client.session.messages({ sessionID, limit: 100 }, { throwOnError: true })
+      const latestItems = [...(latest.data ?? [])]
+      const latestPage = pageInfo(latest.response.headers.get("link") ?? "")
+      const latestOldest = latestItems.at(0)?.info.id
+      const latestNewest = latestItems.at(-1)?.info.id
+      if (!revertMessageID) {
+        return {
+          items: latestItems,
+          oldest: latestOldest,
+          newest: latestNewest,
+          ...latestPage,
+        }
+      }
+
+      try {
+        const revert = await sdk.client.session.message(
+          { sessionID, messageID: revertMessageID },
+          { throwOnError: true },
+        )
+        const boundary = revert.data
+        if (!boundary) {
+          return {
+            items: latestItems,
+            oldest: latestOldest,
+            newest: latestNewest,
+            ...latestPage,
+          }
+        }
+
+        if (
+          hasUserBeforeBoundary(
+            latestItems.map((item) => item.info),
+            boundary.info,
+          )
+        ) {
+          insertLoadedMessage(latestItems, boundary)
+          return {
+            items: latestItems,
+            oldest: latestItems.at(0)?.info.id,
+            newest: latestNewest ?? latestItems.at(-1)?.info.id,
+            ...latestPage,
+          }
+        }
+
+        let olderCursor = boundary.cursor
+        if (!olderCursor)
+          return {
+            items: latestItems,
+            oldest: latestOldest,
+            newest: latestNewest,
+            ...latestPage,
+          }
+        let olderPage = latestPage
+        let oldestLoaded = boundary.info.id
+        do {
+          const older = await sdk.client.session.messages(
+            {
+              sessionID,
+              before: olderCursor,
+              limit: 100,
+            },
+            { throwOnError: true },
+          )
+          const olderItems = older.data ?? []
+          olderPage = pageInfo(older.response.headers.get("link") ?? "")
+          oldestLoaded = olderItems.at(0)?.info.id ?? oldestLoaded
+          for (const message of olderItems) {
+            insertLoadedMessage(latestItems, message)
+          }
+          olderCursor = olderPage.olderCursor ?? ""
+        } while (
+          olderCursor &&
+          !hasUserBeforeBoundary(
+            latestItems.map((item) => item.info),
+            boundary.info,
+          )
+        )
+        insertLoadedMessage(latestItems, boundary)
+        return {
+          items: latestItems,
+          hasOlder: olderPage.hasOlder,
+          hasNewer: olderPage.hasNewer || latestPage.hasNewer,
+          olderCursor: olderPage.olderCursor,
+          newerCursor: olderPage.newerCursor ?? latestPage.newerCursor,
+          oldest: oldestLoaded,
+          newest: latestNewest ?? latestItems.at(-1)?.info.id,
+        }
+      } catch (e) {
+        Log.Default.info("Revert marker fetch failed during latest-page load", {
+          messageID: revertMessageID,
+          error: e,
+        })
+        if (errorStatus(e) === 404) {
+          clearRevert(sessionID)
+          return {
+            items: latestItems,
+            oldest: latestOldest,
+            newest: latestNewest,
+            clearedRevert: true,
+            ...latestPage,
+          }
+        }
+        return {
+          items: latestItems,
+          oldest: latestOldest,
+          newest: latestNewest,
+          ...latestPage,
+        }
+      }
+    }
+
     const fullSyncedSessions = new Set<string>()
+    const loadingGuard = new Set<string>()
+    let syncEpoch = 0
     let syncedWorkspace = project.workspace.current()
 
     function sessionListQuery(): { scope?: "project"; path?: string } {
@@ -133,7 +341,25 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
     event.subscribe((event) => {
       switch (event.type) {
         case "server.instance.disposed":
-          void bootstrap()
+          const synced = [...fullSyncedSessions]
+          syncEpoch += 1
+          fullSyncedSessions.clear()
+          loadingGuard.clear()
+          setStore(
+            produce((draft) => {
+              for (const sessionID of synced) {
+                for (const msg of draft.message[sessionID] ?? []) {
+                  delete draft.part[msg.id]
+                  delete draft.message_cursor[msg.id]
+                }
+                delete draft.message[sessionID]
+                delete draft.message_page[sessionID]
+                delete draft.todo[sessionID]
+                delete draft.session_diff[sessionID]
+              }
+            }),
+          )
+          void bootstrap().then(() => Promise.allSettled(synced.map((sessionID) => result.session.sync(sessionID))))
           break
         case "permission.replied": {
           const requests = store.permission[event.properties.sessionID]
@@ -231,15 +457,22 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           break
         }
         case "session.updated": {
-          const result = Binary.search(store.session, event.properties.info.id, (s) => s.id)
-          if (result.found) {
-            setStore("session", result.index, reconcile(event.properties.info))
+          const info = event.properties.info
+          const match = Binary.search(store.session, info.id, (s) => s.id)
+          const previous = match.found ? store.session[match.index] : undefined
+          const revertChanged =
+            previous?.revert?.messageID !== info.revert?.messageID || previous?.revert?.partID !== info.revert?.partID
+          if (match.found) {
+            setStore("session", match.index, reconcile(info))
+            if (revertChanged && store.message[info.id]) {
+              void result.session.jumpToLatest(info.id, { force: true })
+            }
             break
           }
           setStore(
             "session",
             produce((draft) => {
-              draft.splice(result.index, 0, event.properties.info)
+              draft.splice(match.index, 0, info)
             }),
           )
           break
@@ -251,59 +484,137 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
         }
 
         case "message.updated": {
-          const messages = store.message[event.properties.info.sessionID]
+          const sessionID = event.properties.info.sessionID
+          const page = store.message_page[sessionID]
+          const messages = store.message[sessionID]
+          const pinned = getRevertMarker(sessionID)
           if (!messages) {
-            setStore("message", event.properties.info.sessionID, [event.properties.info])
+            setStore("message", sessionID, [event.properties.info])
             break
           }
-          const result = Binary.search(messages, event.properties.info.id, (m) => m.id)
-          if (result.found) {
-            setStore("message", event.properties.info.sessionID, result.index, reconcile(event.properties.info))
+          const current = messageIndex(messages, event.properties.info.id)
+          if (current !== -1) {
+            setStore("message", sessionID, current, reconcile(event.properties.info))
             break
           }
+          const loadingNewer = page?.loading && page.loadingDirection === "newer"
+          const loadingOlder = page?.loading && page.loadingDirection === "older"
+          if (page?.hasNewer && !loadingNewer) {
+            break
+          }
+          const oldest = page?.oldest ? messages.find((item) => item.id === page.oldest) : undefined
+          if (oldest && messageBefore(event.properties.info, oldest) && !loadingOlder) {
+            break
+          }
+          const result = messageInsert(messages, event.properties.info)
+          const preview = [...messages]
+          preview.splice(result.index, 0, event.properties.info)
           setStore(
             "message",
-            event.properties.info.sessionID,
+            sessionID,
             produce((draft) => {
               draft.splice(result.index, 0, event.properties.info)
             }),
           )
-          const updated = store.message[event.properties.info.sessionID]
-          if (updated.length > 100) {
-            const oldest = updated[0]
+          if (page) {
+            const nextOldest = windowOldest(preview, pinned) ?? page.oldest
+            const nextNewest = windowNewest(preview, pinned) ?? page.newest
+            setStore("message_page", event.properties.info.sessionID, {
+              ...page,
+              newest: nextNewest,
+              oldest: nextOldest,
+            })
+          }
+          if (preview.length > MAX_LOADED_MESSAGES) {
+            const evictCount = preview.length - MAX_LOADED_MESSAGES
+            const trimmed = [...preview]
+            const evicted = evictFromStart(trimmed, evictCount, pinned)
+            const nextOldest = windowOldest(trimmed, pinned) ?? page?.oldest
+            const nextNewest = windowNewest(trimmed, pinned) ?? page?.newest
             batch(() => {
               setStore(
                 "message",
                 event.properties.info.sessionID,
                 produce((draft) => {
-                  draft.shift()
+                  evictFromStart(draft, evictCount, pinned)
                 }),
               )
               setStore(
                 "part",
                 produce((draft) => {
-                  delete draft[oldest.id]
+                  for (const msg of evicted) {
+                    delete draft[msg.id]
+                  }
                 }),
               )
+              setStore(
+                "message_cursor",
+                produce((draft) => {
+                  for (const msg of evicted) {
+                    delete draft[msg.id]
+                  }
+                }),
+              )
+              if (page) {
+                setStore("message_page", event.properties.info.sessionID, {
+                  ...page,
+                  hasOlder: true,
+                  oldest: nextOldest,
+                  newest: nextNewest,
+                  olderCursor: edgeCursor(store.message_cursor, nextOldest),
+                })
+              }
             })
           }
           break
         }
         case "message.removed": {
           const messages = store.message[event.properties.sessionID]
-          const result = Binary.search(messages, event.properties.messageID, (m) => m.id)
-          if (result.found) {
+          const page = store.message_page[event.properties.sessionID]
+          const pinned = getRevertMarker(event.properties.sessionID)
+          const index = messageIndex(messages, event.properties.messageID)
+          if (index !== -1) {
+            const preview = [...messages]
+            preview.splice(index, 1)
+            const nextOldest = windowOldest(preview, pinned) ?? preview.at(0)?.id
+            const nextNewest = windowNewest(preview, pinned) ?? preview.at(-1)?.id
+            const onlyPinned = preview.length === 1 && preview[0]?.id === pinned
             setStore(
-              "message",
-              event.properties.sessionID,
               produce((draft) => {
-                draft.splice(result.index, 1)
+                draft.message[event.properties.sessionID]?.splice(index, 1)
+                delete draft.part[event.properties.messageID]
+                delete draft.message_cursor[event.properties.messageID]
+                if (page) {
+                  draft.message_page[event.properties.sessionID] = {
+                    ...page,
+                    oldest: nextOldest,
+                    newest: nextNewest,
+                    olderCursor: page.hasOlder
+                      ? preview.length > 0 && !onlyPinned
+                        ? edgeCursor(draft.message_cursor, nextOldest)
+                        : page.olderCursor
+                      : undefined,
+                    newerCursor: page.hasNewer
+                      ? preview.length > 0 && !onlyPinned
+                        ? edgeCursor(draft.message_cursor, nextNewest)
+                        : page.newerCursor
+                      : undefined,
+                  }
+                }
               }),
             )
           }
           break
         }
         case "message.part.updated": {
+          const sessionID = event.properties.part.sessionID
+          const page = store.message_page[sessionID]
+          const messages = store.message[sessionID]
+          const messageExists = messages?.some((m) => m.id === event.properties.part.messageID)
+          const loadingNewer = page?.loading && page.loadingDirection === "newer"
+          if (!messageExists && !loadingNewer) {
+            break
+          }
           const parts = store.part[event.properties.part.messageID]
           if (!parts) {
             setStore("part", event.properties.part.messageID, [event.properties.part])
@@ -460,7 +771,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
         })
         .catch(async (e) => {
           Log.Default.error("tui bootstrap failed", {
-            error: e instanceof Error ? e.message : String(e),
+            error: paginationError(e),
             name: e instanceof Error ? e.name : undefined,
             stack: e instanceof Error ? e.stack : undefined,
           })
@@ -514,27 +825,372 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
         },
         async sync(sessionID: string) {
           if (fullSyncedSessions.has(sessionID)) return
-          const [session, messages, todo, diff] = await Promise.all([
+          const epoch = syncEpoch
+          const [session, todo, diff] = await Promise.all([
             sdk.client.session.get({ sessionID }, { throwOnError: true }),
-            sdk.client.session.messages({ sessionID, limit: 100 }),
             sdk.client.session.todo({ sessionID }),
             sdk.client.session.diff({ sessionID }),
           ])
+          if (epoch !== syncEpoch) return
+          let sessionInfo = session.data!
+          const page = await loadLatestPage(sessionID, sessionInfo.revert?.messageID)
+          if (epoch !== syncEpoch) return
+          if (page.clearedRevert) sessionInfo = { ...sessionInfo, revert: undefined }
           setStore(
             produce((draft) => {
               const match = Binary.search(draft.session, sessionID, (s) => s.id)
-              if (match.found) draft.session[match.index] = session.data!
-              if (!match.found) draft.session.splice(match.index, 0, session.data!)
+              if (match.found) draft.session[match.index] = sessionInfo
+              if (!match.found) draft.session.splice(match.index, 0, sessionInfo)
               draft.todo[sessionID] = todo.data ?? []
-              draft.message[sessionID] = messages.data!.map((x) => x.info)
-              for (const message of messages.data!) {
+              draft.message[sessionID] = page.items.map((x) => x.info)
+              for (const message of page.items) {
                 draft.part[message.info.id] = message.parts
+                draft.message_cursor[message.info.id] = message.cursor
               }
               draft.session_diff[sessionID] = diff.data ?? []
+              draft.message_page[sessionID] = {
+                hasOlder: page.hasOlder,
+                hasNewer: page.hasNewer,
+                loading: false,
+                oldest: page.oldest,
+                newest: page.newest,
+                olderCursor: page.olderCursor,
+                newerCursor: page.newerCursor,
+                error: undefined,
+              }
             }),
           )
+          if (epoch !== syncEpoch) return
           fullSyncedSessions.add(sessionID)
         },
+        async loadOlder(sessionID: string) {
+          const page = store.message_page[sessionID]
+          if (page?.loading || !page?.hasOlder) return
+          const cursor = page?.olderCursor
+          if (!cursor) return
+          if (loadingGuard.has(sessionID)) return
+          loadingGuard.add(sessionID)
+          const epoch = syncEpoch
+          const pinned = getRevertMarker(sessionID)
+          try {
+            setStore("message_page", sessionID, { ...page, loading: true, loadingDirection: "older", error: undefined })
+
+            const res = await sdk.client.session.messages(
+              { sessionID, before: cursor, limit: 100 },
+              { throwOnError: true },
+            )
+            if (epoch !== syncEpoch) return
+            const info = pageInfo(res.response.headers.get("link") ?? "")
+            setStore(
+              produce((draft) => {
+                const existing = draft.message[sessionID] ?? []
+                const pageOldest = res.data?.at(0)?.info.id
+                for (const msg of res.data ?? []) {
+                  draft.message_cursor[msg.info.id] = msg.cursor
+                  const match = messageInsert(existing, msg.info)
+                  if (!match.found) {
+                    existing.splice(match.index, 0, msg.info)
+                    draft.part[msg.info.id] = msg.parts
+                  }
+                }
+                const nextOldest = pageOldest ?? draft.message_page[sessionID]?.oldest
+                if (existing.length > MAX_LOADED_MESSAGES) {
+                  const evictCount = existing.length - MAX_LOADED_MESSAGES
+                  const evicted = evictFromEnd(existing, evictCount, pinned)
+                  for (const msg of evicted) {
+                    delete draft.part[msg.id]
+                    delete draft.message_cursor[msg.id]
+                  }
+                  const nextNewest = windowNewest(existing, pinned) ?? draft.message_page[sessionID]?.newest
+                  draft.message_page[sessionID] = {
+                    hasOlder: info.hasOlder,
+                    hasNewer: true,
+                    loading: false,
+                    oldest: nextOldest,
+                    newest: nextNewest,
+                    olderCursor: info.olderCursor,
+                    newerCursor: edgeCursor(draft.message_cursor, nextNewest),
+                    error: undefined,
+                  }
+                } else {
+                  const nextNewest = windowNewest(existing, pinned) ?? draft.message_page[sessionID]?.newest
+                  draft.message_page[sessionID] = {
+                    hasOlder: info.hasOlder,
+                    hasNewer: draft.message_page[sessionID]?.hasNewer ?? false,
+                    loading: false,
+                    oldest: nextOldest,
+                    newest: nextNewest,
+                    olderCursor: info.olderCursor,
+                    newerCursor: draft.message_page[sessionID]?.newerCursor,
+                    error: undefined,
+                  }
+                }
+              }),
+            )
+          } catch (e) {
+            if (epoch !== syncEpoch) return
+            const page = store.message_page[sessionID]
+            setStore("message_page", sessionID, {
+              hasOlder: page?.hasOlder ?? false,
+              hasNewer: page?.hasNewer ?? false,
+              loading: false,
+              oldest: page?.oldest,
+              newest: page?.newest,
+              olderCursor: page?.olderCursor,
+              newerCursor: page?.newerCursor,
+              error: paginationError(e),
+            })
+          } finally {
+            loadingGuard.delete(sessionID)
+          }
+        },
+        async loadNewer(sessionID: string) {
+          const page = store.message_page[sessionID]
+          if (page?.loading || !page?.hasNewer) return
+          const cursor = page?.newerCursor
+          if (!cursor) return
+          if (loadingGuard.has(sessionID)) return
+          loadingGuard.add(sessionID)
+          const epoch = syncEpoch
+          const pinned = getRevertMarker(sessionID)
+          try {
+            setStore("message_page", sessionID, { ...page, loading: true, loadingDirection: "newer", error: undefined })
+            const res = await sdk.client.session.messages(
+              { sessionID, after: cursor, limit: 100 },
+              { throwOnError: true },
+            )
+            if (epoch !== syncEpoch) return
+            const info = pageInfo(res.response.headers.get("link") ?? "")
+            setStore(
+              produce((draft) => {
+                const existing = draft.message[sessionID] ?? []
+                const pageNewest = res.data?.at(-1)?.info.id
+                for (const msg of res.data ?? []) {
+                  draft.message_cursor[msg.info.id] = msg.cursor
+                  const match = messageInsert(existing, msg.info)
+                  if (!match.found) {
+                    existing.splice(match.index, 0, msg.info)
+                    draft.part[msg.info.id] = msg.parts
+                  }
+                }
+                const nextNewest = pageNewest ?? draft.message_page[sessionID]?.newest
+                if (existing.length > MAX_LOADED_MESSAGES) {
+                  const evictCount = existing.length - MAX_LOADED_MESSAGES
+                  const evicted = evictFromStart(existing, evictCount, pinned)
+                  for (const msg of evicted) {
+                    delete draft.part[msg.id]
+                    delete draft.message_cursor[msg.id]
+                  }
+                  const nextOldest = windowOldest(existing, pinned) ?? draft.message_page[sessionID]?.oldest
+                  draft.message_page[sessionID] = {
+                    hasOlder: true,
+                    hasNewer: info.hasNewer,
+                    loading: false,
+                    oldest: nextOldest,
+                    newest: nextNewest,
+                    olderCursor: edgeCursor(draft.message_cursor, nextOldest),
+                    newerCursor: info.newerCursor,
+                    error: undefined,
+                  }
+                } else {
+                  const nextOldest = windowOldest(existing, pinned) ?? draft.message_page[sessionID]?.oldest
+                  draft.message_page[sessionID] = {
+                    hasOlder: draft.message_page[sessionID]?.hasOlder ?? false,
+                    hasNewer: info.hasNewer,
+                    loading: false,
+                    oldest: nextOldest,
+                    newest: nextNewest,
+                    olderCursor: draft.message_page[sessionID]?.olderCursor,
+                    newerCursor: info.newerCursor,
+                    error: undefined,
+                  }
+                }
+              }),
+            )
+          } catch (e) {
+            if (epoch !== syncEpoch) return
+            const page = store.message_page[sessionID]
+            setStore("message_page", sessionID, {
+              hasOlder: page?.hasOlder ?? false,
+              hasNewer: page?.hasNewer ?? false,
+              loading: false,
+              oldest: page?.oldest,
+              newest: page?.newest,
+              olderCursor: page?.olderCursor,
+              newerCursor: page?.newerCursor,
+              error: paginationError(e),
+            })
+          } finally {
+            loadingGuard.delete(sessionID)
+          }
+        },
+        async jumpToLatest(sessionID: string, opts?: { force?: boolean }) {
+          const page = store.message_page[sessionID]
+          if (page?.loading) return
+          if (!opts?.force && !page?.hasNewer) return
+          if (loadingGuard.has(sessionID)) return
+          loadingGuard.add(sessionID)
+          const epoch = syncEpoch
+
+          try {
+            const session = store.session.find((s) => s.id === sessionID)
+            setStore("message_page", sessionID, {
+              hasOlder: page?.hasOlder ?? false,
+              hasNewer: page?.hasNewer ?? false,
+              loading: true,
+              loadingDirection: "newer",
+              oldest: page?.oldest,
+              newest: page?.newest,
+              olderCursor: page?.olderCursor,
+              newerCursor: page?.newerCursor,
+              error: undefined,
+            })
+
+            const latest = await loadLatestPage(sessionID, session?.revert?.messageID)
+            if (epoch !== syncEpoch) return
+
+            setStore(
+              produce((draft) => {
+                const oldMessages = draft.message[sessionID] ?? []
+                const newIds = new Set(latest.items.map((m) => m.info.id))
+                for (const msg of oldMessages) {
+                  if (!newIds.has(msg.id)) {
+                    delete draft.part[msg.id]
+                    delete draft.message_cursor[msg.id]
+                  }
+                }
+
+                draft.message[sessionID] = latest.items.map((m) => m.info)
+                for (const msg of latest.items) {
+                  draft.part[msg.info.id] = msg.parts
+                  draft.message_cursor[msg.info.id] = msg.cursor
+                }
+                draft.message_page[sessionID] = {
+                  hasOlder: latest.hasOlder,
+                  hasNewer: latest.hasNewer,
+                  loading: false,
+                  oldest: latest.oldest,
+                  newest: latest.newest,
+                  olderCursor: latest.olderCursor,
+                  newerCursor: latest.newerCursor,
+                  error: undefined,
+                }
+              }),
+            )
+          } catch (e) {
+            if (epoch !== syncEpoch) return
+            setStore(
+              produce((draft) => {
+                const p = draft.message_page[sessionID]
+                if (p) {
+                  p.loading = false
+                  p.error = paginationError(e)
+                }
+              }),
+            )
+          } finally {
+            loadingGuard.delete(sessionID)
+          }
+        },
+        async jumpToOldest(sessionID: string) {
+          const page = store.message_page[sessionID]
+          if (page?.loading || !page?.hasOlder) return
+          if (loadingGuard.has(sessionID)) return
+          loadingGuard.add(sessionID)
+          const epoch = syncEpoch
+
+          try {
+            setStore("message_page", sessionID, {
+              ...page,
+              loading: true,
+              loadingDirection: "older",
+              error: undefined,
+            })
+
+            const res = await sdk.client.session.messages(
+              { sessionID, oldest: "true", limit: 100 },
+              { throwOnError: true },
+            )
+            if (epoch !== syncEpoch) return
+
+            const session = store.session.find((s) => s.id === sessionID)
+            const revertMessageID = session?.revert?.messageID
+
+            let messages = res.data ?? []
+            const pageOldest = messages.at(0)?.info.id
+            const pageNewest = messages.at(-1)?.info.id
+            const info = pageInfo(res.response.headers.get("link") ?? "")
+
+            if (revertMessageID && !messages.some((m) => m.info.id === revertMessageID)) {
+              try {
+                const revertResult = await sdk.client.session.message(
+                  { sessionID, messageID: revertMessageID },
+                  { throwOnError: true },
+                )
+                if (epoch !== syncEpoch) return
+                if (revertResult.data) {
+                  const index = messageInsert(
+                    messages.map((m) => m.info),
+                    revertResult.data.info,
+                  )
+                  if (!index.found) messages.splice(index.index, 0, revertResult.data)
+                }
+              } catch (e) {
+                if (epoch !== syncEpoch) return
+                Log.Default.info("Revert marker fetch failed during jumpToOldest", {
+                  messageID: revertMessageID,
+                  error: e,
+                })
+                if (errorStatus(e) === 404) clearRevert(sessionID)
+              }
+            }
+
+            const nextOldest = pageOldest ?? messages.at(0)?.info.id
+            const nextNewest = pageNewest ?? messages.at(-1)?.info.id
+
+            setStore(
+              produce((draft) => {
+                const oldMessages = draft.message[sessionID] ?? []
+                const newIds = new Set(messages.map((m) => m.info.id))
+                for (const msg of oldMessages) {
+                  if (!newIds.has(msg.id)) {
+                    delete draft.part[msg.id]
+                    delete draft.message_cursor[msg.id]
+                  }
+                }
+
+                draft.message[sessionID] = messages.map((m) => m.info)
+                for (const msg of messages) {
+                  draft.part[msg.info.id] = msg.parts
+                  draft.message_cursor[msg.info.id] = msg.cursor
+                }
+                draft.message_page[sessionID] = {
+                  hasOlder: info.hasOlder,
+                  hasNewer: info.hasNewer,
+                  loading: false,
+                  oldest: nextOldest,
+                  newest: nextNewest,
+                  olderCursor: info.olderCursor,
+                  newerCursor: info.newerCursor,
+                  error: undefined,
+                }
+              }),
+            )
+          } catch (e) {
+            if (epoch !== syncEpoch) return
+            setStore(
+              produce((draft) => {
+                const p = draft.message_page[sessionID]
+                if (p) {
+                  p.loading = false
+                  p.error = paginationError(e)
+                }
+              }),
+            )
+          } finally {
+            loadingGuard.delete(sessionID)
+          }
+        },
       },
       bootstrap,
     }
diff --git a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
index 8855338d1d4b..29e61bda3610 100644
--- a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
@@ -21,17 +21,17 @@ import { useEvent } from "@tui/context/event"
 import { SplitBorder } from "@tui/component/border"
 import { Spinner } from "@tui/component/spinner"
 import { selectedForeground, useTheme } from "@tui/context/theme"
-import { BoxRenderable, ScrollBoxRenderable, addDefaultParsers, TextAttributes, RGBA } from "@opentui/core"
+import {
+  BoxRenderable,
+  ScrollBoxRenderable,
+  addDefaultParsers,
+  MacOSScrollAccel,
+  type ScrollAcceleration,
+  TextAttributes,
+  RGBA,
+} from "@opentui/core"
 import { Prompt, type PromptRef } from "@tui/component/prompt"
-import type {
-  AssistantMessage,
-  Part,
-  Provider,
-  ToolPart,
-  UserMessage,
-  TextPart,
-  ReasoningPart,
-} from "@opencode-ai/sdk/v2"
+import type { AssistantMessage, Part, ToolPart, UserMessage, TextPart, ReasoningPart } from "@opencode-ai/sdk/v2"
 import { useLocal } from "@tui/context/local"
 import { Locale } from "@/util/locale"
 import type { Tool } from "@/tool/tool"
@@ -63,7 +63,6 @@ import { DialogTimeline } from "./dialog-timeline"
 import { DialogForkFromTimeline } from "./dialog-fork-from-timeline"
 import { DialogSessionRename } from "../../component/dialog-session-rename"
 import { Sidebar } from "./sidebar"
-import { SubagentFooter } from "./subagent-footer.tsx"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { LANGUAGE_EXTENSIONS } from "@/lsp/language"
 import parsers from "../../../../../../parsers-config.ts"
@@ -73,6 +72,8 @@ import { Toast, useToast } from "../../ui/toast"
 import { useKV } from "../../context/kv.tsx"
 import * as Editor from "../../util/editor"
 import stripAnsi from "strip-ansi"
+import { Footer } from "./footer.tsx"
+import { SubagentFooter } from "./subagent-footer.tsx"
 import { usePromptRef } from "../../context/prompt"
 import { useExit } from "../../context/exit"
 import { Filesystem } from "@/util/filesystem"
@@ -80,7 +81,6 @@ import { Global } from "@opencode-ai/core/global"
 import { PermissionPrompt } from "./permission"
 import { QuestionPrompt } from "./question"
 import { DialogExportOptions } from "../../ui/dialog-export-options"
-import * as Model from "../../util/model"
 import { formatTranscript } from "../../util/transcript"
 import { UI } from "@/cli/ui.ts"
 import { useTuiConfig } from "../../context/tui-config"
@@ -89,13 +89,13 @@ import { TuiPluginRuntime } from "@/cli/cmd/tui/plugin/runtime"
 import { DialogGoUpsell } from "../../component/dialog-go-upsell"
 import { SessionRetry } from "@/session/retry"
 import { getRevertDiffFiles } from "../../util/revert-diff"
+import { edgeHints, messageBefore, olderScrollTarget, queueBoundaryLoad } from "@tui/util/pagination"
 
 addDefaultParsers(parsers.parsers)
 
 const GO_UPSELL_LAST_SEEN_AT = "go_upsell_last_seen_at"
 const GO_UPSELL_DONT_SHOW = "go_upsell_dont_show"
 const GO_UPSELL_WINDOW = 86_400_000 // 24 hrs
-
 const context = createContext<{
   width: number
   sessionID: string
@@ -105,7 +105,6 @@ const context = createContext<{
   showDetails: () => boolean
   showGenericToolOutput: () => boolean
   diffWrapMode: () => "word" | "none"
-  providers: () => ReadonlyMap<string, Provider>
   sync: ReturnType<typeof useSync>
   tui: ReturnType<typeof useTuiConfig>
 }>()
@@ -134,6 +133,7 @@ export function Session() {
       .toSorted((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
   })
   const messages = createMemo(() => sync.data.message[route.sessionID] ?? [])
+  const paging = createMemo(() => sync.data.message_page[route.sessionID])
   const permissions = createMemo(() => {
     if (session()?.parentID) return []
     return children().flatMap((x) => sync.data.permission[x.id] ?? [])
@@ -145,6 +145,67 @@ export function Session() {
   const visible = createMemo(() => !session()?.parentID && permissions().length === 0 && questions().length === 0)
   const disabled = createMemo(() => permissions().length > 0 || questions().length > 0)
 
+  const LOAD_MORE_THRESHOLD = 5
+
+  const loadOlder = () => {
+    const page = paging()
+    if (!page?.hasOlder || page.loading || !scroll || scroll.isDestroyed) return
+    if (scroll.scrollTop > LOAD_MORE_THRESHOLD) return
+
+    const anchor = (() => {
+      const scrollTop = scroll.scrollTop
+      const children = scroll.getChildren()
+      for (const child of children) {
+        if (!child.id) continue
+        if (child.y + child.height > scrollTop) {
+          return { id: child.id, offset: scrollTop - child.y }
+        }
+      }
+      return undefined
+    })()
+
+    const height = scroll.scrollHeight
+    const scrollTop = scroll.scrollTop
+    sync.session.loadOlder(route.sessionID).then(() => {
+      queueMicrotask(() => {
+        requestAnimationFrame(() => {
+          if (!scroll || scroll.isDestroyed) return
+          const nextTop = olderScrollTarget(scroll.getChildren(), scroll.scrollHeight, height, scrollTop, anchor)
+          if (nextTop !== undefined) scroll.scrollTo(nextTop)
+          refreshEdges()
+        })
+      })
+    })
+  }
+
+  const loadNewer = () => {
+    const page = paging()
+    if (!page?.hasNewer || page.loading || !scroll || scroll.isDestroyed) return
+    const bottomDistance = scroll.scrollHeight - scroll.scrollTop - scroll.viewport.height
+    if (bottomDistance > LOAD_MORE_THRESHOLD) return
+    sync.session.loadNewer(route.sessionID).then(() => {
+      queueMicrotask(() => {
+        requestAnimationFrame(() => {
+          refreshEdges()
+        })
+      })
+    })
+  }
+
+  const refreshEdges = () => {
+    if (!scroll || scroll.isDestroyed) return
+    const edges = edgeHints(scroll.scrollTop, scroll.scrollHeight, scroll.viewport.height, HINT_THRESHOLD)
+    setNearTop(edges.nearTop)
+    setNearBottom(edges.nearBottom)
+  }
+
+  const scrollMove = (delta: number) => {
+    if (!scroll || scroll.isDestroyed) return
+    scroll.scrollBy(delta)
+    refreshEdges()
+    queueBoundaryLoad(delta, loadOlder, loadNewer)
+  }
+
   const pending = createMemo(() => {
     return messages().findLast((x) => x.role === "assistant" && !x.time.completed)?.id
   })
@@ -162,9 +223,14 @@ export function Session() {
   const [showDetails, setShowDetails] = kv.signal("tool_details_visibility", true)
   const [showAssistantMetadata, _setShowAssistantMetadata] = kv.signal("assistant_metadata_visibility", true)
   const [showScrollbar, setShowScrollbar] = kv.signal("scrollbar_visible", false)
+  const [showHeader, setShowHeader] = kv.signal("header_visible", true)
   const [diffWrapMode] = kv.signal<"word" | "none">("diff_wrap_mode", "word")
   const [_animationsEnabled, _setAnimationsEnabled] = kv.signal("animations_enabled", true)
   const [showGenericToolOutput, setShowGenericToolOutput] = kv.signal("generic_tool_output_visibility", false)
+  const [nearTop, setNearTop] = createSignal(false)
+  const [nearBottom, setNearBottom] = createSignal(false)
+  const [revertPreview, setRevertPreview] = createSignal<{ userCount: number; nextMessageID?: string }>()
+  const HINT_THRESHOLD = 20
 
   const wide = createMemo(() => dimensions().width > 120)
   const sidebarVisible = createMemo(() => {
@@ -175,7 +241,6 @@ export function Session() {
   })
   const showTimestamps = createMemo(() => timestamps() === "show")
   const contentWidth = createMemo(() => dimensions().width - (sidebarVisible() ? 42 : 0) - 4)
-  const providers = createMemo(() => Model.index(sync.data.provider))
 
   const scrollAcceleration = createMemo(() => getScrollAcceleration(tuiConfig))
   const toast = useToast()
@@ -210,7 +275,9 @@ export function Session() {
       }
       editor.reconnect(result.data.directory)
       await sync.session.sync(sessionID)
-      if (route.sessionID === sessionID && scroll) scroll.scrollBy(100_000)
+      if (route.sessionID !== sessionID || !scroll || scroll.isDestroyed) return
+      scroll.scrollBy(100_000)
+      refreshEdges()
     })().catch((error) => {
       if (route.sessionID !== sessionID) return
       toast.show({
@@ -222,6 +289,16 @@ export function Session() {
     })
   })
 
+  createEffect(() => {
+    if (!scroll || scroll.isDestroyed) return
+    messages()
+    queueMicrotask(() => {
+      requestAnimationFrame(() => {
+        refreshEdges()
+      })
+    })
+  })
+
   let lastSwitch: string | undefined = undefined
   event.on("message.part.updated", (evt) => {
     const part = evt.properties.part
@@ -303,7 +380,7 @@ export function Session() {
   const findNextVisibleMessage = (direction: "next" | "prev"): string | null => {
     const children = scroll.getChildren()
     const messagesList = messages()
-    const scrollTop = scroll.y
+    const scrollTop = scroll.scrollTop
 
     // Get visible messages sorted by position, filtering for valid non-synthetic, non-ignored content
     const visibleMessages = children
@@ -335,13 +412,16 @@ export function Session() {
     const targetID = findNextVisibleMessage(direction)
 
     if (!targetID) {
-      scroll.scrollBy(direction === "next" ? scroll.height : -scroll.height)
+      scrollMove(direction === "next" ? scroll.height : -scroll.height)
       dialog.clear()
       return
     }
 
     const child = scroll.getChildren().find((c) => c.id === targetID)
-    if (child) scroll.scrollBy(child.y - scroll.y - 1)
+    if (child) {
+      scroll.scrollBy(child.y - scroll.scrollTop - 1)
+      refreshEdges()
+    }
     dialog.clear()
   }
 
@@ -349,6 +429,9 @@ export function Session() {
     setTimeout(() => {
       if (!scroll || scroll.isDestroyed) return
       scroll.scrollTo(scroll.scrollHeight)
+      requestAnimationFrame(() => {
+        refreshEdges()
+      })
     }, 50)
   }
 
@@ -369,7 +452,7 @@ export function Session() {
     if (children().length === 1) return
 
     const sessions = children().filter((x) => !!x.parentID)
-    let next = sessions.findIndex((x) => x.id === session()?.id) - direction
+    let next = sessions.findIndex((x) => x.id === session()?.id) + direction
 
     if (next >= sessions.length) next = 0
     if (next < 0) next = sessions.length - 1
@@ -457,7 +540,10 @@ export function Session() {
               const child = scroll.getChildren().find((child) => {
                 return child.id === messageID
               })
-              if (child) scroll.scrollBy(child.y - scroll.y - 1)
+              if (child) {
+                scroll.scrollBy(child.y - scroll.scrollTop - 1)
+                refreshEdges()
+              }
             }}
             sessionID={route.sessionID}
             setPrompt={(promptInfo) => prompt?.set(promptInfo)}
@@ -481,7 +567,10 @@ export function Session() {
               const child = scroll.getChildren().find((child) => {
                 return child.id === messageID
               })
-              if (child) scroll.scrollBy(child.y - scroll.y - 1)
+              if (child) {
+                scroll.scrollBy(child.y - scroll.scrollTop - 1)
+                refreshEdges()
+              }
             }}
             sessionID={route.sessionID}
           />
@@ -550,8 +639,15 @@ export function Session() {
       onSelect: async (dialog) => {
         const status = sync.data.session_status?.[route.sessionID]
         if (status?.type !== "idle") await sdk.client.session.abort({ sessionID: route.sessionID }).catch(() => {})
-        const revert = session()?.revert?.messageID
-        const message = messages().findLast((x) => (!revert || x.id < revert) && x.role === "user")
+        const page = paging()
+        if (page?.hasNewer && page.loading) return
+        if (page?.hasNewer) {
+          await sync.session.jumpToLatest(route.sessionID)
+        }
+        const boundary = revertBoundary()
+        const message = (sync.data.message[route.sessionID] ?? []).findLast(
+          (x) => x.role === "user" && (!boundary || messageBefore(x, boundary)),
+        )
         if (!message) return
         void sdk.client.session
           .revert({
@@ -586,12 +682,17 @@ export function Session() {
       slash: {
         name: "redo",
       },
-      onSelect: (dialog) => {
+      onSelect: async (dialog) => {
         dialog.clear()
-        const messageID = session()?.revert?.messageID
-        if (!messageID) return
-        const message = messages().find((x) => x.role === "user" && x.id > messageID)
-        if (!message) {
+        const preview =
+          revertPreview() ??
+          (await sdk.client.session
+            .revertPreview({ sessionID: route.sessionID })
+            .then((result) => result.data ?? undefined)) ??
+          undefined
+        const nextMessageID = preview?.nextMessageID
+        if (!preview && session()?.revert?.messageID) return
+        if (!nextMessageID) {
           void sdk.client.session.unrevert({
             sessionID: route.sessionID,
           })
@@ -600,7 +701,7 @@ export function Session() {
         }
         void sdk.client.session.revert({
           sessionID: route.sessionID,
-          messageID: message.id,
+          messageID: nextMessageID,
         })
       },
     },
@@ -675,6 +776,15 @@ export function Session() {
         dialog.clear()
       },
     },
+    {
+      title: showHeader() ? "Hide header" : "Show header",
+      value: "session.toggle.header",
+      category: "Session",
+      onSelect: (dialog) => {
+        setShowHeader((prev) => !prev)
+        dialog.clear()
+      },
+    },
     {
       title: showGenericToolOutput() ? "Hide generic tool output" : "Show generic tool output",
       value: "session.toggle.generic_tool_output",
@@ -691,7 +801,7 @@ export function Session() {
       category: "Session",
       hidden: true,
       onSelect: (dialog) => {
-        scroll.scrollBy(-scroll.height / 2)
+        scrollMove(-scroll.height / 2)
         dialog.clear()
       },
     },
@@ -702,7 +812,7 @@ export function Session() {
       category: "Session",
       hidden: true,
       onSelect: (dialog) => {
-        scroll.scrollBy(scroll.height / 2)
+        scrollMove(scroll.height / 2)
         dialog.clear()
       },
     },
@@ -713,7 +823,7 @@ export function Session() {
       category: "Session",
       disabled: true,
       onSelect: (dialog) => {
-        scroll.scrollBy(-1)
+        scrollMove(-1)
         dialog.clear()
       },
     },
@@ -724,7 +834,7 @@ export function Session() {
       category: "Session",
       disabled: true,
       onSelect: (dialog) => {
-        scroll.scrollBy(1)
+        scrollMove(1)
         dialog.clear()
       },
     },
@@ -735,7 +845,7 @@ export function Session() {
       category: "Session",
       hidden: true,
       onSelect: (dialog) => {
-        scroll.scrollBy(-scroll.height / 4)
+        scrollMove(-scroll.height / 4)
         dialog.clear()
       },
     },
@@ -746,7 +856,7 @@ export function Session() {
       category: "Session",
       hidden: true,
       onSelect: (dialog) => {
-        scroll.scrollBy(scroll.height / 4)
+        scrollMove(scroll.height / 4)
         dialog.clear()
       },
     },
@@ -757,7 +867,23 @@ export function Session() {
       category: "Session",
       hidden: true,
       onSelect: (dialog) => {
-        scroll.scrollTo(0)
+        const page = paging()
+        if (page?.hasOlder && !page.loading) {
+          sync.session.jumpToOldest(route.sessionID).then(() => {
+            requestAnimationFrame(() => {
+              if (!scroll || scroll.isDestroyed) return
+              scroll.scrollTo(0)
+              refreshEdges()
+            })
+          })
+        } else {
+          if (!scroll || scroll.isDestroyed) {
+            dialog.clear()
+            return
+          }
+          scroll.scrollTo(0)
+          refreshEdges()
+        }
         dialog.clear()
       },
     },
@@ -768,7 +894,23 @@ export function Session() {
       category: "Session",
       hidden: true,
       onSelect: (dialog) => {
-        scroll.scrollTo(scroll.scrollHeight)
+        const page = paging()
+        if (page?.hasNewer && !page.loading) {
+          sync.session.jumpToLatest(route.sessionID).then(() => {
+            requestAnimationFrame(() => {
+              if (!scroll || scroll.isDestroyed) return
+              scroll.scrollTo(scroll.scrollHeight)
+              refreshEdges()
+            })
+          })
+        } else {
+          if (!scroll || scroll.isDestroyed) {
+            dialog.clear()
+            return
+          }
+          scroll.scrollTo(scroll.scrollHeight)
+          refreshEdges()
+        }
         dialog.clear()
       },
     },
@@ -798,7 +940,10 @@ export function Session() {
             const child = scroll.getChildren().find((child) => {
               return child.id === message.id
             })
-            if (child) scroll.scrollBy(child.y - scroll.y - 1)
+            if (child) {
+              scroll.scrollBy(child.y - scroll.scrollTop - 1)
+              refreshEdges()
+            }
             break
           }
         }
@@ -826,9 +971,9 @@ export function Session() {
       keybind: "messages_copy",
       category: "Session",
       onSelect: (dialog) => {
-        const revertID = session()?.revert?.messageID
+        const boundary = revertBoundary()
         const lastAssistantMessage = messages().findLast(
-          (msg) => msg.role === "assistant" && (!revertID || msg.id < revertID),
+          (msg) => msg.role === "assistant" && (!boundary || messageBefore(msg, boundary)),
         )
         if (!lastAssistantMessage) {
           toast.show({ message: "No assistant messages found", variant: "error" })
@@ -882,7 +1027,6 @@ export function Session() {
               thinking: showThinking(),
               toolDetails: showDetails(),
               assistantMetadata: showAssistantMetadata(),
-              providers: sync.data.provider,
             },
           )
           await Clipboard.copy(transcript)
@@ -927,7 +1071,6 @@ export function Session() {
               thinking: options.thinking,
               toolDetails: options.toolDetails,
               assistantMetadata: options.assistantMetadata,
-              providers: sync.data.provider,
             },
           )
 
@@ -1012,13 +1155,47 @@ export function Session() {
 
   const revertInfo = createMemo(() => session()?.revert)
   const revertMessageID = createMemo(() => revertInfo()?.messageID)
+  let revertPreviewEpoch = 0
+
+  createEffect(
+    on(
+      () => [route.sessionID, revertMessageID()] as const,
+      ([sessionID, revert]) => {
+        const epoch = ++revertPreviewEpoch
+        setRevertPreview(undefined)
+        if (!revert) {
+          return
+        }
+        void sdk.client.session
+          .revertPreview({ sessionID })
+          .then((result) => {
+            if (epoch !== revertPreviewEpoch) return
+            setRevertPreview(result.data ?? undefined)
+          })
+          .catch(() => {
+            if (epoch !== revertPreviewEpoch) return
+            setRevertPreview(undefined)
+          })
+      },
+      { defer: true },
+    ),
+  )
 
   const revertDiffFiles = createMemo(() => getRevertDiffFiles(revertInfo()?.diff ?? ""))
 
   const revertRevertedMessages = createMemo(() => {
     const messageID = revertMessageID()
     if (!messageID) return []
-    return messages().filter((x) => x.id >= messageID && x.role === "user")
+    const boundary = messages().find((x) => x.id === messageID)
+    if (!boundary) return []
+    return messages().filter((x) => x.role === "user" && !messageBefore(x, boundary))
+  })
+  const revertUserCount = createMemo(() => revertPreview()?.userCount ?? revertRevertedMessages().length)
+
+  const revertBoundary = createMemo(() => {
+    const messageID = revertMessageID()
+    if (!messageID) return undefined
+    return messages().find((x) => x.id === messageID)
   })
 
   const revert = createMemo(() => {
@@ -1027,7 +1204,7 @@ export function Session() {
     if (!info.messageID) return
     return {
       messageID: info.messageID,
-      reverted: revertRevertedMessages(),
+      revertedCount: revertUserCount(),
       diff: info.diff,
       diffFiles: revertDiffFiles(),
     }
@@ -1049,16 +1226,51 @@ export function Session() {
         showDetails,
         showGenericToolOutput,
         diffWrapMode,
-        providers,
         sync,
         tui: tuiConfig,
       }}
     >
       <box flexDirection="row">
-        <box flexGrow={1} paddingBottom={1} paddingLeft={2} paddingRight={2} gap={1}>
+        <box flexGrow={1} paddingBottom={1} paddingTop={1} paddingLeft={2} paddingRight={2} gap={1}>
           <Show when={session()}>
+            <Show when={paging()?.loading && paging()?.loadingDirection === "older"}>
+              <box flexShrink={0} paddingLeft={1}>
+                <text fg={theme.textMuted}>Loading older messages...</text>
+              </box>
+            </Show>
+            <Show when={!paging()?.loading && paging()?.hasOlder && nearTop()}>
+              <box flexShrink={0} paddingLeft={1}>
+                <text fg={theme.textMuted}>(scroll up for more)</text>
+              </box>
+            </Show>
+            <Show when={paging()?.error}>
+              <box flexShrink={0} paddingLeft={1}>
+                <text fg={theme.error}>Failed to load: {paging()?.error}</text>
+                <text fg={theme.textMuted}> (scroll to retry)</text>
+              </box>
+            </Show>
             <scrollbox
               ref={(r) => (scroll = r)}
+              onMouseScroll={() => {
+                refreshEdges()
+                loadOlder()
+                loadNewer()
+              }}
+              onKeyDown={(e) => {
+                if (["up", "pageup", "home"].includes(e.name)) {
+                  setTimeout(() => {
+                    refreshEdges()
+                    loadOlder()
+                  }, 0)
+                }
+                if (["down", "pagedown", "end"].includes(e.name)) {
+                  setTimeout(() => {
+                    refreshEdges()
+                    loadNewer()
+                  }, 0)
+                }
+              }}
+              viewportCulling={true}
               viewportOptions={{
                 paddingRight: showScrollbar() ? 1 : 0,
               }}
@@ -1075,7 +1287,6 @@ export function Session() {
               flexGrow={1}
               scrollAcceleration={scrollAcceleration()}
             >
-              <box height={1} />
               <For each={messages()}>
                 {(message, index) => (
                   <Switch>
@@ -1113,7 +1324,7 @@ export function Session() {
                               paddingLeft={2}
                               backgroundColor={hover() ? theme.backgroundElement : theme.backgroundPanel}
                             >
-                              <text fg={theme.textMuted}>{revert()!.reverted.length} message reverted</text>
+                              <text fg={theme.textMuted}>{revert()!.revertedCount} message reverted</text>
                               <text fg={theme.textMuted}>
                                 <span style={{ fg: theme.text }}>{keybind.print("messages_redo")}</span> or /redo to
                                 restore
@@ -1140,7 +1351,13 @@ export function Session() {
                         )
                       })()}
                     </Match>
-                    <Match when={revert()?.messageID && message.id >= revert()!.messageID}>
+                    <Match
+                      when={(() => {
+                        const boundary = revertBoundary()
+                        if (!boundary) return false
+                        return !messageBefore(message, boundary)
+                      })()}
+                    >
                       <></>
                     </Match>
                     <Match when={message.role === "user"}>
@@ -1172,6 +1389,16 @@ export function Session() {
                 )}
               </For>
             </scrollbox>
+            <Show when={paging()?.loading && paging()?.loadingDirection === "newer"}>
+              <box flexShrink={0} paddingLeft={1}>
+                <text fg={theme.textMuted}>Loading newer messages...</text>
+              </box>
+            </Show>
+            <Show when={!paging()?.loading && paging()?.hasNewer && nearBottom()}>
+              <box flexShrink={0} paddingLeft={1}>
+                <text fg={theme.textMuted}>(scroll down for more)</text>
+              </box>
+            </Show>
             <box flexShrink={0}>
               <Show when={permissions().length > 0}>
                 <PermissionPrompt request={permissions()[0]} />
@@ -1182,6 +1409,9 @@ export function Session() {
               <Show when={session()?.parentID}>
                 <SubagentFooter />
               </Show>
+              <Show when={!session()?.parentID && showHeader()}>
+                <Footer />
+              </Show>
               <Show when={visible()}>
                 <TuiPluginRuntime.Slot
                   name="session_prompt"
@@ -1264,6 +1494,7 @@ function UserMessage(props: {
     return texts.join("\n\n")
   })
   const files = createMemo(() => props.parts.flatMap((x) => (x.type === "file" ? [x] : [])))
+  const sync = useSync()
   const { theme } = useTheme()
   const [hover, setHover] = createSignal(false)
   const queued = createMemo(() => props.pending && props.message.id > props.pending)
@@ -1350,12 +1581,10 @@ function UserMessage(props: {
 }
 
 function AssistantMessage(props: { message: AssistantMessage; parts: Part[]; last: boolean }) {
-  const ctx = use()
   const local = useLocal()
   const { theme } = useTheme()
   const sync = useSync()
   const messages = createMemo(() => sync.data.message[props.message.sessionID] ?? [])
-  const model = createMemo(() => Model.name(ctx.providers(), props.message.providerID, props.message.modelID))
 
   const final = createMemo(() => {
     return props.message.finish && !["tool-calls", "unknown"].includes(props.message.finish)
@@ -1425,7 +1654,7 @@ function AssistantMessage(props: { message: AssistantMessage; parts: Part[]; las
                 ▣{" "}
               </span>{" "}
               <span style={{ fg: theme.text }}>{Locale.titlecase(props.message.mode)}</span>
-              <span style={{ fg: theme.textMuted }}> · {model()}</span>
+              <span style={{ fg: theme.textMuted }}> · {props.message.modelID}</span>
               <Show when={duration()}>
                 <span style={{ fg: theme.textMuted }}> · {Locale.duration(duration())}</span>
               </Show>
@@ -1990,7 +2219,7 @@ function Task(props: ToolProps<typeof TaskTool>) {
 
   const content = createMemo(() => {
     if (!props.input.description) return ""
-    let content = [`${Locale.titlecase(props.input.subagent_type ?? "General")} Task — ${props.input.description}`]
+    let content = [`Task ${props.input.description}`]
 
     if (isRunning() && tools().length > 0) {
       // content[0] += ` · ${tools().length} toolcalls`
diff --git a/packages/opencode/src/cli/cmd/tui/util/pagination.ts b/packages/opencode/src/cli/cmd/tui/util/pagination.ts
new file mode 100644
index 000000000000..11d1620dc649
--- /dev/null
+++ b/packages/opencode/src/cli/cmd/tui/util/pagination.ts
@@ -0,0 +1,176 @@
+import type { Message } from "@opencode-ai/sdk/v2"
+
+type Timed = {
+  id: string
+  time: {
+    created: number
+  }
+}
+
+const compare = (a: Timed, b: Timed) => {
+  if (a.time.created !== b.time.created) return a.time.created - b.time.created
+  if (a.id < b.id) return -1
+  if (a.id > b.id) return 1
+  return 0
+}
+
+export const messageInsert = <T extends Timed>(messages: T[], message: T) => {
+  let left = 0
+  let right = messages.length
+  while (left < right) {
+    const mid = (left + right) >>> 1
+    const current = messages[mid]
+    if (!current) break
+    if (compare(current, message) < 0) left = mid + 1
+    else right = mid
+  }
+  const found = left < messages.length && compare(messages[left]!, message) === 0
+  return { found, index: left }
+}
+
+export const messageBefore = (a: Timed, b: Timed) => compare(a, b) < 0
+
+export const hasBeforeBoundary = <T extends Timed>(messages: T[], boundary?: Timed) => {
+  if (!boundary) return true
+  return messages.some((message) => messageBefore(message, boundary))
+}
+
+export const hasUserBeforeBoundary = <T extends Timed & { role: string }>(messages: T[], boundary?: Timed) => {
+  if (!boundary) return true
+  return messages.some((message) => message.role === "user" && messageBefore(message, boundary))
+}
+
+const text = (value: unknown) => {
+  if (typeof value === "string") return value
+  if (typeof value === "number") return String(value)
+  if (typeof value === "boolean") return String(value)
+  return undefined
+}
+
+const message = (value: unknown) => {
+  if (typeof value !== "object" || value === null) return undefined
+  return text((value as Record<string, unknown>).message)
+}
+
+export const windowOldest = (messages: Message[], pinned?: string) => {
+  if (!pinned) return messages.at(0)?.id
+  for (const msg of messages) {
+    if (msg.id !== pinned) return msg.id
+  }
+  return undefined
+}
+
+export const windowNewest = (messages: Message[], pinned?: string) => {
+  if (!pinned) return messages.at(-1)?.id
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i]
+    if (msg && msg.id !== pinned) return msg.id
+  }
+  return undefined
+}
+
+export const evictFromStart = (messages: Message[], count: number, pinned?: string) => {
+  const evicted: Message[] = []
+  if (count <= 0) return evicted
+  let index = 0
+  while (index < messages.length && evicted.length < count) {
+    const msg = messages[index]
+    if (!msg) break
+    if (msg.id !== pinned) {
+      evicted.push(msg)
+      messages.splice(index, 1)
+      continue
+    }
+    index += 1
+  }
+  return evicted
+}
+
+export const evictFromEnd = (messages: Message[], count: number, pinned?: string) => {
+  const evicted: Message[] = []
+  if (count <= 0) return evicted
+  let index = messages.length - 1
+  while (index >= 0 && evicted.length < count) {
+    const msg = messages[index]
+    if (!msg) break
+    if (msg.id !== pinned) {
+      evicted.push(msg)
+      messages.splice(index, 1)
+    }
+    index -= 1
+  }
+  return evicted
+}
+
+export const paginationError = (error: unknown) => {
+  if (error instanceof Error) return error.message
+  const plain = text(error)
+  if (plain) return plain
+  const direct = message(error)
+  if (direct) return direct
+  if (typeof error === "object" && error !== null) {
+    const nested = message((error as Record<string, unknown>).error)
+    if (nested) return nested
+    return Bun.inspect(error)
+  }
+  return "Unknown error"
+}
+
+export const queueBoundaryLoad = (
+  delta: number,
+  older: () => void,
+  newer: () => void,
+  queue: (run: () => void) => void = (run) => {
+    setTimeout(run, 0)
+  },
+) => {
+  if (delta < 0) {
+    queue(older)
+    return
+  }
+  if (delta > 0) queue(newer)
+}
+
+type Edges = {
+  nearTop: boolean
+  nearBottom: boolean
+}
+
+export const edgeHints = (
+  scrollTop: number,
+  scrollHeight: number,
+  viewportHeight: number,
+  threshold: number,
+): Edges => {
+  return {
+    nearTop: scrollTop <= threshold,
+    nearBottom: scrollHeight - scrollTop - viewportHeight <= threshold,
+  }
+}
+
+type Anchor = {
+  id: string
+  offset: number
+}
+
+type Child = {
+  id?: string
+  y: number
+  height: number
+}
+
+export const olderScrollTarget = (
+  children: Child[],
+  nextHeight: number,
+  prevHeight: number,
+  prevTop: number,
+  anchor?: Anchor,
+) => {
+  if (anchor) {
+    const child = children.find((item) => item.id === anchor.id)
+    if (child) return child.y + anchor.offset
+  }
+  const delta = nextHeight - prevHeight
+  if (delta > 0) return prevTop + delta
+  return undefined
+}
diff --git a/packages/opencode/src/server/routes/instance/httpapi/groups/session.ts b/packages/opencode/src/server/routes/instance/httpapi/groups/session.ts
index 77d064ff5a28..e86529a1ad83 100644
--- a/packages/opencode/src/server/routes/instance/httpapi/groups/session.ts
+++ b/packages/opencode/src/server/routes/instance/httpapi/groups/session.ts
@@ -37,6 +37,8 @@ export const DiffQuery = Schema.Struct(Struct.omit(SessionSummary.DiffInput.fiel
 export const MessagesQuery = Schema.Struct({
   limit: Schema.optional(Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))),
   before: Schema.optional(Schema.String),
+  after: Schema.optional(Schema.String),
+  oldest: Schema.optional(QueryBoolean),
 })
 export const StatusMap = Schema.Record(Schema.String, SessionStatus.Info)
 export const UpdatePayload = Schema.Struct({
@@ -339,6 +341,17 @@ export const SessionApi = HttpApi.make("session")
             description: "Execute a shell command within the session context and return the AI's response.",
           }),
         ),
+        HttpApiEndpoint.get("revertPreview", SessionPaths.revert, {
+          params: { sessionID: SessionID },
+          success: described(Schema.NullOr(SessionRevert.Preview), "Revert preview"),
+          error: [HttpApiError.BadRequest, HttpApiError.NotFound],
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "session.revertPreview",
+            summary: "Get revert preview",
+            description: "Return the reverted user messages and next restore boundary for a reverted session.",
+          }),
+        ),
         HttpApiEndpoint.post("revert", SessionPaths.revert, {
           params: { sessionID: SessionID },
           payload: RevertPayload,
diff --git a/packages/opencode/src/server/routes/instance/httpapi/handlers/session.ts b/packages/opencode/src/server/routes/instance/httpapi/handlers/session.ts
index 8cc969f483f5..a49b5ce6c165 100644
--- a/packages/opencode/src/server/routes/instance/httpapi/handlers/session.ts
+++ b/packages/opencode/src/server/routes/instance/httpapi/handlers/session.ts
@@ -103,36 +103,63 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
     }) {
       return yield* mapNotFound(
         Effect.gen(function* () {
-          if (ctx.query.before && ctx.query.limit === undefined) return yield* new HttpApiError.BadRequest({})
-          if (ctx.query.before) {
-            const before = ctx.query.before
+          const oldest = ctx.query.oldest === true
+          if (ctx.query.before && ctx.query.after) return yield* new HttpApiError.BadRequest({})
+          if (oldest && (ctx.query.before || ctx.query.after)) return yield* new HttpApiError.BadRequest({})
+          for (const cursor of [ctx.query.before, ctx.query.after]) {
+            if (!cursor) continue
             yield* Effect.try({
-              try: () => MessageV2.cursor.decode(before),
+              try: () => MessageV2.cursor.decode(cursor),
               catch: () => new HttpApiError.BadRequest({}),
             })
           }
-          if (ctx.query.limit === undefined || ctx.query.limit === 0) {
+          if (
+            ctx.query.before === undefined &&
+            ctx.query.after === undefined &&
+            !oldest &&
+            ctx.query.limit === undefined
+          ) {
             yield* session.get(ctx.params.sessionID)
             return yield* session.messages({ sessionID: ctx.params.sessionID })
           }
+          if (ctx.query.limit === 0) {
+            yield* session.get(ctx.params.sessionID)
+            return []
+          }
 
-          yield* session.get(ctx.params.sessionID)
+          const pageLimit = ctx.query.limit ?? 100
           const page = MessageV2.page({
             sessionID: ctx.params.sessionID,
-            limit: ctx.query.limit,
+            limit: pageLimit,
             before: ctx.query.before,
+            after: ctx.query.after,
+            oldest,
           })
-          if (!page.cursor) return page.items
 
           const request = yield* HttpServerRequest.HttpServerRequest
-          const url = new URL(request.url, "http://localhost")
-          url.searchParams.set("limit", ctx.query.limit.toString())
-          url.searchParams.set("before", page.cursor)
+          const links: string[] = []
+          if (page.before) {
+            const prev = new URL(request.url, "http://localhost")
+            prev.searchParams.delete("after")
+            prev.searchParams.delete("oldest")
+            prev.searchParams.set("limit", pageLimit.toString())
+            prev.searchParams.set("before", page.before)
+            links.push(`<${prev.toString()}>; rel="prev"`)
+          }
+          if (page.after) {
+            const next = new URL(request.url, "http://localhost")
+            next.searchParams.delete("before")
+            next.searchParams.delete("oldest")
+            next.searchParams.set("limit", pageLimit.toString())
+            next.searchParams.set("after", page.after)
+            links.push(`<${next.toString()}>; rel="next"`)
+          }
+          if (links.length === 0) return page.items
+
           return HttpServerResponse.jsonUnsafe(page.items, {
             headers: {
-              "Access-Control-Expose-Headers": "Link, X-Next-Cursor",
-              Link: `<${url.toString()}>; rel="next"`,
-              "X-Next-Cursor": page.cursor,
+              "Access-Control-Expose-Headers": "Link",
+              Link: links.join(", "),
             },
           })
         }),
@@ -305,6 +332,12 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
       return yield* promptSvc.shell({ ...ctx.payload, sessionID: ctx.params.sessionID })
     })
 
+    const revertPreview = Effect.fn("SessionHttpApi.revertPreview")(function* (ctx: {
+      params: { sessionID: SessionID }
+    }) {
+      return (yield* revertSvc.preview({ sessionID: ctx.params.sessionID })) ?? null
+    })
+
     const revert = Effect.fn("SessionHttpApi.revert")(function* (ctx: {
       params: { sessionID: SessionID }
       payload: typeof RevertPayload.Type
@@ -378,6 +411,7 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
       .handle("promptAsync", promptAsync)
       .handle("command", command)
       .handle("shell", shell)
+      .handle("revertPreview", revertPreview)
       .handle("revert", revert)
       .handle("unrevert", unrevert)
       .handle("permissionRespond", permissionRespond)
diff --git a/packages/opencode/src/server/routes/instance/httpapi/public.ts b/packages/opencode/src/server/routes/instance/httpapi/public.ts
index 17d6e0d063f9..2d8bb9763cd0 100644
--- a/packages/opencode/src/server/routes/instance/httpapi/public.ts
+++ b/packages/opencode/src/server/routes/instance/httpapi/public.ts
@@ -71,7 +71,7 @@ const InstanceQueryParameters = [
 // public call shape. These keep SDK callers passing numbers/booleans while the
 // server still decodes string query params at runtime.
 const QueryNumberParameters = new Set(["start", "cursor", "limit", "method"])
-const QueryBooleanParameters = new Set(["roots", "archived"])
+const QueryBooleanParameters = new Set(["roots", "archived", "oldest"])
 const QueryParameterSchemas = {
   "GET /find/file limit": { type: "integer", minimum: 1, maximum: 200 },
   "GET /session/{sessionID}/message limit": { type: "integer", minimum: 0, maximum: Number.MAX_SAFE_INTEGER },
diff --git a/packages/opencode/src/server/routes/instance/session.ts b/packages/opencode/src/server/routes/instance/session.ts
index a16a92f927a6..06fb2d81377d 100644
--- a/packages/opencode/src/server/routes/instance/session.ts
+++ b/packages/opencode/src/server/routes/instance/session.ts
@@ -624,6 +624,14 @@ export const SessionRoutes = lazy(() =>
         responses: {
           200: {
             description: "List of messages",
+            headers: {
+              Link: {
+                description: "RFC 8288 pagination links for previous/next message pages",
+                schema: {
+                  type: "string",
+                },
+              },
+            },
             content: {
               "application/json": {
                 schema: resolver(MessageV2.WithParts.zod.array()),
@@ -641,40 +649,59 @@ export const SessionRoutes = lazy(() =>
       ),
       validator(
         "query",
-        z
-          .object({
-            limit: z.coerce
-              .number()
-              .int()
-              .min(0)
-              .optional()
-              .meta({ description: "Maximum number of messages to return" }),
-            before: z
-              .string()
-              .optional()
-              .meta({ description: "Opaque cursor for loading older messages" })
-              .refine(
-                (value) => {
-                  if (!value) return true
-                  try {
-                    MessageV2.cursor.decode(value)
-                    return true
-                  } catch {
-                    return false
-                  }
-                },
-                { message: "Invalid cursor" },
-              ),
-          })
-          .refine((value) => !value.before || value.limit !== undefined, {
-            message: "before requires limit",
-            path: ["before"],
-          }),
+        z.object({
+          limit: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .meta({ description: "Maximum number of messages to return" }),
+          before: z
+            .string()
+            .optional()
+            .meta({ description: "Opaque cursor for loading older messages" })
+            .refine(
+              (value) => {
+                if (!value) return true
+                try {
+                  MessageV2.cursor.decode(value)
+                  return true
+                } catch {
+                  return false
+                }
+              },
+              { message: "Invalid cursor" },
+            ),
+          after: z
+            .string()
+            .optional()
+            .meta({ description: "Opaque cursor for loading newer messages" })
+            .refine(
+              (value) => {
+                if (!value) return true
+                try {
+                  MessageV2.cursor.decode(value)
+                  return true
+                } catch {
+                  return false
+                }
+              },
+              { message: "Invalid cursor" },
+            ),
+          oldest: QueryBoolean.optional(),
+        }),
       ),
       async (c) => {
         const query = c.req.valid("query")
         const sessionID = c.req.valid("param").sessionID
-        if (query.limit === undefined || query.limit === 0) {
+        const oldest = queryBoolean(query.oldest) === true
+        if (query.before && query.after) {
+          return c.json({ error: "Cannot specify both 'before' and 'after'" }, 400)
+        }
+        if (oldest && (query.before || query.after)) {
+          return c.json({ error: "Cannot use 'oldest' with 'before' or 'after'" }, 400)
+        }
+        if (query.before === undefined && query.after === undefined && !oldest && query.limit === undefined) {
           const messages = await runRequest(
             "SessionRoutes.messages",
             c,
@@ -686,20 +713,49 @@ export const SessionRoutes = lazy(() =>
           )
           return c.json(messages)
         }
+        if (query.limit === 0) {
+          await runRequest(
+            "SessionRoutes.messages",
+            c,
+            Effect.gen(function* () {
+              const session = yield* Session.Service
+              yield* session.get(sessionID)
+            }),
+          )
+          return c.json([])
+        }
 
+        const pageLimit = query.limit ?? 100
         const page = await MessageV2.page({
           sessionID,
-          limit: query.limit,
+          limit: pageLimit,
           before: query.before,
+          after: query.after,
+          oldest,
         })
-        if (page.cursor) {
-          const url = new URL(c.req.url)
-          url.searchParams.set("limit", query.limit.toString())
-          url.searchParams.set("before", page.cursor)
-          c.header("Access-Control-Expose-Headers", "Link, X-Next-Cursor")
-          c.header("Link", `<${url.toString()}>; rel="next"`)
-          c.header("X-Next-Cursor", page.cursor)
+
+        const links: string[] = []
+        if (page.before) {
+          const prev = new URL(c.req.url)
+          prev.searchParams.delete("after")
+          prev.searchParams.delete("oldest")
+          prev.searchParams.set("limit", pageLimit.toString())
+          prev.searchParams.set("before", page.before)
+          links.push(`<${prev.toString()}>; rel="prev"`)
         }
+        if (page.after) {
+          const next = new URL(c.req.url)
+          next.searchParams.delete("before")
+          next.searchParams.delete("oldest")
+          next.searchParams.set("limit", pageLimit.toString())
+          next.searchParams.set("after", page.after)
+          links.push(`<${next.toString()}>; rel="next"`)
+        }
+        if (links.length > 0) {
+          c.header("Access-Control-Expose-Headers", "Link")
+          c.header("Link", links.join(", "))
+        }
+
         return c.json(page.items)
       },
     )
@@ -718,6 +774,7 @@ export const SessionRoutes = lazy(() =>
                   z.object({
                     info: MessageV2.Info.zod,
                     parts: MessageV2.Part.zod.array(),
+                    cursor: z.string().optional(),
                   }),
                 ),
               },
@@ -1017,6 +1074,37 @@ export const SessionRoutes = lazy(() =>
           return yield* svc.shell({ ...body, sessionID })
         }),
     )
+    .get(
+      "/:sessionID/revert",
+      describeRoute({
+        summary: "Get revert preview",
+        description: "Return the reverted user messages and next restore boundary for a reverted session.",
+        operationId: "session.revertPreview",
+        responses: {
+          200: {
+            description: "Revert preview",
+            content: {
+              "application/json": {
+                schema: resolver(z.nullable(SessionRevert.Preview.zod)),
+              },
+            },
+          },
+          ...errors(400, 404),
+        },
+      }),
+      validator(
+        "param",
+        z.object({
+          sessionID: SessionID.zod,
+        }),
+      ),
+      async (c) =>
+        jsonRequest("SessionRoutes.revertPreview", c, function* () {
+          const sessionID = c.req.valid("param").sessionID
+          const svc = yield* SessionRevert.Service
+          return (yield* svc.preview({ sessionID })) ?? null
+        }),
+    )
     .post(
       "/:sessionID/revert",
       describeRoute({
diff --git a/packages/opencode/src/session/message-v2.ts b/packages/opencode/src/session/message-v2.ts
index 5f97074b20c0..21c59822cefe 100644
--- a/packages/opencode/src/session/message-v2.ts
+++ b/packages/opencode/src/session/message-v2.ts
@@ -8,9 +8,11 @@ import { Snapshot } from "@/snapshot"
 import { SyncEvent } from "../sync"
 import { Database } from "@/storage/db"
 import { NotFoundError } from "@/storage/storage"
+import { asc } from "drizzle-orm"
 import { and } from "drizzle-orm"
 import { desc } from "drizzle-orm"
 import { eq } from "drizzle-orm"
+import { gt } from "drizzle-orm"
 import { inArray } from "drizzle-orm"
 import { lt } from "drizzle-orm"
 import { or } from "drizzle-orm"
@@ -653,10 +655,12 @@ export const Event = {
 export const WithParts = Schema.Struct({
   info: _Info,
   parts: Schema.Array(_Part),
+  cursor: Schema.optional(Schema.String),
 }).pipe(withStatics((s) => ({ zod: zod(s) })))
 export type WithParts = {
   info: Info
   parts: Part[]
+  cursor?: string
 }
 
 const Cursor = Schema.Struct({
@@ -694,6 +698,9 @@ const part = (row: typeof PartTable.$inferSelect) =>
 const older = (row: Cursor) =>
   or(lt(MessageTable.time_created, row.time), and(eq(MessageTable.time_created, row.time), lt(MessageTable.id, row.id)))
 
+const newer = (row: Cursor) =>
+  or(gt(MessageTable.time_created, row.time), and(eq(MessageTable.time_created, row.time), gt(MessageTable.id, row.id)))
+
 function hydrate(rows: (typeof MessageTable.$inferSelect)[]) {
   const ids = rows.map((row) => row.id)
   const partByMessage = new Map<string, Part[]>()
@@ -717,6 +724,7 @@ function hydrate(rows: (typeof MessageTable.$inferSelect)[]) {
   return rows.map((row) => ({
     info: info(row),
     parts: partByMessage.get(row.id) ?? [],
+    cursor: cursor.encode({ id: row.id, time: row.time_created }),
   }))
 }
 
@@ -999,17 +1007,39 @@ export function toModelMessages(
   return Effect.runPromise(toModelMessagesEffect(input, model, options).pipe(Effect.provide(EffectLogger.layer)))
 }
 
-export function page(input: { sessionID: SessionID; limit: number; before?: string }) {
+export function page(input: {
+  sessionID: SessionID
+  limit: number
+  before?: string
+  after?: string
+  oldest?: boolean
+}) {
+  if (input.before && input.after) {
+    throw new Error("Cannot specify both 'before' and 'after' cursors")
+  }
+  if (input.oldest && (input.before || input.after)) {
+    throw new Error("Cannot use 'oldest' with 'before' or 'after' cursors")
+  }
+
   const before = input.before ? cursor.decode(input.before) : undefined
-  const where = before
-    ? and(eq(MessageTable.session_id, input.sessionID), older(before))
-    : eq(MessageTable.session_id, input.sessionID)
+  const after = input.after ? cursor.decode(input.after) : undefined
+  const where = input.oldest
+    ? eq(MessageTable.session_id, input.sessionID)
+    : after
+      ? and(eq(MessageTable.session_id, input.sessionID), newer(after))
+      : before
+        ? and(eq(MessageTable.session_id, input.sessionID), older(before))
+        : eq(MessageTable.session_id, input.sessionID)
+  const order =
+    input.oldest || after
+      ? [asc(MessageTable.time_created), asc(MessageTable.id)]
+      : [desc(MessageTable.time_created), desc(MessageTable.id)]
   const rows = Database.use((db) =>
     db
       .select()
       .from(MessageTable)
       .where(where)
-      .orderBy(desc(MessageTable.time_created), desc(MessageTable.id))
+      .orderBy(...order)
       .limit(input.limit + 1)
       .all(),
   )
@@ -1020,19 +1050,42 @@ export function page(input: { sessionID: SessionID; limit: number; before?: stri
     if (!row) throw new NotFoundError({ message: `Session not found: ${input.sessionID}` })
     return {
       items: [] as WithParts[],
-      more: false,
+      before: undefined,
+      after: undefined,
     }
   }
 
   const more = rows.length > input.limit
   const slice = more ? rows.slice(0, input.limit) : rows
   const items = hydrate(slice)
-  items.reverse()
-  const tail = slice.at(-1)
+  if (!input.oldest && !after) items.reverse()
+  const first = slice.at(0)
+  const last = slice.at(-1)
+  const encode = (row: typeof MessageTable.$inferSelect) => cursor.encode({ id: row.id, time: row.time_created })
   return {
     items,
-    more,
-    cursor: more && tail ? cursor.encode({ id: tail.id, time: tail.time_created }) : undefined,
+    before: input.oldest
+      ? undefined
+      : after
+        ? first
+          ? encode(first)
+          : undefined
+        : more && last
+          ? encode(last)
+          : undefined,
+    after: input.oldest
+      ? more && last
+        ? encode(last)
+        : undefined
+      : after
+        ? more && last
+          ? encode(last)
+          : undefined
+        : before
+          ? first
+            ? encode(first)
+            : undefined
+          : undefined,
   }
 }
 
@@ -1045,8 +1098,8 @@ export function* stream(sessionID: SessionID) {
     for (let i = next.items.length - 1; i >= 0; i--) {
       yield next.items[i]
     }
-    if (!next.more || !next.cursor) break
-    before = next.cursor
+    if (!next.before) break
+    before = next.before
   }
 }
 
@@ -1077,6 +1130,7 @@ export function get(input: { sessionID: SessionID; messageID: MessageID }): With
   return {
     info: info(row),
     parts: parts(input.messageID),
+    cursor: cursor.encode({ id: row.id, time: row.time_created }),
   }
 }
 
diff --git a/packages/opencode/src/session/revert.ts b/packages/opencode/src/session/revert.ts
index 58d69a2040e2..c3eb79e6c44c 100644
--- a/packages/opencode/src/session/revert.ts
+++ b/packages/opencode/src/session/revert.ts
@@ -21,10 +21,25 @@ export const RevertInput = Schema.Struct({
 }).pipe(withStatics((s) => ({ zod: zod(s) })))
 export type RevertInput = Schema.Schema.Type<typeof RevertInput>
 
+export const PreviewItem = Schema.Struct({
+  id: MessageID,
+  text: Schema.String,
+}).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type PreviewItem = Schema.Schema.Type<typeof PreviewItem>
+
+export const Preview = Schema.Struct({
+  userCount: Schema.Number,
+  nextMessageID: Schema.optional(MessageID),
+  partID: Schema.optional(PartID),
+  items: Schema.Array(PreviewItem),
+}).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type Preview = Schema.Schema.Type<typeof Preview>
+
 export interface Interface {
   readonly revert: (input: RevertInput) => Effect.Effect<Session.Info>
   readonly unrevert: (input: { sessionID: SessionID }) => Effect.Effect<Session.Info>
   readonly cleanup: (session: Session.Info) => Effect.Effect<void>
+  readonly preview: (input: { sessionID: SessionID }) => Effect.Effect<Preview | undefined>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/SessionRevert") {}
@@ -40,6 +55,58 @@ export const layer = Layer.effect(
     const state = yield* SessionRunState.Service
     const sync = yield* SyncEvent.Service
 
+    const previewText = (message: MessageV2.WithParts) => {
+      const text = message.parts
+        .flatMap((part) => (part.type === "text" && !part.synthetic && part.text.trim() ? [part.text.trim()] : []))
+        .join("\n\n")
+      if (text) return text
+      const attachments = message.parts.flatMap((part) => (part.type === "file" ? [part.filename] : []))
+      if (attachments.length === 0) return ""
+      return attachments.map((name) => `[attachment:${name}]`).join(" ")
+    }
+
+    const messageAtOrAfter = (message: MessageV2.WithParts, boundary: MessageV2.WithParts) =>
+      message.info.time.created > boundary.info.time.created ||
+      (message.info.time.created === boundary.info.time.created && message.info.id >= boundary.info.id)
+    const messageBefore = (message: MessageV2.WithParts, boundary: MessageV2.WithParts) =>
+      message.info.time.created < boundary.info.time.created ||
+      (message.info.time.created === boundary.info.time.created && message.info.id < boundary.info.id)
+    const revertedUser = (message: MessageV2.WithParts, boundary: MessageV2.WithParts) =>
+      message.info.role === "user" && messageAtOrAfter(message, boundary)
+
+    const preview = Effect.fn("SessionRevert.preview")(function* (input: { sessionID: SessionID }) {
+      const session = yield* sessions.get(input.sessionID)
+      if (!session.revert) return undefined
+      const messages = yield* sessions.messages({ sessionID: input.sessionID })
+      const boundary = messages.find((message) => message.info.id === session.revert!.messageID)
+      if (!boundary) return undefined
+      if (session.revert.partID) {
+        return {
+          userCount: messages.filter((message) => revertedUser(message, boundary)).length,
+          nextMessageID: undefined,
+          partID: session.revert.partID,
+          items: [
+            {
+              id: boundary.info.id,
+              text: previewText(boundary),
+            },
+          ],
+        }
+      }
+      const items = messages
+        .filter((message) => revertedUser(message, boundary))
+        .map((message) => ({
+          id: message.info.id,
+          text: previewText(message),
+        }))
+      return {
+        userCount: items.length,
+        nextMessageID: items[1]?.id,
+        partID: undefined,
+        items,
+      }
+    })
+
     const revert = Effect.fn("SessionRevert.revert")(function* (input: RevertInput) {
       yield* state.assertNotBusy(input.sessionID)
       const all = yield* sessions.messages({ sessionID: input.sessionID })
@@ -76,7 +143,8 @@ export const layer = Layer.effect(
       if (session.revert?.snapshot) yield* snap.restore(session.revert.snapshot)
       yield* snap.revert(patches)
       if (rev.snapshot) rev.diff = yield* snap.diff(rev.snapshot as string)
-      const range = all.filter((msg) => msg.info.id >= rev!.messageID)
+      const boundary = all.find((msg) => msg.info.id === rev!.messageID)
+      const range = boundary ? all.filter((msg) => messageAtOrAfter(msg, boundary)) : []
       const diffs = yield* summary.computeDiff({ messages: range })
       yield* storage.write(["session_diff", input.sessionID], diffs).pipe(Effect.ignore)
       yield* bus.publish(Session.Event.Diff, { sessionID: input.sessionID, diff: diffs })
@@ -107,11 +175,16 @@ export const layer = Layer.effect(
       const sessionID = session.id
       const msgs = yield* sessions.messages({ sessionID })
       const messageID = session.revert.messageID
+      const boundary = msgs.find((msg) => msg.info.id === messageID)
+      if (!boundary) {
+        yield* sessions.clearRevert(sessionID)
+        return
+      }
       const remove = [] as MessageV2.WithParts[]
       let target: MessageV2.WithParts | undefined
       for (const msg of msgs) {
-        if (msg.info.id < messageID) continue
-        if (msg.info.id > messageID) {
+        if (messageBefore(msg, boundary)) continue
+        if (msg.info.id !== messageID) {
           remove.push(msg)
           continue
         }
@@ -145,7 +218,7 @@ export const layer = Layer.effect(
       yield* sessions.clearRevert(sessionID)
     })
 
-    return Service.of({ revert, unrevert, cleanup })
+    return Service.of({ revert, unrevert, cleanup, preview })
   }),
 )
 
diff --git a/packages/opencode/src/util/link-header.ts b/packages/opencode/src/util/link-header.ts
new file mode 100644
index 000000000000..81475bf1a36e
--- /dev/null
+++ b/packages/opencode/src/util/link-header.ts
@@ -0,0 +1,24 @@
+export function parseLinkHeader(header: string): Record<string, string> {
+  if (!header) return {}
+  const links: Record<string, string> = {}
+  const parts = header.split(/,(?=\s*<)/)
+  for (const part of parts) {
+    const section = part.split(";")
+    if (section.length < 2) continue
+    const url = section[0].replace(/<(.*?)>/, "$1").trim()
+
+    for (const attr of section.slice(1)) {
+      const match = attr.match(/rel=["']?(?<rel>[^"']+)["']?/)
+      if (match?.groups?.rel) {
+        links[match.groups.rel.trim()] = url
+        break
+      }
+    }
+  }
+  return links
+}
+
+export function linkParam(url: string | undefined, key: string) {
+  if (!url || !URL.canParse(url)) return undefined
+  return new URL(url).searchParams.get(key) ?? undefined
+}
diff --git a/packages/opencode/test/cli/tui/pagination-helpers.test.ts b/packages/opencode/test/cli/tui/pagination-helpers.test.ts
new file mode 100644
index 000000000000..4e54a2f15c0f
--- /dev/null
+++ b/packages/opencode/test/cli/tui/pagination-helpers.test.ts
@@ -0,0 +1,187 @@
+import { describe, expect, test } from "bun:test"
+import {
+  edgeHints,
+  evictFromEnd,
+  evictFromStart,
+  hasBeforeBoundary,
+  hasUserBeforeBoundary,
+  messageBefore,
+  messageInsert,
+  olderScrollTarget,
+  paginationError,
+  queueBoundaryLoad,
+  windowNewest,
+  windowOldest,
+} from "../../../src/cli/cmd/tui/util/pagination"
+import type { Message } from "@opencode-ai/sdk/v2"
+
+const make = (ids: string[]) =>
+  ids.map(
+    (id) =>
+      ({
+        id,
+        sessionID: "ses_test",
+        role: "user",
+        agent: "default",
+        model: { providerID: "test", modelID: "test" },
+        time: { created: Date.now() },
+      }) as Message,
+  )
+
+describe("tui pagination helpers", () => {
+  test("window bounds skip pinned message", () => {
+    const messages = make(["m1", "m2", "m3", "m4"])
+    expect(windowOldest(messages, "m1")).toBe("m2")
+    expect(windowNewest(messages, "m4")).toBe("m3")
+  })
+
+  test("detects whether any loaded message is visible before the revert boundary", () => {
+    const boundary = { ...make(["m6"])[0], time: { created: 6 } }
+    expect(hasBeforeBoundary([{ ...make(["m6"])[0], time: { created: 6 } }], boundary)).toBe(false)
+    expect(hasBeforeBoundary([{ ...make(["m5"])[0], time: { created: 5 } }, boundary], boundary)).toBe(true)
+  })
+
+  test("requires a user message before the revert boundary", () => {
+    const boundary = { ...make(["m6"])[0], time: { created: 6 }, role: "user" as const }
+    const assistant = { ...make(["m5"])[0], time: { created: 5 }, role: "assistant" as const }
+    const user = { ...make(["m4"])[0], time: { created: 4 }, role: "user" as const }
+    expect(hasUserBeforeBoundary([assistant, boundary], boundary)).toBe(false)
+    expect(hasUserBeforeBoundary([assistant, user, boundary], boundary)).toBe(true)
+  })
+
+  test("messageBefore sorts by time then id", () => {
+    const a = { ...make(["m1"])[0], time: { created: 1 } }
+    const b = { ...make(["m2"])[0], time: { created: 2 } }
+    expect(messageBefore(a, b)).toBe(true)
+  })
+
+  test("messageBefore handles fractional timestamps numerically", () => {
+    const a = { ...make(["m1"])[0], time: { created: 1710000000000.5 } }
+    const b = { ...make(["m2"])[0], time: { created: 1710000000001 } }
+    expect(messageBefore(a, b)).toBe(true)
+  })
+
+  test("messageInsert uses chronological ordering", () => {
+    const messages = [
+      { ...make(["m2"])[0], time: { created: 20 } },
+      { ...make(["m3"])[0], time: { created: 30 } },
+    ]
+    const result = messageInsert(messages, { ...make(["m1"])[0], time: { created: 10 } })
+    expect(result).toEqual({ found: false, index: 0 })
+  })
+
+  test("evictFromStart skips pinned messages", () => {
+    const messages = make(["m1", "m2", "m3", "m4", "m5"])
+    const evicted = evictFromStart(messages, 2, "m2")
+    expect(evicted.map((m) => m.id)).toEqual(["m1", "m3"])
+    expect(messages.map((m) => m.id)).toEqual(["m2", "m4", "m5"])
+  })
+
+  test("evictFromEnd skips pinned messages", () => {
+    const messages = make(["m1", "m2", "m3", "m4", "m5"])
+    const evicted = evictFromEnd(messages, 2, "m4")
+    expect(evicted.map((m) => m.id)).toEqual(["m5", "m3"])
+    expect(messages.map((m) => m.id)).toEqual(["m1", "m2", "m4"])
+  })
+
+  test("paginationError reads object message fields", () => {
+    expect(paginationError({ message: "timeout" })).toBe("timeout")
+    expect(paginationError({ error: { message: "denied" } })).toBe("denied")
+  })
+
+  test("paginationError avoids [object Object] fallback", () => {
+    expect(paginationError({ foo: "bar" })).not.toBe("[object Object]")
+  })
+
+  test("queueBoundaryLoad routes direction by delta", () => {
+    let older = 0
+    let newer = 0
+    const queue = (run: () => void) => run()
+    queueBoundaryLoad(
+      -1,
+      () => older++,
+      () => newer++,
+      queue,
+    )
+    queueBoundaryLoad(
+      1,
+      () => older++,
+      () => newer++,
+      queue,
+    )
+    queueBoundaryLoad(
+      0,
+      () => older++,
+      () => newer++,
+      queue,
+    )
+    expect(older).toBe(1)
+    expect(newer).toBe(1)
+  })
+
+  test("edgeHints computes nearTop and nearBottom", () => {
+    expect(edgeHints(0, 300, 100, 20)).toEqual({ nearTop: true, nearBottom: false })
+    expect(edgeHints(200, 300, 100, 20)).toEqual({ nearTop: false, nearBottom: true })
+  })
+
+  test("olderScrollTarget prefers anchor child", () => {
+    const top = olderScrollTarget(
+      [
+        { id: "m1", y: 80, height: 20 },
+        { id: "m2", y: 120, height: 20 },
+      ],
+      500,
+      400,
+      0,
+      { id: "m1", offset: 3 },
+    )
+    expect(top).toBe(83)
+  })
+
+  test("olderScrollTarget falls back to delta", () => {
+    const top = olderScrollTarget([{ id: "m1", y: 80, height: 20 }], 500, 400, 25, {
+      id: "missing",
+      offset: 0,
+    })
+    expect(top).toBe(125)
+  })
+
+  test("olderScrollTarget can keep viewport unchanged", () => {
+    const top = olderScrollTarget([], 400, 400, 10)
+    expect(top).toBeUndefined()
+  })
+
+  test("anchor restore moves edge state away from top", () => {
+    const top = olderScrollTarget([{ id: "m1", y: 60, height: 20 }], 500, 400, 0, {
+      id: "m1",
+      offset: 0,
+    })
+    expect(top).toBe(60)
+    expect(edgeHints(top!, 500, 100, 20).nearTop).toBe(false)
+  })
+
+  test("command scroll flow updates top hint after older load restore", () => {
+    let older = 0
+    let newer = 0
+    const queue = (run: () => void) => run()
+
+    expect(edgeHints(0, 320, 100, 20)).toEqual({ nearTop: true, nearBottom: false })
+
+    queueBoundaryLoad(
+      -40,
+      () => older++,
+      () => newer++,
+      queue,
+    )
+
+    const top = olderScrollTarget([{ id: "a", y: 55, height: 10 }], 460, 320, 0, {
+      id: "a",
+      offset: 0,
+    })
+
+    expect(older).toBe(1)
+    expect(newer).toBe(0)
+    expect(top).toBe(55)
+    expect(edgeHints(top!, 460, 100, 20)).toEqual({ nearTop: false, nearBottom: false })
+  })
+})
diff --git a/packages/opencode/test/server/httpapi-session.test.ts b/packages/opencode/test/server/httpapi-session.test.ts
index 5f2af06f1ee3..50af851ff875 100644
--- a/packages/opencode/test/server/httpapi-session.test.ts
+++ b/packages/opencode/test/server/httpapi-session.test.ts
@@ -17,6 +17,7 @@ import { MessageID, PartID, type SessionID } from "../../src/session/schema"
 import { MessageV2 } from "../../src/session/message-v2"
 import { Database } from "@/storage/db"
 import { SessionTable } from "@/session/session.sql"
+import { linkParam, parseLinkHeader } from "../../src/util/link-header"
 import * as Log from "@opencode-ai/core/util/log"
 import { eq } from "drizzle-orm"
 import { resetDatabase } from "../fixture/db"
@@ -181,21 +182,29 @@ describe("session HttpApi", () => {
           headers,
         })
         const messagePage = yield* json<MessageV2.WithParts[]>(messages)
-        const nextCursor = messages.headers.get("x-next-cursor")
-        expect(nextCursor).toBeTruthy()
+        const links = parseLinkHeader(messages.headers.get("link") ?? "")
+        const before = linkParam(links.prev, "before")
+        expect(before).toBeTruthy()
         expect(messagePage[0]?.parts[0]).toMatchObject({ type: "text" })
 
-        expect(
-          (yield* request(`${pathFor(SessionPaths.messages, { sessionID: parent.id })}?before=${nextCursor}`, {
-            headers,
-          })).status,
-        ).toBe(400)
+        const older = yield* request(`${pathFor(SessionPaths.messages, { sessionID: parent.id })}?before=${before}`, {
+          headers,
+        })
+        expect(older.status).toBe(200)
+        expect(older.headers.get("x-next-cursor")).toBeNull()
+        expect(parseLinkHeader(older.headers.get("link") ?? "").next).toBeTruthy()
         expect(
           (yield* request(`${pathFor(SessionPaths.messages, { sessionID: parent.id })}?limit=1&before=invalid`, {
             headers,
           })).status,
         ).toBe(400)
 
+        const explicitFalse = yield* requestJson<MessageV2.WithParts[]>(
+          `${pathFor(SessionPaths.messages, { sessionID: parent.id })}?oldest=false`,
+          { headers },
+        )
+        expect(explicitFalse.map((item) => item.info.id)).toEqual([message.info.id, messagePage[0]!.info.id])
+
         expect(
           yield* requestJson<MessageV2.WithParts>(
             pathFor(SessionPaths.message, { sessionID: parent.id, messageID: message.info.id }),
@@ -423,6 +432,40 @@ describe("session HttpApi", () => {
     ),
   )
 
+  it.live(
+    "serves revert preview through Hono bridge",
+    withTmp({ git: true, config: { formatter: false, lsp: false, share: "disabled" } }, (tmp) =>
+      Effect.gen(function* () {
+        const headers = { "x-opencode-directory": tmp.path, "content-type": "application/json" }
+        const session = yield* createSession(tmp.path, { title: "revert preview" })
+        yield* createTextMessage(tmp.path, session.id, "first")
+        const second = yield* createTextMessage(tmp.path, session.id, "second")
+        const third = yield* createTextMessage(tmp.path, session.id, "third")
+
+        expect(
+          yield* requestJson<Session.Info>(pathFor(SessionPaths.revert, { sessionID: session.id }), {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ messageID: second.info.id }),
+          }),
+        ).toMatchObject({ id: session.id })
+
+        const preview = yield* requestJson<{
+          userCount: number
+          nextMessageID?: string
+          items: { id: string; text: string }[]
+        }>(pathFor(SessionPaths.revert, { sessionID: session.id }), { headers })
+
+        expect(preview.userCount).toBe(2)
+        expect(preview.nextMessageID).toBe(third.info.id)
+        expect(preview.items).toEqual([
+          { id: second.info.id, text: "second" },
+          { id: third.info.id, text: "third" },
+        ])
+      }),
+    ),
+  )
+
   it.live(
     "serves remaining non-LLM session mutation routes through Hono bridge",
     withTmp({ git: true, config: { formatter: false, lsp: false } }, (tmp) =>
diff --git a/packages/opencode/test/server/session-messages.test.ts b/packages/opencode/test/server/session-messages.test.ts
index e64d28bb44c2..6857facbe7d6 100644
--- a/packages/opencode/test/server/session-messages.test.ts
+++ b/packages/opencode/test/server/session-messages.test.ts
@@ -4,7 +4,9 @@ import { Instance } from "../../src/project/instance"
 import { Server } from "../../src/server/server"
 import { Session as SessionNs } from "@/session/session"
 import { MessageV2 } from "../../src/session/message-v2"
-import { MessageID, PartID, type SessionID } from "../../src/session/schema"
+import { MessageID, PartID, SessionID, type SessionID as SessionIDType } from "../../src/session/schema"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { linkParam, parseLinkHeader } from "../../src/util/link-header"
 import * as Log from "@opencode-ai/core/util/log"
 import { tmpdir } from "../fixture/fixture"
 
@@ -19,7 +21,7 @@ const svc = {
   create(input?: SessionNs.CreateInput) {
     return run(SessionNs.Service.use((svc) => svc.create(input)))
   },
-  remove(id: SessionID) {
+  remove(id: SessionIDType) {
     return run(SessionNs.Service.use((svc) => svc.remove(id)))
   },
   updateMessage<T extends MessageV2.Info>(msg: T) {
@@ -34,6 +36,47 @@ afterEach(async () => {
   await Instance.disposeAll()
 })
 
+const password = process.env.OPENCODE_SERVER_PASSWORD
+const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode"
+const auth = password ? "Basic " + Buffer.from(`${username}:${password}`).toString("base64") : undefined
+const requestContext: { directory?: string } = {}
+
+const request = (app: ReturnType<typeof Server.Default>, url: string) => {
+  const headers: Record<string, string> = {}
+  if (auth) headers.Authorization = auth
+  if (requestContext.directory) headers["x-opencode-directory"] = requestContext.directory
+  if (Object.keys(headers).length === 0) return app.app.request(url)
+  return app.app.request(url, { headers })
+}
+
+const requestPost = (app: ReturnType<typeof Server.Default>, url: string, body: Record<string, unknown>) => {
+  const headers: Record<string, string> = { "Content-Type": "application/json" }
+  if (auth) headers.Authorization = auth
+  if (requestContext.directory) headers["x-opencode-directory"] = requestContext.directory
+  return app.app.request(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  })
+}
+
+const TEST_TIMEOUT_MS = 120_000
+
+async function withTmp(fn: () => Promise<void>) {
+  await using tmp = await tmpdir({ git: true })
+  const previous = requestContext.directory
+  requestContext.directory = tmp.path
+  try {
+    await Instance.provide({
+      directory: tmp.path,
+      fn,
+    })
+  } finally {
+    requestContext.directory = previous
+    await Instance.disposeAll()
+  }
+}
+
 async function withoutWatcher<T>(fn: () => Promise<T>) {
   if (process.platform !== "win32") return fn()
   const prev = process.env.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER
@@ -46,7 +89,7 @@ async function withoutWatcher<T>(fn: () => Promise<T>) {
   }
 }
 
-async function fill(sessionID: SessionID, count: number, time = (i: number) => Date.now() + i) {
+async function fill(sessionID: SessionIDType, count: number, time = (i: number) => Date.now() + i) {
   const ids = [] as MessageID[]
   for (let i = 0; i < count; i++) {
     const id = MessageID.ascending()
@@ -57,10 +100,9 @@ async function fill(sessionID: SessionID, count: number, time = (i: number) => D
       role: "user",
       time: { created: time(i) },
       agent: "test",
-      model: { providerID: "test", modelID: "test" },
+      model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
       tools: {},
-      mode: "",
-    } as unknown as MessageV2.Info)
+    } satisfies MessageV2.User)
     await svc.updatePart({
       id: PartID.ascending(),
       sessionID,
@@ -73,95 +115,409 @@ async function fill(sessionID: SessionID, count: number, time = (i: number) => D
 }
 
 describe("session messages endpoint", () => {
-  test("returns cursor headers for older pages", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await withoutWatcher(() =>
-      Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const session = await svc.create({})
-          const ids = await fill(session.id, 5)
-          const app = Server.Default().app
-
-          const a = await app.request(`/session/${session.id}/message?limit=2`)
-          expect(a.status).toBe(200)
-          const aBody = (await a.json()) as MessageV2.WithParts[]
-          expect(aBody.map((item) => item.info.id)).toEqual(ids.slice(-2))
-          const cursor = a.headers.get("x-next-cursor")
-          expect(cursor).toBeTruthy()
-          expect(a.headers.get("link")).toContain('rel="next"')
-
-          const b = await app.request(`/session/${session.id}/message?limit=2&before=${encodeURIComponent(cursor!)}`)
-          expect(b.status).toBe(200)
-          const bBody = (await b.json()) as MessageV2.WithParts[]
-          expect(bBody.map((item) => item.info.id)).toEqual(ids.slice(-4, -2))
-
-          await svc.remove(session.id)
-        },
-      }),
-    )
-  })
+  test(
+    "returns Link header with rel=prev for older pages",
+    async () => {
+      await using tmp = await tmpdir({ git: true })
+      await withoutWatcher(() =>
+        Instance.provide({
+          directory: tmp.path,
+          fn: async () => {
+            const session = await svc.create({})
+            const ids = await fill(session.id, 5)
+            const app = Server.Default().app
 
-  test("keeps full-history responses when limit is omitted", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await withoutWatcher(() =>
-      Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const session = await svc.create({})
-          const ids = await fill(session.id, 3)
-          const app = Server.Default().app
-
-          const res = await app.request(`/session/${session.id}/message`)
-          expect(res.status).toBe(200)
-          const body = (await res.json()) as MessageV2.WithParts[]
-          expect(body.map((item) => item.info.id)).toEqual(ids)
-
-          await svc.remove(session.id)
-        },
-      }),
-    )
-  })
+            const a = await app.request(`/session/${session.id}/message?limit=2`)
+            expect(a.status).toBe(200)
+            const aBody = (await a.json()) as MessageV2.WithParts[]
+            expect(aBody.map((item) => item.info.id)).toEqual(ids.slice(-2))
+            const links = parseLinkHeader(a.headers.get("link") ?? "")
+            expect(links.prev).toBeDefined()
+            const before = linkParam(links.prev, "before")
+            expect(before).toBeTruthy()
 
-  test("rejects invalid cursors and missing sessions", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await withoutWatcher(() =>
-      Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const session = await svc.create({})
-          const app = Server.Default().app
-
-          const bad = await app.request(`/session/${session.id}/message?limit=2&before=bad`)
-          expect(bad.status).toBe(400)
-
-          const miss = await app.request(`/session/ses_missing/message?limit=2`)
-          expect(miss.status).toBe(404)
-
-          await svc.remove(session.id)
-        },
-      }),
-    )
-  })
+            const b = await app.request(`/session/${session.id}/message?limit=2&before=${encodeURIComponent(before!)}`)
+            expect(b.status).toBe(200)
+            const bBody = (await b.json()) as MessageV2.WithParts[]
+            expect(bBody.map((item) => item.info.id)).toEqual(ids.slice(-4, -2))
 
-  test("does not truncate large legacy limit requests", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await withoutWatcher(() =>
-      Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const session = await svc.create({})
-          await fill(session.id, 520)
-          const app = Server.Default().app
-
-          const res = await app.request(`/session/${session.id}/message?limit=510`)
-          expect(res.status).toBe(200)
-          const body = (await res.json()) as MessageV2.WithParts[]
-          expect(body).toHaveLength(510)
-
-          await svc.remove(session.id)
-        },
-      }),
-    )
-  })
+            await svc.remove(session.id)
+          },
+        }),
+      )
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "keeps full-history responses when limit is omitted",
+    async () => {
+      await using tmp = await tmpdir({ git: true })
+      await withoutWatcher(() =>
+        Instance.provide({
+          directory: tmp.path,
+          fn: async () => {
+            const session = await svc.create({})
+            const ids = await fill(session.id, 3)
+            const app = Server.Default().app
+
+            const res = await app.request(`/session/${session.id}/message`)
+            expect(res.status).toBe(200)
+            const body = (await res.json()) as MessageV2.WithParts[]
+            expect(body.map((item) => item.info.id)).toEqual(ids)
+
+            const explicitFalse = await app.request(`/session/${session.id}/message?oldest=false`)
+            expect(explicitFalse.status).toBe(200)
+            const explicitFalseBody = (await explicitFalse.json()) as MessageV2.WithParts[]
+            expect(explicitFalseBody.map((item) => item.info.id)).toEqual(ids)
+
+            await svc.remove(session.id)
+          },
+        }),
+      )
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "rejects invalid cursors and missing sessions",
+    async () => {
+      await using tmp = await tmpdir({ git: true })
+      await withoutWatcher(() =>
+        Instance.provide({
+          directory: tmp.path,
+          fn: async () => {
+            const session = await svc.create({})
+            const app = Server.Default().app
+
+            const bad = await app.request(`/session/${session.id}/message?limit=2&before=bad`)
+            expect(bad.status).toBe(400)
+
+            const miss = await app.request(`/session/ses_missing/message?limit=2`)
+            expect(miss.status).toBe(404)
+
+            await svc.remove(session.id)
+          },
+        }),
+      )
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "does not truncate large legacy limit requests",
+    async () => {
+      await using tmp = await tmpdir({ git: true })
+      await withoutWatcher(() =>
+        Instance.provide({
+          directory: tmp.path,
+          fn: async () => {
+            const session = await svc.create({})
+            await fill(session.id, 520)
+            const app = Server.Default().app
+
+            const res = await app.request(`/session/${session.id}/message?limit=510`)
+            expect(res.status).toBe(200)
+            const body = (await res.json()) as MessageV2.WithParts[]
+            expect(body).toHaveLength(510)
+
+            await svc.remove(session.id)
+          },
+        }),
+      )
+    },
+    TEST_TIMEOUT_MS,
+  )
+})
+
+describe("session.messages API", () => {
+  test(
+    "returns 400 when both before and after specified",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+        await fill(session.id, 3)
+        const first = await request(app, `/session/${session.id}/message?limit=1`)
+        const cur = linkParam(parseLinkHeader(first.headers.get("Link") ?? "").prev, "before")
+
+        const response = await request(app, `/session/${session.id}/message?before=${cur}&after=${cur}&limit=2`)
+
+        expect(response.status).toBe(400)
+        const body = (await response.json()) as { error: string }
+        expect(body.error).toContain("Cannot specify both")
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "includes Link header with rel=prev when more pages exist (latest page)",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+        await fill(session.id, 5)
+
+        const response = await request(app, `/session/${session.id}/message?limit=2`)
+
+        expect(response.status).toBe(200)
+        const links = parseLinkHeader(response.headers.get("Link") ?? "")
+        expect(links.prev).toBeDefined()
+        expect(linkParam(links.prev, "before")).toBeTruthy()
+        expect(links.next).toBeUndefined()
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "before cursor returns older page and exposes rel=next",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+        const ids = await fill(session.id, 5)
+
+        const latest = await request(app, `/session/${session.id}/message?limit=2`)
+        const latestLinks = parseLinkHeader(latest.headers.get("Link") ?? "")
+        const before = linkParam(latestLinks.prev, "before")
+
+        const response = await request(app, `/session/${session.id}/message?before=${before}&limit=2`)
+        expect(response.status).toBe(200)
+        const body = (await response.json()) as Array<{ info: { id: string } }>
+        expect(body.map((item) => item.info.id)).toEqual([ids[1], ids[2]])
+
+        const links = parseLinkHeader(response.headers.get("Link") ?? "")
+        expect(links.prev).toBeDefined()
+        expect(links.next).toBeDefined()
+        expect(linkParam(links.prev, "before")).toBeTruthy()
+        expect(linkParam(links.next, "after")).toBeTruthy()
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "oldest=true returns messages in ascending order with rel=next Link",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+        const ids = await fill(session.id, 5)
+
+        const response = await request(app, `/session/${session.id}/message?oldest=true&limit=2`)
+
+        expect(response.status).toBe(200)
+        const messages = (await response.json()) as Array<{ info: { id: string } }>
+        expect(messages.map((item) => item.info.id)).toEqual([ids[0], ids[1]])
+
+        const links = parseLinkHeader(response.headers.get("Link") ?? "")
+        expect(links.next).toBeDefined()
+        expect(linkParam(links.next, "after")).toBeTruthy()
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "after cursor returns newer page and exposes rel=prev",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+        const ids = await fill(session.id, 5)
+
+        const oldest = await request(app, `/session/${session.id}/message?oldest=true&limit=2`)
+        const oldestLinks = parseLinkHeader(oldest.headers.get("Link") ?? "")
+        const after = linkParam(oldestLinks.next, "after")
+
+        const response = await request(app, `/session/${session.id}/message?after=${after}&limit=2`)
+        expect(response.status).toBe(200)
+        const body = (await response.json()) as Array<{ info: { id: string } }>
+        expect(body.map((item) => item.info.id)).toEqual([ids[2], ids[3]])
+
+        const links = parseLinkHeader(response.headers.get("Link") ?? "")
+        expect(links.prev).toBeDefined()
+        expect(links.next).toBeDefined()
+        expect(linkParam(links.prev, "before")).toBeTruthy()
+        expect(linkParam(links.next, "after")).toBeTruthy()
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "returns 400 for invalid cursor",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+
+        const response = await request(app, `/session/${session.id}/message?before=invalid&limit=2`)
+        expect(response.status).toBe(400)
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "single message responses include server-generated cursor",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+        const [messageID] = await fill(session.id, 1)
+
+        const response = await request(app, `/session/${session.id}/message/${messageID}`)
+        expect(response.status).toBe(200)
+        const body = (await response.json()) as MessageV2.WithParts
+        expect(body.cursor).toBeTruthy()
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "returns 400 when oldest used with before or after",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+        await fill(session.id, 3)
+        const first = await request(app, `/session/${session.id}/message?limit=1`)
+        const cur = linkParam(parseLinkHeader(first.headers.get("Link") ?? "").prev, "before")
+
+        const response1 = await request(app, `/session/${session.id}/message?oldest=true&before=${cur}&limit=2`)
+        expect(response1.status).toBe(400)
+        const response2 = await request(app, `/session/${session.id}/message?oldest=true&after=${cur}&limit=2`)
+        expect(response2.status).toBe(400)
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "limit=0 returns empty results",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+        await fill(session.id, 3)
+
+        const response = await request(app, `/session/${session.id}/message?limit=0`)
+        expect(response.status).toBe(200)
+        expect(await response.json()).toEqual([])
+        expect(response.headers.get("Link")).toBeNull()
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "limit=0 still validates session existence",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const response = await request(app, `/session/${SessionID.descending()}/message?limit=0`)
+        expect(response.status).toBe(404)
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "revert preview returns all reverted user messages and next restore boundary",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+        const ids = await fill(session.id, 5)
+
+        const revert = await requestPost(app, `/session/${session.id}/revert`, { messageID: ids[1] })
+        expect(revert.status).toBe(200)
+
+        const preview = await request(app, `/session/${session.id}/revert`)
+        expect(preview.status).toBe(200)
+        const body = (await preview.json()) as {
+          userCount: number
+          nextMessageID?: string
+          items: { id: string; text: string }[]
+        }
+
+        expect(body.userCount).toBe(4)
+        expect(body.nextMessageID).toBe(ids[2])
+        expect(body.items).toEqual([
+          { id: ids[1], text: "m1" },
+          { id: ids[2], text: "m2" },
+          { id: ids[3], text: "m3" },
+          { id: ids[4], text: "m4" },
+        ])
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
+
+  test(
+    "revert preview disables stepwise redo for part-level reverts",
+    async () => {
+      await withTmp(async () => {
+        const app = Server.Default()
+        const session = await svc.create({})
+        const [userID] = await fill(session.id, 1)
+        const assistantID = MessageID.ascending()
+        await svc.updateMessage({
+          id: assistantID,
+          sessionID: session.id,
+          role: "assistant",
+          time: { created: Date.now() + 10 },
+          parentID: userID,
+          modelID: ModelID.make("test"),
+          providerID: ProviderID.make("test"),
+          mode: "",
+          agent: "default",
+          path: { cwd: "/", root: "/" },
+          cost: 0,
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        } satisfies MessageV2.Assistant)
+        const firstPartID = PartID.ascending()
+        const secondPartID = PartID.ascending()
+        await svc.updatePart({
+          id: firstPartID,
+          sessionID: session.id,
+          messageID: assistantID,
+          type: "text",
+          text: "first",
+        } satisfies MessageV2.TextPart)
+        await svc.updatePart({
+          id: secondPartID,
+          sessionID: session.id,
+          messageID: assistantID,
+          type: "text",
+          text: "second",
+        } satisfies MessageV2.TextPart)
+
+        const revert = await requestPost(app, `/session/${session.id}/revert`, {
+          messageID: assistantID,
+          partID: secondPartID,
+        })
+        expect(revert.status).toBe(200)
+
+        const preview = await request(app, `/session/${session.id}/revert`)
+        expect(preview.status).toBe(200)
+        const body = (await preview.json()) as {
+          userCount: number
+          nextMessageID?: string
+          partID?: string
+          items: { id: string; text: string }[]
+        }
+
+        expect(body.userCount).toBe(0)
+        expect(body.partID).toBe(secondPartID)
+        expect(body.nextMessageID).toBeUndefined()
+        expect(body.items).toEqual([{ id: assistantID, text: "first\n\nsecond" }])
+      })
+    },
+    TEST_TIMEOUT_MS,
+  )
 })
diff --git a/packages/opencode/test/server/session-select.test.ts b/packages/opencode/test/server/session-select.test.ts
index 278fba94dcf8..4582a16dd8d9 100644
--- a/packages/opencode/test/server/session-select.test.ts
+++ b/packages/opencode/test/server/session-select.test.ts
@@ -27,74 +27,64 @@ afterEach(async () => {
   await Instance.disposeAll()
 })
 
-describe("tui.selectSession endpoint", () => {
-  test("should return 200 when called with valid session", async () => {
-    await using tmp = await tmpdir({ git: true })
+const password = process.env.OPENCODE_SERVER_PASSWORD
+const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode"
+const auth = password ? "Basic " + Buffer.from(`${username}:${password}`).toString("base64") : undefined
+
+const request = (app: ReturnType<typeof Server.Default>, url: string, body: Record<string, unknown>) => {
+  const headers: Record<string, string> = { "Content-Type": "application/json" }
+  if (auth) headers.Authorization = auth
+  return app.app.request(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  })
+}
+
+async function withTmp(fn: () => Promise<void>) {
+  await using tmp = await tmpdir({ git: true })
+  try {
     await Instance.provide({
       directory: tmp.path,
-      fn: async () => {
-        // #given
-        const session = await svc.create({})
+      fn,
+    })
+  } finally {
+    await Instance.disposeAll()
+  }
+}
 
-        // #when
-        const app = Server.Default().app
-        const response = await app.request("/tui/select-session", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: session.id }),
-        })
+describe("tui.selectSession endpoint", () => {
+  test("should return 200 when called with valid session", async () => {
+    await withTmp(async () => {
+      const session = await svc.create({})
+      const app = Server.Default()
+      const response = await request(app, "/tui/select-session", { sessionID: session.id })
 
-        // #then
-        expect(response.status).toBe(200)
-        const body = await response.json()
-        expect(body).toBe(true)
+      expect(response.status).toBe(200)
+      const body = await response.json()
+      expect(body).toBe(true)
 
-        await svc.remove(session.id)
-      },
+      await svc.remove(session.id)
     })
   })
 
   test("should return 404 when session does not exist", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // #given
-        const nonExistentSessionID = "ses_nonexistent123"
+    await withTmp(async () => {
+      const nonExistentSessionID = "ses_nonexistent123"
+      const app = Server.Default()
+      const response = await request(app, "/tui/select-session", { sessionID: nonExistentSessionID })
 
-        // #when
-        const app = Server.Default().app
-        const response = await app.request("/tui/select-session", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: nonExistentSessionID }),
-        })
-
-        // #then
-        expect(response.status).toBe(404)
-      },
+      expect(response.status).toBe(404)
     })
   })
 
   test("should return 400 when session ID format is invalid", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // #given
-        const invalidSessionID = "invalid_session_id"
-
-        // #when
-        const app = Server.Default().app
-        const response = await app.request("/tui/select-session", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: invalidSessionID }),
-        })
+    await withTmp(async () => {
+      const invalidSessionID = "invalid_session_id"
+      const app = Server.Default()
+      const response = await request(app, "/tui/select-session", { sessionID: invalidSessionID })
 
-        // #then
-        expect(response.status).toBe(400)
-      },
+      expect(response.status).toBe(400)
     })
   })
 })
diff --git a/packages/opencode/test/session/messages-pagination.test.ts b/packages/opencode/test/session/messages-pagination.test.ts
index 17370bbe62a8..47fea97c59a8 100644
--- a/packages/opencode/test/session/messages-pagination.test.ts
+++ b/packages/opencode/test/session/messages-pagination.test.ts
@@ -4,7 +4,7 @@ import path from "path"
 import { Instance } from "../../src/project/instance"
 import { Session as SessionNs } from "@/session/session"
 import { MessageV2 } from "../../src/session/message-v2"
-import { MessageID, PartID, type SessionID } from "../../src/session/schema"
+import { MessageID, PartID, SessionID, type SessionID as SessionIDType } from "../../src/session/schema"
 import { ModelID, ProviderID } from "../../src/provider/schema"
 import * as Log from "@opencode-ai/core/util/log"
 
@@ -20,7 +20,7 @@ const svc = {
   create(input?: SessionNs.CreateInput) {
     return run(SessionNs.Service.use((svc) => svc.create(input)))
   },
-  remove(id: SessionID) {
+  remove(id: SessionIDType) {
     return run(SessionNs.Service.use((svc) => svc.remove(id)))
   },
   updateMessage<T extends MessageV2.Info>(msg: T) {
@@ -29,12 +29,12 @@ const svc = {
   updatePart<T extends MessageV2.Part>(part: T) {
     return run(SessionNs.Service.use((svc) => svc.updatePart(part)))
   },
-  fork(input: { sessionID: SessionID; messageID?: MessageID }) {
+  fork(input: { sessionID: SessionIDType; messageID?: MessageID }) {
     return run(SessionNs.Service.use((svc) => svc.fork(input)))
   },
 }
 
-async function fill(sessionID: SessionID, count: number, time = (i: number) => Date.now() + i) {
+async function fill(sessionID: SessionIDType, count: number, time = (i: number) => Date.now() + i) {
   const ids = [] as MessageID[]
   for (let i = 0; i < count; i++) {
     const id = MessageID.ascending()
@@ -45,10 +45,9 @@ async function fill(sessionID: SessionID, count: number, time = (i: number) => D
       role: "user",
       time: { created: time(i) },
       agent: "test",
-      model: { providerID: "test", modelID: "test" },
+      model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
       tools: {},
-      mode: "",
-    } as unknown as MessageV2.Info)
+    } satisfies MessageV2.User)
     await svc.updatePart({
       id: PartID.ascending(),
       sessionID,
@@ -60,7 +59,7 @@ async function fill(sessionID: SessionID, count: number, time = (i: number) => D
   return ids
 }
 
-async function addUser(sessionID: SessionID, text?: string) {
+async function addUser(sessionID: SessionIDType, text?: string) {
   const id = MessageID.ascending()
   await svc.updateMessage({
     id,
@@ -68,10 +67,9 @@ async function addUser(sessionID: SessionID, text?: string) {
     role: "user",
     time: { created: Date.now() },
     agent: "test",
-    model: { providerID: "test", modelID: "test" },
+    model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
     tools: {},
-    mode: "",
-  } as unknown as MessageV2.Info)
+  } satisfies MessageV2.User)
   if (text) {
     await svc.updatePart({
       id: PartID.ascending(),
@@ -85,7 +83,7 @@ async function addUser(sessionID: SessionID, text?: string) {
 }
 
 async function addAssistant(
-  sessionID: SessionID,
+  sessionID: SessionIDType,
   parentID: MessageID,
   opts?: { summary?: boolean; finish?: string; error?: MessageV2.Assistant["error"] },
 ) {
@@ -106,11 +104,11 @@ async function addAssistant(
     summary: opts?.summary,
     finish: opts?.finish,
     error: opts?.error,
-  } as unknown as MessageV2.Info)
+  } satisfies MessageV2.Assistant)
   return id
 }
 
-async function addCompactionPart(sessionID: SessionID, messageID: MessageID, tailStartID?: MessageID) {
+async function addCompactionPart(sessionID: SessionIDType, messageID: MessageID, tailStartID?: MessageID) {
   await svc.updatePart({
     id: PartID.ascending(),
     sessionID,
@@ -118,7 +116,7 @@ async function addCompactionPart(sessionID: SessionID, messageID: MessageID, tai
     type: "compaction",
     auto: true,
     tail_start_id: tailStartID,
-  } as any)
+  } satisfies MessageV2.CompactionPart)
 }
 
 describe("MessageV2.page", () => {
@@ -148,18 +146,15 @@ describe("MessageV2.page", () => {
         const a = MessageV2.page({ sessionID: session.id, limit: 2 })
         expect(a.items.map((item) => item.info.id)).toEqual(ids.slice(-2))
         expect(a.items.every((item) => item.parts.length === 1)).toBe(true)
-        expect(a.more).toBe(true)
-        expect(a.cursor).toBeTruthy()
+        expect(a.before).toBeTruthy()
 
-        const b = MessageV2.page({ sessionID: session.id, limit: 2, before: a.cursor! })
+        const b = MessageV2.page({ sessionID: session.id, limit: 2, before: a.before! })
         expect(b.items.map((item) => item.info.id)).toEqual(ids.slice(-4, -2))
-        expect(b.more).toBe(true)
-        expect(b.cursor).toBeTruthy()
+        expect(b.before).toBeTruthy()
 
-        const c = MessageV2.page({ sessionID: session.id, limit: 2, before: b.cursor! })
+        const c = MessageV2.page({ sessionID: session.id, limit: 2, before: b.before! })
         expect(c.items.map((item) => item.info.id)).toEqual(ids.slice(0, 2))
-        expect(c.more).toBe(false)
-        expect(c.cursor).toBeUndefined()
+        expect(c.before).toBeUndefined()
 
         await svc.remove(session.id)
       },
@@ -189,8 +184,8 @@ describe("MessageV2.page", () => {
 
         const result = MessageV2.page({ sessionID: session.id, limit: 10 })
         expect(result.items).toEqual([])
-        expect(result.more).toBe(false)
-        expect(result.cursor).toBeUndefined()
+        expect(result.before).toBeUndefined()
+        expect(result.after).toBeUndefined()
 
         await svc.remove(session.id)
       },
@@ -216,8 +211,7 @@ describe("MessageV2.page", () => {
 
         const result = MessageV2.page({ sessionID: session.id, limit: 3 })
         expect(result.items.map((item) => item.info.id)).toEqual(ids)
-        expect(result.more).toBe(false)
-        expect(result.cursor).toBeUndefined()
+        expect(result.before).toBeUndefined()
 
         await svc.remove(session.id)
       },
@@ -234,7 +228,7 @@ describe("MessageV2.page", () => {
         const result = MessageV2.page({ sessionID: session.id, limit: 1 })
         expect(result.items).toHaveLength(1)
         expect(result.items[0].info.id).toBe(ids[ids.length - 1])
-        expect(result.more).toBe(true)
+        expect(result.before).toBeTruthy()
 
         await svc.remove(session.id)
       },
@@ -273,7 +267,7 @@ describe("MessageV2.page", () => {
         const ids = await fill(session.id, 4, (i) => 1000.5 + i)
 
         const a = MessageV2.page({ sessionID: session.id, limit: 2 })
-        const b = MessageV2.page({ sessionID: session.id, limit: 2, before: a.cursor! })
+        const b = MessageV2.page({ sessionID: session.id, limit: 2, before: a.before! })
 
         expect(a.items.map((item) => item.info.id)).toEqual(ids.slice(-2))
         expect(b.items.map((item) => item.info.id)).toEqual(ids.slice(0, 2))
@@ -292,11 +286,11 @@ describe("MessageV2.page", () => {
 
         const a = MessageV2.page({ sessionID: session.id, limit: 2 })
         expect(a.items.map((item) => item.info.id)).toEqual(ids.slice(-2))
-        expect(a.more).toBe(true)
+        expect(a.before).toBeTruthy()
 
-        const b = MessageV2.page({ sessionID: session.id, limit: 2, before: a.cursor! })
+        const b = MessageV2.page({ sessionID: session.id, limit: 2, before: a.before! })
         expect(b.items.map((item) => item.info.id)).toEqual(ids.slice(0, 2))
-        expect(b.more).toBe(false)
+        expect(b.before).toBeUndefined()
 
         await svc.remove(session.id)
       },
@@ -335,8 +329,53 @@ describe("MessageV2.page", () => {
         const result = MessageV2.page({ sessionID: session.id, limit: 100 })
         expect(result.items).toHaveLength(10)
         expect(result.items.map((item) => item.info.id)).toEqual(ids)
-        expect(result.more).toBe(false)
-        expect(result.cursor).toBeUndefined()
+        expect(result.before).toBeUndefined()
+        expect(result.after).toBeUndefined()
+
+        await svc.remove(session.id)
+      },
+    })
+  })
+
+  test("pages forward with after cursors and oldest jump", async () => {
+    await Instance.provide({
+      directory: root,
+      fn: async () => {
+        const session = await svc.create({})
+        const ids = await fill(session.id, 6)
+
+        const oldest = MessageV2.page({ sessionID: session.id, limit: 2, oldest: true })
+        expect(oldest.items.map((item) => item.info.id)).toEqual(ids.slice(0, 2))
+        expect(oldest.before).toBeUndefined()
+        expect(oldest.after).toBeTruthy()
+
+        const middle = MessageV2.page({ sessionID: session.id, limit: 2, after: oldest.after! })
+        expect(middle.items.map((item) => item.info.id)).toEqual(ids.slice(2, 4))
+        expect(middle.before).toBeTruthy()
+        expect(middle.after).toBeTruthy()
+
+        const latest = MessageV2.page({ sessionID: session.id, limit: 2, after: middle.after! })
+        expect(latest.items.map((item) => item.info.id)).toEqual(ids.slice(4, 6))
+        expect(latest.before).toBeTruthy()
+        expect(latest.after).toBeUndefined()
+
+        await svc.remove(session.id)
+      },
+    })
+  })
+
+  test("rejects incompatible cursor combinations", async () => {
+    await Instance.provide({
+      directory: root,
+      fn: async () => {
+        const session = await svc.create({})
+        await fill(session.id, 2)
+
+        const seed = MessageV2.page({ sessionID: session.id, limit: 1 })
+        expect(() =>
+          MessageV2.page({ sessionID: session.id, limit: 1, before: seed.before!, after: seed.before! }),
+        ).toThrow()
+        expect(() => MessageV2.page({ sessionID: session.id, limit: 1, oldest: true, before: seed.before! })).toThrow()
 
         await svc.remove(session.id)
       },
@@ -1048,19 +1087,27 @@ describe("MessageV2.filterCompacted", () => {
   })
 
   test("works with array input", () => {
-    // filterCompacted accepts any Iterable, not just generators
+    const sessionID = SessionID.descending()
     const id = MessageID.ascending()
     const items: MessageV2.WithParts[] = [
       {
         info: {
           id,
-          sessionID: "s1",
+          sessionID,
           role: "user",
           time: { created: 1 },
           agent: "test",
-          model: { providerID: "test", modelID: "test" },
-        } as unknown as MessageV2.Info,
-        parts: [{ type: "text", text: "hello" }] as unknown as MessageV2.Part[],
+          model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
+        } satisfies MessageV2.User,
+        parts: [
+          {
+            id: PartID.ascending(),
+            sessionID,
+            messageID: id,
+            type: "text",
+            text: "hello",
+          } satisfies MessageV2.TextPart,
+        ],
       },
     ]
     const result = MessageV2.filterCompacted(items)
@@ -1143,8 +1190,8 @@ describe("MessageV2 consistency", () => {
           for (let i = result.items.length - 1; i >= 0; i--) {
             paged.push(result.items[i])
           }
-          if (!result.more || !result.cursor) break
-          cursor = result.cursor
+          if (!result.before) break
+          cursor = result.before
         }
 
         expect(streamed.map((m) => m.info.id)).toEqual(paged.map((m) => m.info.id))
diff --git a/packages/opencode/test/util/parse-link-header.test.ts b/packages/opencode/test/util/parse-link-header.test.ts
new file mode 100644
index 000000000000..aafb25d30e4a
--- /dev/null
+++ b/packages/opencode/test/util/parse-link-header.test.ts
@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test"
+import { linkParam, parseLinkHeader } from "../../src/util/link-header"
+
+describe("util.parseLinkHeader", () => {
+  test("returns empty object for empty string", () => {
+    expect(parseLinkHeader("")).toEqual({})
+  })
+
+  test("parses single link with rel", () => {
+    const header = '<https://api.example.com/items?page=2>; rel="next"'
+    expect(parseLinkHeader(header)).toEqual({
+      next: "https://api.example.com/items?page=2",
+    })
+  })
+
+  test("parses multiple links", () => {
+    const header =
+      '<https://api.example.com/items?page=1>; rel="prev", <https://api.example.com/items?page=3>; rel="next"'
+    expect(parseLinkHeader(header)).toEqual({
+      prev: "https://api.example.com/items?page=1",
+      next: "https://api.example.com/items?page=3",
+    })
+  })
+
+  test("handles unquoted rel values", () => {
+    const header = "<https://example.com>; rel=next"
+    expect(parseLinkHeader(header)).toEqual({
+      next: "https://example.com",
+    })
+  })
+
+  test("handles single-quoted rel values", () => {
+    const header = "<https://example.com>; rel='next'"
+    expect(parseLinkHeader(header)).toEqual({
+      next: "https://example.com",
+    })
+  })
+
+  test("ignores links without rel attribute", () => {
+    const header = "<https://example.com>; type=text/html"
+    expect(parseLinkHeader(header)).toEqual({})
+  })
+
+  test("handles malformed input gracefully", () => {
+    expect(parseLinkHeader("not a valid header")).toEqual({})
+    expect(parseLinkHeader("<<>>;;")).toEqual({})
+  })
+
+  test("handles extra whitespace", () => {
+    const header = '  <https://example.com>  ;  rel="next"  '
+    expect(parseLinkHeader(header)).toEqual({
+      next: "https://example.com",
+    })
+  })
+
+  test("extracts query params from parsed link urls", () => {
+    const links = parseLinkHeader('<https://example.com/items?before=abc&limit=100>; rel="prev"')
+    expect(linkParam(links.prev, "before")).toBe("abc")
+    expect(linkParam(links.prev, "limit")).toBe("100")
+  })
+
+  test("returns undefined for invalid link param url", () => {
+    expect(linkParam("not a url", "before")).toBeUndefined()
+  })
+})
diff --git a/packages/sdk/js/src/v2/gen/sdk.gen.ts b/packages/sdk/js/src/v2/gen/sdk.gen.ts
index 67261d7499a8..6b022d613ea8 100644
--- a/packages/sdk/js/src/v2/gen/sdk.gen.ts
+++ b/packages/sdk/js/src/v2/gen/sdk.gen.ts
@@ -142,6 +142,8 @@ import type {
   SessionPromptErrors,
   SessionPromptResponses,
   SessionRevertErrors,
+  SessionRevertPreviewErrors,
+  SessionRevertPreviewResponses,
   SessionRevertResponses,
   SessionShareErrors,
   SessionShareResponses,
@@ -2193,6 +2195,8 @@ export class Session2 extends HeyApiClient {
       workspace?: string
       limit?: number
       before?: string
+      after?: string
+      oldest?: boolean | "true" | "false"
     },
     options?: Options<never, ThrowOnError>,
   ) {
@@ -2206,6 +2210,8 @@ export class Session2 extends HeyApiClient {
             { in: "query", key: "workspace" },
             { in: "query", key: "limit" },
             { in: "query", key: "before" },
+            { in: "query", key: "after" },
+            { in: "query", key: "oldest" },
           ],
         },
       ],
@@ -2515,6 +2521,42 @@ export class Session2 extends HeyApiClient {
     })
   }
 
+  /**
+   * Get revert preview
+   *
+   * Return the reverted user messages and next restore boundary for a reverted session.
+   */
+  public revertPreview<ThrowOnError extends boolean = false>(
+    parameters: {
+      sessionID: string
+      directory?: string
+      workspace?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "sessionID" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).get<
+      SessionRevertPreviewResponses,
+      SessionRevertPreviewErrors,
+      ThrowOnError
+    >({
+      url: "/session/{sessionID}/revert",
+      ...options,
+      ...params,
+    })
+  }
+
   /**
    * Revert message
    *
diff --git a/packages/sdk/js/src/v2/gen/types.gen.ts b/packages/sdk/js/src/v2/gen/types.gen.ts
index b925ec60969d..d5d1c10c65cc 100644
--- a/packages/sdk/js/src/v2/gen/types.gen.ts
+++ b/packages/sdk/js/src/v2/gen/types.gen.ts
@@ -3800,6 +3800,8 @@ export type SessionMessagesData = {
      */
     limit?: number
     before?: string
+    after?: string
+    oldest?: boolean | "true" | "false"
   }
   url: "/session/{sessionID}/message"
 }
@@ -3824,6 +3826,7 @@ export type SessionMessagesResponses = {
   200: Array<{
     info: Message
     parts: Array<Part>
+    cursor?: string
   }>
 }
 
@@ -3952,6 +3955,7 @@ export type SessionMessageResponses = {
   200: {
     info: Message
     parts: Array<Part>
+    cursor?: string
   }
 }
 
@@ -4173,11 +4177,54 @@ export type SessionShellResponses = {
   200: {
     info: Message
     parts: Array<Part>
+    cursor?: string
   }
 }
 
 export type SessionShellResponse = SessionShellResponses[keyof SessionShellResponses]
 
+export type SessionRevertPreviewData = {
+  body?: never
+  path: {
+    sessionID: string
+  }
+  query?: {
+    directory?: string
+    workspace?: string
+  }
+  url: "/session/{sessionID}/revert"
+}
+
+export type SessionRevertPreviewErrors = {
+  /**
+   * Bad request
+   */
+  400: BadRequestError
+  /**
+   * Not found
+   */
+  404: NotFoundError
+}
+
+export type SessionRevertPreviewError = SessionRevertPreviewErrors[keyof SessionRevertPreviewErrors]
+
+export type SessionRevertPreviewResponses = {
+  /**
+   * Revert preview
+   */
+  200: {
+    userCount: number
+    nextMessageID?: string
+    partID?: string
+    items: Array<{
+      id: string
+      text: string
+    }>
+  } | null
+}
+
+export type SessionRevertPreviewResponse = SessionRevertPreviewResponses[keyof SessionRevertPreviewResponses]
+
 export type SessionRevertData = {
   body?: {
     messageID: string
diff --git a/packages/sdk/openapi.json b/packages/sdk/openapi.json
index cfd8277a3ba9..ef772b77d237 100644
--- a/packages/sdk/openapi.json
+++ b/packages/sdk/openapi.json
@@ -3478,6 +3478,28 @@
             "schema": {
               "type": "string"
             }
+          },
+          {
+            "in": "query",
+            "name": "after",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "in": "query",
+            "name": "oldest",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "enum": ["true", "false"]
+                }
+              ]
+            }
           }
         ],
         "summary": "Get session messages",
@@ -3485,6 +3507,14 @@
         "responses": {
           "200": {
             "description": "List of messages",
+            "headers": {
+              "Link": {
+                "description": "RFC 8288 pagination links for previous/next message pages",
+                "schema": {
+                  "type": "string"
+                }
+              }
+            },
             "content": {
               "application/json": {
                 "schema": {
@@ -3500,6 +3530,9 @@
                         "items": {
                           "$ref": "#/components/schemas/Part"
                         }
+                      },
+                      "cursor": {
+                        "type": "string"
                       }
                     },
                     "required": ["info", "parts"]
@@ -3744,6 +3777,9 @@
                       "items": {
                         "$ref": "#/components/schemas/Part"
                       }
+                    },
+                    "cursor": {
+                      "type": "string"
                     }
                   },
                   "required": ["info", "parts"]
@@ -4361,6 +4397,9 @@
                       "items": {
                         "$ref": "#/components/schemas/Part"
                       }
+                    },
+                    "cursor": {
+                      "type": "string"
                     }
                   },
                   "required": ["info", "parts"]
@@ -4432,6 +4471,111 @@
       }
     },
     "/session/{sessionID}/revert": {
+      "get": {
+        "operationId": "session.revertPreview",
+        "parameters": [
+          {
+            "in": "query",
+            "name": "directory",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "in": "query",
+            "name": "workspace",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "in": "path",
+            "name": "sessionID",
+            "schema": {
+              "type": "string",
+              "pattern": "^ses.*"
+            },
+            "required": true
+          }
+        ],
+        "summary": "Get revert preview",
+        "description": "Return the reverted user messages and next restore boundary for a reverted session.",
+        "responses": {
+          "200": {
+            "description": "Revert preview",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "type": "object",
+                      "properties": {
+                        "userCount": {
+                          "type": "number"
+                        },
+                        "nextMessageID": {
+                          "type": "string",
+                          "pattern": "^msg.*"
+                        },
+                        "partID": {
+                          "type": "string",
+                          "pattern": "^prt.*"
+                        },
+                        "items": {
+                          "type": "array",
+                          "items": {
+                            "type": "object",
+                            "properties": {
+                              "id": {
+                                "type": "string",
+                                "pattern": "^msg.*"
+                              },
+                              "text": {
+                                "type": "string"
+                              }
+                            },
+                            "required": ["id", "text"]
+                          }
+                        }
+                      },
+                      "required": ["userCount", "items"]
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/BadRequestError"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/NotFoundError"
+                }
+              }
+            }
+          }
+        },
+        "x-codeSamples": [
+          {
+            "lang": "js",
+            "source": "import { createOpencodeClient } from \"@opencode-ai/sdk\n\nconst client = createOpencodeClient()\nawait client.session.revertPreview({\n  ...\n})"
+          }
+        ]
+      },
       "post": {
         "operationId": "session.revert",
         "parameters": [