From 0bb704418e007add959a7f1151744bf14827c53e Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Mon, 13 Apr 2026 10:59:06 -0700
Subject: [PATCH 1/6] Use latest user message time for thread timestamps

- Show thread timestamps from `latestUserMessageAt` when available
- Compare nested session and turn objects by value to avoid stale sidebar state
---
 .../src/components/CommandPalette.logic.ts    |  2 +-
 apps/web/src/components/Sidebar.tsx           |  2 +-
 apps/web/src/store.ts                         | 68 ++++++++++++++-----
 3 files changed, 52 insertions(+), 20 deletions(-)

diff --git a/apps/web/src/components/CommandPalette.logic.ts b/apps/web/src/components/CommandPalette.logic.ts
index c29f1271087..a8a0b5387d7 100644
--- a/apps/web/src/components/CommandPalette.logic.ts
+++ b/apps/web/src/components/CommandPalette.logic.ts
@@ -114,7 +114,7 @@ export function buildThreadActionItems(input: {
       searchTerms: [thread.title, projectTitle ?? "", thread.branch ?? ""],
       title: thread.title,
       description: descriptionParts.join(" · "),
-      timestamp: formatRelativeTimeLabel(thread.updatedAt ?? thread.createdAt),
+      timestamp: formatRelativeTimeLabel(thread.latestUserMessageAt ?? thread.updatedAt ?? thread.createdAt),
       icon: input.icon,
       run: async () => {
         await input.runThread(thread);
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index 2495429efd8..05e394b5db5 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -745,7 +745,7 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: SidebarThreadRowP
                         : "text-muted-foreground/40"
                     }`}
                   >
-                    {formatRelativeTimeLabel(thread.updatedAt ?? thread.createdAt)}
+                    {formatRelativeTimeLabel(thread.latestUserMessageAt ?? thread.updatedAt ?? thread.createdAt)}
                   </span>
                 )}
               </span>
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
index 092593b06d2..7b515979528 100644
--- a/apps/web/src/store.ts
+++ b/apps/web/src/store.ts
@@ -3,6 +3,7 @@ import type {
   MessageId,
   OrchestrationCheckpointSummary,
   OrchestrationEvent,
+  OrchestrationLatestTurn,
   OrchestrationMessage,
   OrchestrationProposedPlan,
   OrchestrationReadModel,
@@ -344,6 +345,49 @@ function buildSidebarThreadSummary(thread: Thread): SidebarThreadSummary {
   };
 }
 
+function sourceProposedPlansEqual(
+  left: OrchestrationLatestTurn["sourceProposedPlan"] | undefined,
+  right: OrchestrationLatestTurn["sourceProposedPlan"] | undefined,
+): boolean {
+  if (left === right) return true;
+  if (left === undefined || right === undefined) return false;
+  return left.threadId === right.threadId && left.planId === right.planId;
+}
+
+function latestTurnsEqual(
+  left: OrchestrationLatestTurn | null | undefined,
+  right: OrchestrationLatestTurn | null | undefined,
+): boolean {
+  if (left === right) return true;
+  if (left == null || right == null) return false;
+  return (
+    left.turnId === right.turnId &&
+    left.state === right.state &&
+    left.requestedAt === right.requestedAt &&
+    left.startedAt === right.startedAt &&
+    left.completedAt === right.completedAt &&
+    left.assistantMessageId === right.assistantMessageId &&
+    sourceProposedPlansEqual(left.sourceProposedPlan, right.sourceProposedPlan)
+  );
+}
+
+function threadSessionsEqual(
+  left: ThreadSession | null | undefined,
+  right: ThreadSession | null | undefined,
+): boolean {
+  if (left === right) return true;
+  if (left == null || right == null) return false;
+  return (
+    left.provider === right.provider &&
+    left.status === right.status &&
+    left.orchestrationStatus === right.orchestrationStatus &&
+    left.activeTurnId === right.activeTurnId &&
+    left.createdAt === right.createdAt &&
+    left.updatedAt === right.updatedAt &&
+    left.lastError === right.lastError
+  );
+}
+
 function sidebarThreadSummariesEqual(
   left: SidebarThreadSummary | undefined,
   right: SidebarThreadSummary,
@@ -354,11 +398,11 @@ function sidebarThreadSummariesEqual(
     left.projectId === right.projectId &&
     left.title === right.title &&
     left.interactionMode === right.interactionMode &&
-    left.session === right.session &&
+    threadSessionsEqual(left.session, right.session) &&
     left.createdAt === right.createdAt &&
     left.archivedAt === right.archivedAt &&
     left.updatedAt === right.updatedAt &&
-    left.latestTurn === right.latestTurn &&
+    latestTurnsEqual(left.latestTurn, right.latestTurn) &&
     left.branch === right.branch &&
     left.worktreePath === right.worktreePath &&
     left.latestUserMessageAt === right.latestUserMessageAt &&
@@ -391,8 +435,8 @@ function threadShellsEqual(left: ThreadShell | undefined, right: ThreadShell): b
 function threadTurnStatesEqual(left: ThreadTurnState | undefined, right: ThreadTurnState): boolean {
   return (
     left !== undefined &&
-    left.latestTurn === right.latestTurn &&
-    left.pendingSourceProposedPlan === right.pendingSourceProposedPlan
+    latestTurnsEqual(left.latestTurn, right.latestTurn) &&
+    sourceProposedPlansEqual(left.pendingSourceProposedPlan, right.pendingSourceProposedPlan)
   );
 }
 
@@ -475,8 +519,6 @@ function writeThreadState(
   const nextTurnState = toThreadTurnState(nextThread);
   const previousShell = state.threadShellById[nextThread.id];
   const previousTurnState = state.threadTurnStateById[nextThread.id];
-  const previousSummary = state.sidebarThreadSummaryById[nextThread.id];
-  const nextSummary = buildSidebarThreadSummary(nextThread);
 
   let nextState = state;
 
@@ -530,7 +572,7 @@ function writeThreadState(
     };
   }
 
-  if ((previousThread?.session ?? null) !== nextThread.session) {
+  if (!threadSessionsEqual(previousThread?.session ?? null, nextThread.session)) {
     nextState = {
       ...nextState,
       threadSessionById: {
@@ -610,16 +652,6 @@ function writeThreadState(
     };
   }
 
-  if (!sidebarThreadSummariesEqual(previousSummary, nextSummary)) {
-    nextState = {
-      ...nextState,
-      sidebarThreadSummaryById: {
-        ...nextState.sidebarThreadSummaryById,
-        [nextThread.id]: nextSummary,
-      },
-    };
-  }
-
   return nextState;
 }
 
@@ -686,7 +718,7 @@ function writeThreadShellState(
     };
   }
 
-  if ((state.threadSessionById[nextThread.shell.id] ?? null) !== nextThread.session) {
+  if (!threadSessionsEqual(state.threadSessionById[nextThread.shell.id] ?? null, nextThread.session)) {
     nextState = {
       ...nextState,
       threadSessionById: {

From 0e8c1fe77b4294ff64423766fc39bcba00b4676d Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Mon, 13 Apr 2026 12:15:59 -0700
Subject: [PATCH 2/6] Stabilize sidebar thread timestamp updates

- Use refs to avoid invalidating sidebar row callbacks
- Keep relative timestamps at "just now" under 60 seconds
- Add React Scan script to the web shell
---
 apps/web/index.html                    |  1 +
 apps/web/src/components/Sidebar.tsx    | 18 ++++++++----------
 apps/web/src/hooks/useThreadActions.ts | 12 +++++++++---
 apps/web/src/timestampFormat.ts        |  3 +--
 4 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/apps/web/index.html b/apps/web/index.html
index 9f0329b6020..a0149eba6d8 100644
--- a/apps/web/index.html
+++ b/apps/web/index.html
@@ -8,6 +8,7 @@
     <meta name="theme-color" content="#161616" />
     <link rel="icon" href="/favicon.ico" sizes="48x48" />
     <link rel="apple-touch-icon" href="/apple-touch-icon.png" />
+    <script crossorigin="anonymous" src="//unpkg.com/react-scan/dist/auto.global.js"></script>
     <script>
       (() => {
         const LIGHT_BACKGROUND = "#ffffff";
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index 05e394b5db5..499723271f1 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -1101,6 +1101,11 @@ const SidebarProjectItem = memo(function SidebarProjectItem(props: SidebarProjec
       ),
     [allSidebarThreads],
   );
+  // Keep a ref so callbacks can read the latest map without appearing in
+  // dependency arrays (avoids invalidating every thread-row memo on each
+  // thread-list change).
+  const sidebarThreadByKeyRef = useRef(sidebarThreadByKey);
+  sidebarThreadByKeyRef.current = sidebarThreadByKey;
   // All threads from the representative + other member environments are
   // already fetched into allSidebarThreads, so we can use them directly.
   const projectThreads = allSidebarThreads;
@@ -1444,7 +1449,7 @@ const SidebarProjectItem = memo(function SidebarProjectItem(props: SidebarProjec
 
       if (clicked === "mark-unread") {
         for (const threadKey of threadKeys) {
-          const thread = sidebarThreadByKey.get(threadKey);
+          const thread = sidebarThreadByKeyRef.current.get(threadKey);
           markThreadUnread(threadKey, thread?.latestTurn?.completedAt);
         }
         clearSelection();
@@ -1465,7 +1470,7 @@ const SidebarProjectItem = memo(function SidebarProjectItem(props: SidebarProjec
 
       const deletedThreadKeys = new Set(threadKeys);
       for (const threadKey of threadKeys) {
-        const thread = sidebarThreadByKey.get(threadKey);
+        const thread = sidebarThreadByKeyRef.current.get(threadKey);
         if (!thread) continue;
         await deleteThread(scopeThreadRef(thread.environmentId, thread.id), {
           deletedThreadKeys,
@@ -1479,7 +1484,6 @@ const SidebarProjectItem = memo(function SidebarProjectItem(props: SidebarProjec
       deleteThread,
       markThreadUnread,
       removeFromSelection,
-      sidebarThreadByKey,
     ],
   );
 
@@ -1608,12 +1612,7 @@ const SidebarProjectItem = memo(function SidebarProjectItem(props: SidebarProjec
       const api = readLocalApi();
       if (!api) return;
       const threadKey = scopedThreadKey(threadRef);
-      const thread =
-        projectThreads.find(
-          (projectThread) =>
-            projectThread.environmentId === threadRef.environmentId &&
-            projectThread.id === threadRef.threadId,
-        ) ?? null;
+      const thread = sidebarThreadByKeyRef.current.get(threadKey) ?? null;
       if (!thread) return;
       const threadWorkspacePath = thread.worktreePath ?? project.cwd ?? null;
       const clicked = await api.contextMenu.show(
@@ -1675,7 +1674,6 @@ const SidebarProjectItem = memo(function SidebarProjectItem(props: SidebarProjec
       deleteThread,
       markThreadUnread,
       project.cwd,
-      projectThreads,
     ],
   );
 
diff --git a/apps/web/src/hooks/useThreadActions.ts b/apps/web/src/hooks/useThreadActions.ts
index 4835edd4d19..60b1be85a70 100644
--- a/apps/web/src/hooks/useThreadActions.ts
+++ b/apps/web/src/hooks/useThreadActions.ts
@@ -2,7 +2,7 @@ import { parseScopedThreadKey, scopeProjectRef, scopeThreadRef } from "@t3tools/
 import { type ScopedThreadRef, ThreadId } from "@t3tools/contracts";
 import { useQueryClient } from "@tanstack/react-query";
 import { useRouter } from "@tanstack/react-router";
-import { useCallback } from "react";
+import { useCallback, useRef } from "react";
 
 import { getFallbackThreadIdAfterDelete } from "../components/Sidebar.logic";
 import { useComposerDraftStore } from "../composerDraftStore";
@@ -33,6 +33,12 @@ export function useThreadActions() {
   const clearTerminalState = useTerminalStateStore((state) => state.clearTerminalState);
   const router = useRouter();
   const { handleNewThread } = useNewThreadHandler();
+  // Keep a ref so archiveThread can call handleNewThread without appearing in
+  // its dependency array — handleNewThread is inherently unstable (depends on
+  // the projects list) and would otherwise cascade new references into every
+  // sidebar row via archiveThread → attemptArchiveThread.
+  const handleNewThreadRef = useRef(handleNewThread);
+  handleNewThreadRef.current = handleNewThread;
   const queryClient = useQueryClient();
 
   const resolveThreadTarget = useCallback((target: ScopedThreadRef) => {
@@ -73,10 +79,10 @@ export function useThreadActions() {
         currentRouteThreadRef?.threadId === threadRef.threadId &&
         currentRouteThreadRef.environmentId === threadRef.environmentId
       ) {
-        await handleNewThread(scopeProjectRef(thread.environmentId, thread.projectId));
+        await handleNewThreadRef.current(scopeProjectRef(thread.environmentId, thread.projectId));
       }
     },
-    [getCurrentRouteThreadRef, handleNewThread, resolveThreadTarget],
+    [getCurrentRouteThreadRef, resolveThreadTarget],
   );
 
   const unarchiveThread = useCallback(async (target: ScopedThreadRef) => {
diff --git a/apps/web/src/timestampFormat.ts b/apps/web/src/timestampFormat.ts
index c39e4a6c7d3..4cf47a2c398 100644
--- a/apps/web/src/timestampFormat.ts
+++ b/apps/web/src/timestampFormat.ts
@@ -57,8 +57,7 @@ export function formatRelativeTime(isoDate: string): { value: string; suffix: st
   const diffMs = Date.now() - new Date(isoDate).getTime();
   if (diffMs < 0) return { value: "just now", suffix: null };
   const seconds = Math.floor(diffMs / 1000);
-  if (seconds < 5) return { value: "just now", suffix: null };
-  if (seconds < 60) return { value: `${seconds}s`, suffix: "ago" };
+  if (seconds < 60) return { value: "just now", suffix: null };
   const minutes = Math.floor(seconds / 60);
   if (minutes < 60) return { value: `${minutes}m`, suffix: "ago" };
   const hours = Math.floor(minutes / 60);

From a812f363ea8873b260d04945a11fd07dc70d64f4 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Mon, 13 Apr 2026 12:18:50 -0700
Subject: [PATCH 3/6] Format sidebar thread timestamps consistently

- Keep thread timestamp formatting aligned in the sidebar and command palette
- Reflow a long store condition for readability
---
 apps/web/src/components/CommandPalette.logic.ts | 4 +++-
 apps/web/src/components/Sidebar.tsx             | 4 +++-
 apps/web/src/store.ts                           | 4 +++-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/apps/web/src/components/CommandPalette.logic.ts b/apps/web/src/components/CommandPalette.logic.ts
index a8a0b5387d7..7524ef859d8 100644
--- a/apps/web/src/components/CommandPalette.logic.ts
+++ b/apps/web/src/components/CommandPalette.logic.ts
@@ -114,7 +114,9 @@ export function buildThreadActionItems(input: {
       searchTerms: [thread.title, projectTitle ?? "", thread.branch ?? ""],
       title: thread.title,
       description: descriptionParts.join(" · "),
-      timestamp: formatRelativeTimeLabel(thread.latestUserMessageAt ?? thread.updatedAt ?? thread.createdAt),
+      timestamp: formatRelativeTimeLabel(
+        thread.latestUserMessageAt ?? thread.updatedAt ?? thread.createdAt,
+      ),
       icon: input.icon,
       run: async () => {
         await input.runThread(thread);
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index 499723271f1..787a027b867 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -745,7 +745,9 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: SidebarThreadRowP
                         : "text-muted-foreground/40"
                     }`}
                   >
-                    {formatRelativeTimeLabel(thread.latestUserMessageAt ?? thread.updatedAt ?? thread.createdAt)}
+                    {formatRelativeTimeLabel(
+                      thread.latestUserMessageAt ?? thread.updatedAt ?? thread.createdAt,
+                    )}
                   </span>
                 )}
               </span>
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
index 7b515979528..29b50af257e 100644
--- a/apps/web/src/store.ts
+++ b/apps/web/src/store.ts
@@ -718,7 +718,9 @@ function writeThreadShellState(
     };
   }
 
-  if (!threadSessionsEqual(state.threadSessionById[nextThread.shell.id] ?? null, nextThread.session)) {
+  if (
+    !threadSessionsEqual(state.threadSessionById[nextThread.shell.id] ?? null, nextThread.session)
+  ) {
     nextState = {
       ...nextState,
       threadSessionById: {

From 1825befac60f049eb2cb0ebbb5ae54a33924f7b0 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Mon, 13 Apr 2026 12:19:28 -0700
Subject: [PATCH 4/6] Remove react-scan from web shell

- Delete the unpkg react-scan script from `apps/web/index.html`
- Keep the app shell lean for production
---
 apps/web/index.html | 1 -
 1 file changed, 1 deletion(-)

diff --git a/apps/web/index.html b/apps/web/index.html
index a0149eba6d8..9f0329b6020 100644
--- a/apps/web/index.html
+++ b/apps/web/index.html
@@ -8,7 +8,6 @@
     <meta name="theme-color" content="#161616" />
     <link rel="icon" href="/favicon.ico" sizes="48x48" />
     <link rel="apple-touch-icon" href="/apple-touch-icon.png" />
-    <script crossorigin="anonymous" src="//unpkg.com/react-scan/dist/auto.global.js"></script>
     <script>
       (() => {
         const LIGHT_BACKGROUND = "#ffffff";

From 77497454932302a652ef798c19c4e49560e99801 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Mon, 13 Apr 2026 12:47:39 -0700
Subject: [PATCH 5/6] Consolidate thread registration across stream updates

- Share bookkeeping for thread IDs and project membership across shell and detail writes
- Remove read-model sync and unused sidebar selector plumbing
- Keep shell data authoritative for sidebar summaries
---
 apps/web/src/store.test.ts     | 300 --------------------------------
 apps/web/src/store.ts          | 303 ++++++++++-----------------------
 apps/web/src/storeSelectors.ts |  11 +-
 3 files changed, 93 insertions(+), 521 deletions(-)

diff --git a/apps/web/src/store.test.ts b/apps/web/src/store.test.ts
index 0673f48c2f0..c02479ec749 100644
--- a/apps/web/src/store.test.ts
+++ b/apps/web/src/store.test.ts
@@ -23,7 +23,6 @@ import {
   selectThreadExistsByRef,
   setThreadBranch,
   selectThreadsAcrossEnvironments,
-  syncServerReadModel,
   syncServerShellSnapshot,
   type AppState,
   type EnvironmentState,
@@ -371,75 +370,6 @@ describe("thread selection memoization", () => {
   });
 });
 
-function makeReadModelThread(overrides: Partial<OrchestrationReadModel["threads"][number]>) {
-  return {
-    id: ThreadId.make("thread-1"),
-    projectId: ProjectId.make("project-1"),
-    title: "Thread",
-    modelSelection: {
-      provider: "codex",
-      model: "gpt-5.3-codex",
-    },
-    runtimeMode: DEFAULT_RUNTIME_MODE,
-    interactionMode: DEFAULT_INTERACTION_MODE,
-    branch: null,
-    worktreePath: null,
-    latestTurn: null,
-    createdAt: "2026-02-27T00:00:00.000Z",
-    updatedAt: "2026-02-27T00:00:00.000Z",
-    archivedAt: null,
-    deletedAt: null,
-    messages: [],
-    activities: [],
-    proposedPlans: [],
-    checkpoints: [],
-    session: null,
-    ...overrides,
-  } satisfies OrchestrationReadModel["threads"][number];
-}
-
-function makeReadModel(thread: OrchestrationReadModel["threads"][number]): OrchestrationReadModel {
-  return {
-    snapshotSequence: 1,
-    updatedAt: "2026-02-27T00:00:00.000Z",
-    projects: [
-      {
-        id: ProjectId.make("project-1"),
-        title: "Project",
-        workspaceRoot: "/tmp/project",
-        defaultModelSelection: {
-          provider: "codex",
-          model: "gpt-5.3-codex",
-        },
-        createdAt: "2026-02-27T00:00:00.000Z",
-        updatedAt: "2026-02-27T00:00:00.000Z",
-        deletedAt: null,
-        scripts: [],
-      },
-    ],
-    threads: [thread],
-  };
-}
-
-function makeReadModelProject(
-  overrides: Partial<OrchestrationReadModel["projects"][number]>,
-): OrchestrationReadModel["projects"][number] {
-  return {
-    id: ProjectId.make("project-1"),
-    title: "Project",
-    workspaceRoot: "/tmp/project",
-    defaultModelSelection: {
-      provider: "codex",
-      model: "gpt-5.3-codex",
-    },
-    createdAt: "2026-02-27T00:00:00.000Z",
-    updatedAt: "2026-02-27T00:00:00.000Z",
-    deletedAt: null,
-    scripts: [],
-    ...overrides,
-  };
-}
-
 describe("setThreadBranch", () => {
   it("updates only the scoped thread environment", () => {
     const sharedThreadId = ThreadId.make("thread-shared");
@@ -480,236 +410,6 @@ describe("setThreadBranch", () => {
   });
 });
 
-describe("store read model sync", () => {
-  it("marks bootstrap complete after snapshot sync", () => {
-    const initialState = withActiveEnvironmentState(
-      localEnvironmentStateOf(makeState(makeThread())),
-      {
-        bootstrapComplete: false,
-      },
-    );
-
-    const next = syncServerReadModel(
-      initialState,
-      makeReadModel(makeReadModelThread({})),
-      localEnvironmentId,
-    );
-
-    expect(localEnvironmentStateOf(next).bootstrapComplete).toBe(true);
-  });
-
-  it("updates shell state without discarding hydrated thread detail", () => {
-    const initialState = makeState(
-      makeThread({
-        title: "Initial thread",
-        messages: [
-          {
-            id: MessageId.make("message-1"),
-            role: "assistant",
-            text: "hydrated body",
-            createdAt: "2026-02-13T00:00:01.000Z",
-            completedAt: "2026-02-13T00:00:01.000Z",
-            streaming: false,
-          },
-        ],
-      }),
-    );
-    const shellSnapshot: OrchestrationShellSnapshot = {
-      snapshotSequence: 2,
-      projects: [
-        {
-          id: ProjectId.make("project-1"),
-          title: "Project",
-          workspaceRoot: "/tmp/project",
-          repositoryIdentity: null,
-          defaultModelSelection: {
-            provider: "codex",
-            model: "gpt-5-codex",
-          },
-          scripts: [],
-          createdAt: "2026-02-13T00:00:00.000Z",
-          updatedAt: "2026-02-13T00:00:00.000Z",
-        },
-      ],
-      threads: [
-        {
-          id: ThreadId.make("thread-1"),
-          projectId: ProjectId.make("project-1"),
-          title: "Renamed thread",
-          modelSelection: {
-            provider: "codex",
-            model: "gpt-5-codex",
-          },
-          runtimeMode: "full-access",
-          interactionMode: "default",
-          branch: "feature/renamed",
-          worktreePath: null,
-          latestTurn: null,
-          createdAt: "2026-02-13T00:00:00.000Z",
-          updatedAt: "2026-02-13T00:00:02.000Z",
-          archivedAt: null,
-          session: null,
-          latestUserMessageAt: null,
-          hasPendingApprovals: false,
-          hasPendingUserInput: false,
-          hasActionableProposedPlan: false,
-        },
-      ],
-      updatedAt: "2026-02-13T00:00:02.000Z",
-    };
-
-    const next = syncServerShellSnapshot(initialState, shellSnapshot, localEnvironmentId);
-    const thread = selectThreadByRef(
-      next,
-      scopeThreadRef(localEnvironmentId, ThreadId.make("thread-1")),
-    );
-
-    expect(thread?.title).toBe("Renamed thread");
-    expect(thread?.branch).toBe("feature/renamed");
-    expect(thread?.messages).toEqual([
-      expect.objectContaining({
-        id: MessageId.make("message-1"),
-        text: "hydrated body",
-      }),
-    ]);
-    expect(localEnvironmentStateOf(next).bootstrapComplete).toBe(true);
-  });
-
-  it("preserves claude model slugs without an active session", () => {
-    const initialState = makeState(makeThread());
-    const readModel = makeReadModel(
-      makeReadModelThread({
-        modelSelection: {
-          provider: "claudeAgent",
-          model: "claude-opus-4-6",
-        },
-      }),
-    );
-
-    const next = syncServerReadModel(initialState, readModel, localEnvironmentId);
-
-    expect(threadsOf(next)[0]?.modelSelection.model).toBe("claude-opus-4-6");
-  });
-
-  it("resolves claude aliases when session provider is claudeAgent", () => {
-    const initialState = makeState(makeThread());
-    const readModel = makeReadModel(
-      makeReadModelThread({
-        modelSelection: {
-          provider: "claudeAgent",
-          model: "sonnet",
-        },
-        session: {
-          threadId: ThreadId.make("thread-1"),
-          status: "ready",
-          providerName: "claudeAgent",
-          runtimeMode: "approval-required",
-          activeTurnId: null,
-          lastError: null,
-          updatedAt: "2026-02-27T00:00:00.000Z",
-        },
-      }),
-    );
-
-    const next = syncServerReadModel(initialState, readModel, localEnvironmentId);
-
-    expect(threadsOf(next)[0]?.modelSelection.model).toBe("claude-sonnet-4-6");
-  });
-
-  it("preserves project and thread updatedAt timestamps from the read model", () => {
-    const initialState = makeState(makeThread());
-    const readModel = makeReadModel(
-      makeReadModelThread({
-        updatedAt: "2026-02-27T00:05:00.000Z",
-      }),
-    );
-
-    const next = syncServerReadModel(initialState, readModel, localEnvironmentId);
-
-    expect(projectsOf(next)[0]?.updatedAt).toBe("2026-02-27T00:00:00.000Z");
-    expect(threadsOf(next)[0]?.updatedAt).toBe("2026-02-27T00:05:00.000Z");
-  });
-
-  it("maps archivedAt from the read model", () => {
-    const initialState = makeState(makeThread());
-    const archivedAt = "2026-02-28T00:00:00.000Z";
-    const next = syncServerReadModel(
-      initialState,
-      makeReadModel(
-        makeReadModelThread({
-          archivedAt,
-        }),
-      ),
-      localEnvironmentId,
-    );
-
-    expect(threadsOf(next)[0]?.archivedAt).toBe(archivedAt);
-  });
-
-  it("replaces projects using snapshot order during recovery", () => {
-    const project1 = ProjectId.make("project-1");
-    const project2 = ProjectId.make("project-2");
-    const project3 = ProjectId.make("project-3");
-    const initialState: AppState = makeEmptyState({
-      projectIds: [project2, project1],
-      projectById: {
-        [project2]: {
-          id: project2,
-          environmentId: localEnvironmentId,
-          name: "Project 2",
-          cwd: "/tmp/project-2",
-          defaultModelSelection: {
-            provider: "codex",
-            model: DEFAULT_MODEL_BY_PROVIDER.codex,
-          },
-          createdAt: "2026-02-27T00:00:00.000Z",
-          updatedAt: "2026-02-27T00:00:00.000Z",
-          scripts: [],
-        },
-        [project1]: {
-          id: project1,
-          environmentId: localEnvironmentId,
-          name: "Project 1",
-          cwd: "/tmp/project-1",
-          defaultModelSelection: {
-            provider: "codex",
-            model: DEFAULT_MODEL_BY_PROVIDER.codex,
-          },
-          createdAt: "2026-02-27T00:00:00.000Z",
-          updatedAt: "2026-02-27T00:00:00.000Z",
-          scripts: [],
-        },
-      },
-    });
-    const readModel: OrchestrationReadModel = {
-      snapshotSequence: 2,
-      updatedAt: "2026-02-27T00:00:00.000Z",
-      projects: [
-        makeReadModelProject({
-          id: project1,
-          title: "Project 1",
-          workspaceRoot: "/tmp/project-1",
-        }),
-        makeReadModelProject({
-          id: project2,
-          title: "Project 2",
-          workspaceRoot: "/tmp/project-2",
-        }),
-        makeReadModelProject({
-          id: project3,
-          title: "Project 3",
-          workspaceRoot: "/tmp/project-3",
-        }),
-      ],
-      threads: [],
-    };
-
-    const next = syncServerReadModel(initialState, readModel, localEnvironmentId);
-
-    expect(projectsOf(next).map((project) => project.id)).toEqual([project1, project2, project3]);
-  });
-});
-
 describe("incremental orchestration updates", () => {
   it("does not mark bootstrap complete for incremental events", () => {
     const state = withActiveEnvironmentState(localEnvironmentStateOf(makeState(makeThread())), {
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
index 29b50af257e..ec326024807 100644
--- a/apps/web/src/store.ts
+++ b/apps/web/src/store.ts
@@ -23,12 +23,6 @@ import type {
 } from "@t3tools/contracts";
 import { resolveModelSlugForProvider } from "@t3tools/shared/model";
 import { create } from "zustand";
-import {
-  derivePendingApprovals,
-  derivePendingUserInputs,
-  findLatestProposedPlan,
-  hasActionableProposedPlan,
-} from "./session-logic";
 import {
   type ChatMessage,
   type Project,
@@ -47,11 +41,33 @@ import { getThreadFromEnvironmentState } from "./threadDerivation";
 export interface EnvironmentState {
   projectIds: ProjectId[];
   projectById: Record<ProjectId, Project>;
+
+  // ---------------------------------------------------------------------------
+  // Thread bookkeeping — written by BOTH shell stream and detail stream.
+  // Both streams ensure the thread is registered here; the bookkeeping is
+  // additive (append-only IDs) so concurrent writes are safe.
+  // ---------------------------------------------------------------------------
   threadIds: ThreadId[];
   threadIdsByProjectId: Record<ProjectId, ThreadId[]>;
+
+  // ---------------------------------------------------------------------------
+  // Thread shell / session / turn — written by BOTH shell stream and detail
+  // stream.  The shell stream is the *authoritative* source (server pre-
+  // computes these from the projection pipeline), but the detail stream also
+  // writes them so the active thread has up-to-date state even if the shell
+  // event hasn't arrived yet.  Structural equality checks in both write
+  // functions prevent unnecessary React re-renders when both streams deliver
+  // equivalent data.
+  // ---------------------------------------------------------------------------
   threadShellById: Record<ThreadId, ThreadShell>;
   threadSessionById: Record<ThreadId, ThreadSession | null>;
   threadTurnStateById: Record<ThreadId, ThreadTurnState>;
+
+  // ---------------------------------------------------------------------------
+  // Thread detail content — written ONLY by the detail stream
+  // (writeThreadState / syncServerThreadDetail).  The shell stream never
+  // touches these.
+  // ---------------------------------------------------------------------------
   messageIdsByThreadId: Record<ThreadId, MessageId[]>;
   messageByThreadId: Record<ThreadId, Record<MessageId, ChatMessage>>;
   activityIdsByThreadId: Record<ThreadId, string[]>;
@@ -60,7 +76,16 @@ export interface EnvironmentState {
   proposedPlanByThreadId: Record<ThreadId, Record<string, ProposedPlan>>;
   turnDiffIdsByThreadId: Record<ThreadId, TurnId[]>;
   turnDiffSummaryByThreadId: Record<ThreadId, Record<TurnId, TurnDiffSummary>>;
+
+  // ---------------------------------------------------------------------------
+  // Sidebar summary — written ONLY by the shell stream
+  // (writeThreadShellState / mapThreadShell).  Pre-computed server-side with
+  // fields like latestUserMessageAt, hasPendingApprovals, etc.  The detail
+  // stream must NOT write here; the shell stream is the single source of
+  // truth for sidebar data.
+  // ---------------------------------------------------------------------------
   sidebarThreadSummaryById: Record<ThreadId, SidebarThreadSummary>;
+
   bootstrapComplete: boolean;
 }
 
@@ -309,42 +334,6 @@ function toThreadTurnState(thread: Thread): ThreadTurnState {
   };
 }
 
-function getLatestUserMessageAt(messages: ReadonlyArray<ChatMessage>): string | null {
-  let latestUserMessageAt: string | null = null;
-  for (const message of messages) {
-    if (message.role !== "user") {
-      continue;
-    }
-    if (latestUserMessageAt === null || message.createdAt > latestUserMessageAt) {
-      latestUserMessageAt = message.createdAt;
-    }
-  }
-  return latestUserMessageAt;
-}
-
-function buildSidebarThreadSummary(thread: Thread): SidebarThreadSummary {
-  return {
-    id: thread.id,
-    environmentId: thread.environmentId,
-    projectId: thread.projectId,
-    title: thread.title,
-    interactionMode: thread.interactionMode,
-    session: thread.session,
-    createdAt: thread.createdAt,
-    archivedAt: thread.archivedAt,
-    updatedAt: thread.updatedAt,
-    latestTurn: thread.latestTurn,
-    branch: thread.branch,
-    worktreePath: thread.worktreePath,
-    latestUserMessageAt: getLatestUserMessageAt(thread.messages),
-    hasPendingApprovals: derivePendingApprovals(thread.activities).length > 0,
-    hasPendingUserInput: derivePendingUserInputs(thread.activities).length > 0,
-    hasActionableProposedPlan: hasActionableProposedPlan(
-      findLatestProposedPlan(thread.proposedPlans, thread.latestTurn?.turnId ?? null),
-    ),
-  };
-}
-
 function sourceProposedPlansEqual(
   left: OrchestrationLatestTurn["sourceProposedPlan"] | undefined,
   right: OrchestrationLatestTurn["sourceProposedPlan"] | undefined,
@@ -510,32 +499,32 @@ function getThreads(state: EnvironmentState): Thread[] {
   });
 }
 
-function writeThreadState(
+/**
+ * Ensure a thread is registered in the bookkeeping indices (threadIds,
+ * threadIdsByProjectId).  Shared by both the shell stream and detail stream
+ * write paths — the bookkeeping is additive (append-only IDs) so concurrent
+ * writes from both streams are safe.
+ */
+function ensureThreadRegistered(
   state: EnvironmentState,
-  nextThread: Thread,
-  previousThread?: Thread,
+  threadId: ThreadId,
+  nextProjectId: ProjectId,
+  previousProjectId: ProjectId | undefined,
 ): EnvironmentState {
-  const nextShell = toThreadShell(nextThread);
-  const nextTurnState = toThreadTurnState(nextThread);
-  const previousShell = state.threadShellById[nextThread.id];
-  const previousTurnState = state.threadTurnStateById[nextThread.id];
-
   let nextState = state;
 
-  if (!state.threadIds.includes(nextThread.id)) {
+  if (!state.threadIds.includes(threadId)) {
     nextState = {
       ...nextState,
-      threadIds: [...nextState.threadIds, nextThread.id],
+      threadIds: [...nextState.threadIds, threadId],
     };
   }
 
-  const previousProjectId = previousThread?.projectId;
-  const nextProjectId = nextThread.projectId;
   if (previousProjectId !== nextProjectId) {
     let threadIdsByProjectId = nextState.threadIdsByProjectId;
     if (previousProjectId) {
       const previousIds = threadIdsByProjectId[previousProjectId] ?? EMPTY_THREAD_IDS;
-      const nextIds = removeId(previousIds, nextThread.id);
+      const nextIds = removeId(previousIds, threadId);
       if (nextIds.length === 0) {
         const { [previousProjectId]: _removed, ...rest } = threadIdsByProjectId;
         threadIdsByProjectId = rest as Record<ProjectId, ThreadId[]>;
@@ -547,7 +536,7 @@ function writeThreadState(
       }
     }
     const projectThreadIds = threadIdsByProjectId[nextProjectId] ?? EMPTY_THREAD_IDS;
-    const nextProjectThreadIds = appendId(projectThreadIds, nextThread.id);
+    const nextProjectThreadIds = appendId(projectThreadIds, threadId);
     if (!arraysEqual(projectThreadIds, nextProjectThreadIds)) {
       threadIdsByProjectId = {
         ...threadIdsByProjectId,
@@ -562,6 +551,36 @@ function writeThreadState(
     }
   }
 
+  return nextState;
+}
+
+/**
+ * Write thread state from the **detail stream** (per-thread subscription).
+ *
+ * Owns: messages, activities, proposed plans, turn diff summaries.
+ * Also writes threadShellById / threadSessionById / threadTurnStateById so
+ * the active thread has up-to-date state even if the shell stream event
+ * hasn't arrived yet (both streams use structural equality checks to avoid
+ * unnecessary re-renders when delivering equivalent data).
+ * Does NOT write sidebarThreadSummaryById — that is shell-stream-only.
+ */
+function writeThreadState(
+  state: EnvironmentState,
+  nextThread: Thread,
+  previousThread?: Thread,
+): EnvironmentState {
+  const nextShell = toThreadShell(nextThread);
+  const nextTurnState = toThreadTurnState(nextThread);
+  const previousShell = state.threadShellById[nextThread.id];
+  const previousTurnState = state.threadTurnStateById[nextThread.id];
+
+  let nextState = ensureThreadRegistered(
+    state,
+    nextThread.id,
+    nextThread.projectId,
+    previousThread?.projectId,
+  );
+
   if (!threadShellsEqual(previousShell, nextShell)) {
     nextState = {
       ...nextState,
@@ -655,6 +674,17 @@ function writeThreadState(
   return nextState;
 }
 
+/**
+ * Write thread state from the **shell stream** (all-threads subscription).
+ *
+ * Owns: sidebarThreadSummaryById (pre-computed server-side sidebar data).
+ * Also writes threadShellById / threadSessionById / threadTurnStateById as
+ * the authoritative source for these fields.  The detail stream may also
+ * write them for the focused thread (see writeThreadState); structural
+ * equality checks prevent unnecessary re-renders.
+ * Does NOT write message/activity/proposedPlan/turnDiff content — that is
+ * detail-stream-only.
+ */
 function writeThreadShellState(
   state: EnvironmentState,
   nextThread: {
@@ -664,49 +694,14 @@ function writeThreadShellState(
     summary: SidebarThreadSummary;
   },
 ): EnvironmentState {
-  let nextState = state;
   const previousShell = state.threadShellById[nextThread.shell.id];
-  const previousProjectId = previousShell?.projectId;
-  const nextProjectId = nextThread.shell.projectId;
-
-  if (!state.threadIds.includes(nextThread.shell.id)) {
-    nextState = {
-      ...nextState,
-      threadIds: [...nextState.threadIds, nextThread.shell.id],
-    };
-  }
-
-  if (previousProjectId !== nextProjectId) {
-    let threadIdsByProjectId = nextState.threadIdsByProjectId;
-    if (previousProjectId) {
-      const previousIds = threadIdsByProjectId[previousProjectId] ?? EMPTY_THREAD_IDS;
-      const nextIds = removeId(previousIds, nextThread.shell.id);
-      if (nextIds.length === 0) {
-        const { [previousProjectId]: _removed, ...rest } = threadIdsByProjectId;
-        threadIdsByProjectId = rest as Record<ProjectId, ThreadId[]>;
-      } else if (!arraysEqual(previousIds, nextIds)) {
-        threadIdsByProjectId = {
-          ...threadIdsByProjectId,
-          [previousProjectId]: nextIds,
-        };
-      }
-    }
 
-    const projectThreadIds = threadIdsByProjectId[nextProjectId] ?? EMPTY_THREAD_IDS;
-    const nextProjectThreadIds = appendId(projectThreadIds, nextThread.shell.id);
-    if (!arraysEqual(projectThreadIds, nextProjectThreadIds)) {
-      threadIdsByProjectId = {
-        ...threadIdsByProjectId,
-        [nextProjectId]: nextProjectThreadIds,
-      };
-    }
-    if (threadIdsByProjectId !== nextState.threadIdsByProjectId) {
-      nextState = {
-        ...nextState,
-        threadIdsByProjectId,
-      };
-    }
-  }
+  let nextState = ensureThreadRegistered(
+    state,
+    nextThread.shell.id,
+    nextThread.shell.projectId,
+    previousShell?.projectId,
+  );
 
   if (!threadShellsEqual(previousShell, nextThread.shell)) {
     nextState = {
@@ -1043,82 +1038,6 @@ function buildProjectState(
   };
 }
 
-function buildThreadState(
-  threads: ReadonlyArray<Thread>,
-): Pick<
-  EnvironmentState,
-  | "threadIds"
-  | "threadIdsByProjectId"
-  | "threadShellById"
-  | "threadSessionById"
-  | "threadTurnStateById"
-  | "messageIdsByThreadId"
-  | "messageByThreadId"
-  | "activityIdsByThreadId"
-  | "activityByThreadId"
-  | "proposedPlanIdsByThreadId"
-  | "proposedPlanByThreadId"
-  | "turnDiffIdsByThreadId"
-  | "turnDiffSummaryByThreadId"
-  | "sidebarThreadSummaryById"
-> {
-  const threadIds: ThreadId[] = [];
-  const threadIdsByProjectId: Record<ProjectId, ThreadId[]> = {};
-  const threadShellById: Record<ThreadId, ThreadShell> = {};
-  const threadSessionById: Record<ThreadId, ThreadSession | null> = {};
-  const threadTurnStateById: Record<ThreadId, ThreadTurnState> = {};
-  const messageIdsByThreadId: Record<ThreadId, MessageId[]> = {};
-  const messageByThreadId: Record<ThreadId, Record<MessageId, ChatMessage>> = {};
-  const activityIdsByThreadId: Record<ThreadId, string[]> = {};
-  const activityByThreadId: Record<ThreadId, Record<string, OrchestrationThreadActivity>> = {};
-  const proposedPlanIdsByThreadId: Record<ThreadId, string[]> = {};
-  const proposedPlanByThreadId: Record<ThreadId, Record<string, ProposedPlan>> = {};
-  const turnDiffIdsByThreadId: Record<ThreadId, TurnId[]> = {};
-  const turnDiffSummaryByThreadId: Record<ThreadId, Record<TurnId, TurnDiffSummary>> = {};
-  const sidebarThreadSummaryById: Record<ThreadId, SidebarThreadSummary> = {};
-
-  for (const thread of threads) {
-    threadIds.push(thread.id);
-    threadIdsByProjectId[thread.projectId] = [
-      ...(threadIdsByProjectId[thread.projectId] ?? EMPTY_THREAD_IDS),
-      thread.id,
-    ];
-    threadShellById[thread.id] = toThreadShell(thread);
-    threadSessionById[thread.id] = thread.session;
-    threadTurnStateById[thread.id] = toThreadTurnState(thread);
-    const messageSlice = buildMessageSlice(thread);
-    messageIdsByThreadId[thread.id] = messageSlice.ids;
-    messageByThreadId[thread.id] = messageSlice.byId;
-    const activitySlice = buildActivitySlice(thread);
-    activityIdsByThreadId[thread.id] = activitySlice.ids;
-    activityByThreadId[thread.id] = activitySlice.byId;
-    const proposedPlanSlice = buildProposedPlanSlice(thread);
-    proposedPlanIdsByThreadId[thread.id] = proposedPlanSlice.ids;
-    proposedPlanByThreadId[thread.id] = proposedPlanSlice.byId;
-    const turnDiffSlice = buildTurnDiffSlice(thread);
-    turnDiffIdsByThreadId[thread.id] = turnDiffSlice.ids;
-    turnDiffSummaryByThreadId[thread.id] = turnDiffSlice.byId;
-    sidebarThreadSummaryById[thread.id] = buildSidebarThreadSummary(thread);
-  }
-
-  return {
-    threadIds,
-    threadIdsByProjectId,
-    threadShellById,
-    threadSessionById,
-    threadTurnStateById,
-    messageIdsByThreadId,
-    messageByThreadId,
-    activityIdsByThreadId,
-    activityByThreadId,
-    proposedPlanIdsByThreadId,
-    proposedPlanByThreadId,
-    turnDiffIdsByThreadId,
-    turnDiffSummaryByThreadId,
-    sidebarThreadSummaryById,
-  };
-}
-
 function getStoredEnvironmentState(
   state: AppState,
   environmentId: EnvironmentId,
@@ -1150,25 +1069,6 @@ function commitEnvironmentState(
   };
 }
 
-function syncEnvironmentReadModel(
-  state: EnvironmentState,
-  readModel: OrchestrationReadModel,
-  environmentId: EnvironmentId,
-): EnvironmentState {
-  const projects = readModel.projects
-    .filter((project) => project.deletedAt === null)
-    .map((project) => mapProject(project, environmentId));
-  const threads = readModel.threads
-    .filter((thread) => thread.deletedAt === null)
-    .map((thread) => mapThread(thread, environmentId));
-  return {
-    ...state,
-    ...buildProjectState(projects),
-    ...buildThreadState(threads),
-    bootstrapComplete: true,
-  };
-}
-
 function syncEnvironmentShellSnapshot(
   state: EnvironmentState,
   snapshot: OrchestrationShellSnapshot,
@@ -1209,22 +1109,6 @@ function syncEnvironmentShellSnapshot(
   return nextState;
 }
 
-export function syncServerReadModel(
-  state: AppState,
-  readModel: OrchestrationReadModel,
-  environmentId: EnvironmentId,
-): AppState {
-  return commitEnvironmentState(
-    state,
-    environmentId,
-    syncEnvironmentReadModel(
-      getStoredEnvironmentState(state, environmentId),
-      readModel,
-      environmentId,
-    ),
-  );
-}
-
 export function syncServerShellSnapshot(
   state: AppState,
   snapshot: OrchestrationShellSnapshot,
@@ -2041,7 +1925,6 @@ export function setThreadBranch(
 
 interface AppStore extends AppState {
   setActiveEnvironmentId: (environmentId: EnvironmentId) => void;
-  syncServerReadModel: (readModel: OrchestrationReadModel, environmentId: EnvironmentId) => void;
   syncServerShellSnapshot: (
     snapshot: OrchestrationShellSnapshot,
     environmentId: EnvironmentId,
@@ -2065,8 +1948,6 @@ export const useStore = create<AppStore>((set) => ({
   ...initialState,
   setActiveEnvironmentId: (environmentId) =>
     set((state) => setActiveEnvironmentId(state, environmentId)),
-  syncServerReadModel: (readModel, environmentId) =>
-    set((state) => syncServerReadModel(state, readModel, environmentId)),
   syncServerShellSnapshot: (snapshot, environmentId) =>
     set((state) => syncServerShellSnapshot(state, snapshot, environmentId)),
   syncServerThreadDetail: (thread, environmentId) =>
diff --git a/apps/web/src/storeSelectors.ts b/apps/web/src/storeSelectors.ts
index 02b88f31b18..95ed6ff1f41 100644
--- a/apps/web/src/storeSelectors.ts
+++ b/apps/web/src/storeSelectors.ts
@@ -1,6 +1,6 @@
 import { type ScopedProjectRef, type ScopedThreadRef, type ThreadId } from "@t3tools/contracts";
 import { selectEnvironmentState, type AppState, type EnvironmentState } from "./store";
-import { type Project, type SidebarThreadSummary, type Thread } from "./types";
+import { type Project, type Thread } from "./types";
 import { getThreadFromEnvironmentState } from "./threadDerivation";
 
 export function createProjectSelectorByRef(
@@ -10,15 +10,6 @@ export function createProjectSelectorByRef(
     ref ? selectEnvironmentState(state, ref.environmentId).projectById[ref.projectId] : undefined;
 }
 
-export function createSidebarThreadSummarySelectorByRef(
-  ref: ScopedThreadRef | null | undefined,
-): (state: AppState) => SidebarThreadSummary | undefined {
-  return (state) =>
-    ref
-      ? selectEnvironmentState(state, ref.environmentId).sidebarThreadSummaryById[ref.threadId]
-      : undefined;
-}
-
 function createScopedThreadSelector(
   resolveRef: (state: AppState) => ScopedThreadRef | null | undefined,
 ): (state: AppState) => Thread | undefined {

From c26d203ecc15534a62b6d113ec37bbf8fb0678b9 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Mon, 13 Apr 2026 13:09:21 -0700
Subject: [PATCH 6/6] kewl

---
 apps/web/src/store.test.ts | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/apps/web/src/store.test.ts b/apps/web/src/store.test.ts
index c02479ec749..9bb01ba0be3 100644
--- a/apps/web/src/store.test.ts
+++ b/apps/web/src/store.test.ts
@@ -5,12 +5,10 @@ import {
   EnvironmentId,
   EventId,
   MessageId,
-  type OrchestrationShellSnapshot,
   ProjectId,
   ThreadId,
   TurnId,
   type OrchestrationEvent,
-  type OrchestrationReadModel,
 } from "@t3tools/contracts";
 import { describe, expect, it } from "vitest";
 
@@ -23,7 +21,6 @@ import {
   selectThreadExistsByRef,
   setThreadBranch,
   selectThreadsAcrossEnvironments,
-  syncServerShellSnapshot,
   type AppState,
   type EnvironmentState,
 } from "./store";