3 files changed, 27 insertions, 20 deletions

diff --git a/src/core/chunks/trim.test.ts b/src/core/chunks/trim.test.ts
index 7c4bbef..24c75fd 100644
--- a/src/core/chunks/trim.test.ts
+++ b/src/core/chunks/trim.test.ts
@@ -146,7 +146,7 @@ describe("windowTranscript", () => {
   it("is the identity within the window", () => {
     const state = stateWith(chunks(1, 50));
     expect(windowTranscript(state, 75)).toBe(state);
-    expect(selectHasEarlier(state)).toBe(false);
+    expect(selectHasEarlier(state, 1)).toBe(false);
   });
 });
 
@@ -178,21 +178,21 @@ describe("restoreEarlier", () => {
     expect(selectHasEarlier(restored)).toBe(true);
   });
 
-  it("restoring down to seq 1 reaches the contractual origin (hasEarlier clears)", () => {
+  it("restoring down to a known boundary clears hasEarlier", () => {
     const windowed = windowTranscript(stateWith(chunks(1, 100)), 75); // hidden: 1..25
     const restored = restoreEarlier(windowed, chunks(1, 100), 64);
     expect(restored.committed).toHaveLength(100);
     expect(restored.committed[0]?.seq).toBe(1);
     expect(restored.hiddenBeforeSeq).toBe(1); // floor at the origin — inert
     expect(restored.hiddenThinkingCount).toBe(0);
-    expect(selectHasEarlier(restored)).toBe(false);
+    expect(selectHasEarlier(restored, 1)).toBe(false);
   });
 
   it("is the identity when nothing older is known locally (server may still hold more)", () => {
     const windowed = windowTranscript(stateWith(chunks(50, 200)), 75);
     const restored = restoreEarlier(windowed, [], 64);
     expect(restored).toBe(windowed);
-    // seqs are 1-based gap-free: window starts at 126 ⇒ older chunks DO exist.
+    // The server boundary is unknown, so another page may exist.
     expect(selectHasEarlier(restored)).toBe(true);
   });
 
@@ -203,7 +203,7 @@ describe("restoreEarlier", () => {
 
   it("works on a server-windowed transcript (no local watermark)", () => {
     // A cold-cache fresh load with `?limit=` commits a suffix (seq 809..1000)
-    // with hiddenBeforeSeq still 0 — hasEarlier derives from seq > 1, and a
+    // with hiddenBeforeSeq still 0 — the server boundary is unknown, and a
     // backfilled run merges below it.
     const state = stateWith(chunks(809, 1000));
     expect(state.hiddenBeforeSeq).toBe(0);
@@ -230,6 +230,15 @@ describe("restoreEarlier", () => {
     const restored = restoreEarlier(trimmed, original, 1000);
     expect(restored.committed).toEqual(original);
     expect(restored.hiddenBeforeSeq).toBe(1);
-    expect(selectHasEarlier(restored)).toBe(false);
+    expect(selectHasEarlier(restored, 1)).toBe(false);
   });
 });
+
+it("uses a non-1 history boundary rather than the seq origin", () => {
+  const state = stateWith(chunks(101, 110));
+  expect(selectHasEarlier(state, 101)).toBe(false);
+  expect(selectHasEarlier(state, null)).toBe(true);
+  const windowed = windowTranscript(state, 5);
+  expect(selectHasEarlier(windowed, 101)).toBe(true);
+  expect(selectHasEarlier(restoreEarlier(windowed, state.committed, 5), 101)).toBe(false);
+});
diff --git a/src/core/chunks/trim.ts b/src/core/chunks/trim.ts
index 9846357..259c101 100644
--- a/src/core/chunks/trim.ts
+++ b/src/core/chunks/trim.ts
@@ -150,8 +150,7 @@ function oldestLoadedSeq(state: TranscriptState): number {
  * `?beforeSeq=` backfill; chunks at/inside the window are ignored). The newest
  * `count` of them are merged back in front of `committed`, and the watermark
  * follows the new window start so history merges still can't resurrect what
- * remains unloaded. Identity when the window already starts at seq 1 (the
- * contractual origin) or nothing older is known locally.
+ * remains unloaded. Identity when nothing older is known locally.
  */
 export function restoreEarlier(
   state: TranscriptState,
@@ -159,7 +158,7 @@ export function restoreEarlier(
   count: number,
 ): TranscriptState {
   const oldest = oldestLoadedSeq(state);
-  if (oldest <= 1) return state;
+  if (oldest === 0) return state;
   const below = earlier.filter((c) => c.seq < oldest).sort((a, b) => a.seq - b.seq);
   if (below.length === 0) return state;
   const keep = below.slice(-Math.max(1, count));
@@ -172,14 +171,11 @@ export function restoreEarlier(
   };
 }
 
-/**
- * Whether earlier history exists below the loaded window — drives the
- * "Show earlier messages" affordance. Derived from the [email protected] CONTRACT
- * that per-conversation seqs are 1-based and gap-free: a loaded window that
- * starts above seq 1 means older chunks exist (locally cached or server-side),
- * whether the window came from a local trim or a server-windowed (`?limit=`)
- * fresh load.
- */
-export function selectHasEarlier(state: TranscriptState): boolean {
-  return oldestLoadedSeq(state) > 1;
+/** Earlier availability uses the known server boundary, never a seq origin. */
+export function selectHasEarlier(
+  state: TranscriptState,
+  earliestSeq: number | null = null,
+): boolean {
+  const oldest = oldestLoadedSeq(state);
+  return oldest > 0 && (earliestSeq === null || oldest > earliestSeq);
 }
diff --git a/src/core/wire/conformance.test.ts b/src/core/wire/conformance.test.ts
index 2b98ca6..e74a663 100644
--- a/src/core/wire/conformance.test.ts
+++ b/src/core/wire/conformance.test.ts
@@ -184,6 +184,7 @@ describe("classifies every WsServerMessage type", () => {
         conversationId: "c1",
         newConversationId: "c2",
         messagesSummarized: 10,
+        historyEpoch: 0,
         messagesKept: 5,
       },
     ];
@@ -268,6 +269,7 @@ describe("ConversationHistoryResponse shape is constructible", () => {
   it("constructs a response with chunks", () => {
     const resp: ConversationHistoryResponse = {
       chunks: [{ seq: 1, role: "user", chunk: { type: "text", text: "hi" } }],
+      historyEpoch: 0,
       latestSeq: 1,
     };
     expect(resp.chunks).toHaveLength(1);
@@ -275,7 +277,7 @@ describe("ConversationHistoryResponse shape is constructible", () => {
   });
 
   it("constructs an empty (caught-up) response", () => {
-    const resp: ConversationHistoryResponse = { chunks: [], latestSeq: 5 };
+    const resp: ConversationHistoryResponse = { chunks: [], historyEpoch: 0, latestSeq: 5 };
     expect(resp.chunks).toHaveLength(0);
     expect(resp.latestSeq).toBe(5);
   });