diff --git a/packages/runtime/src/__tests__/runtime-event-read-model.test.ts b/packages/runtime/src/__tests__/runtime-event-read-model.test.ts
index 172b380e9a..6ee8324c4d 100644
--- a/packages/runtime/src/__tests__/runtime-event-read-model.test.ts
+++ b/packages/runtime/src/__tests__/runtime-event-read-model.test.ts
@@ -1894,17 +1894,6 @@ class ReadOnlyStore implements SessionStore {
     return { ...makeHeader(id), ...patch };
   }
 
-  async markSessionReadThrough(id: string, readThroughTs: number): Promise<SessionHeader> {
-    const header = makeHeader(id);
-    if (
-      !Number.isFinite(readThroughTs) ||
-      !header.hasUnread ||
-      (header.lastMessageAt !== undefined && header.lastMessageAt > readThroughTs)
-    )
-      return header;
-    return { ...header, hasUnread: false };
-  }
-
   async archive(_sessionId: string): Promise<void> {}
   async unarchive(_sessionId: string): Promise<void> {}
   async setFlagged(_sessionId: string, _isFlagged: boolean): Promise<void> {}
diff --git a/packages/runtime/src/__tests__/runtime-kernel-interaction.test.ts b/packages/runtime/src/__tests__/runtime-kernel-interaction.test.ts
index f2b15a75d4..de1c08abf4 100644
--- a/packages/runtime/src/__tests__/runtime-kernel-interaction.test.ts
+++ b/packages/runtime/src/__tests__/runtime-kernel-interaction.test.ts
@@ -641,7 +641,6 @@ function memoryStore(): SessionStore {
       header = { ...header, ...patch };
       return header;
     },
-    markSessionReadThrough: async () => header,
     archive: async () => {},
     unarchive: async () => {},
     setFlagged: async () => {},
diff --git a/packages/runtime/src/__tests__/session-manager-terminal-ledger.test.ts b/packages/runtime/src/__tests__/session-manager-terminal-ledger.test.ts
index 53eaecd5b6..c1aa0ccb04 100644
--- a/packages/runtime/src/__tests__/session-manager-terminal-ledger.test.ts
+++ b/packages/runtime/src/__tests__/session-manager-terminal-ledger.test.ts
@@ -2538,10 +2538,6 @@ class TinySessionStore implements SessionStore {
     return clone(next);
   }
 
-  async markSessionReadThrough(sessionId: string, _readThroughTs: number): Promise<SessionHeader> {
-    return this.readHeader(sessionId);
-  }
-
   async archive(sessionId: string): Promise<void> {
     await this.updateHeader(sessionId, { isArchived: true, status: 'archived' });
   }
diff --git a/packages/runtime/src/__tests__/session-manager.test.ts b/packages/runtime/src/__tests__/session-manager.test.ts
index f242bf0b32..ca7438438a 100644
--- a/packages/runtime/src/__tests__/session-manager.test.ts
+++ b/packages/runtime/src/__tests__/session-manager.test.ts
@@ -17060,7 +17060,6 @@ class MemorySessionStore implements SessionStore {
   readonly failNextReadMessagesFor = new Map<string, number>();
   readonly failListTurnsFor = new Set<string>();
   readonly failUpdateHeaderFor = new Set<string>();
-  readonly interleaveBeforeMarkSessionReadWriteFor = new Map<string, () => Promise<void> | void>();
   failNextAppendMessage: ((message: StoredMessage) => boolean) | undefined;
   failAfterNextAppendMessage: ((message: StoredMessage) => boolean) | undefined;
   disposeCount = 0;
@@ -17277,7 +17276,6 @@ class MemorySessionStore implements SessionStore {
       error.code = 'ENOENT';
       throw error;
     }
-    await this.runMarkSessionReadInterleave(sessionId);
     return header;
   }
 
@@ -17323,26 +17321,6 @@ class MemorySessionStore implements SessionStore {
     return next;
   }
 
-  async markSessionReadThrough(sessionId: string, readThroughTs: number): Promise<SessionHeader> {
-    await this.runMarkSessionReadInterleave(sessionId);
-    if (this.failUpdateHeaderFor.has(sessionId))
-      throw new Error(`Cannot update header for ${sessionId}`);
-    const current = await this.readHeader(sessionId);
-    if (!current.hasUnread) return current;
-    if (current.lastMessageAt !== undefined && current.lastMessageAt > readThroughTs)
-      return current;
-    const next = { ...current, hasUnread: false };
-    this.headers.set(sessionId, next);
-    return next;
-  }
-
-  private async runMarkSessionReadInterleave(sessionId: string): Promise<void> {
-    const hook = this.interleaveBeforeMarkSessionReadWriteFor.get(sessionId);
-    if (!hook) return;
-    this.interleaveBeforeMarkSessionReadWriteFor.delete(sessionId);
-    await hook();
-  }
-
   async archive(sessionId: string): Promise<void> {
     await this.updateHeader(sessionId, {
       isArchived: true,
diff --git a/packages/runtime/src/session-manager.ts b/packages/runtime/src/session-manager.ts
index 384cfa049e..4fac649cec 100644
--- a/packages/runtime/src/session-manager.ts
+++ b/packages/runtime/src/session-manager.ts
@@ -678,7 +678,6 @@ export interface SessionStore {
     sessionId: string,
     input: SessionConfigurationStoreUpdate,
   ): Promise<VersionedSessionHeader>;
-  markSessionReadThrough(sessionId: string, readThroughTs: number): Promise<SessionHeader>;
   archive(sessionId: string): Promise<void>;
   unarchive(sessionId: string): Promise<void>;
   setFlagged(sessionId: string, isFlagged: boolean): Promise<void>;
@@ -1642,12 +1641,6 @@ export class SessionManager {
     if (header) this.runtimeKernel.updateCachedHeader(sessionId, header);
   }
 
-  async markSessionRead(sessionId: string, readThroughTs: number | undefined): Promise<void> {
-    if (readThroughTs === undefined || !Number.isFinite(readThroughTs)) return;
-    const next = await this.deps.store.markSessionReadThrough(sessionId, readThroughTs);
-    this.runtimeKernel.updateCachedHeader(sessionId, next);
-  }
-
   async renameSession(sessionId: string, name: string): Promise<void> {
     await this.deps.store.rename(sessionId, name);
     const header = await this.deps.store.readHeader(sessionId).catch(() => undefined);
diff --git a/packages/storage/src/execution-stores.ts b/packages/storage/src/execution-stores.ts
index 32d8fb0fd9..ff2dec15de 100644
--- a/packages/storage/src/execution-stores.ts
+++ b/packages/storage/src/execution-stores.ts
@@ -395,8 +395,6 @@ async function createExecutionStoresForWrite<K extends StorageRootKind, E extend
         run(() => sessionStore.updateSessionConfiguration(sessionId, input)),
       markSessionReadThroughMessage: (sessionId, messageId) =>
         run(() => sessionStore.markSessionReadThroughMessage(sessionId, messageId)),
-      markSessionReadThrough: (sessionId, readThroughTs) =>
-        run(() => sessionStore.markSessionReadThrough(sessionId, readThroughTs)),
       archive: (sessionId) => run(() => sessionStore.archive(sessionId)),
       unarchive: (sessionId) => run(() => sessionStore.unarchive(sessionId)),
       setFlagged: (sessionId, isFlagged) =>
diff --git a/packages/storage/src/session-store.ts b/packages/storage/src/session-store.ts
index 147ba58117..02eb0ec807 100644
--- a/packages/storage/src/session-store.ts
+++ b/packages/storage/src/session-store.ts
@@ -260,7 +260,6 @@ export interface SessionStore {
   appendMessage(sessionId: string, message: StoredMessage): Promise<void>;
   appendMessages(sessionId: string, messages: StoredMessage[]): Promise<void>;
   updateHeader(sessionId: string, patch: Partial<SessionHeader>): Promise<SessionHeader>;
-  markSessionReadThrough(sessionId: string, readThroughTs: number): Promise<SessionHeader>;
   archive(sessionId: string): Promise<void>;
   unarchive(sessionId: string): Promise<void>;
   setFlagged(sessionId: string, isFlagged: boolean): Promise<void>;
@@ -870,23 +869,6 @@ class SqliteSessionStore implements SessionAuthorityStore {
     await this.metadata.completeSessionRetirementCleanup(sessionId);
   }
 
-  async markSessionReadThrough(sessionId: string, readThroughTs: number): Promise<SessionHeader> {
-    const header = await this.readHeaderSnapshot(sessionId);
-    const messages = await this.readMessagesSnapshot(sessionId);
-    const effectiveLastMessageAt = maxTimestamp(
-      header.lastMessageAt,
-      latestVisibleMessageAt(messages),
-    );
-    if (
-      !Number.isFinite(readThroughTs) ||
-      !header.hasUnread ||
-      (effectiveLastMessageAt !== undefined && effectiveLastMessageAt > readThroughTs)
-    ) {
-      return header;
-    }
-    return this.updateHeader(sessionId, { hasUnread: false });
-  }
-
   async archive(sessionId: string): Promise<void> {
     const now = Date.now();
     await this.updateHeader(sessionId, {