refactor(web): merge read state at render and give loaded pages one owner

CHANGELOG.md

@@ -2,6 +2,13 @@
 
 New features, integrations, and notable improvements to Open-Inspect — newest first.
 
+## September 2, 2026
+
+**Opening a session marks it read.** A session's latest reply is read as soon as its page is
+visible, without scrolling to the end of the timeline. The sidebar reflects the change on every row
+at once, including sessions loaded through "Load more", and Needs attention lists only sessions with
+an unread reply.
+
 ## September 1, 2026
 
 **Workspace audit log.** Owners, Administrators, and authorized custom roles can review paginated

packages/control-plane/src/session/alarm/scheduler.ts

@@ -171,7 +171,17 @@ export function createEarliestAlarmScheduler(
   };
 }
 
-/** Track delivery separately so retries cannot acknowledge a replacement deadline. */
+/**
+ * Runs one alarm delivery against the runtime's single alarm slot.
+ *
+ * `beginDelivery` moves the pending deadline into flight and clears it, so
+ * while `handle` runs the store holds no future deadline. Every step of the
+ * handler that still needs a wake-up must schedule it again from its own
+ * persisted state (a deferred projection, a stop-confirmation deadline, an
+ * execution timeout); otherwise `rearm` finds nothing and that deadline is
+ * lost until the next rehydration. Delivery is tracked separately from the
+ * pending deadline so a retry cannot acknowledge a replacement deadline.
+ */
 export async function handleAlarmDelivery(
   deadlines: AlarmDeadlineStore,
   handle: () => Promise<void>,

packages/control-plane/src/session/message-queue.ts

@@ -649,14 +649,7 @@ export class SessionMessageQueue {
           completion.messageId,
           completion.messageCreatedAt,
           completion.completedAt
-        )
-          .catch((projectionError) => {
-            this.log.error("terminal_message.projection_failed", {
-              message_id: message.id,
-              error: projectionError,
-            });
-          })
-          .then(() => this.messenger.broadcast({ type: "sandbox_event", event })),
+        ).then(() => this.messenger.broadcast({ type: "sandbox_event", event })),
       {
         name: "terminal_message.project",
         context: { message_id: message.id },

packages/web/src/hooks/use-mark-session-read.test.tsx

@@ -4,16 +4,18 @@ import { act, cleanup, renderHook } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { SessionReadResult } from "@open-inspect/shared/types/sessions";
 import { useMarkSessionRead } from "./use-mark-session-read";
-import { SessionReadRequestError } from "@/lib/session-read-state";
+import {
+  getSessionReadOverlay,
+  resetSessionReadOverlay,
+  SessionReadRequestError,
+} from "@/lib/session-read-state";
 
 const markMessageRead =
   vi.fn<(sessionId: string, messageId: string) => Promise<SessionReadResult>>();
-const reconcileSessionReadState = vi.fn(async (_result: SessionReadResult) => {});
 
 vi.mock("@/lib/session-read-state", async (importOriginal) => ({
   ...(await importOriginal<Record<string, unknown>>()),
   markMessageRead: (sessionId: string, messageId: string) => markMessageRead(sessionId, messageId),
-  reconcileSessionReadState: (result: SessionReadResult) => reconcileSessionReadState(result),
 }));
 
 function result(
@@ -36,8 +38,8 @@ function setVisibility(value: "visible" | "hidden") {
 
 beforeEach(() => {
   setVisibility("visible");
+  resetSessionReadOverlay();
   markMessageRead.mockReset();
-  reconcileSessionReadState.mockClear();
   vi.spyOn(console, "error").mockImplementation(() => {});
 });
 afterEach(() => {
@@ -56,7 +58,29 @@ describe("useMarkSessionRead", () => {
     });
 
     expect(markMessageRead).toHaveBeenCalledExactlyOnceWith("session-1", "message-1");
-    expect(reconcileSessionReadState).toHaveBeenCalledExactlyOnceWith(result("marked_read"));
+    expect(getSessionReadOverlay().get("session-1")).toEqual({
+      latestMessageId: "message-1",
+      unread: false,
+      version: 1,
+    });
+  });
+
+  it("does not ask again about a message this page already read", async () => {
+    markMessageRead.mockResolvedValue(result("marked_read"));
+    const first = await act(async () =>
+      renderHook(() => useMarkSessionRead("session-1", "message-1"))
+    );
+    first.unmount();
+
+    await act(async () => {
+      renderHook(() => useMarkSessionRead("session-1", "message-1"));
+    });
+    expect(markMessageRead).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      renderHook(() => useMarkSessionRead("session-1", "message-2"));
+    });
+    expect(markMessageRead).toHaveBeenCalledTimes(2);
   });
 
   it("acknowledges each message once and follows the message ID", async () => {

packages/web/src/hooks/use-mark-session-read.ts

@@ -1,50 +1,57 @@
 "use client";
 
 import { useEffect } from "react";
+import { useSWRConfig } from "swr";
 import {
-  classifySessionReadAttempt,
+  applySessionReadResult,
+  isSessionMessageRead,
   markMessageRead,
-  reconcileSessionReadState,
   SessionReadRequestError,
-  type SessionReadAttemptDisposition,
 } from "@/lib/session-read-state";
 
 const SESSION_READ_RETRY_MS = 2_000;
 const SESSION_READ_MAX_ATTEMPTS = 4;
 const PERMANENT_FAILURE_STATUSES = new Set([400, 401, 403, 404, 405]);
 
-async function attemptMarkMessageRead(
-  sessionId: string,
-  messageId: string
-): Promise<SessionReadAttemptDisposition> {
-  try {
-    const result = await markMessageRead(sessionId, messageId);
-    await reconcileSessionReadState(result);
-    return classifySessionReadAttempt(result);
-  } catch (error) {
-    if (error instanceof SessionReadRequestError && PERMANENT_FAILURE_STATUSES.has(error.status)) {
-      return "permanent_failure";
-    }
-    console.error("Failed to mark session message read", error);
-    return "retry";
-  }
-}
-
 /**
  * Opening a session reads its latest terminal message. Each message ID is
  * acknowledged once while the document is visible; a hidden tab waits for
  * visibility. Focus is not required, since the terminal pane holds it for
- * much of a working session.
+ * much of a working session. A message this page already read is not asked
+ * about again.
+ *
+ * Only a missing projection is retried: the message exists on the client,
+ * so the server row will catch up. A `not_latest` result means a newer
+ * message is on its way to the client, which acknowledges that one instead.
  */
 export function useMarkSessionRead(sessionId: string, messageId: string | null): void {
+  const { mutate } = useSWRConfig();
+
   useEffect(() => {
-    if (!messageId) return;
+    if (!messageId || isSessionMessageRead(sessionId, messageId)) return;
     let cancelled = false;
     let settled = false;
     let inFlight = false;
     let attempts = 0;
     let retryTimer: ReturnType<typeof setTimeout> | null = null;
 
+    const attemptOnce = async (): Promise<"settled" | "retry"> => {
+      try {
+        const result = await markMessageRead(sessionId, messageId);
+        await applySessionReadResult(result, mutate);
+        return result.outcome === "no_terminal_message" ? "retry" : "settled";
+      } catch (error) {
+        if (
+          error instanceof SessionReadRequestError &&
+          PERMANENT_FAILURE_STATUSES.has(error.status)
+        ) {
+          return "settled";
+        }
+        console.error("Failed to mark session message read", error);
+        return "retry";
+      }
+    };
+
     const attempt = async () => {
       if (
         cancelled ||
@@ -57,10 +64,10 @@ export function useMarkSessionRead(sessionId: string, messageId: string | null):
       }
       inFlight = true;
       attempts += 1;
-      const disposition = await attemptMarkMessageRead(sessionId, messageId);
+      const disposition = await attemptOnce();
       inFlight = false;
       if (cancelled) return;
-      if (disposition !== "retry") {
+      if (disposition === "settled") {
         settled = true;
         return;
       }
@@ -88,5 +95,5 @@ export function useMarkSessionRead(sessionId: string, messageId: string | null):
       document.removeEventListener("visibilitychange", onVisibilityChange);
       if (retryTimer) clearTimeout(retryTimer);
     };
-  }, [messageId, sessionId]);
+  }, [messageId, mutate, sessionId]);
 }

packages/web/src/hooks/use-session-rename.ts

@@ -7,15 +7,14 @@ import { applyTitleUpdate, isSessionListKey, type SessionListResponse } from "@/
 import {
   applySessionInboxTitleUpdate,
   isSessionInboxKey,
-  type SessionInboxPage,
   type SessionInboxSnapshot,
 } from "@/lib/session-inbox-api";
 
 type SessionCacheMutator = ReturnType<typeof useSWRConfig>["mutate"];
 
 /**
  * A session's title is cached in two payload families: session-list responses
- * and inbox snapshots/pages. Every optimistic update, settlement, and rollback
+ * and inbox snapshots. Every optimistic update, settlement, and rollback
  * must touch both, or the sidebar inbox briefly reverts to the stale title
  * once the optimistic overlay clears.
  */
@@ -30,7 +29,7 @@ function applyTitleToSessionCaches(
       (current) => applyTitleUpdate(current, sessionId, title),
       { populateCache: true, revalidate: false }
     ),
-    mutate<SessionInboxSnapshot | SessionInboxPage>(
+    mutate<SessionInboxSnapshot>(
       isSessionInboxKey,
       (current) => applySessionInboxTitleUpdate(current, sessionId, title),
       { populateCache: true, revalidate: false }