Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Refactor web orchestration sync to incremental events and isolated recovery (#1560)

Julius Marminge0ea639196a7b
diff --git a/apps/web/src/components/ChatView.browser.tsx b/apps/web/src/components/ChatView.browser.tsx
index 0d612534e..20816d693 100644
--- a/apps/web/src/components/ChatView.browser.tsx
+++ b/apps/web/src/components/ChatView.browser.tsx
@@ -2,8 +2,11 @@
import "../index.css";
import {
+ EventId,
ORCHESTRATION_WS_METHODS,
+ ORCHESTRATION_WS_CHANNELS,
type MessageId,
+ type OrchestrationEvent,
type OrchestrationReadModel,
type ProjectId,
type ServerConfig,
@@ -57,6 +60,8 @@ interface TestFixture {
let fixture: TestFixture;
const wsRequests: WsRequestEnvelope["body"][] = [];
let customWsRpcResolver: ((body: WsRequestEnvelope["body"]) => unknown | undefined) | null = null;
+let wsClient: { send: (message: string) => void } | null = null;
+let pushSequence = 1;
const wsLink = ws.link(/ws(s)?:\/\/.*/);
interface ViewportSpec {
@@ -336,6 +341,79 @@ function addThreadToSnapshot(
};
}
+function createThreadCreatedEvent(threadId: ThreadId, sequence: number): OrchestrationEvent {
+ return {
+ sequence,
+ eventId: EventId.makeUnsafe(`event-thread-created-${sequence}`),
+ aggregateKind: "thread",
+ aggregateId: threadId,
+ occurredAt: NOW_ISO,
+ commandId: null,
+ causationEventId: null,
+ correlationId: null,
+ metadata: {},
+ type: "thread.created",
+ payload: {
+ threadId,
+ projectId: PROJECT_ID,
+ title: "New thread",
+ modelSelection: {
+ provider: "codex",
+ model: "gpt-5",
+ },
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ branch: "main",
+ worktreePath: null,
+ createdAt: NOW_ISO,
+ updatedAt: NOW_ISO,
+ },
+ };
+}
+
+function sendOrchestrationDomainEvent(event: OrchestrationEvent): void {
+ if (!wsClient) {
+ throw new Error("WebSocket client not connected");
+ }
+ wsClient.send(
+ JSON.stringify({
+ type: "push",
+ sequence: pushSequence++,
+ channel: ORCHESTRATION_WS_CHANNELS.domainEvent,
+ data: event,
+ }),
+ );
+}
+
+async function waitForWsClient(): Promise<{ send: (message: string) => void }> {
+ let client: { send: (message: string) => void } | null = null;
+ await vi.waitFor(
+ () => {
+ client = wsClient;
+ expect(client).toBeTruthy();
+ },
+ { timeout: 8_000, interval: 16 },
+ );
+ if (!client) {
+ throw new Error("WebSocket client not connected");
+ }
+ return client;
+}
+
+async function promoteDraftThreadViaDomainEvent(threadId: ThreadId): Promise<void> {
+ await waitForWsClient();
+ fixture.snapshot = addThreadToSnapshot(fixture.snapshot, threadId);
+ sendOrchestrationDomainEvent(
+ createThreadCreatedEvent(threadId, fixture.snapshot.snapshotSequence),
+ );
+ await vi.waitFor(
+ () => {
+ expect(useComposerDraftStore.getState().draftThreadsByThreadId[threadId]).toBeUndefined();
+ },
+ { timeout: 8_000, interval: 16 },
+ );
+}
+
function createDraftOnlySnapshot(): OrchestrationReadModel {
const snapshot = createSnapshotForTargetUser({
targetMessageId: "msg-user-draft-target" as MessageId,
@@ -500,10 +578,12 @@ function resolveWsRpc(body: WsRequestEnvelope["body"]): unknown {
const worker = setupWorker(
wsLink.addEventListener("connection", ({ client }) => {
+ wsClient = client;
+ pushSequence = 1;
client.send(
JSON.stringify({
type: "push",
- sequence: 1,
+ sequence: pushSequence++,
channel: WS_CHANNELS.serverWelcome,
data: fixture.welcome,
}),
@@ -875,7 +955,7 @@ describe("ChatView timeline estimator parity (full app)", () => {
useStore.setState({
projects: [],
threads: [],
- threadsHydrated: false,
+ bootstrapComplete: false,
});
});
@@ -1881,21 +1961,16 @@ describe("ChatView timeline estimator parity (full app)", () => {
// The composer editor should be present for the new draft thread.
await waitForComposerEditor();
- // Simulate the snapshot sync arriving from the server after the draft
- // thread has been promoted to a server thread (thread.create + turn.start
- // succeeded). The snapshot now includes the new thread, and the sync
- // should clear the draft without disrupting the route.
- const { syncServerReadModel } = useStore.getState();
- syncServerReadModel(addThreadToSnapshot(fixture.snapshot, newThreadId));
-
- // Clear the draft now that the server thread exists (mirrors EventRouter behavior).
- useComposerDraftStore.getState().clearDraftThread(newThreadId);
+ // Simulate the steady-state promotion path: the server emits
+ // `thread.created`, the client materializes the thread incrementally,
+ // and the draft is cleared by live batch effects.
+ await promoteDraftThreadViaDomainEvent(newThreadId);
// The route should still be on the new thread — not redirected away.
await waitForURL(
mounted.router,
(path) => path === newThreadPath,
- "New thread should remain selected after snapshot sync clears the draft.",
+ "New thread should remain selected after server thread promotion clears the draft.",
);
// The empty thread view and composer should still be visible.
@@ -2217,9 +2292,7 @@ describe("ChatView timeline estimator parity (full app)", () => {
);
const promotedThreadId = promotedThreadPath.slice(1) as ThreadId;
- const { syncServerReadModel } = useStore.getState();
- syncServerReadModel(addThreadToSnapshot(fixture.snapshot, promotedThreadId));
- useComposerDraftStore.getState().clearDraftThread(promotedThreadId);
+ await promoteDraftThreadViaDomainEvent(promotedThreadId);
const freshThreadPath = await triggerChatNewShortcutUntilPath(
mounted.router,
diff --git a/apps/web/src/components/ChatView.logic.test.ts b/apps/web/src/components/ChatView.logic.test.ts
index bf72ec0b8..80c842d91 100644
--- a/apps/web/src/components/ChatView.logic.test.ts
+++ b/apps/web/src/components/ChatView.logic.test.ts
@@ -1,7 +1,14 @@
-import { ThreadId } from "@t3tools/contracts";
-import { describe, expect, it } from "vitest";
+import { ProjectId, ThreadId, TurnId } from "@t3tools/contracts";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { useStore } from "../store";
-import { buildExpiredTerminalContextToastCopy, deriveComposerSendState } from "./ChatView.logic";
+import {
+ buildExpiredTerminalContextToastCopy,
+ createLocalDispatchSnapshot,
+ deriveComposerSendState,
+ hasServerAcknowledgedLocalDispatch,
+ waitForStartedServerThread,
+} from "./ChatView.logic";
describe("deriveComposerSendState", () => {
it("treats expired terminal pills as non-sendable content", () => {
@@ -67,3 +74,290 @@ describe("buildExpiredTerminalContextToastCopy", () => {
});
});
});
+
+const makeThread = (input?: {
+ id?: ThreadId;
+ latestTurn?: {
+ turnId: TurnId;
+ state: "running" | "completed";
+ requestedAt: string;
+ startedAt: string | null;
+ completedAt: string | null;
+ } | null;
+}) => ({
+ id: input?.id ?? ThreadId.makeUnsafe("thread-1"),
+ codexThreadId: null,
+ projectId: ProjectId.makeUnsafe("project-1"),
+ title: "Thread",
+ modelSelection: { provider: "codex" as const, model: "gpt-5.4" },
+ runtimeMode: "full-access" as const,
+ interactionMode: "default" as const,
+ session: null,
+ messages: [],
+ proposedPlans: [],
+ error: null,
+ createdAt: "2026-03-29T00:00:00.000Z",
+ archivedAt: null,
+ updatedAt: "2026-03-29T00:00:00.000Z",
+ latestTurn: input?.latestTurn
+ ? {
+ ...input.latestTurn,
+ assistantMessageId: null,
+ }
+ : null,
+ branch: null,
+ worktreePath: null,
+ turnDiffSummaries: [],
+ activities: [],
+});
+
+afterEach(() => {
+ vi.useRealTimers();
+ vi.restoreAllMocks();
+ useStore.setState((state) => ({
+ ...state,
+ projects: [],
+ threads: [],
+ bootstrapComplete: true,
+ }));
+});
+
+describe("waitForStartedServerThread", () => {
+ it("resolves immediately when the thread is already started", async () => {
+ const threadId = ThreadId.makeUnsafe("thread-started");
+ useStore.setState((state) => ({
+ ...state,
+ threads: [
+ makeThread({
+ id: threadId,
+ latestTurn: {
+ turnId: TurnId.makeUnsafe("turn-started"),
+ state: "running",
+ requestedAt: "2026-03-29T00:00:01.000Z",
+ startedAt: "2026-03-29T00:00:01.000Z",
+ completedAt: null,
+ },
+ }),
+ ],
+ }));
+
+ await expect(waitForStartedServerThread(threadId)).resolves.toBe(true);
+ });
+
+ it("waits for the thread to start via subscription updates", async () => {
+ const threadId = ThreadId.makeUnsafe("thread-wait");
+ useStore.setState((state) => ({
+ ...state,
+ threads: [makeThread({ id: threadId })],
+ }));
+
+ const promise = waitForStartedServerThread(threadId, 500);
+
+ useStore.setState((state) => ({
+ ...state,
+ threads: [
+ makeThread({
+ id: threadId,
+ latestTurn: {
+ turnId: TurnId.makeUnsafe("turn-started"),
+ state: "running",
+ requestedAt: "2026-03-29T00:00:01.000Z",
+ startedAt: "2026-03-29T00:00:01.000Z",
+ completedAt: null,
+ },
+ }),
+ ],
+ }));
+
+ await expect(promise).resolves.toBe(true);
+ });
+
+ it("handles the thread starting between the initial read and subscription setup", async () => {
+ const threadId = ThreadId.makeUnsafe("thread-race");
+ useStore.setState((state) => ({
+ ...state,
+ threads: [makeThread({ id: threadId })],
+ }));
+
+ const originalSubscribe = useStore.subscribe.bind(useStore);
+ let raced = false;
+ vi.spyOn(useStore, "subscribe").mockImplementation((listener) => {
+ if (!raced) {
+ raced = true;
+ useStore.setState((state) => ({
+ ...state,
+ threads: [
+ makeThread({
+ id: threadId,
+ latestTurn: {
+ turnId: TurnId.makeUnsafe("turn-race"),
+ state: "running",
+ requestedAt: "2026-03-29T00:00:01.000Z",
+ startedAt: "2026-03-29T00:00:01.000Z",
+ completedAt: null,
+ },
+ }),
+ ],
+ }));
+ }
+ return originalSubscribe(listener);
+ });
+
+ await expect(waitForStartedServerThread(threadId, 500)).resolves.toBe(true);
+ });
+
+ it("returns false after the timeout when the thread never starts", async () => {
+ vi.useFakeTimers();
+
+ const threadId = ThreadId.makeUnsafe("thread-timeout");
+ useStore.setState((state) => ({
+ ...state,
+ threads: [makeThread({ id: threadId })],
+ }));
+ const promise = waitForStartedServerThread(threadId, 500);
+
+ await vi.advanceTimersByTimeAsync(500);
+
+ await expect(promise).resolves.toBe(false);
+ });
+});
+
+describe("hasServerAcknowledgedLocalDispatch", () => {
+ const projectId = ProjectId.makeUnsafe("project-1");
+ const previousLatestTurn = {
+ turnId: TurnId.makeUnsafe("turn-1"),
+ state: "completed" as const,
+ requestedAt: "2026-03-29T00:00:00.000Z",
+ startedAt: "2026-03-29T00:00:01.000Z",
+ completedAt: "2026-03-29T00:00:10.000Z",
+ assistantMessageId: null,
+ };
+
+ const previousSession = {
+ provider: "codex" as const,
+ status: "ready" as const,
+ createdAt: "2026-03-29T00:00:00.000Z",
+ updatedAt: "2026-03-29T00:00:10.000Z",
+ orchestrationStatus: "idle" as const,
+ };
+
+ it("does not clear local dispatch before server state changes", () => {
+ const localDispatch = createLocalDispatchSnapshot({
+ id: ThreadId.makeUnsafe("thread-1"),
+ codexThreadId: null,
+ projectId,
+ title: "Thread",
+ modelSelection: { provider: "codex", model: "gpt-5.4" },
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ session: previousSession,
+ messages: [],
+ proposedPlans: [],
+ error: null,
+ createdAt: "2026-03-29T00:00:00.000Z",
+ archivedAt: null,
+ updatedAt: "2026-03-29T00:00:10.000Z",
+ latestTurn: previousLatestTurn,
+ branch: null,
+ worktreePath: null,
+ turnDiffSummaries: [],
+ activities: [],
+ });
+
+ expect(
+ hasServerAcknowledgedLocalDispatch({
+ localDispatch,
+ phase: "ready",
+ latestTurn: previousLatestTurn,
+ session: previousSession,
+ hasPendingApproval: false,
+ hasPendingUserInput: false,
+ threadError: null,
+ }),
+ ).toBe(false);
+ });
+
+ it("clears local dispatch when a new turn is already settled", () => {
+ const localDispatch = createLocalDispatchSnapshot({
+ id: ThreadId.makeUnsafe("thread-1"),
+ codexThreadId: null,
+ projectId,
+ title: "Thread",
+ modelSelection: { provider: "codex", model: "gpt-5.4" },
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ session: previousSession,
+ messages: [],
+ proposedPlans: [],
+ error: null,
+ createdAt: "2026-03-29T00:00:00.000Z",
+ archivedAt: null,
+ updatedAt: "2026-03-29T00:00:10.000Z",
+ latestTurn: previousLatestTurn,
+ branch: null,
+ worktreePath: null,
+ turnDiffSummaries: [],
+ activities: [],
+ });
+
+ expect(
+ hasServerAcknowledgedLocalDispatch({
+ localDispatch,
+ phase: "ready",
+ latestTurn: {
+ ...previousLatestTurn,
+ turnId: TurnId.makeUnsafe("turn-2"),
+ requestedAt: "2026-03-29T00:01:00.000Z",
+ startedAt: "2026-03-29T00:01:01.000Z",
+ completedAt: "2026-03-29T00:01:30.000Z",
+ },
+ session: {
+ ...previousSession,
+ updatedAt: "2026-03-29T00:01:30.000Z",
+ },
+ hasPendingApproval: false,
+ hasPendingUserInput: false,
+ threadError: null,
+ }),
+ ).toBe(true);
+ });
+
+ it("clears local dispatch when the session changes without an observed running phase", () => {
+ const localDispatch = createLocalDispatchSnapshot({
+ id: ThreadId.makeUnsafe("thread-1"),
+ codexThreadId: null,
+ projectId,
+ title: "Thread",
+ modelSelection: { provider: "codex", model: "gpt-5.4" },
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ session: previousSession,
+ messages: [],
+ proposedPlans: [],
+ error: null,
+ createdAt: "2026-03-29T00:00:00.000Z",
+ archivedAt: null,
+ updatedAt: "2026-03-29T00:00:10.000Z",
+ latestTurn: previousLatestTurn,
+ branch: null,
+ worktreePath: null,
+ turnDiffSummaries: [],
+ activities: [],
+ });
+
+ expect(
+ hasServerAcknowledgedLocalDispatch({
+ localDispatch,
+ phase: "ready",
+ latestTurn: previousLatestTurn,
+ session: {
+ ...previousSession,
+ updatedAt: "2026-03-29T00:00:11.000Z",
+ },
+ hasPendingApproval: false,
+ hasPendingUserInput: false,
+ threadError: null,
+ }),
+ ).toBe(true);
+ });
+});
diff --git a/apps/web/src/components/ChatView.logic.ts b/apps/web/src/components/ChatView.logic.ts
index 0a27fb203..1821c65ed 100644
--- a/apps/web/src/components/ChatView.logic.ts
+++ b/apps/web/src/components/ChatView.logic.ts
@@ -1,8 +1,9 @@
-import { ProjectId, type ModelSelection, type ThreadId } from "@t3tools/contracts";
-import { type ChatMessage, type Thread } from "../types";
+import { ProjectId, type ModelSelection, type ThreadId, type TurnId } from "@t3tools/contracts";
+import { type ChatMessage, type SessionPhase, type Thread, type ThreadSession } from "../types";
import { randomUUID } from "~/lib/utils";
import { type ComposerImageAttachment, type DraftThreadState } from "../composerDraftStore";
import { Schema } from "effect";
+import { useStore } from "../store";
import {
filterTerminalContextsWithText,
stripInlineTerminalContextPlaceholders,
@@ -34,7 +35,6 @@ export function buildLocalDraftThread(
createdAt: draftThread.createdAt,
archivedAt: null,
latestTurn: null,
- lastVisitedAt: draftThread.createdAt,
branch: draftThread.branch,
worktreePath: draftThread.worktreePath,
turnDiffSummaries: [],
@@ -75,8 +75,6 @@ export function collectUserMessageBlobPreviewUrls(message: ChatMessage): string[
return previewUrls;
}
-export type SendPhase = "idle" | "preparing-worktree" | "sending-turn";
-
export interface PullRequestDialogState {
initialReference: string | null;
key: number;
@@ -161,3 +159,116 @@ export function buildExpiredTerminalContextToastCopy(
description: "Re-add it if you want that terminal output included.",
};
}
+
+export function threadHasStarted(thread: Thread | null | undefined): boolean {
+ return Boolean(
+ thread && (thread.latestTurn !== null || thread.messages.length > 0 || thread.session !== null),
+ );
+}
+
+export async function waitForStartedServerThread(
+ threadId: ThreadId,
+ timeoutMs = 1_000,
+): Promise<boolean> {
+ const getThread = () => useStore.getState().threads.find((thread) => thread.id === threadId);
+ const thread = getThread();
+
+ if (threadHasStarted(thread)) {
+ return true;
+ }
+
+ return await new Promise<boolean>((resolve) => {
+ let settled = false;
+ let timeoutId: ReturnType<typeof globalThis.setTimeout> | null = null;
+ const finish = (result: boolean) => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ if (timeoutId !== null) {
+ globalThis.clearTimeout(timeoutId);
+ }
+ unsubscribe();
+ resolve(result);
+ };
+
+ const unsubscribe = useStore.subscribe((state) => {
+ if (!threadHasStarted(state.threads.find((thread) => thread.id === threadId))) {
+ return;
+ }
+ finish(true);
+ });
+
+ if (threadHasStarted(getThread())) {
+ finish(true);
+ return;
+ }
+
+ timeoutId = globalThis.setTimeout(() => {
+ finish(false);
+ }, timeoutMs);
+ });
+}
+
+export interface LocalDispatchSnapshot {
+ startedAt: string;
+ preparingWorktree: boolean;
+ latestTurnTurnId: TurnId | null;
+ latestTurnRequestedAt: string | null;
+ latestTurnStartedAt: string | null;
+ latestTurnCompletedAt: string | null;
+ sessionOrchestrationStatus: ThreadSession["orchestrationStatus"] | null;
+ sessionUpdatedAt: string | null;
+}
+
+export function createLocalDispatchSnapshot(
+ activeThread: Thread | undefined,
+ options?: { preparingWorktree?: boolean },
+): LocalDispatchSnapshot {
+ const latestTurn = activeThread?.latestTurn ?? null;
+ const session = activeThread?.session ?? null;
+ return {
+ startedAt: new Date().toISOString(),
+ preparingWorktree: Boolean(options?.preparingWorktree),
+ latestTurnTurnId: latestTurn?.turnId ?? null,
+ latestTurnRequestedAt: latestTurn?.requestedAt ?? null,
+ latestTurnStartedAt: latestTurn?.startedAt ?? null,
+ latestTurnCompletedAt: latestTurn?.completedAt ?? null,
+ sessionOrchestrationStatus: session?.orchestrationStatus ?? null,
+ sessionUpdatedAt: session?.updatedAt ?? null,
+ };
+}
+
+export function hasServerAcknowledgedLocalDispatch(input: {
+ localDispatch: LocalDispatchSnapshot | null;
+ phase: SessionPhase;
+ latestTurn: Thread["latestTurn"] | null;
+ session: Thread["session"] | null;
+ hasPendingApproval: boolean;
+ hasPendingUserInput: boolean;
+ threadError: string | null | undefined;
+}): boolean {
+ if (!input.localDispatch) {
+ return false;
+ }
+ if (
+ input.phase === "running" ||
+ input.hasPendingApproval ||
+ input.hasPendingUserInput ||
+ Boolean(input.threadError)
+ ) {
+ return true;
+ }
+
+ const latestTurn = input.latestTurn ?? null;
+ const session = input.session ?? null;
+
+ return (
+ input.localDispatch.latestTurnTurnId !== (latestTurn?.turnId ?? null) ||
+ input.localDispatch.latestTurnRequestedAt !== (latestTurn?.requestedAt ?? null) ||
+ input.localDispatch.latestTurnStartedAt !== (latestTurn?.startedAt ?? null) ||
+ input.localDispatch.latestTurnCompletedAt !== (latestTurn?.completedAt ?? null) ||
+ input.localDispatch.sessionOrchestrationStatus !== (session?.orchestrationStatus ?? null) ||
+ input.localDispatch.sessionUpdatedAt !== (session?.updatedAt ?? null)
+ );
+}
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index fbd332354..7562f845e 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -20,6 +20,7 @@ import {
OrchestrationThreadActivity,
ProviderInteractionMode,
RuntimeMode,
+ TerminalOpenInput,
} from "@t3tools/contracts";
import { applyClaudePromptEffortPrefix, normalizeModelSlug } from "@t3tools/shared/model";
import { truncate } from "@t3tools/shared/String";
@@ -42,6 +43,7 @@ import {
replaceTextRange,
} from "../composer-logic";
import {
+ deriveCompletionDividerBeforeEntryId,
derivePendingApprovals,
derivePendingUserInputs,
derivePhase,
@@ -64,6 +66,8 @@ import {
type PendingUserInputDraftAnswer,
} from "../pendingUserInput";
import { useStore } from "../store";
+import { useProjectById, useThreadById } from "../storeSelectors";
+import { useUiStateStore } from "../uiStateStore";
import {
buildPlanImplementationThreadTitle,
buildPlanImplementationPrompt,
@@ -76,8 +80,12 @@ import {
DEFAULT_THREAD_TERMINAL_ID,
MAX_TERMINALS_PER_GROUP,
type ChatMessage,
+ type SessionPhase,
+ type Thread,
type TurnDiffSummary,
} from "../types";
+import { LRUCache } from "../lib/lruCache";
+
import { basenameOfPath } from "../vscode-icons";
import { useTheme } from "../hooks/useTheme";
import { useTurnDiffSummaries } from "../hooks/useTurnDiffSummaries";
@@ -168,14 +176,18 @@ import {
buildTemporaryWorktreeBranchName,
cloneComposerImageForRetry,
collectUserMessageBlobPreviewUrls,
+ createLocalDispatchSnapshot,
deriveComposerSendState,
+ hasServerAcknowledgedLocalDispatch,
LAST_INVOKED_SCRIPT_BY_PROJECT_KEY,
LastInvokedScriptByProjectSchema,
+ type LocalDispatchSnapshot,
PullRequestDialogState,
readFileAsDataUrl,
revokeBlobPreviewUrl,
revokeUserMessagePreviewUrls,
- SendPhase,
+ threadHasStarted,
+ waitForStartedServerThread,
} from "./ChatView.logic";
import { useLocalStorage } from "~/hooks/useLocalStorage";
@@ -190,6 +202,81 @@ const EMPTY_AVAILABLE_EDITORS: EditorId[] = [];
const EMPTY_PROVIDERS: ServerProvider[] = [];
const EMPTY_PENDING_USER_INPUT_ANSWERS: Record<string, PendingUserInputDraftAnswer> = {};
+type ThreadPlanCatalogEntry = Pick<Thread, "id" | "proposedPlans">;
+
+const MAX_THREAD_PLAN_CATALOG_CACHE_ENTRIES = 500;
+const MAX_THREAD_PLAN_CATALOG_CACHE_MEMORY_BYTES = 512 * 1024;
+const threadPlanCatalogCache = new LRUCache<{
+ proposedPlans: Thread["proposedPlans"];
+ entry: ThreadPlanCatalogEntry;
+}>(MAX_THREAD_PLAN_CATALOG_CACHE_ENTRIES, MAX_THREAD_PLAN_CATALOG_CACHE_MEMORY_BYTES);
+
+function estimateThreadPlanCatalogEntrySize(thread: Thread): number {
+ return Math.max(
+ 64,
+ thread.id.length +
+ thread.proposedPlans.reduce(
+ (total, plan) =>
+ total +
+ plan.id.length +
+ plan.planMarkdown.length +
+ plan.updatedAt.length +
+ (plan.turnId?.length ?? 0),
+ 0,
+ ),
+ );
+}
+
+function toThreadPlanCatalogEntry(thread: Thread): ThreadPlanCatalogEntry {
+ const cached = threadPlanCatalogCache.get(thread.id);
+ if (cached && cached.proposedPlans === thread.proposedPlans) {
+ return cached.entry;
+ }
+
+ const entry: ThreadPlanCatalogEntry = {
+ id: thread.id,
+ proposedPlans: thread.proposedPlans,
+ };
+ threadPlanCatalogCache.set(
+ thread.id,
+ {
+ proposedPlans: thread.proposedPlans,
+ entry,
+ },
+ estimateThreadPlanCatalogEntrySize(thread),
+ );
+ return entry;
+}
+
+function useThreadPlanCatalog(threadIds: readonly ThreadId[]): ThreadPlanCatalogEntry[] {
+ const selector = useMemo(() => {
+ let previousThreads: Array<Thread | undefined> | null = null;
+ let previousEntries: ThreadPlanCatalogEntry[] = [];
+
+ return (state: { threads: Thread[] }): ThreadPlanCatalogEntry[] => {
+ const nextThreads = threadIds.map((threadId) =>
+ state.threads.find((thread) => thread.id === threadId),
+ );
+ const cachedThreads = previousThreads;
+ if (
+ cachedThreads &&
+ nextThreads.length === cachedThreads.length &&
+ nextThreads.every((thread, index) => thread === cachedThreads[index])
+ ) {
+ return previousEntries;
+ }
+
+ previousThreads = nextThreads;
+ previousEntries = nextThreads.flatMap((thread) =>
+ thread ? [toThreadPlanCatalogEntry(thread)] : [],
+ );
+ return previousEntries;
+ };
+ }, [threadIds]);
+
+ return useStore(selector);
+}
+
function formatOutgoingPrompt(params: {
provider: ProviderKind;
model: string | null;
@@ -245,13 +332,81 @@ interface PendingPullRequestSetupRequest {
scriptId: string;
}
+function useLocalDispatchState(input: {
+ activeThread: Thread | undefined;
+ activeLatestTurn: Thread["latestTurn"] | null;
+ phase: SessionPhase;
+ activePendingApproval: ApprovalRequestId | null;
+ activePendingUserInput: ApprovalRequestId | null;
+ threadError: string | null | undefined;
+}) {
+ const [localDispatch, setLocalDispatch] = useState<LocalDispatchSnapshot | null>(null);
+
+ const beginLocalDispatch = useCallback(
+ (options?: { preparingWorktree?: boolean }) => {
+ const preparingWorktree = Boolean(options?.preparingWorktree);
+ setLocalDispatch((current) => {
+ if (current) {
+ return current.preparingWorktree === preparingWorktree
+ ? current
+ : { ...current, preparingWorktree };
+ }
+ return createLocalDispatchSnapshot(input.activeThread, options);
+ });
+ },
+ [input.activeThread],
+ );
+
+ const resetLocalDispatch = useCallback(() => {
+ setLocalDispatch(null);
+ }, []);
+
+ const serverAcknowledgedLocalDispatch = useMemo(
+ () =>
+ hasServerAcknowledgedLocalDispatch({
+ localDispatch,
+ phase: input.phase,
+ latestTurn: input.activeLatestTurn,
+ session: input.activeThread?.session ?? null,
+ hasPendingApproval: input.activePendingApproval !== null,
+ hasPendingUserInput: input.activePendingUserInput !== null,
+ threadError: input.threadError,
+ }),
+ [
+ input.activeLatestTurn,
+ input.activePendingApproval,
+ input.activePendingUserInput,
+ input.activeThread?.session,
+ input.phase,
+ input.threadError,
+ localDispatch,
+ ],
+ );
+
+ useEffect(() => {
+ if (!serverAcknowledgedLocalDispatch) {
+ return;
+ }
+ resetLocalDispatch();
+ }, [resetLocalDispatch, serverAcknowledgedLocalDispatch]);
+
+ return {
+ beginLocalDispatch,
+ resetLocalDispatch,
+ localDispatchStartedAt: localDispatch?.startedAt ?? null,
+ isPreparingWorktree: localDispatch?.preparingWorktree ?? false,
+ isSendBusy: localDispatch !== null && !serverAcknowledgedLocalDispatch,
+ };
+}
+
export default function ChatView({ threadId }: ChatViewProps) {
- const threads = useStore((store) => store.threads);
- const projects = useStore((store) => store.projects);
- const markThreadVisited = useStore((store) => store.markThreadVisited);
- const syncServerReadModel = useStore((store) => store.syncServerReadModel);
+ const serverThread = useThreadById(threadId);
const setStoreThreadError = useStore((store) => store.setError);
const setStoreThreadBranch = useStore((store) => store.setThreadBranch);
+ const markThreadVisited = useUiStateStore((store) => store.markThreadVisited);
+ const activeThreadLastVisitedAt = useUiStateStore(
+ (store) => store.threadLastVisitedAtById[threadId],
+ );
const settings = useSettings();
const setStickyComposerModelSelection = useComposerDraftStore(
(store) => store.setStickyModelSelection,
@@ -330,8 +485,6 @@ export default function ChatView({ threadId }: ChatViewProps) {
const [localDraftErrorsByThreadId, setLocalDraftErrorsByThreadId] = useState<
Record<ThreadId, string | null>
>({});
- const [sendPhase, setSendPhase] = useState<SendPhase>("idle");
- const [sendStartedAt, setSendStartedAt] = useState<string | null>(null);
const [isConnecting, _setIsConnecting] = useState(false);
const [isRevertingCheckpoint, setIsRevertingCheckpoint] = useState(false);
const [respondingRequestIds, setRespondingRequestIds] = useState<ApprovalRequestId[]>([]);
@@ -466,8 +619,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
[composerTerminalContexts, removeComposerDraftTerminalContext, setPrompt, threadId],
);
- const serverThread = threads.find((t) => t.id === threadId);
- const fallbackDraftProject = projects.find((project) => project.id === draftThread?.projectId);
+ const fallbackDraftProject = useProjectById(draftThread?.projectId);
const localDraftError = serverThread ? null : (localDraftErrorsByThreadId[threadId] ?? null);
const localDraftThread = useMemo(
() =>
@@ -495,12 +647,25 @@ export default function ChatView({ threadId }: ChatViewProps) {
const diffOpen = rawSearch.diff === "1";
const activeThreadId = activeThread?.id ?? null;
const activeLatestTurn = activeThread?.latestTurn ?? null;
+ const threadPlanCatalog = useThreadPlanCatalog(
+ useMemo(() => {
+ const threadIds: ThreadId[] = [];
+ if (activeThread?.id) {
+ threadIds.push(activeThread.id);
+ }
+ const sourceThreadId = activeLatestTurn?.sourceProposedPlan?.threadId;
+ if (sourceThreadId && sourceThreadId !== activeThread?.id) {
+ threadIds.push(sourceThreadId);
+ }
+ return threadIds;
+ }, [activeLatestTurn?.sourceProposedPlan?.threadId, activeThread?.id]),
+ );
const activeContextWindow = useMemo(
() => deriveLatestContextWindowSnapshot(activeThread?.activities ?? []),
[activeThread?.activities],
);
const latestTurnSettled = isLatestTurnSettled(activeLatestTurn, activeThread?.session ?? null);
- const activeProject = projects.find((p) => p.id === activeThread?.projectId);
+ const activeProject = useProjectById(activeThread?.projectId);
const openPullRequestDialog = useCallback(
(reference?: string) => {
@@ -595,33 +760,28 @@ export default function ChatView({ threadId }: ChatViewProps) {
);
useEffect(() => {
- if (!activeThread?.id) return;
+ if (!serverThread?.id) return;
if (!latestTurnSettled) return;
if (!activeLatestTurn?.completedAt) return;
const turnCompletedAt = Date.parse(activeLatestTurn.completedAt);
if (Number.isNaN(turnCompletedAt)) return;
- const lastVisitedAt = activeThread.lastVisitedAt ? Date.parse(activeThread.lastVisitedAt) : NaN;
+ const lastVisitedAt = activeThreadLastVisitedAt ? Date.parse(activeThreadLastVisitedAt) : NaN;
if (!Number.isNaN(lastVisitedAt) && lastVisitedAt >= turnCompletedAt) return;
- markThreadVisited(activeThread.id);
+ markThreadVisited(serverThread.id);
}, [
- activeThread?.id,
- activeThread?.lastVisitedAt,
activeLatestTurn?.completedAt,
+ activeThreadLastVisitedAt,
latestTurnSettled,
markThreadVisited,
+ serverThread?.id,
]);
const sessionProvider = activeThread?.session?.provider ?? null;
const selectedProviderByThreadId = composerDraft.activeProvider ?? null;
const threadProvider =
activeThread?.modelSelection.provider ?? activeProject?.defaultModelSelection?.provider ?? null;
- const hasThreadStarted = Boolean(
- activeThread &&
- (activeThread.latestTurn !== null ||
- activeThread.messages.length > 0 ||
- activeThread.session !== null),
- );
+ const hasThreadStarted = threadHasStarted(activeThread);
const lockedProvider: ProviderKind | null = hasThreadStarted
? (sessionProvider ?? threadProvider ?? selectedProviderByThreadId ?? null)
: null;
@@ -664,15 +824,6 @@ export default function ChatView({ threadId }: ChatViewProps) {
);
const selectedModelForPicker = selectedModel;
const phase = derivePhase(activeThread?.session ?? null);
- const isSendBusy = sendPhase !== "idle";
- const isPreparingWorktree = sendPhase === "preparing-worktree";
- const isWorking = phase === "running" || isSendBusy || isConnecting || isRevertingCheckpoint;
- const nowIso = new Date(nowTick).toISOString();
- const activeWorkStartedAt = deriveActiveWorkStartedAt(
- activeLatestTurn,
- activeThread?.session ?? null,
- sendStartedAt,
- );
const threadActivities = activeThread?.activities ?? EMPTY_ACTIVITIES;
const workLogEntries = useMemo(
() => deriveWorkLogEntries(threadActivities, activeLatestTurn?.turnId ?? undefined),
@@ -735,12 +886,12 @@ export default function ChatView({ threadId }: ChatViewProps) {
const sidebarProposedPlan = useMemo(
() =>
findSidebarProposedPlan({
- threads,
+ threads: threadPlanCatalog,
latestTurn: activeLatestTurn,
latestTurnSettled,
threadId: activeThread?.id ?? null,
}),
- [activeLatestTurn, activeThread?.id, latestTurnSettled, threads],
+ [activeLatestTurn, activeThread?.id, latestTurnSettled, threadPlanCatalog],
);
const activePlan = useMemo(
() => deriveActivePlanState(threadActivities, activeLatestTurn?.turnId ?? undefined),
@@ -752,6 +903,27 @@ export default function ChatView({ threadId }: ChatViewProps) {
latestTurnSettled &&
hasActionableProposedPlan(activeProposedPlan);
const activePendingApproval = pendingApprovals[0] ?? null;
+ const {
+ beginLocalDispatch,
+ resetLocalDispatch,
+ localDispatchStartedAt,
+ isPreparingWorktree,
+ isSendBusy,
+ } = useLocalDispatchState({
+ activeThread,
+ activeLatestTurn,
+ phase,
+ activePendingApproval: activePendingApproval?.requestId ?? null,
+ activePendingUserInput: activePendingUserInput?.requestId ?? null,
+ threadError: activeThread?.error,
+ });
+ const isWorking = phase === "running" || isSendBusy || isConnecting || isRevertingCheckpoint;
+ const nowIso = new Date(nowTick).toISOString();
+ const activeWorkStartedAt = deriveActiveWorkStartedAt(
+ activeLatestTurn,
+ activeThread?.session ?? null,
+ localDispatchStartedAt,
+ );
const isComposerApprovalState = activePendingApproval !== null;
const hasComposerHeader =
isComposerApprovalState ||
@@ -980,35 +1152,9 @@ export default function ChatView({ threadId }: ChatViewProps) {
]);
const completionDividerBeforeEntryId = useMemo(() => {
if (!latestTurnSettled) return null;
- if (!activeLatestTurn?.startedAt) return null;
- if (!activeLatestTurn.completedAt) return null;
if (!completionSummary) return null;
-
- const turnStartedAt = Date.parse(activeLatestTurn.startedAt);
- const turnCompletedAt = Date.parse(activeLatestTurn.completedAt);
- if (Number.isNaN(turnStartedAt)) return null;
- if (Number.isNaN(turnCompletedAt)) return null;
-
- let inRangeMatch: string | null = null;
- let fallbackMatch: string | null = null;
- for (const timelineEntry of timelineEntries) {
- if (timelineEntry.kind !== "message") continue;
- if (timelineEntry.message.role !== "assistant") continue;
- const messageAt = Date.parse(timelineEntry.message.createdAt);
- if (Number.isNaN(messageAt) || messageAt < turnStartedAt) continue;
- fallbackMatch = timelineEntry.id;
- if (messageAt <= turnCompletedAt) {
- inRangeMatch = timelineEntry.id;
- }
- }
- return inRangeMatch ?? fallbackMatch;
- }, [
- activeLatestTurn?.completedAt,
- activeLatestTurn?.startedAt,
- completionSummary,
- latestTurnSettled,
- timelineEntries,
- ]);
+ return deriveCompletionDividerBeforeEntryId(timelineEntries, activeLatestTurn);
+ }, [activeLatestTurn, completionSummary, latestTurnSettled, timelineEntries]);
const gitCwd = activeProject
? projectScriptCwd({
project: { cwd: activeProject.cwd },
@@ -1230,7 +1376,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
const setThreadError = useCallback(
(targetThreadId: ThreadId | null, error: string | null) => {
if (!targetThreadId) return;
- if (threads.some((thread) => thread.id === targetThreadId)) {
+ if (useStore.getState().threads.some((thread) => thread.id === targetThreadId)) {
setStoreThreadError(targetThreadId, error);
return;
}
@@ -1244,7 +1390,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
};
});
},
- [setStoreThreadError, threads],
+ [setStoreThreadError],
);
const focusComposer = useCallback(() => {
@@ -1411,7 +1557,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
worktreePath: options?.worktreePath ?? activeThread.worktreePath ?? null,
...(options?.env ? { extraEnv: options.env } : {}),
});
- const openTerminalInput: Parameters<typeof api.terminal.open>[0] = shouldCreateNewTerminal
+ const openTerminalInput: TerminalOpenInput = shouldCreateNewTerminal
? {
threadId: activeThreadId,
terminalId: targetTerminalId,
@@ -2020,15 +2166,14 @@ export default function ChatView({ threadId }: ChatViewProps) {
}
return [];
});
- setSendPhase("idle");
- setSendStartedAt(null);
+ resetLocalDispatch();
setComposerHighlightedItemId(null);
setComposerCursor(collapseExpandedComposerCursor(promptRef.current, promptRef.current.length));
setComposerTrigger(detectComposerTrigger(promptRef.current, promptRef.current.length));
dragDepthRef.current = 0;
setIsDragOverComposer(false);
setExpandedImage(null);
- }, [threadId]);
+ }, [resetLocalDispatch, threadId]);
useEffect(() => {
let cancelled = false;
@@ -2161,37 +2306,6 @@ export default function ChatView({ threadId }: ChatViewProps) {
};
}, [phase]);
- const beginSendPhase = useCallback((nextPhase: Exclude<SendPhase, "idle">) => {
- setSendStartedAt((current) => current ?? new Date().toISOString());
- setSendPhase(nextPhase);
- }, []);
-
- const resetSendPhase = useCallback(() => {
- setSendPhase("idle");
- setSendStartedAt(null);
- }, []);
-
- useEffect(() => {
- if (sendPhase === "idle") {
- return;
- }
- if (
- phase === "running" ||
- activePendingApproval !== null ||
- activePendingUserInput !== null ||
- activeThread?.error
- ) {
- resetSendPhase();
- }
- }, [
- activePendingApproval,
- activePendingUserInput,
- activeThread?.error,
- phase,
- resetSendPhase,
- sendPhase,
- ]);
-
useEffect(() => {
if (!activeThreadId) return;
const previous = terminalOpenByThreadRef.current[activeThreadId] ?? false;
@@ -2529,7 +2643,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
}
sendInFlightRef.current = true;
- beginSendPhase(baseBranchForWorktree ? "preparing-worktree" : "sending-turn");
+ beginLocalDispatch({ preparingWorktree: Boolean(baseBranchForWorktree) });
const composerImagesSnapshot = [...composerImages];
const composerTerminalContextsSnapshot = [...sendableComposerTerminalContexts];
@@ -2603,7 +2717,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
await (async () => {
// On first message: lock in branch + create worktree if needed.
if (baseBranchForWorktree) {
- beginSendPhase("preparing-worktree");
+ beginLocalDispatch({ preparingWorktree: true });
const newBranch = buildTemporaryWorktreeBranchName();
const result = await createWorktreeMutation.mutateAsync({
cwd: activeProject.cwd,
@@ -2715,7 +2829,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
});
}
- beginSendPhase("sending-turn");
+ beginLocalDispatch({ preparingWorktree: false });
const turnAttachments = await turnAttachmentsPromise;
await api.orchestration.dispatchCommand({
type: "thread.turn.start",
@@ -2772,7 +2886,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
});
sendInFlightRef.current = false;
if (!turnStartSucceeded) {
- resetSendPhase();
+ resetLocalDispatch();
}
};
@@ -2971,7 +3085,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
});
sendInFlightRef.current = true;
- beginSendPhase("sending-turn");
+ beginLocalDispatch({ preparingWorktree: false });
setThreadError(threadIdForSend, null);
setOptimisticUserMessages((existing) => [
...existing,
@@ -3040,19 +3154,19 @@ export default function ChatView({ threadId }: ChatViewProps) {
err instanceof Error ? err.message : "Failed to send plan follow-up.",
);
sendInFlightRef.current = false;
- resetSendPhase();
+ resetLocalDispatch();
}
},
[
activeThread,
activeProposedPlan,
- beginSendPhase,
+ beginLocalDispatch,
forceStickToBottom,
isConnecting,
isSendBusy,
isServerThread,
persistThreadSettingsForNextTurn,
- resetSendPhase,
+ resetLocalDispatch,
runtimeMode,
selectedPromptEffort,
selectedModelSelection,
@@ -3094,10 +3208,10 @@ export default function ChatView({ threadId }: ChatViewProps) {
const nextThreadModelSelection: ModelSelection = selectedModelSelection;
sendInFlightRef.current = true;
- beginSendPhase("sending-turn");
+ beginLocalDispatch({ preparingWorktree: false });
const finish = () => {
sendInFlightRef.current = false;
- resetSendPhase();
+ resetLocalDispatch();
};
await api.orchestration
@@ -3132,9 +3246,10 @@ export default function ChatView({ threadId }: ChatViewProps) {
createdAt,
});
})
- .then(() => api.orchestration.getSnapshot())
- .then((snapshot) => {
- syncServerReadModel(snapshot);
+ .then(() => {
+ return waitForStartedServerThread(nextThreadId);
+ })
+ .then(() => {
// Signal that the plan sidebar should open on the new thread.
planSidebarOpenOnNextThreadRef.current = true;
return navigate({
@@ -3150,12 +3265,6 @@ export default function ChatView({ threadId }: ChatViewProps) {
threadId: nextThreadId,
})
.catch(() => undefined);
- await api.orchestration
- .getSnapshot()
- .then((snapshot) => {
- syncServerReadModel(snapshot);
- })
- .catch(() => undefined);
toastManager.add({
type: "error",
title: "Could not start implementation thread",
@@ -3168,18 +3277,17 @@ export default function ChatView({ threadId }: ChatViewProps) {
activeProject,
activeProposedPlan,
activeThread,
- beginSendPhase,
+ beginLocalDispatch,
isConnecting,
isSendBusy,
isServerThread,
navigate,
- resetSendPhase,
+ resetLocalDispatch,
runtimeMode,
selectedPromptEffort,
selectedModelSelection,
selectedProvider,
selectedProviderModels,
- syncServerReadModel,
selectedModel,
]);
diff --git a/apps/web/src/components/KeybindingsToast.browser.tsx b/apps/web/src/components/KeybindingsToast.browser.tsx
index ba21af4b7..224bd2f88 100644
--- a/apps/web/src/components/KeybindingsToast.browser.tsx
+++ b/apps/web/src/components/KeybindingsToast.browser.tsx
@@ -323,7 +323,7 @@ describe("Keybindings update toast", () => {
useStore.setState({
projects: [],
threads: [],
- threadsHydrated: false,
+ bootstrapComplete: false,
});
});
diff --git a/apps/web/src/components/Sidebar.logic.test.ts b/apps/web/src/components/Sidebar.logic.test.ts
index 232da5bd0..d4cd25db4 100644
--- a/apps/web/src/components/Sidebar.logic.test.ts
+++ b/apps/web/src/components/Sidebar.logic.test.ts
@@ -9,6 +9,7 @@ import {
getProjectSortTimestamp,
hasUnseenCompletion,
isContextMenuPointerDown,
+ orderItemsByPreferredIds,
resolveProjectStatusIndicator,
resolveSidebarNewThreadEnvMode,
resolveThreadRowClassName,
@@ -18,7 +19,7 @@ import {
sortThreadsForSidebar,
THREAD_JUMP_HINT_SHOW_DELAY_MS,
} from "./Sidebar.logic";
-import { ProjectId, ThreadId } from "@t3tools/contracts";
+import { OrchestrationLatestTurn, ProjectId, ThreadId } from "@t3tools/contracts";
import {
DEFAULT_INTERACTION_MODE,
DEFAULT_RUNTIME_MODE,
@@ -29,7 +30,7 @@ import {
function makeLatestTurn(overrides?: {
completedAt?: string | null;
startedAt?: string | null;
-}): Parameters<typeof hasUnseenCompletion>[0]["latestTurn"] {
+}): OrchestrationLatestTurn {
return {
turnId: "turn-1" as never,
state: "completed",
@@ -163,6 +164,50 @@ describe("resolveSidebarNewThreadEnvMode", () => {
});
});
+describe("orderItemsByPreferredIds", () => {
+ it("keeps preferred ids first, skips stale ids, and preserves the relative order of remaining items", () => {
+ const ordered = orderItemsByPreferredIds({
+ items: [
+ { id: ProjectId.makeUnsafe("project-1"), name: "One" },
+ { id: ProjectId.makeUnsafe("project-2"), name: "Two" },
+ { id: ProjectId.makeUnsafe("project-3"), name: "Three" },
+ ],
+ preferredIds: [
+ ProjectId.makeUnsafe("project-3"),
+ ProjectId.makeUnsafe("project-missing"),
+ ProjectId.makeUnsafe("project-1"),
+ ],
+ getId: (project) => project.id,
+ });
+
+ expect(ordered.map((project) => project.id)).toEqual([
+ ProjectId.makeUnsafe("project-3"),
+ ProjectId.makeUnsafe("project-1"),
+ ProjectId.makeUnsafe("project-2"),
+ ]);
+ });
+
+ it("does not duplicate items when preferred ids repeat", () => {
+ const ordered = orderItemsByPreferredIds({
+ items: [
+ { id: ProjectId.makeUnsafe("project-1"), name: "One" },
+ { id: ProjectId.makeUnsafe("project-2"), name: "Two" },
+ ],
+ preferredIds: [
+ ProjectId.makeUnsafe("project-2"),
+ ProjectId.makeUnsafe("project-1"),
+ ProjectId.makeUnsafe("project-2"),
+ ],
+ getId: (project) => project.id,
+ });
+
+ expect(ordered.map((project) => project.id)).toEqual([
+ ProjectId.makeUnsafe("project-2"),
+ ProjectId.makeUnsafe("project-1"),
+ ]);
+ });
+});
+
describe("resolveAdjacentThreadId", () => {
it("resolves adjacent thread ids in ordered sidebar traversal", () => {
const threads = [
@@ -552,7 +597,6 @@ function makeProject(overrides: Partial<Project> = {}): Project {
model: "gpt-5.4",
...defaultModelSelection,
},
- expanded: true,
createdAt: "2026-03-09T10:00:00.000Z",
updatedAt: "2026-03-09T10:00:00.000Z",
scripts: [],
diff --git a/apps/web/src/components/Sidebar.logic.ts b/apps/web/src/components/Sidebar.logic.ts
index baf829211..16c7752f7 100644
--- a/apps/web/src/components/Sidebar.logic.ts
+++ b/apps/web/src/components/Sidebar.logic.ts
@@ -17,7 +17,10 @@ type SidebarProject = {
createdAt?: string | undefined;
updatedAt?: string | undefined;
};
-type SidebarThreadSortInput = Pick<Thread, "createdAt" | "updatedAt" | "messages">;
+type SidebarThreadSortInput = Pick<Thread, "createdAt" | "updatedAt"> & {
+ latestUserMessageAt?: string | null;
+ messages?: Pick<Thread["messages"][number], "createdAt" | "role">[];
+};
export type ThreadTraversalDirection = "previous" | "next";
@@ -45,8 +48,10 @@ const THREAD_STATUS_PRIORITY: Record<ThreadStatusPill["label"], number> = {
type ThreadStatusInput = Pick<
Thread,
- "interactionMode" | "latestTurn" | "lastVisitedAt" | "proposedPlans" | "session"
->;
+ "interactionMode" | "latestTurn" | "proposedPlans" | "session"
+> & {
+ lastVisitedAt?: string | undefined;
+};
export interface ThreadJumpHintVisibilityController {
sync: (shouldShow: boolean) => void;
@@ -156,6 +161,34 @@ export function resolveSidebarNewThreadEnvMode(input: {
return input.requestedEnvMode ?? input.defaultEnvMode;
}
+export function orderItemsByPreferredIds<TItem, TId>(input: {
+ items: readonly TItem[];
+ preferredIds: readonly TId[];
+ getId: (item: TItem) => TId;
+}): TItem[] {
+ const { getId, items, preferredIds } = input;
+ if (preferredIds.length === 0) {
+ return [...items];
+ }
+
+ const itemsById = new Map(items.map((item) => [getId(item), item] as const));
+ const preferredIdSet = new Set(preferredIds);
+ const emittedPreferredIds = new Set<TId>();
+ const ordered = preferredIds.flatMap((id) => {
+ if (emittedPreferredIds.has(id)) {
+ return [];
+ }
+ const item = itemsById.get(id);
+ if (!item) {
+ return [];
+ }
+ emittedPreferredIds.add(id);
+ return [item];
+ });
+ const remaining = items.filter((item) => !preferredIdSet.has(getId(item)));
+ return [...ordered, ...remaining];
+}
+
export function getVisibleSidebarThreadIds<TThreadId>(
renderedProjects: readonly {
shouldShowThreadPanel?: boolean;
@@ -327,15 +360,15 @@ export function resolveProjectStatusIndicator(
return highestPriorityStatus;
}
-export function getVisibleThreadsForProject(input: {
- threads: readonly Thread[];
- activeThreadId: Thread["id"] | undefined;
+export function getVisibleThreadsForProject<T extends Pick<Thread, "id">>(input: {
+ threads: readonly T[];
+ activeThreadId: T["id"] | undefined;
isThreadListExpanded: boolean;
previewLimit: number;
}): {
hasHiddenThreads: boolean;
- hiddenThreads: Thread[];
- visibleThreads: Thread[];
+ visibleThreads: T[];
+ hiddenThreads: T[];
} {
const { activeThreadId, isThreadListExpanded, previewLimit, threads } = input;
const hasHiddenThreads = threads.length > previewLimit;
@@ -382,9 +415,13 @@ function toSortableTimestamp(iso: string | undefined): number | null {
}
function getLatestUserMessageTimestamp(thread: SidebarThreadSortInput): number {
+ if (thread.latestUserMessageAt) {
+ return toSortableTimestamp(thread.latestUserMessageAt) ?? Number.NEGATIVE_INFINITY;
+ }
+
let latestUserMessageTimestamp: number | null = null;
- for (const message of thread.messages) {
+ for (const message of thread.messages ?? []) {
if (message.role !== "user") continue;
const messageTimestamp = toSortableTimestamp(message.createdAt);
if (messageTimestamp === null) continue;
@@ -412,7 +449,7 @@ function getThreadSortTimestamp(
}
export function sortThreadsForSidebar<
- T extends Pick<Thread, "id" | "createdAt" | "updatedAt" | "messages">,
+ T extends Pick<Thread, "id" | "createdAt" | "updatedAt"> & SidebarThreadSortInput,
>(threads: readonly T[], sortOrder: SidebarThreadSortOrder): T[] {
return threads.toSorted((left, right) => {
const rightTimestamp = getThreadSortTimestamp(right, sortOrder);
@@ -425,7 +462,7 @@ export function sortThreadsForSidebar<
}
export function getFallbackThreadIdAfterDelete<
- T extends Pick<Thread, "id" | "projectId" | "createdAt" | "updatedAt" | "messages">,
+ T extends Pick<Thread, "id" | "projectId" | "createdAt" | "updatedAt"> & SidebarThreadSortInput,
>(input: {
threads: readonly T[];
deletedThreadId: T["id"];
@@ -469,7 +506,10 @@ export function getProjectSortTimestamp(
return toSortableTimestamp(project.updatedAt ?? project.createdAt) ?? Number.NEGATIVE_INFINITY;
}
-export function sortProjectsForSidebar<TProject extends SidebarProject, TThread extends Thread>(
+export function sortProjectsForSidebar<
+ TProject extends SidebarProject,
+ TThread extends Pick<Thread, "projectId" | "createdAt" | "updatedAt"> & SidebarThreadSortInput,
+>(
projects: readonly TProject[],
threads: readonly TThread[],
sortOrder: SidebarProjectSortOrder,
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index 207082477..efa512428 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -21,6 +21,7 @@ import {
type MouseEvent,
type PointerEvent,
} from "react";
+import { useShallow } from "zustand/react/shallow";
import {
DndContext,
type DragCancelEvent,
@@ -55,6 +56,7 @@ import { APP_STAGE_LABEL, APP_VERSION } from "../branding";
import { isTerminalFocused } from "../lib/terminalFocus";
import { isLinuxPlatform, isMacPlatform, newCommandId, newProjectId } from "../lib/utils";
import { useStore } from "../store";
+import { useUiStateStore } from "../uiStateStore";
import {
resolveShortcutCommand,
shortcutLabelForCommand,
@@ -114,6 +116,7 @@ import {
resolveSidebarNewThreadEnvMode,
resolveThreadRowClassName,
resolveThreadStatusPill,
+ orderItemsByPreferredIds,
shouldClearThreadSelectionOnMouseDown,
sortProjectsForSidebar,
sortThreadsForSidebar,
@@ -122,6 +125,7 @@ import {
import { SidebarUpdatePill } from "./sidebar/SidebarUpdatePill";
import { useCopyToClipboard } from "~/hooks/useCopyToClipboard";
import { useSettings, useUpdateSettings } from "~/hooks/useSettings";
+import type { Project, Thread } from "../types";
const EMPTY_KEYBINDINGS: ResolvedKeybindingsConfig = [];
const THREAD_PREVIEW_LIMIT = 6;
@@ -138,6 +142,80 @@ const SIDEBAR_LIST_ANIMATION_OPTIONS = {
duration: 180,
easing: "ease-out",
} as const;
+
+type SidebarThreadSnapshot = Pick<
+ Thread,
+ | "activities"
+ | "archivedAt"
+ | "branch"
+ | "createdAt"
+ | "id"
+ | "interactionMode"
+ | "latestTurn"
+ | "projectId"
+ | "proposedPlans"
+ | "session"
+ | "title"
+ | "updatedAt"
+ | "worktreePath"
+> & {
+ lastVisitedAt?: string | undefined;
+ latestUserMessageAt: string | null;
+};
+
+type SidebarProjectSnapshot = Project & {
+ expanded: boolean;
+};
+
+const sidebarThreadSnapshotCache = new WeakMap<
+ Thread,
+ { lastVisitedAt?: string | undefined; snapshot: SidebarThreadSnapshot }
+>();
+
+function getLatestUserMessageAt(thread: Thread): string | null {
+ let latestUserMessageAt: string | null = null;
+
+ for (const message of thread.messages) {
+ if (message.role !== "user") {
+ continue;
+ }
+ if (latestUserMessageAt === null || message.createdAt > latestUserMessageAt) {
+ latestUserMessageAt = message.createdAt;
+ }
+ }
+
+ return latestUserMessageAt;
+}
+
+function toSidebarThreadSnapshot(
+ thread: Thread,
+ lastVisitedAt: string | undefined,
+): SidebarThreadSnapshot {
+ const cached = sidebarThreadSnapshotCache.get(thread);
+ if (cached && cached.lastVisitedAt === lastVisitedAt) {
+ return cached.snapshot;
+ }
+
+ const snapshot: SidebarThreadSnapshot = {
+ id: thread.id,
+ projectId: thread.projectId,
+ title: thread.title,
+ interactionMode: thread.interactionMode,
+ session: thread.session,
+ createdAt: thread.createdAt,
+ updatedAt: thread.updatedAt,
+ archivedAt: thread.archivedAt,
+ latestTurn: thread.latestTurn,
+ lastVisitedAt,
+ branch: thread.branch,
+ worktreePath: thread.worktreePath,
+ activities: thread.activities,
+ proposedPlans: thread.proposedPlans,
+ latestUserMessageAt: getLatestUserMessageAt(thread),
+ };
+ sidebarThreadSnapshotCache.set(thread, { lastVisitedAt, snapshot });
+ return snapshot;
+}
interface TerminalStatusIndicator {
label: "Terminal process running";
colorClass: string;
@@ -361,10 +439,17 @@ function SortableProjectItem({
export default function Sidebar() {
const projects = useStore((store) => store.projects);
- const threads = useStore((store) => store.threads);
- const markThreadUnread = useStore((store) => store.markThreadUnread);
- const toggleProject = useStore((store) => store.toggleProject);
- const reorderProjects = useStore((store) => store.reorderProjects);
+ const serverThreads = useStore((store) => store.threads);
+ const { projectExpandedById, projectOrder, threadLastVisitedAtById } = useUiStateStore(
+ useShallow((store) => ({
+ projectExpandedById: store.projectExpandedById,
+ projectOrder: store.projectOrder,
+ threadLastVisitedAtById: store.threadLastVisitedAtById,
+ })),
+ );
+ const markThreadUnread = useUiStateStore((store) => store.markThreadUnread);
+ const toggleProject = useUiStateStore((store) => store.toggleProject);
+ const reorderProjects = useUiStateStore((store) => store.reorderProjects);
const clearComposerDraftForThread = useComposerDraftStore((store) => store.clearDraftThread);
const getDraftThreadByProjectId = useComposerDraftStore(
(store) => store.getDraftThreadByProjectId,
@@ -418,6 +503,28 @@ export default function Sidebar() {
const platform = navigator.platform;
const shouldBrowseForProjectImmediately = isElectron && !isLinuxDesktop;
const shouldShowProjectPathEntry = addingProject && !shouldBrowseForProjectImmediately;
+ const orderedProjects = useMemo(() => {
+ return orderItemsByPreferredIds({
+ items: projects,
+ preferredIds: projectOrder,
+ getId: (project) => project.id,
+ });
+ }, [projectOrder, projects]);
+ const sidebarProjects = useMemo<SidebarProjectSnapshot[]>(
+ () =>
+ orderedProjects.map((project) => ({
+ ...project,
+ expanded: projectExpandedById[project.id] ?? true,
+ })),
+ [orderedProjects, projectExpandedById],
+ );
+ const threads = useMemo(
+ () =>
+ serverThreads.map((thread) =>
+ toSidebarThreadSnapshot(thread, threadLastVisitedAtById[thread.id]),
+ ),
+ [serverThreads, threadLastVisitedAtById],
+ );
const projectCwdById = useMemo(
() => new Map(projects.map((project) => [project.id, project.cwd] as const)),
[projects],
@@ -752,7 +859,7 @@ export default function Sidebar() {
}
if (clicked === "mark-unread") {
- markThreadUnread(threadId);
+ markThreadUnread(threadId, thread.latestTurn?.completedAt);
return;
}
if (clicked === "copy-path") {
@@ -814,7 +921,8 @@ export default function Sidebar() {
if (clicked === "mark-unread") {
for (const id of ids) {
- markThreadUnread(id);
+ const thread = threads.find((candidate) => candidate.id === id);
+ markThreadUnread(id, thread?.latestTurn?.completedAt);
}
clearSelection();
return;
@@ -845,6 +953,7 @@ export default function Sidebar() {
markThreadUnread,
removeFromSelection,
selectedThreadIds,
+ threads,
],
);
@@ -987,12 +1096,12 @@ export default function Sidebar() {
dragInProgressRef.current = false;
const { active, over } = event;
if (!over || active.id === over.id) return;
- const activeProject = projects.find((project) => project.id === active.id);
- const overProject = projects.find((project) => project.id === over.id);
+ const activeProject = sidebarProjects.find((project) => project.id === active.id);
+ const overProject = sidebarProjects.find((project) => project.id === over.id);
if (!activeProject || !overProject) return;
reorderProjects(activeProject.id, overProject.id);
},
- [appSettings.sidebarProjectSortOrder, projects, reorderProjects],
+ [appSettings.sidebarProjectSortOrder, reorderProjects, sidebarProjects],
);
const handleProjectDragStart = useCallback(
@@ -1052,8 +1161,9 @@ export default function Sidebar() {
[threads],
);
const sortedProjects = useMemo(
- () => sortProjectsForSidebar(projects, visibleThreads, appSettings.sidebarProjectSortOrder),
- [appSettings.sidebarProjectSortOrder, projects, visibleThreads],
+ () =>
+ sortProjectsForSidebar(sidebarProjects, visibleThreads, appSettings.sidebarProjectSortOrder),
+ [appSettings.sidebarProjectSortOrder, sidebarProjects, visibleThreads],
);
const isManualProjectSorting = appSettings.sidebarProjectSortOrder === "manual";
const renderedProjects = useMemo(
diff --git a/apps/web/src/composerDraftStore.test.ts b/apps/web/src/composerDraftStore.test.ts
index b68663a89..797e27a6e 100644
--- a/apps/web/src/composerDraftStore.test.ts
+++ b/apps/web/src/composerDraftStore.test.ts
@@ -9,6 +9,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import {
COMPOSER_DRAFT_STORAGE_KEY,
+ clearPromotedDraftThread,
+ clearPromotedDraftThreads,
type ComposerImageAttachment,
useComposerDraftStore,
} from "./composerDraftStore";
@@ -549,6 +551,57 @@ describe("composerDraftStore project draft thread mapping", () => {
expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
});
+ it("clears a promoted draft by thread id", () => {
+ const store = useComposerDraftStore.getState();
+ store.setProjectDraftThreadId(projectId, threadId);
+ store.setPrompt(threadId, "promote me");
+
+ clearPromotedDraftThread(threadId);
+
+ expect(useComposerDraftStore.getState().getDraftThreadByProjectId(projectId)).toBeNull();
+ expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+ expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
+ });
+
+ it("does not clear composer drafts for existing server threads during promotion cleanup", () => {
+ const store = useComposerDraftStore.getState();
+ store.setPrompt(threadId, "keep me");
+
+ clearPromotedDraftThread(threadId);
+
+ expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+ expect(useComposerDraftStore.getState().draftsByThreadId[threadId]?.prompt).toBe("keep me");
+ });
+
+ it("clears promoted drafts from an iterable of server thread ids", () => {
+ const store = useComposerDraftStore.getState();
+ store.setProjectDraftThreadId(projectId, threadId);
+ store.setPrompt(threadId, "promote me");
+ store.setProjectDraftThreadId(otherProjectId, otherThreadId);
+ store.setPrompt(otherThreadId, "keep me");
+
+ clearPromotedDraftThreads([threadId]);
+
+ expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+ expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
+ expect(
+ useComposerDraftStore.getState().getDraftThreadByProjectId(otherProjectId)?.threadId,
+ ).toBe(otherThreadId);
+ expect(useComposerDraftStore.getState().draftsByThreadId[otherThreadId]?.prompt).toBe(
+ "keep me",
+ );
+ });
+
+ it("keeps existing server-thread composer drafts during iterable promotion cleanup", () => {
+ const store = useComposerDraftStore.getState();
+ store.setPrompt(threadId, "keep me");
+
+ clearPromotedDraftThreads([threadId]);
+
+ expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+ expect(useComposerDraftStore.getState().draftsByThreadId[threadId]?.prompt).toBe("keep me");
+ });
+
it("updates branch context on an existing draft thread", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectId, threadId, {
diff --git a/apps/web/src/composerDraftStore.ts b/apps/web/src/composerDraftStore.ts
index 17b06e7bd..8a93b7b0d 100644
--- a/apps/web/src/composerDraftStore.ts
+++ b/apps/web/src/composerDraftStore.ts
@@ -2195,18 +2195,21 @@ export function useEffectiveComposerModelState(input: {
}
/**
- * Clear draft threads that have been promoted to server threads.
+ * Clear a draft thread once the server has materialized the same thread id.
*
- * Call this after a snapshot sync so the route guard in `_chat.$threadId`
- * sees the server thread before the draft is removed — avoids a redirect
- * to `/` caused by a gap where neither draft nor server thread exists.
+ * Use the single-thread helper for live `thread.created` events and the
+ * iterable helper for bootstrap/recovery paths that discover multiple server
+ * threads at once.
*/
-export function clearPromotedDraftThreads(serverThreadIds: ReadonlySet<ThreadId>): void {
- const store = useComposerDraftStore.getState();
- const draftThreadIds = Object.keys(store.draftThreadsByThreadId) as ThreadId[];
- for (const draftId of draftThreadIds) {
- if (serverThreadIds.has(draftId)) {
- store.clearDraftThread(draftId);
- }
+export function clearPromotedDraftThread(threadId: ThreadId): void {
+ if (!useComposerDraftStore.getState().getDraftThread(threadId)) {
+ return;
+ }
+ useComposerDraftStore.getState().clearDraftThread(threadId);
+}
+
+export function clearPromotedDraftThreads(serverThreadIds: Iterable<ThreadId>): void {
+ for (const threadId of serverThreadIds) {
+ clearPromotedDraftThread(threadId);
}
}
diff --git a/apps/web/src/hooks/useHandleNewThread.ts b/apps/web/src/hooks/useHandleNewThread.ts
index ffb4b5cf6..1547035bf 100644
--- a/apps/web/src/hooks/useHandleNewThread.ts
+++ b/apps/web/src/hooks/useHandleNewThread.ts
@@ -1,29 +1,37 @@
import { DEFAULT_RUNTIME_MODE, type ProjectId, ThreadId } from "@t3tools/contracts";
import { useNavigate, useParams } from "@tanstack/react-router";
-import { useCallback } from "react";
+import { useCallback, useMemo } from "react";
+import { useShallow } from "zustand/react/shallow";
import {
type DraftThreadEnvMode,
type DraftThreadState,
useComposerDraftStore,
} from "../composerDraftStore";
import { newThreadId } from "../lib/utils";
+import { orderItemsByPreferredIds } from "../components/Sidebar.logic";
import { useStore } from "../store";
+import { useThreadById } from "../storeSelectors";
+import { useUiStateStore } from "../uiStateStore";
export function useHandleNewThread() {
- const projects = useStore((store) => store.projects);
- const threads = useStore((store) => store.threads);
+ const projectIds = useStore(useShallow((store) => store.projects.map((project) => project.id)));
+ const projectOrder = useUiStateStore((store) => store.projectOrder);
const navigate = useNavigate();
const routeThreadId = useParams({
strict: false,
select: (params) => (params.threadId ? ThreadId.makeUnsafe(params.threadId) : null),
});
+ const activeThread = useThreadById(routeThreadId);
const activeDraftThread = useComposerDraftStore((store) =>
routeThreadId ? (store.draftThreadsByThreadId[routeThreadId] ?? null) : null,
);
-
- const activeThread = routeThreadId
- ? threads.find((thread) => thread.id === routeThreadId)
- : undefined;
+ const orderedProjects = useMemo(() => {
+ return orderItemsByPreferredIds({
+ items: projectIds,
+ preferredIds: projectOrder,
+ getId: (projectId) => projectId,
+ });
+ }, [projectIds, projectOrder]);
const handleNewThread = useCallback(
(
@@ -111,8 +119,8 @@ export function useHandleNewThread() {
return {
activeDraftThread,
activeThread,
+ defaultProjectId: orderedProjects[0] ?? null,
handleNewThread,
- projects,
routeThreadId,
};
}
diff --git a/apps/web/src/hooks/useThreadActions.ts b/apps/web/src/hooks/useThreadActions.ts
index 83cfe911f..d5557b4a9 100644
--- a/apps/web/src/hooks/useThreadActions.ts
+++ b/apps/web/src/hooks/useThreadActions.ts
@@ -16,8 +16,6 @@ import { toastManager } from "../components/ui/toast";
import { useSettings } from "./useSettings";
export function useThreadActions() {
- const threads = useStore((store) => store.threads);
- const projects = useStore((store) => store.projects);
const appSettings = useSettings();
const clearComposerDraftForThread = useComposerDraftStore((store) => store.clearDraftThread);
const clearProjectDraftThreadById = useComposerDraftStore(
@@ -37,7 +35,7 @@ export function useThreadActions() {
async (threadId: ThreadId) => {
const api = readNativeApi();
if (!api) return;
- const thread = threads.find((entry) => entry.id === threadId);
+ const thread = useStore.getState().threads.find((entry) => entry.id === threadId);
if (!thread) return;
if (thread.session?.status === "running" && thread.session.activeTurnId != null) {
throw new Error("Cannot archive a running thread.");
@@ -53,7 +51,7 @@ export function useThreadActions() {
await handleNewThread(thread.projectId);
}
},
- [handleNewThread, routeThreadId, threads],
+ [handleNewThread, routeThreadId],
);
const unarchiveThread = useCallback(async (threadId: ThreadId) => {
@@ -70,6 +68,7 @@ export function useThreadActions() {
async (threadId: ThreadId, opts: { deletedThreadIds?: ReadonlySet<ThreadId> } = {}) => {
const api = readNativeApi();
if (!api) return;
+ const { projects, threads } = useStore.getState();
const thread = threads.find((entry) => entry.id === threadId);
if (!thread) return;
const threadProject = projects.find((project) => project.id === thread.projectId);
@@ -171,10 +170,8 @@ export function useThreadActions() {
clearTerminalState,
appSettings.sidebarThreadSortOrder,
navigate,
- projects,
removeWorktreeMutation,
routeThreadId,
- threads,
],
);
@@ -182,7 +179,7 @@ export function useThreadActions() {
async (threadId: ThreadId) => {
const api = readNativeApi();
if (!api) return;
- const thread = threads.find((entry) => entry.id === threadId);
+ const thread = useStore.getState().threads.find((entry) => entry.id === threadId);
if (!thread) return;
if (appSettings.confirmThreadDelete) {
@@ -199,7 +196,7 @@ export function useThreadActions() {
await deleteThread(threadId);
},
- [appSettings.confirmThreadDelete, deleteThread, threads],
+ [appSettings.confirmThreadDelete, deleteThread],
);
return {
diff --git a/apps/web/src/orchestrationEventEffects.test.ts b/apps/web/src/orchestrationEventEffects.test.ts
new file mode 100644
index 000000000..263610bb9
--- /dev/null
+++ b/apps/web/src/orchestrationEventEffects.test.ts
@@ -0,0 +1,108 @@
+import {
+ CheckpointRef,
+ EventId,
+ MessageId,
+ ProjectId,
+ ThreadId,
+ TurnId,
+ type OrchestrationEvent,
+} from "@t3tools/contracts";
+import { describe, expect, it } from "vitest";
+
+import { deriveOrchestrationBatchEffects } from "./orchestrationEventEffects";
+
+function makeEvent<T extends OrchestrationEvent["type"]>(
+ type: T,
+ payload: Extract<OrchestrationEvent, { type: T }>["payload"],
+ overrides: Partial<Extract<OrchestrationEvent, { type: T }>> = {},
+): Extract<OrchestrationEvent, { type: T }> {
+ const sequence = overrides.sequence ?? 1;
+ return {
+ sequence,
+ eventId: EventId.makeUnsafe(`event-${sequence}`),
+ aggregateKind: "thread",
+ aggregateId:
+ "threadId" in payload
+ ? payload.threadId
+ : "projectId" in payload
+ ? payload.projectId
+ : ProjectId.makeUnsafe("project-1"),
+ occurredAt: "2026-02-27T00:00:00.000Z",
+ commandId: null,
+ causationEventId: null,
+ correlationId: null,
+ metadata: {},
+ type,
+ payload,
+ ...overrides,
+ } as Extract<OrchestrationEvent, { type: T }>;
+}
+
+describe("deriveOrchestrationBatchEffects", () => {
+ it("targets draft promotion and terminal cleanup from thread lifecycle events", () => {
+ const createdThreadId = ThreadId.makeUnsafe("thread-created");
+ const deletedThreadId = ThreadId.makeUnsafe("thread-deleted");
+
+ const effects = deriveOrchestrationBatchEffects([
+ makeEvent("thread.created", {
+ threadId: createdThreadId,
+ projectId: ProjectId.makeUnsafe("project-1"),
+ title: "Created thread",
+ modelSelection: { provider: "codex", model: "gpt-5-codex" },
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ branch: null,
+ worktreePath: null,
+ createdAt: "2026-02-27T00:00:00.000Z",
+ updatedAt: "2026-02-27T00:00:00.000Z",
+ }),
+ makeEvent("thread.deleted", {
+ threadId: deletedThreadId,
+ deletedAt: "2026-02-27T00:00:01.000Z",
+ }),
+ ]);
+
+ expect(effects.clearPromotedDraftThreadIds).toEqual([createdThreadId]);
+ expect(effects.clearDeletedThreadIds).toEqual([deletedThreadId]);
+ expect(effects.removeTerminalStateThreadIds).toEqual([deletedThreadId]);
+ expect(effects.needsProviderInvalidation).toBe(false);
+ });
+
+ it("keeps only the final lifecycle outcome for a thread within one batch", () => {
+ const threadId = ThreadId.makeUnsafe("thread-1");
+
+ const effects = deriveOrchestrationBatchEffects([
+ makeEvent("thread.deleted", {
+ threadId,
+ deletedAt: "2026-02-27T00:00:01.000Z",
+ }),
+ makeEvent("thread.created", {
+ threadId,
+ projectId: ProjectId.makeUnsafe("project-1"),
+ title: "Recreated thread",
+ modelSelection: { provider: "codex", model: "gpt-5-codex" },
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ branch: null,
+ worktreePath: null,
+ createdAt: "2026-02-27T00:00:02.000Z",
+ updatedAt: "2026-02-27T00:00:02.000Z",
+ }),
+ makeEvent("thread.turn-diff-completed", {
+ threadId,
+ turnId: TurnId.makeUnsafe("turn-1"),
+ checkpointTurnCount: 1,
+ checkpointRef: CheckpointRef.makeUnsafe("checkpoint-1"),
+ status: "ready",
+ files: [],
+ assistantMessageId: MessageId.makeUnsafe("assistant-1"),
+ completedAt: "2026-02-27T00:00:03.000Z",
+ }),
+ ]);
+
+ expect(effects.clearPromotedDraftThreadIds).toEqual([threadId]);
+ expect(effects.clearDeletedThreadIds).toEqual([]);
+ expect(effects.removeTerminalStateThreadIds).toEqual([]);
+ expect(effects.needsProviderInvalidation).toBe(true);
+ });
+});
diff --git a/apps/web/src/orchestrationEventEffects.ts b/apps/web/src/orchestrationEventEffects.ts
new file mode 100644
index 000000000..d4dda76d9
--- /dev/null
+++ b/apps/web/src/orchestrationEventEffects.ts
@@ -0,0 +1,76 @@
+import type { OrchestrationEvent, ThreadId } from "@t3tools/contracts";
+
+export interface OrchestrationBatchEffects {
+ clearPromotedDraftThreadIds: ThreadId[];
+ clearDeletedThreadIds: ThreadId[];
+ removeTerminalStateThreadIds: ThreadId[];
+ needsProviderInvalidation: boolean;
+}
+
+export function deriveOrchestrationBatchEffects(
+ events: readonly OrchestrationEvent[],
+): OrchestrationBatchEffects {
+ const threadLifecycleEffects = new Map<
+ ThreadId,
+ {
+ clearPromotedDraft: boolean;
+ clearDeletedThread: boolean;
+ removeTerminalState: boolean;
+ }
+ >();
+ let needsProviderInvalidation = false;
+
+ for (const event of events) {
+ switch (event.type) {
+ case "thread.turn-diff-completed":
+ case "thread.reverted": {
+ needsProviderInvalidation = true;
+ break;
+ }
+
+ case "thread.created": {
+ threadLifecycleEffects.set(event.payload.threadId, {
+ clearPromotedDraft: true,
+ clearDeletedThread: false,
+ removeTerminalState: false,
+ });
+ break;
+ }
+
+ case "thread.deleted": {
+ threadLifecycleEffects.set(event.payload.threadId, {
+ clearPromotedDraft: false,
+ clearDeletedThread: true,
+ removeTerminalState: true,
+ });
+ break;
+ }
+
+ default: {
+ break;
+ }
+ }
+ }
+
+ const clearPromotedDraftThreadIds: ThreadId[] = [];
+ const clearDeletedThreadIds: ThreadId[] = [];
+ const removeTerminalStateThreadIds: ThreadId[] = [];
+ for (const [threadId, effect] of threadLifecycleEffects) {
+ if (effect.clearPromotedDraft) {
+ clearPromotedDraftThreadIds.push(threadId);
+ }
+ if (effect.clearDeletedThread) {
+ clearDeletedThreadIds.push(threadId);
+ }
+ if (effect.removeTerminalState) {
+ removeTerminalStateThreadIds.push(threadId);
+ }
+ }
+
+ return {
+ clearPromotedDraftThreadIds,
+ clearDeletedThreadIds,
+ removeTerminalStateThreadIds,
+ needsProviderInvalidation,
+ };
+}
diff --git a/apps/web/src/orchestrationRecovery.test.ts b/apps/web/src/orchestrationRecovery.test.ts
new file mode 100644
index 000000000..bea16cdbc
--- /dev/null
+++ b/apps/web/src/orchestrationRecovery.test.ts
@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest";
+
+import { createOrchestrationRecoveryCoordinator } from "./orchestrationRecovery";
+
+describe("createOrchestrationRecoveryCoordinator", () => {
+ it("defers live events until bootstrap completes and then requests replay", () => {
+ const coordinator = createOrchestrationRecoveryCoordinator();
+
+ expect(coordinator.beginSnapshotRecovery("bootstrap")).toBe(true);
+ expect(coordinator.classifyDomainEvent(4)).toBe("defer");
+
+ expect(coordinator.completeSnapshotRecovery(2)).toBe(true);
+ expect(coordinator.getState()).toMatchObject({
+ latestSequence: 2,
+ highestObservedSequence: 4,
+ bootstrapped: true,
+ pendingReplay: false,
+ inFlight: null,
+ });
+ });
+
+ it("classifies sequence gaps as recovery-only replay work", () => {
+ const coordinator = createOrchestrationRecoveryCoordinator();
+
+ coordinator.beginSnapshotRecovery("bootstrap");
+ coordinator.completeSnapshotRecovery(3);
+
+ expect(coordinator.classifyDomainEvent(5)).toBe("recover");
+ expect(coordinator.beginReplayRecovery("sequence-gap")).toBe(true);
+ expect(coordinator.getState().inFlight).toEqual({
+ kind: "replay",
+ reason: "sequence-gap",
+ });
+ });
+
+ it("tracks live event batches without entering recovery", () => {
+ const coordinator = createOrchestrationRecoveryCoordinator();
+
+ coordinator.beginSnapshotRecovery("bootstrap");
+ coordinator.completeSnapshotRecovery(3);
+
+ expect(coordinator.classifyDomainEvent(4)).toBe("apply");
+ expect(coordinator.markEventBatchApplied([{ sequence: 4 }])).toEqual([{ sequence: 4 }]);
+ expect(coordinator.getState()).toMatchObject({
+ latestSequence: 4,
+ highestObservedSequence: 4,
+ bootstrapped: true,
+ inFlight: null,
+ });
+ });
+
+ it("requests another replay when deferred events arrive during replay recovery", () => {
+ const coordinator = createOrchestrationRecoveryCoordinator();
+
+ coordinator.beginSnapshotRecovery("bootstrap");
+ coordinator.completeSnapshotRecovery(3);
+ coordinator.classifyDomainEvent(5);
+ coordinator.beginReplayRecovery("sequence-gap");
+ coordinator.classifyDomainEvent(7);
+ coordinator.markEventBatchApplied([{ sequence: 4 }, { sequence: 5 }, { sequence: 6 }]);
+
+ expect(coordinator.completeReplayRecovery()).toBe(true);
+ });
+
+ it("does not immediately replay again when replay returns no new events", () => {
+ const coordinator = createOrchestrationRecoveryCoordinator();
+
+ coordinator.beginSnapshotRecovery("bootstrap");
+ coordinator.completeSnapshotRecovery(3);
+ coordinator.classifyDomainEvent(5);
+ coordinator.beginReplayRecovery("sequence-gap");
+
+ expect(coordinator.completeReplayRecovery()).toBe(false);
+ expect(coordinator.getState()).toMatchObject({
+ latestSequence: 3,
+ highestObservedSequence: 5,
+ pendingReplay: false,
+ inFlight: null,
+ });
+ });
+
+ it("marks replay failure as unbootstrapped so snapshot fallback is recovery-only", () => {
+ const coordinator = createOrchestrationRecoveryCoordinator();
+
+ coordinator.beginSnapshotRecovery("bootstrap");
+ coordinator.completeSnapshotRecovery(3);
+ coordinator.beginReplayRecovery("sequence-gap");
+ coordinator.failReplayRecovery();
+
+ expect(coordinator.getState()).toMatchObject({
+ bootstrapped: false,
+ inFlight: null,
+ });
+ expect(coordinator.beginSnapshotRecovery("replay-failed")).toBe(true);
+ expect(coordinator.getState().inFlight).toEqual({
+ kind: "snapshot",
+ reason: "replay-failed",
+ });
+ });
+});
diff --git a/apps/web/src/orchestrationRecovery.ts b/apps/web/src/orchestrationRecovery.ts
new file mode 100644
index 000000000..ee81d5d53
--- /dev/null
+++ b/apps/web/src/orchestrationRecovery.ts
@@ -0,0 +1,136 @@
+export type OrchestrationRecoveryReason = "bootstrap" | "sequence-gap" | "replay-failed";
+
+export interface OrchestrationRecoveryPhase {
+ kind: "snapshot" | "replay";
+ reason: OrchestrationRecoveryReason;
+}
+
+export interface OrchestrationRecoveryState {
+ latestSequence: number;
+ highestObservedSequence: number;
+ bootstrapped: boolean;
+ pendingReplay: boolean;
+ inFlight: OrchestrationRecoveryPhase | null;
+}
+
+type SequencedEvent = Readonly<{ sequence: number }>;
+
+export function createOrchestrationRecoveryCoordinator() {
+ let state: OrchestrationRecoveryState = {
+ latestSequence: 0,
+ highestObservedSequence: 0,
+ bootstrapped: false,
+ pendingReplay: false,
+ inFlight: null,
+ };
+ let replayStartSequence: number | null = null;
+
+ const snapshotState = (): OrchestrationRecoveryState => ({
+ ...state,
+ ...(state.inFlight ? { inFlight: { ...state.inFlight } } : {}),
+ });
+
+ const observeSequence = (sequence: number) => {
+ state.highestObservedSequence = Math.max(state.highestObservedSequence, sequence);
+ };
+
+ const shouldReplayAfterRecovery = (): boolean => {
+ const shouldReplay =
+ state.pendingReplay || state.highestObservedSequence > state.latestSequence;
+ state.pendingReplay = false;
+ return shouldReplay;
+ };
+
+ return {
+ getState(): OrchestrationRecoveryState {
+ return snapshotState();
+ },
+
+ classifyDomainEvent(sequence: number): "ignore" | "defer" | "recover" | "apply" {
+ observeSequence(sequence);
+ if (sequence <= state.latestSequence) {
+ return "ignore";
+ }
+ if (!state.bootstrapped || state.inFlight) {
+ state.pendingReplay = true;
+ return "defer";
+ }
+ if (sequence !== state.latestSequence + 1) {
+ state.pendingReplay = true;
+ return "recover";
+ }
+ return "apply";
+ },
+
+ markEventBatchApplied<T extends SequencedEvent>(events: ReadonlyArray<T>): ReadonlyArray<T> {
+ const nextEvents = events
+ .filter((event) => event.sequence > state.latestSequence)
+ .toSorted((left, right) => left.sequence - right.sequence);
+ if (nextEvents.length === 0) {
+ return [];
+ }
+
+ state.latestSequence = nextEvents.at(-1)?.sequence ?? state.latestSequence;
+ state.highestObservedSequence = Math.max(state.highestObservedSequence, state.latestSequence);
+ return nextEvents;
+ },
+
+ beginSnapshotRecovery(reason: OrchestrationRecoveryReason): boolean {
+ if (state.inFlight?.kind === "snapshot") {
+ state.pendingReplay = true;
+ return false;
+ }
+ if (state.inFlight?.kind === "replay") {
+ state.pendingReplay = true;
+ return false;
+ }
+ state.inFlight = { kind: "snapshot", reason };
+ return true;
+ },
+
+ completeSnapshotRecovery(snapshotSequence: number): boolean {
+ state.latestSequence = Math.max(state.latestSequence, snapshotSequence);
+ state.highestObservedSequence = Math.max(state.highestObservedSequence, state.latestSequence);
+ state.bootstrapped = true;
+ state.inFlight = null;
+ return shouldReplayAfterRecovery();
+ },
+
+ failSnapshotRecovery(): void {
+ state.inFlight = null;
+ },
+
+ beginReplayRecovery(reason: OrchestrationRecoveryReason): boolean {
+ if (!state.bootstrapped || state.inFlight?.kind === "snapshot") {
+ state.pendingReplay = true;
+ return false;
+ }
+ if (state.inFlight?.kind === "replay") {
+ state.pendingReplay = true;
+ return false;
+ }
+ state.pendingReplay = false;
+ replayStartSequence = state.latestSequence;
+ state.inFlight = { kind: "replay", reason };
+ return true;
+ },
+
+ completeReplayRecovery(): boolean {
+ const replayMadeProgress =
+ replayStartSequence !== null && state.latestSequence > replayStartSequence;
+ replayStartSequence = null;
+ state.inFlight = null;
+ if (!replayMadeProgress) {
+ state.pendingReplay = false;
+ return false;
+ }
+ return shouldReplayAfterRecovery();
+ },
+
+ failReplayRecovery(): void {
+ replayStartSequence = null;
+ state.bootstrapped = false;
+ state.inFlight = null;
+ },
+ };
+}
diff --git a/apps/web/src/router.ts b/apps/web/src/router.ts
index 0192ee0c6..16b78e69d 100644
--- a/apps/web/src/router.ts
+++ b/apps/web/src/router.ts
@@ -1,11 +1,8 @@
import { createElement } from "react";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { createRouter } from "@tanstack/react-router";
+import { createRouter, RouterHistory } from "@tanstack/react-router";
import { routeTree } from "./routeTree.gen";
-import { StoreProvider } from "./store";
-
-type RouterHistory = NonNullable<Parameters<typeof createRouter>[0]["history"]>;
export function getRouter(history: RouterHistory) {
const queryClient = new QueryClient();
@@ -16,12 +13,7 @@ export function getRouter(history: RouterHistory) {
context: {
queryClient,
},
- Wrap: ({ children }) =>
- createElement(
- QueryClientProvider,
- { client: queryClient },
- createElement(StoreProvider, null, children),
- ),
+ Wrap: ({ children }) => createElement(QueryClientProvider, { client: queryClient }, children),
});
}
diff --git a/apps/web/src/routes/__root.tsx b/apps/web/src/routes/__root.tsx
index e99ec5022..4765b0a8e 100644
--- a/apps/web/src/routes/__root.tsx
+++ b/apps/web/src/routes/__root.tsx
@@ -1,4 +1,4 @@
-import { ThreadId } from "@t3tools/contracts";
+import { OrchestrationEvent, ThreadId } from "@t3tools/contracts";
import {
Outlet,
createRootRouteWithContext,
@@ -17,8 +17,13 @@ import { AnchoredToastProvider, ToastProvider, toastManager } from "../component
import { resolveAndPersistPreferredEditor } from "../editorPreferences";
import { serverConfigQueryOptions, serverQueryKeys } from "../lib/serverReactQuery";
import { readNativeApi } from "../nativeApi";
-import { clearPromotedDraftThreads, useComposerDraftStore } from "../composerDraftStore";
+import {
+ clearPromotedDraftThread,
+ clearPromotedDraftThreads,
+ useComposerDraftStore,
+} from "../composerDraftStore";
import { useStore } from "../store";
+import { useUiStateStore } from "../uiStateStore";
import { useTerminalStateStore } from "../terminalStateStore";
import { terminalRunningSubprocessFromEvent } from "../terminalActivity";
import { onServerConfigUpdated, onServerProvidersUpdated, onServerWelcome } from "../wsNativeApi";
@@ -26,6 +31,8 @@ import { migrateLocalSettingsToServer } from "../hooks/useSettings";
import { providerQueryKeys } from "../lib/providerReactQuery";
import { projectQueryKeys } from "../lib/projectReactQuery";
import { collectActiveTerminalThreadIds } from "../lib/terminalStateCleanup";
+import { deriveOrchestrationBatchEffects } from "../orchestrationEventEffects";
+import { createOrchestrationRecoveryCoordinator } from "../orchestrationRecovery";
export const Route = createRootRouteWithContext<{
queryClient: QueryClient;
@@ -135,8 +142,13 @@ function errorDetails(error: unknown): string {
}
function EventRouter() {
+ const applyOrchestrationEvents = useStore((store) => store.applyOrchestrationEvents);
const syncServerReadModel = useStore((store) => store.syncServerReadModel);
- const setProjectExpanded = useStore((store) => store.setProjectExpanded);
+ const setProjectExpanded = useUiStateStore((store) => store.setProjectExpanded);
+ const syncProjects = useUiStateStore((store) => store.syncProjects);
+ const syncThreads = useUiStateStore((store) => store.syncThreads);
+ const clearThreadUi = useUiStateStore((store) => store.clearThreadUi);
+ const removeTerminalState = useTerminalStateStore((store) => store.removeTerminalState);
const removeOrphanedTerminalStates = useTerminalStateStore(
(store) => store.removeOrphanedTerminalStates,
);
@@ -152,56 +164,40 @@ function EventRouter() {
const api = readNativeApi();
if (!api) return;
let disposed = false;
- let latestSequence = 0;
- let syncing = false;
- let pending = false;
+ const recovery = createOrchestrationRecoveryCoordinator();
let needsProviderInvalidation = false;
- const flushSnapshotSync = async (): Promise<void> => {
- const snapshot = await api.orchestration.getSnapshot();
- if (disposed) return;
- latestSequence = Math.max(latestSequence, snapshot.snapshotSequence);
- syncServerReadModel(snapshot);
- clearPromotedDraftThreads(new Set(snapshot.threads.map((t) => t.id)));
+ const reconcileSnapshotDerivedState = () => {
+ const threads = useStore.getState().threads;
+ const projects = useStore.getState().projects;
+ syncProjects(projects.map((project) => ({ id: project.id, cwd: project.cwd })));
+ syncThreads(
+ threads.map((thread) => ({
+ id: thread.id,
+ seedVisitedAt: thread.updatedAt ?? thread.createdAt,
+ })),
+ );
+ clearPromotedDraftThreads(threads.map((thread) => thread.id));
const draftThreadIds = Object.keys(
useComposerDraftStore.getState().draftThreadsByThreadId,
) as ThreadId[];
const activeThreadIds = collectActiveTerminalThreadIds({
- snapshotThreads: snapshot.threads,
+ snapshotThreads: threads.map((thread) => ({ id: thread.id, deletedAt: null })),
draftThreadIds,
});
removeOrphanedTerminalStates(activeThreadIds);
- if (pending) {
- pending = false;
- await flushSnapshotSync();
- }
};
- const syncSnapshot = async () => {
- if (syncing) {
- pending = true;
- return;
- }
- syncing = true;
- pending = false;
- try {
- await flushSnapshotSync();
- } catch {
- // Keep prior state and wait for next domain event to trigger a resync.
- }
- syncing = false;
- };
-
- const domainEventFlushThrottler = new Throttler(
+ const queryInvalidationThrottler = new Throttler(
() => {
- if (needsProviderInvalidation) {
- needsProviderInvalidation = false;
- void queryClient.invalidateQueries({ queryKey: providerQueryKeys.all });
- // Invalidate workspace entry queries so the @-mention file picker
- // reflects files created, deleted, or restored during this turn.
- void queryClient.invalidateQueries({ queryKey: projectQueryKeys.all });
+ if (!needsProviderInvalidation) {
+ return;
}
- void syncSnapshot();
+ needsProviderInvalidation = false;
+ void queryClient.invalidateQueries({ queryKey: providerQueryKeys.all });
+ // Invalidate workspace entry queries so the @-mention file picker
+ // reflects files created, deleted, or restored during this turn.
+ void queryClient.invalidateQueries({ queryKey: projectQueryKeys.all });
},
{
wait: 100,
@@ -210,15 +206,113 @@ function EventRouter() {
},
);
- const unsubDomainEvent = api.orchestration.onDomainEvent((event) => {
- if (event.sequence <= latestSequence) {
+ const applyEventBatch = (events: ReadonlyArray<OrchestrationEvent>) => {
+ const nextEvents = recovery.markEventBatchApplied(events);
+ if (nextEvents.length === 0) {
return;
}
- latestSequence = event.sequence;
- if (event.type === "thread.turn-diff-completed" || event.type === "thread.reverted") {
+
+ const batchEffects = deriveOrchestrationBatchEffects(nextEvents);
+ const needsProjectUiSync = nextEvents.some(
+ (event) =>
+ event.type === "project.created" ||
+ event.type === "project.meta-updated" ||
+ event.type === "project.deleted",
+ );
+
+ if (batchEffects.needsProviderInvalidation) {
needsProviderInvalidation = true;
+ void queryInvalidationThrottler.maybeExecute();
+ }
+
+ applyOrchestrationEvents(nextEvents);
+ if (needsProjectUiSync) {
+ const projects = useStore.getState().projects;
+ syncProjects(projects.map((project) => ({ id: project.id, cwd: project.cwd })));
+ }
+ const needsThreadUiSync = nextEvents.some(
+ (event) => event.type === "thread.created" || event.type === "thread.deleted",
+ );
+ if (needsThreadUiSync) {
+ const threads = useStore.getState().threads;
+ syncThreads(
+ threads.map((thread) => ({
+ id: thread.id,
+ seedVisitedAt: thread.updatedAt ?? thread.createdAt,
+ })),
+ );
+ }
+ const draftStore = useComposerDraftStore.getState();
+ for (const threadId of batchEffects.clearPromotedDraftThreadIds) {
+ clearPromotedDraftThread(threadId);
+ }
+ for (const threadId of batchEffects.clearDeletedThreadIds) {
+ draftStore.clearDraftThread(threadId);
+ clearThreadUi(threadId);
+ }
+ for (const threadId of batchEffects.removeTerminalStateThreadIds) {
+ removeTerminalState(threadId);
+ }
+ };
+
+ const recoverFromSequenceGap = async (): Promise<void> => {
+ if (!recovery.beginReplayRecovery("sequence-gap")) {
+ return;
+ }
+
+ try {
+ const events = await api.orchestration.replayEvents(recovery.getState().latestSequence);
+ if (!disposed) {
+ applyEventBatch(events);
+ }
+ } catch {
+ recovery.failReplayRecovery();
+ void fallbackToSnapshotRecovery();
+ return;
+ }
+
+ if (!disposed && recovery.completeReplayRecovery()) {
+ void recoverFromSequenceGap();
+ }
+ };
+
+ const runSnapshotRecovery = async (reason: "bootstrap" | "replay-failed"): Promise<void> => {
+ if (!recovery.beginSnapshotRecovery(reason)) {
+ return;
+ }
+
+ try {
+ const snapshot = await api.orchestration.getSnapshot();
+ if (!disposed) {
+ syncServerReadModel(snapshot);
+ reconcileSnapshotDerivedState();
+ if (recovery.completeSnapshotRecovery(snapshot.snapshotSequence)) {
+ void recoverFromSequenceGap();
+ }
+ }
+ } catch {
+ // Keep prior state and wait for welcome or a later replay attempt.
+ recovery.failSnapshotRecovery();
+ }
+ };
+
+ const bootstrapFromSnapshot = async (): Promise<void> => {
+ await runSnapshotRecovery("bootstrap");
+ };
+
+ const fallbackToSnapshotRecovery = async (): Promise<void> => {
+ await runSnapshotRecovery("replay-failed");
+ };
+
+ const unsubDomainEvent = api.orchestration.onDomainEvent((event) => {
+ const action = recovery.classifyDomainEvent(event.sequence);
+ if (action === "apply") {
+ applyEventBatch([event]);
+ return;
+ }
+ if (action === "recover") {
+ void recoverFromSequenceGap();
}
- domainEventFlushThrottler.maybeExecute();
});
const unsubTerminalEvent = api.terminal.onEvent((event) => {
const hasRunningSubprocess = terminalRunningSubprocessFromEvent(event);
@@ -237,7 +331,7 @@ function EventRouter() {
// Migrate old localStorage settings to server on first connect
migrateLocalSettingsToServer();
void (async () => {
- await syncSnapshot();
+ await bootstrapFromSnapshot();
if (disposed) {
return;
}
@@ -319,7 +413,7 @@ function EventRouter() {
return () => {
disposed = true;
needsProviderInvalidation = false;
- domainEventFlushThrottler.cancel();
+ queryInvalidationThrottler.cancel();
unsubDomainEvent();
unsubTerminalEvent();
unsubWelcome();
@@ -327,11 +421,16 @@ function EventRouter() {
unsubProvidersUpdated();
};
}, [
+ applyOrchestrationEvents,
navigate,
queryClient,
+ removeTerminalState,
removeOrphanedTerminalStates,
+ clearThreadUi,
setProjectExpanded,
+ syncProjects,
syncServerReadModel,
+ syncThreads,
]);
return null;
diff --git a/apps/web/src/routes/_chat.$threadId.tsx b/apps/web/src/routes/_chat.$threadId.tsx
index 8e7a5d3ba..b95d1ef7b 100644
--- a/apps/web/src/routes/_chat.$threadId.tsx
+++ b/apps/web/src/routes/_chat.$threadId.tsx
@@ -161,7 +161,7 @@ const DiffPanelInlineSidebar = (props: {
};
function ChatThreadRouteView() {
- const threadsHydrated = useStore((store) => store.threadsHydrated);
+ const bootstrapComplete = useStore((store) => store.bootstrapComplete);
const navigate = useNavigate();
const threadId = Route.useParams({
select: (params) => ThreadId.makeUnsafe(params.threadId),
@@ -202,7 +202,7 @@ function ChatThreadRouteView() {
}, [diffOpen]);
useEffect(() => {
- if (!threadsHydrated) {
+ if (!bootstrapComplete) {
return;
}
@@ -210,9 +210,9 @@ function ChatThreadRouteView() {
void navigate({ to: "/", replace: true });
return;
}
- }, [navigate, routeThreadExists, threadsHydrated, threadId]);
+ }, [bootstrapComplete, navigate, routeThreadExists, threadId]);
- if (!threadsHydrated || !routeThreadExists) {
+ if (!bootstrapComplete || !routeThreadExists) {
return null;
}
diff --git a/apps/web/src/routes/_chat.tsx b/apps/web/src/routes/_chat.tsx
index 3c86ab42f..245ed9c57 100644
--- a/apps/web/src/routes/_chat.tsx
+++ b/apps/web/src/routes/_chat.tsx
@@ -17,7 +17,7 @@ const EMPTY_KEYBINDINGS: ResolvedKeybindingsConfig = [];
function ChatRouteGlobalShortcuts() {
const clearSelection = useThreadSelectionStore((state) => state.clearSelection);
const selectedThreadIdsSize = useThreadSelectionStore((state) => state.selectedThreadIds.size);
- const { activeDraftThread, activeThread, handleNewThread, projects, routeThreadId } =
+ const { activeDraftThread, activeThread, defaultProjectId, handleNewThread, routeThreadId } =
useHandleNewThread();
const serverConfigQuery = useQuery(serverConfigQueryOptions());
const keybindings = serverConfigQuery.data?.keybindings ?? EMPTY_KEYBINDINGS;
@@ -38,7 +38,7 @@ function ChatRouteGlobalShortcuts() {
return;
}
- const projectId = activeThread?.projectId ?? activeDraftThread?.projectId ?? projects[0]?.id;
+ const projectId = activeThread?.projectId ?? activeDraftThread?.projectId ?? defaultProjectId;
if (!projectId) return;
const command = resolveShortcutCommand(event, keybindings, {
@@ -59,14 +59,17 @@ function ChatRouteGlobalShortcuts() {
return;
}
- if (command !== "chat.new") return;
- event.preventDefault();
- event.stopPropagation();
- void handleNewThread(projectId, {
- branch: activeThread?.branch ?? activeDraftThread?.branch ?? null,
- worktreePath: activeThread?.worktreePath ?? activeDraftThread?.worktreePath ?? null,
- envMode: activeDraftThread?.envMode ?? (activeThread?.worktreePath ? "worktree" : "local"),
- });
+ if (command === "chat.new") {
+ event.preventDefault();
+ event.stopPropagation();
+ void handleNewThread(projectId, {
+ branch: activeThread?.branch ?? activeDraftThread?.branch ?? null,
+ worktreePath: activeThread?.worktreePath ?? activeDraftThread?.worktreePath ?? null,
+ envMode:
+ activeDraftThread?.envMode ?? (activeThread?.worktreePath ? "worktree" : "local"),
+ });
+ return;
+ }
};
window.addEventListener("keydown", onWindowKeyDown);
@@ -79,7 +82,7 @@ function ChatRouteGlobalShortcuts() {
clearSelection,
handleNewThread,
keybindings,
- projects,
+ defaultProjectId,
selectedThreadIdsSize,
terminalOpen,
appSettings.defaultThreadEnvMode,
diff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.ts
index c786ffc72..e05c3b5e9 100644
--- a/apps/web/src/session-logic.test.ts
+++ b/apps/web/src/session-logic.test.ts
@@ -8,6 +8,7 @@ import {
import { describe, expect, it } from "vitest";
import {
+ deriveCompletionDividerBeforeEntryId,
deriveActiveWorkStartedAt,
deriveActivePlanState,
PROVIDER_OPTIONS,
@@ -964,6 +965,37 @@ describe("deriveTimelineEntries", () => {
},
});
});
+
+ it("anchors the completion divider to latestTurn.assistantMessageId before timestamp fallback", () => {
+ const entries = deriveTimelineEntries(
+ [
+ {
+ id: MessageId.makeUnsafe("assistant-earlier"),
+ role: "assistant",
+ text: "progress update",
+ createdAt: "2026-02-23T00:00:01.000Z",
+ streaming: false,
+ },
+ {
+ id: MessageId.makeUnsafe("assistant-final"),
+ role: "assistant",
+ text: "final answer",
+ createdAt: "2026-02-23T00:00:01.000Z",
+ streaming: false,
+ },
+ ],
+ [],
+ [],
+ );
+
+ expect(
+ deriveCompletionDividerBeforeEntryId(entries, {
+ assistantMessageId: MessageId.makeUnsafe("assistant-final"),
+ startedAt: "2026-02-23T00:00:00.000Z",
+ completedAt: "2026-02-23T00:00:02.000Z",
+ }),
+ ).toBe("assistant-final");
+ });
});
describe("deriveWorkLogEntries context window handling", () => {
diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.ts
index 83a95d631..fc3382701 100644
--- a/apps/web/src/session-logic.ts
+++ b/apps/web/src/session-logic.ts
@@ -852,6 +852,53 @@ export function deriveTimelineEntries(
);
}
+export function deriveCompletionDividerBeforeEntryId(
+ timelineEntries: ReadonlyArray<TimelineEntry>,
+ latestTurn: Pick<
+ OrchestrationLatestTurn,
+ "assistantMessageId" | "startedAt" | "completedAt"
+ > | null,
+): string | null {
+ if (!latestTurn?.startedAt || !latestTurn.completedAt) {
+ return null;
+ }
+
+ if (latestTurn.assistantMessageId) {
+ const exactMatch = timelineEntries.find(
+ (timelineEntry) =>
+ timelineEntry.kind === "message" &&
+ timelineEntry.message.role === "assistant" &&
+ timelineEntry.message.id === latestTurn.assistantMessageId,
+ );
+ if (exactMatch) {
+ return exactMatch.id;
+ }
+ }
+
+ const turnStartedAt = Date.parse(latestTurn.startedAt);
+ const turnCompletedAt = Date.parse(latestTurn.completedAt);
+ if (Number.isNaN(turnStartedAt) || Number.isNaN(turnCompletedAt)) {
+ return null;
+ }
+
+ let inRangeMatch: string | null = null;
+ let fallbackMatch: string | null = null;
+ for (const timelineEntry of timelineEntries) {
+ if (timelineEntry.kind !== "message" || timelineEntry.message.role !== "assistant") {
+ continue;
+ }
+ const messageAt = Date.parse(timelineEntry.message.createdAt);
+ if (Number.isNaN(messageAt) || messageAt < turnStartedAt) {
+ continue;
+ }
+ fallbackMatch = timelineEntry.id;
+ if (messageAt <= turnCompletedAt) {
+ inRangeMatch = timelineEntry.id;
+ }
+ }
+ return inRangeMatch ?? fallbackMatch;
+}
+
export function inferCheckpointTurnCountByTurnId(
summaries: TurnDiffSummary[],
): Record<TurnId, number> {
diff --git a/apps/web/src/store.test.ts b/apps/web/src/store.test.ts
index db62bad52..6e909b38f 100644
--- a/apps/web/src/store.test.ts
+++ b/apps/web/src/store.test.ts
@@ -1,13 +1,22 @@
import {
+ CheckpointRef,
DEFAULT_MODEL_BY_PROVIDER,
+ EventId,
+ MessageId,
ProjectId,
ThreadId,
TurnId,
+ type OrchestrationEvent,
type OrchestrationReadModel,
} from "@t3tools/contracts";
import { describe, expect, it } from "vitest";
-import { markThreadUnread, reorderProjects, syncServerReadModel, type AppState } from "./store";
+import {
+ applyOrchestrationEvent,
+ applyOrchestrationEvents,
+ syncServerReadModel,
+ type AppState,
+} from "./store";
import { DEFAULT_INTERACTION_MODE, DEFAULT_RUNTIME_MODE, type Thread } from "./types";
function makeThread(overrides: Partial<Thread> = {}): Thread {
@@ -48,15 +57,41 @@ function makeState(thread: Thread): AppState {
provider: "codex",
model: "gpt-5-codex",
},
- expanded: true,
scripts: [],
},
],
threads: [thread],
- threadsHydrated: true,
+ bootstrapComplete: true,
};
}
+function makeEvent<T extends OrchestrationEvent["type"]>(
+ type: T,
+ payload: Extract<OrchestrationEvent, { type: T }>["payload"],
+ overrides: Partial<Extract<OrchestrationEvent, { type: T }>> = {},
+): Extract<OrchestrationEvent, { type: T }> {
+ const sequence = overrides.sequence ?? 1;
+ return {
+ sequence,
+ eventId: EventId.makeUnsafe(`event-${sequence}`),
+ aggregateKind: "thread",
+ aggregateId:
+ "threadId" in payload
+ ? payload.threadId
+ : "projectId" in payload
+ ? payload.projectId
+ : ProjectId.makeUnsafe("project-1"),
+ occurredAt: "2026-02-27T00:00:00.000Z",
+ commandId: null,
+ causationEventId: null,
+ correlationId: null,
+ metadata: {},
+ type,
+ payload,
+ ...overrides,
+ } as Extract<OrchestrationEvent, { type: T }>;
+}
+
function makeReadModelThread(overrides: Partial<OrchestrationReadModel["threads"][number]>) {
return {
id: ThreadId.makeUnsafe("thread-1"),
@@ -126,97 +161,18 @@ function makeReadModelProject(
};
}
-describe("store pure functions", () => {
- it("markThreadUnread moves lastVisitedAt before completion for a completed thread", () => {
- const latestTurnCompletedAt = "2026-02-25T12:30:00.000Z";
- const initialState = makeState(
- makeThread({
- latestTurn: {
- turnId: TurnId.makeUnsafe("turn-1"),
- state: "completed",
- requestedAt: "2026-02-25T12:28:00.000Z",
- startedAt: "2026-02-25T12:28:30.000Z",
- completedAt: latestTurnCompletedAt,
- assistantMessageId: null,
- },
- lastVisitedAt: "2026-02-25T12:35:00.000Z",
- }),
- );
-
- const next = markThreadUnread(initialState, ThreadId.makeUnsafe("thread-1"));
-
- const updatedThread = next.threads[0];
- expect(updatedThread).toBeDefined();
- expect(updatedThread?.lastVisitedAt).toBe("2026-02-25T12:29:59.999Z");
- expect(Date.parse(updatedThread?.lastVisitedAt ?? "")).toBeLessThan(
- Date.parse(latestTurnCompletedAt),
- );
- });
-
- it("markThreadUnread does not change a thread without a completed turn", () => {
- const initialState = makeState(
- makeThread({
- latestTurn: null,
- lastVisitedAt: "2026-02-25T12:35:00.000Z",
- }),
- );
-
- const next = markThreadUnread(initialState, ThreadId.makeUnsafe("thread-1"));
-
- expect(next).toEqual(initialState);
- });
-
- it("reorderProjects moves a project to a target index", () => {
- const project1 = ProjectId.makeUnsafe("project-1");
- const project2 = ProjectId.makeUnsafe("project-2");
- const project3 = ProjectId.makeUnsafe("project-3");
- const state: AppState = {
- projects: [
- {
- id: project1,
- name: "Project 1",
- cwd: "/tmp/project-1",
- defaultModelSelection: {
- provider: "codex",
- model: DEFAULT_MODEL_BY_PROVIDER.codex,
- },
- expanded: true,
- scripts: [],
- },
- {
- id: project2,
- name: "Project 2",
- cwd: "/tmp/project-2",
- defaultModelSelection: {
- provider: "codex",
- model: DEFAULT_MODEL_BY_PROVIDER.codex,
- },
- expanded: true,
- scripts: [],
- },
- {
- id: project3,
- name: "Project 3",
- cwd: "/tmp/project-3",
- defaultModelSelection: {
- provider: "codex",
- model: DEFAULT_MODEL_BY_PROVIDER.codex,
- },
- expanded: true,
- scripts: [],
- },
- ],
- threads: [],
- threadsHydrated: true,
+describe("store read model sync", () => {
+ it("marks bootstrap complete after snapshot sync", () => {
+ const initialState: AppState = {
+ ...makeState(makeThread()),
+ bootstrapComplete: false,
};
- const next = reorderProjects(state, project1, project3);
+ const next = syncServerReadModel(initialState, makeReadModel(makeReadModelThread({})));
- expect(next.projects.map((project) => project.id)).toEqual([project2, project3, project1]);
+ expect(next.bootstrapComplete).toBe(true);
});
-});
-describe("store read model sync", () => {
it("preserves claude model slugs without an active session", () => {
const initialState = makeState(makeThread());
const readModel = makeReadModel(
@@ -287,7 +243,7 @@ describe("store read model sync", () => {
expect(next.threads[0]?.archivedAt).toBe(archivedAt);
});
- it("preserves the current project order when syncing incoming read model updates", () => {
+ it("replaces projects using snapshot order during recovery", () => {
const project1 = ProjectId.makeUnsafe("project-1");
const project2 = ProjectId.makeUnsafe("project-2");
const project3 = ProjectId.makeUnsafe("project-3");
@@ -301,7 +257,6 @@ describe("store read model sync", () => {
provider: "codex",
model: DEFAULT_MODEL_BY_PROVIDER.codex,
},
- expanded: true,
scripts: [],
},
{
@@ -312,12 +267,11 @@ describe("store read model sync", () => {
provider: "codex",
model: DEFAULT_MODEL_BY_PROVIDER.codex,
},
- expanded: true,
scripts: [],
},
],
threads: [],
- threadsHydrated: true,
+ bootstrapComplete: true,
};
const readModel: OrchestrationReadModel = {
snapshotSequence: 2,
@@ -344,6 +298,446 @@ describe("store read model sync", () => {
const next = syncServerReadModel(initialState, readModel);
- expect(next.projects.map((project) => project.id)).toEqual([project2, project1, project3]);
+ expect(next.projects.map((project) => project.id)).toEqual([project1, project2, project3]);
+ });
+});
+
+describe("incremental orchestration updates", () => {
+ it("does not mark bootstrap complete for incremental events", () => {
+ const state: AppState = {
+ ...makeState(makeThread()),
+ bootstrapComplete: false,
+ };
+
+ const next = applyOrchestrationEvent(
+ state,
+ makeEvent("thread.meta-updated", {
+ threadId: ThreadId.makeUnsafe("thread-1"),
+ title: "Updated title",
+ updatedAt: "2026-02-27T00:00:01.000Z",
+ }),
+ );
+
+ expect(next.bootstrapComplete).toBe(false);
+ });
+
+ it("preserves state identity for no-op project and thread deletes", () => {
+ const thread = makeThread();
+ const state = makeState(thread);
+
+ const nextAfterProjectDelete = applyOrchestrationEvent(
+ state,
+ makeEvent("project.deleted", {
+ projectId: ProjectId.makeUnsafe("project-missing"),
+ deletedAt: "2026-02-27T00:00:01.000Z",
+ }),
+ );
+ const nextAfterThreadDelete = applyOrchestrationEvent(
+ state,
+ makeEvent("thread.deleted", {
+ threadId: ThreadId.makeUnsafe("thread-missing"),
+ deletedAt: "2026-02-27T00:00:01.000Z",
+ }),
+ );
+
+ expect(nextAfterProjectDelete).toBe(state);
+ expect(nextAfterThreadDelete).toBe(state);
+ });
+
+ it("reuses an existing project row when project.created arrives with a new id for the same cwd", () => {
+ const originalProjectId = ProjectId.makeUnsafe("project-1");
+ const recreatedProjectId = ProjectId.makeUnsafe("project-2");
+ const state: AppState = {
+ projects: [
+ {
+ id: originalProjectId,
+ name: "Project",
+ cwd: "/tmp/project",
+ defaultModelSelection: {
+ provider: "codex",
+ model: DEFAULT_MODEL_BY_PROVIDER.codex,
+ },
+ scripts: [],
+ },
+ ],
+ threads: [],
+ bootstrapComplete: true,
+ };
+
+ const next = applyOrchestrationEvent(
+ state,
+ makeEvent("project.created", {
+ projectId: recreatedProjectId,
+ title: "Project Recreated",
+ workspaceRoot: "/tmp/project",
+ defaultModelSelection: {
+ provider: "codex",
+ model: DEFAULT_MODEL_BY_PROVIDER.codex,
+ },
+ scripts: [],
+ createdAt: "2026-02-27T00:00:01.000Z",
+ updatedAt: "2026-02-27T00:00:01.000Z",
+ }),
+ );
+
+ expect(next.projects).toHaveLength(1);
+ expect(next.projects[0]?.id).toBe(recreatedProjectId);
+ expect(next.projects[0]?.cwd).toBe("/tmp/project");
+ expect(next.projects[0]?.name).toBe("Project Recreated");
+ });
+
+ it("updates only the affected thread for message events", () => {
+ const thread1 = makeThread({
+ id: ThreadId.makeUnsafe("thread-1"),
+ messages: [
+ {
+ id: MessageId.makeUnsafe("message-1"),
+ role: "assistant",
+ text: "hello",
+ turnId: TurnId.makeUnsafe("turn-1"),
+ createdAt: "2026-02-27T00:00:00.000Z",
+ completedAt: "2026-02-27T00:00:00.000Z",
+ streaming: false,
+ },
+ ],
+ });
+ const thread2 = makeThread({ id: ThreadId.makeUnsafe("thread-2") });
+ const state: AppState = {
+ ...makeState(thread1),
+ threads: [thread1, thread2],
+ };
+
+ const next = applyOrchestrationEvent(
+ state,
+ makeEvent("thread.message-sent", {
+ threadId: thread1.id,
+ messageId: MessageId.makeUnsafe("message-1"),
+ role: "assistant",
+ text: " world",
+ turnId: TurnId.makeUnsafe("turn-1"),
+ streaming: true,
+ createdAt: "2026-02-27T00:00:01.000Z",
+ updatedAt: "2026-02-27T00:00:01.000Z",
+ }),
+ );
+
+ expect(next.threads[0]?.messages[0]?.text).toBe("hello world");
+ expect(next.threads[0]?.latestTurn?.state).toBe("running");
+ expect(next.threads[1]).toBe(thread2);
+ });
+
+ it("applies replay batches in sequence and updates session state", () => {
+ const thread = makeThread({
+ latestTurn: {
+ turnId: TurnId.makeUnsafe("turn-1"),
+ state: "running",
+ requestedAt: "2026-02-27T00:00:00.000Z",
+ startedAt: "2026-02-27T00:00:00.000Z",
+ completedAt: null,
+ assistantMessageId: null,
+ },
+ });
+ const state = makeState(thread);
+
+ const next = applyOrchestrationEvents(state, [
+ makeEvent(
+ "thread.session-set",
+ {
+ threadId: thread.id,
+ session: {
+ threadId: thread.id,
+ status: "running",
+ providerName: "codex",
+ runtimeMode: "full-access",
+ activeTurnId: TurnId.makeUnsafe("turn-1"),
+ lastError: null,
+ updatedAt: "2026-02-27T00:00:02.000Z",
+ },
+ },
+ { sequence: 2 },
+ ),
+ makeEvent(
+ "thread.message-sent",
+ {
+ threadId: thread.id,
+ messageId: MessageId.makeUnsafe("assistant-1"),
+ role: "assistant",
+ text: "done",
+ turnId: TurnId.makeUnsafe("turn-1"),
+ streaming: false,
+ createdAt: "2026-02-27T00:00:03.000Z",
+ updatedAt: "2026-02-27T00:00:03.000Z",
+ },
+ { sequence: 3 },
+ ),
+ ]);
+
+ expect(next.threads[0]?.session?.status).toBe("running");
+ expect(next.threads[0]?.latestTurn?.state).toBe("completed");
+ expect(next.threads[0]?.messages).toHaveLength(1);
+ });
+
+ it("does not regress latestTurn when an older turn diff completes late", () => {
+ const state = makeState(
+ makeThread({
+ latestTurn: {
+ turnId: TurnId.makeUnsafe("turn-2"),
+ state: "running",
+ requestedAt: "2026-02-27T00:00:02.000Z",
+ startedAt: "2026-02-27T00:00:03.000Z",
+ completedAt: null,
+ assistantMessageId: null,
+ },
+ }),
+ );
+
+ const next = applyOrchestrationEvent(
+ state,
+ makeEvent("thread.turn-diff-completed", {
+ threadId: ThreadId.makeUnsafe("thread-1"),
+ turnId: TurnId.makeUnsafe("turn-1"),
+ checkpointTurnCount: 1,
+ checkpointRef: CheckpointRef.makeUnsafe("checkpoint-1"),
+ status: "ready",
+ files: [],
+ assistantMessageId: MessageId.makeUnsafe("assistant-1"),
+ completedAt: "2026-02-27T00:00:04.000Z",
+ }),
+ );
+
+ expect(next.threads[0]?.turnDiffSummaries).toHaveLength(1);
+ expect(next.threads[0]?.latestTurn).toEqual(state.threads[0]?.latestTurn);
+ });
+
+ it("rebinds live turn diffs to the authoritative assistant message when it arrives later", () => {
+ const turnId = TurnId.makeUnsafe("turn-1");
+ const state = makeState(
+ makeThread({
+ latestTurn: {
+ turnId,
+ state: "completed",
+ requestedAt: "2026-02-27T00:00:00.000Z",
+ startedAt: "2026-02-27T00:00:00.000Z",
+ completedAt: "2026-02-27T00:00:02.000Z",
+ assistantMessageId: MessageId.makeUnsafe("assistant:turn-1"),
+ },
+ turnDiffSummaries: [
+ {
+ turnId,
+ completedAt: "2026-02-27T00:00:02.000Z",
+ status: "ready",
+ checkpointTurnCount: 1,
+ checkpointRef: CheckpointRef.makeUnsafe("checkpoint-1"),
+ assistantMessageId: MessageId.makeUnsafe("assistant:turn-1"),
+ files: [{ path: "src/app.ts", additions: 1, deletions: 0 }],
+ },
+ ],
+ }),
+ );
+
+ const next = applyOrchestrationEvent(
+ state,
+ makeEvent("thread.message-sent", {
+ threadId: ThreadId.makeUnsafe("thread-1"),
+ messageId: MessageId.makeUnsafe("assistant-real"),
+ role: "assistant",
+ text: "final answer",
+ turnId,
+ streaming: false,
+ createdAt: "2026-02-27T00:00:03.000Z",
+ updatedAt: "2026-02-27T00:00:03.000Z",
+ }),
+ );
+
+ expect(next.threads[0]?.turnDiffSummaries[0]?.assistantMessageId).toBe(
+ MessageId.makeUnsafe("assistant-real"),
+ );
+ expect(next.threads[0]?.latestTurn?.assistantMessageId).toBe(
+ MessageId.makeUnsafe("assistant-real"),
+ );
+ });
+
+ it("reverts messages, plans, activities, and checkpoints by retained turns", () => {
+ const state = makeState(
+ makeThread({
+ messages: [
+ {
+ id: MessageId.makeUnsafe("user-1"),
+ role: "user",
+ text: "first",
+ turnId: TurnId.makeUnsafe("turn-1"),
+ createdAt: "2026-02-27T00:00:00.000Z",
+ completedAt: "2026-02-27T00:00:00.000Z",
+ streaming: false,
+ },
+ {
+ id: MessageId.makeUnsafe("assistant-1"),
+ role: "assistant",
+ text: "first reply",
+ turnId: TurnId.makeUnsafe("turn-1"),
+ createdAt: "2026-02-27T00:00:01.000Z",
+ completedAt: "2026-02-27T00:00:01.000Z",
+ streaming: false,
+ },
+ {
+ id: MessageId.makeUnsafe("user-2"),
+ role: "user",
+ text: "second",
+ turnId: TurnId.makeUnsafe("turn-2"),
+ createdAt: "2026-02-27T00:00:02.000Z",
+ completedAt: "2026-02-27T00:00:02.000Z",
+ streaming: false,
+ },
+ ],
+ proposedPlans: [
+ {
+ id: "plan-1",
+ turnId: TurnId.makeUnsafe("turn-1"),
+ planMarkdown: "plan 1",
+ implementedAt: null,
+ implementationThreadId: null,
+ createdAt: "2026-02-27T00:00:00.000Z",
+ updatedAt: "2026-02-27T00:00:00.000Z",
+ },
+ {
+ id: "plan-2",
+ turnId: TurnId.makeUnsafe("turn-2"),
+ planMarkdown: "plan 2",
+ implementedAt: null,
+ implementationThreadId: null,
+ createdAt: "2026-02-27T00:00:02.000Z",
+ updatedAt: "2026-02-27T00:00:02.000Z",
+ },
+ ],
+ activities: [
+ {
+ id: EventId.makeUnsafe("activity-1"),
+ tone: "info",
+ kind: "step",
+ summary: "one",
+ payload: {},
+ turnId: TurnId.makeUnsafe("turn-1"),
+ createdAt: "2026-02-27T00:00:00.000Z",
+ },
+ {
+ id: EventId.makeUnsafe("activity-2"),
+ tone: "info",
+ kind: "step",
+ summary: "two",
+ payload: {},
+ turnId: TurnId.makeUnsafe("turn-2"),
+ createdAt: "2026-02-27T00:00:02.000Z",
+ },
+ ],
+ turnDiffSummaries: [
+ {
+ turnId: TurnId.makeUnsafe("turn-1"),
+ completedAt: "2026-02-27T00:00:01.000Z",
+ status: "ready",
+ checkpointTurnCount: 1,
+ checkpointRef: CheckpointRef.makeUnsafe("ref-1"),
+ files: [],
+ },
+ {
+ turnId: TurnId.makeUnsafe("turn-2"),
+ completedAt: "2026-02-27T00:00:03.000Z",
+ status: "ready",
+ checkpointTurnCount: 2,
+ checkpointRef: CheckpointRef.makeUnsafe("ref-2"),
+ files: [],
+ },
+ ],
+ }),
+ );
+
+ const next = applyOrchestrationEvent(
+ state,
+ makeEvent("thread.reverted", {
+ threadId: ThreadId.makeUnsafe("thread-1"),
+ turnCount: 1,
+ }),
+ );
+
+ expect(next.threads[0]?.messages.map((message) => message.id)).toEqual([
+ "user-1",
+ "assistant-1",
+ ]);
+ expect(next.threads[0]?.proposedPlans.map((plan) => plan.id)).toEqual(["plan-1"]);
+ expect(next.threads[0]?.activities.map((activity) => activity.id)).toEqual([
+ EventId.makeUnsafe("activity-1"),
+ ]);
+ expect(next.threads[0]?.turnDiffSummaries.map((summary) => summary.turnId)).toEqual([
+ TurnId.makeUnsafe("turn-1"),
+ ]);
+ });
+
+ it("clears pending source proposed plans after revert before a new session-set event", () => {
+ const thread = makeThread({
+ latestTurn: {
+ turnId: TurnId.makeUnsafe("turn-2"),
+ state: "completed",
+ requestedAt: "2026-02-27T00:00:02.000Z",
+ startedAt: "2026-02-27T00:00:02.000Z",
+ completedAt: "2026-02-27T00:00:03.000Z",
+ assistantMessageId: MessageId.makeUnsafe("assistant-2"),
+ sourceProposedPlan: {
+ threadId: ThreadId.makeUnsafe("thread-source"),
+ planId: "plan-2" as never,
+ },
+ },
+ pendingSourceProposedPlan: {
+ threadId: ThreadId.makeUnsafe("thread-source"),
+ planId: "plan-2" as never,
+ },
+ turnDiffSummaries: [
+ {
+ turnId: TurnId.makeUnsafe("turn-1"),
+ completedAt: "2026-02-27T00:00:01.000Z",
+ status: "ready",
+ checkpointTurnCount: 1,
+ checkpointRef: CheckpointRef.makeUnsafe("ref-1"),
+ files: [],
+ },
+ {
+ turnId: TurnId.makeUnsafe("turn-2"),
+ completedAt: "2026-02-27T00:00:03.000Z",
+ status: "ready",
+ checkpointTurnCount: 2,
+ checkpointRef: CheckpointRef.makeUnsafe("ref-2"),
+ files: [],
+ },
+ ],
+ });
+ const reverted = applyOrchestrationEvent(
+ makeState(thread),
+ makeEvent("thread.reverted", {
+ threadId: thread.id,
+ turnCount: 1,
+ }),
+ );
+
+ expect(reverted.threads[0]?.pendingSourceProposedPlan).toBeUndefined();
+
+ const next = applyOrchestrationEvent(
+ reverted,
+ makeEvent("thread.session-set", {
+ threadId: thread.id,
+ session: {
+ threadId: thread.id,
+ status: "running",
+ providerName: "codex",
+ runtimeMode: "full-access",
+ activeTurnId: TurnId.makeUnsafe("turn-3"),
+ lastError: null,
+ updatedAt: "2026-02-27T00:00:04.000Z",
+ },
+ }),
+ );
+
+ expect(next.threads[0]?.latestTurn).toMatchObject({
+ turnId: TurnId.makeUnsafe("turn-3"),
+ state: "running",
+ });
+ expect(next.threads[0]?.latestTurn?.sourceProposedPlan).toBeUndefined();
});
});
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
index a5beb5b1b..eff6a6fd0 100644
--- a/apps/web/src/store.ts
+++ b/apps/web/src/store.ts
@@ -1,98 +1,36 @@
-import { Fragment, type ReactNode, createElement, useEffect } from "react";
import {
+ type OrchestrationEvent,
+ type OrchestrationMessage,
+ type OrchestrationProposedPlan,
type ProviderKind,
ThreadId,
type OrchestrationReadModel,
+ type OrchestrationSession,
+ type OrchestrationCheckpointSummary,
+ type OrchestrationThread,
type OrchestrationSessionStatus,
} from "@t3tools/contracts";
import { resolveModelSlugForProvider } from "@t3tools/shared/model";
import { create } from "zustand";
import { type ChatMessage, type Project, type Thread } from "./types";
-import { Debouncer } from "@tanstack/react-pacer";
// ── State ────────────────────────────────────────────────────────────
export interface AppState {
projects: Project[];
threads: Thread[];
- threadsHydrated: boolean;
+ bootstrapComplete: boolean;
}
-const PERSISTED_STATE_KEY = "t3code:renderer-state:v8";
-const LEGACY_PERSISTED_STATE_KEYS = [
- "t3code:renderer-state:v7",
- "t3code:renderer-state:v6",
- "t3code:renderer-state:v5",
- "t3code:renderer-state:v4",
- "t3code:renderer-state:v3",
- "codething:renderer-state:v4",
- "codething:renderer-state:v3",
- "codething:renderer-state:v2",
- "codething:renderer-state:v1",
-] as const;
-
const initialState: AppState = {
projects: [],
threads: [],
- threadsHydrated: false,
+ bootstrapComplete: false,
};
-const persistedExpandedProjectCwds = new Set<string>();
-const persistedProjectOrderCwds: string[] = [];
-
-// ── Persist helpers ──────────────────────────────────────────────────
-
-function readPersistedState(): AppState {
- if (typeof window === "undefined") return initialState;
- try {
- const raw = window.localStorage.getItem(PERSISTED_STATE_KEY);
- if (!raw) return initialState;
- const parsed = JSON.parse(raw) as {
- expandedProjectCwds?: string[];
- projectOrderCwds?: string[];
- };
- persistedExpandedProjectCwds.clear();
- persistedProjectOrderCwds.length = 0;
- for (const cwd of parsed.expandedProjectCwds ?? []) {
- if (typeof cwd === "string" && cwd.length > 0) {
- persistedExpandedProjectCwds.add(cwd);
- }
- }
- for (const cwd of parsed.projectOrderCwds ?? []) {
- if (typeof cwd === "string" && cwd.length > 0 && !persistedProjectOrderCwds.includes(cwd)) {
- persistedProjectOrderCwds.push(cwd);
- }
- }
- return { ...initialState };
- } catch {
- return initialState;
- }
-}
-
-let legacyKeysCleanedUp = false;
-
-function persistState(state: AppState): void {
- if (typeof window === "undefined") return;
- try {
- window.localStorage.setItem(
- PERSISTED_STATE_KEY,
- JSON.stringify({
- expandedProjectCwds: state.projects
- .filter((project) => project.expanded)
- .map((project) => project.cwd),
- projectOrderCwds: state.projects.map((project) => project.cwd),
- }),
- );
- if (!legacyKeysCleanedUp) {
- legacyKeysCleanedUp = true;
- for (const legacyKey of LEGACY_PERSISTED_STATE_KEYS) {
- window.localStorage.removeItem(legacyKey);
- }
- }
- } catch {
- // Ignore quota/storage errors to avoid breaking chat UX.
- }
-}
-const debouncedPersistState = new Debouncer(persistState, { wait: 500 });
+const MAX_THREAD_MESSAGES = 2_000;
+const MAX_THREAD_CHECKPOINTS = 500;
+const MAX_THREAD_PROPOSED_PLANS = 200;
+const MAX_THREAD_ACTIVITIES = 500;
// ── Pure helpers ──────────────────────────────────────────────────────
@@ -111,66 +49,295 @@ function updateThread(
return changed ? next : threads;
}
-function mapProjectsFromReadModel(
- incoming: OrchestrationReadModel["projects"],
- previous: Project[],
+function updateProject(
+ projects: Project[],
+ projectId: Project["id"],
+ updater: (project: Project) => Project,
): Project[] {
- const previousById = new Map(previous.map((project) => [project.id, project] as const));
- const previousByCwd = new Map(previous.map((project) => [project.cwd, project] as const));
- const previousOrderById = new Map(previous.map((project, index) => [project.id, index] as const));
- const previousOrderByCwd = new Map(
- previous.map((project, index) => [project.cwd, index] as const),
- );
- const persistedOrderByCwd = new Map(
- persistedProjectOrderCwds.map((cwd, index) => [cwd, index] as const),
- );
- const usePersistedOrder = previous.length === 0;
+ let changed = false;
+ const next = projects.map((project) => {
+ if (project.id !== projectId) {
+ return project;
+ }
+ const updated = updater(project);
+ if (updated !== project) {
+ changed = true;
+ }
+ return updated;
+ });
+ return changed ? next : projects;
+}
+
+function normalizeModelSelection<T extends { provider: "codex" | "claudeAgent"; model: string }>(
+ selection: T,
+): T {
+ return {
+ ...selection,
+ model: resolveModelSlugForProvider(selection.provider, selection.model),
+ };
+}
- const mappedProjects = incoming.map((project) => {
- const existing = previousById.get(project.id) ?? previousByCwd.get(project.workspaceRoot);
+function mapProjectScripts(scripts: ReadonlyArray<Project["scripts"][number]>): Project["scripts"] {
+ return scripts.map((script) => ({ ...script }));
+}
+
+function mapSession(session: OrchestrationSession): Thread["session"] {
+ return {
+ provider: toLegacyProvider(session.providerName),
+ status: toLegacySessionStatus(session.status),
+ orchestrationStatus: session.status,
+ activeTurnId: session.activeTurnId ?? undefined,
+ createdAt: session.updatedAt,
+ updatedAt: session.updatedAt,
+ ...(session.lastError ? { lastError: session.lastError } : {}),
+ };
+}
+
+function mapMessage(message: OrchestrationMessage): ChatMessage {
+ const attachments = message.attachments?.map((attachment) => ({
+ type: "image" as const,
+ id: attachment.id,
+ name: attachment.name,
+ mimeType: attachment.mimeType,
+ sizeBytes: attachment.sizeBytes,
+ previewUrl: toAttachmentPreviewUrl(attachmentPreviewRoutePath(attachment.id)),
+ }));
+
+ return {
+ id: message.id,
+ role: message.role,
+ text: message.text,
+ turnId: message.turnId,
+ createdAt: message.createdAt,
+ streaming: message.streaming,
+ ...(message.streaming ? {} : { completedAt: message.updatedAt }),
+ ...(attachments && attachments.length > 0 ? { attachments } : {}),
+ };
+}
+
+function mapProposedPlan(proposedPlan: OrchestrationProposedPlan): Thread["proposedPlans"][number] {
+ return {
+ id: proposedPlan.id,
+ turnId: proposedPlan.turnId,
+ planMarkdown: proposedPlan.planMarkdown,
+ implementedAt: proposedPlan.implementedAt,
+ implementationThreadId: proposedPlan.implementationThreadId,
+ createdAt: proposedPlan.createdAt,
+ updatedAt: proposedPlan.updatedAt,
+ };
+}
+
+function mapTurnDiffSummary(
+ checkpoint: OrchestrationCheckpointSummary,
+): Thread["turnDiffSummaries"][number] {
+ return {
+ turnId: checkpoint.turnId,
+ completedAt: checkpoint.completedAt,
+ status: checkpoint.status,
+ assistantMessageId: checkpoint.assistantMessageId ?? undefined,
+ checkpointTurnCount: checkpoint.checkpointTurnCount,
+ checkpointRef: checkpoint.checkpointRef,
+ files: checkpoint.files.map((file) => ({ ...file })),
+ };
+}
+
+function mapThread(thread: OrchestrationThread): Thread {
+ return {
+ id: thread.id,
+ codexThreadId: null,
+ projectId: thread.projectId,
+ title: thread.title,
+ modelSelection: normalizeModelSelection(thread.modelSelection),
+ runtimeMode: thread.runtimeMode,
+ interactionMode: thread.interactionMode,
+ session: thread.session ? mapSession(thread.session) : null,
+ messages: thread.messages.map(mapMessage),
+ proposedPlans: thread.proposedPlans.map(mapProposedPlan),
+ error: thread.session?.lastError ?? null,
+ createdAt: thread.createdAt,
+ archivedAt: thread.archivedAt,
+ updatedAt: thread.updatedAt,
+ latestTurn: thread.latestTurn,
+ pendingSourceProposedPlan: thread.latestTurn?.sourceProposedPlan,
+ branch: thread.branch,
+ worktreePath: thread.worktreePath,
+ turnDiffSummaries: thread.checkpoints.map(mapTurnDiffSummary),
+ activities: thread.activities.map((activity) => ({ ...activity })),
+ };
+}
+
+function mapProject(project: OrchestrationReadModel["projects"][number]): Project {
+ return {
+ id: project.id,
+ name: project.title,
+ cwd: project.workspaceRoot,
+ defaultModelSelection: project.defaultModelSelection
+ ? normalizeModelSelection(project.defaultModelSelection)
+ : null,
+ createdAt: project.createdAt,
+ updatedAt: project.updatedAt,
+ scripts: mapProjectScripts(project.scripts),
+ };
+}
+
+function checkpointStatusToLatestTurnState(status: "ready" | "missing" | "error") {
+ if (status === "error") {
+ return "error" as const;
+ }
+ if (status === "missing") {
+ return "interrupted" as const;
+ }
+ return "completed" as const;
+}
+
+function compareActivities(
+ left: Thread["activities"][number],
+ right: Thread["activities"][number],
+): number {
+ if (left.sequence !== undefined && right.sequence !== undefined) {
+ if (left.sequence !== right.sequence) {
+ return left.sequence - right.sequence;
+ }
+ } else if (left.sequence !== undefined) {
+ return 1;
+ } else if (right.sequence !== undefined) {
+ return -1;
+ }
+
+ return left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id);
+}
+
+function buildLatestTurn(params: {
+ previous: Thread["latestTurn"];
+ turnId: NonNullable<Thread["latestTurn"]>["turnId"];
+ state: NonNullable<Thread["latestTurn"]>["state"];
+ requestedAt: string;
+ startedAt: string | null;
+ completedAt: string | null;
+ assistantMessageId: NonNullable<Thread["latestTurn"]>["assistantMessageId"];
+ sourceProposedPlan?: Thread["pendingSourceProposedPlan"];
+}): NonNullable<Thread["latestTurn"]> {
+ const resolvedPlan =
+ params.previous?.turnId === params.turnId
+ ? params.previous.sourceProposedPlan
+ : params.sourceProposedPlan;
+ return {
+ turnId: params.turnId,
+ state: params.state,
+ requestedAt: params.requestedAt,
+ startedAt: params.startedAt,
+ completedAt: params.completedAt,
+ assistantMessageId: params.assistantMessageId,
+ ...(resolvedPlan ? { sourceProposedPlan: resolvedPlan } : {}),
+ };
+}
+
+function rebindTurnDiffSummariesForAssistantMessage(
+ turnDiffSummaries: ReadonlyArray<Thread["turnDiffSummaries"][number]>,
+ turnId: Thread["turnDiffSummaries"][number]["turnId"],
+ assistantMessageId: NonNullable<Thread["latestTurn"]>["assistantMessageId"],
+): Thread["turnDiffSummaries"] {
+ let changed = false;
+ const nextSummaries = turnDiffSummaries.map((summary) => {
+ if (summary.turnId !== turnId || summary.assistantMessageId === assistantMessageId) {
+ return summary;
+ }
+ changed = true;
return {
- id: project.id,
- name: project.title,
- cwd: project.workspaceRoot,
- defaultModelSelection:
- existing?.defaultModelSelection ??
- (project.defaultModelSelection
- ? {
- ...project.defaultModelSelection,
- model: resolveModelSlugForProvider(
- project.defaultModelSelection.provider,
- project.defaultModelSelection.model,
- ),
- }
- : null),
- expanded:
- existing?.expanded ??
- (persistedExpandedProjectCwds.size > 0
- ? persistedExpandedProjectCwds.has(project.workspaceRoot)
- : true),
- createdAt: project.createdAt,
- updatedAt: project.updatedAt,
- scripts: project.scripts.map((script) => ({ ...script })),
- } satisfies Project;
+ ...summary,
+ assistantMessageId: assistantMessageId ?? undefined,
+ };
});
+ return changed ? nextSummaries : [...turnDiffSummaries];
+}
+
+function retainThreadMessagesAfterRevert(
+ messages: ReadonlyArray<ChatMessage>,
+ retainedTurnIds: ReadonlySet<string>,
+ turnCount: number,
+): ChatMessage[] {
+ const retainedMessageIds = new Set<string>();
+ for (const message of messages) {
+ if (message.role === "system") {
+ retainedMessageIds.add(message.id);
+ continue;
+ }
+ if (
+ message.turnId !== undefined &&
+ message.turnId !== null &&
+ retainedTurnIds.has(message.turnId)
+ ) {
+ retainedMessageIds.add(message.id);
+ }
+ }
+
+ const retainedUserCount = messages.filter(
+ (message) => message.role === "user" && retainedMessageIds.has(message.id),
+ ).length;
+ const missingUserCount = Math.max(0, turnCount - retainedUserCount);
+ if (missingUserCount > 0) {
+ const fallbackUserMessages = messages
+ .filter(
+ (message) =>
+ message.role === "user" &&
+ !retainedMessageIds.has(message.id) &&
+ (message.turnId === undefined ||
+ message.turnId === null ||
+ retainedTurnIds.has(message.turnId)),
+ )
+ .toSorted(
+ (left, right) =>
+ left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id),
+ )
+ .slice(0, missingUserCount);
+ for (const message of fallbackUserMessages) {
+ retainedMessageIds.add(message.id);
+ }
+ }
+
+ const retainedAssistantCount = messages.filter(
+ (message) => message.role === "assistant" && retainedMessageIds.has(message.id),
+ ).length;
+ const missingAssistantCount = Math.max(0, turnCount - retainedAssistantCount);
+ if (missingAssistantCount > 0) {
+ const fallbackAssistantMessages = messages
+ .filter(
+ (message) =>
+ message.role === "assistant" &&
+ !retainedMessageIds.has(message.id) &&
+ (message.turnId === undefined ||
+ message.turnId === null ||
+ retainedTurnIds.has(message.turnId)),
+ )
+ .toSorted(
+ (left, right) =>
+ left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id),
+ )
+ .slice(0, missingAssistantCount);
+ for (const message of fallbackAssistantMessages) {
+ retainedMessageIds.add(message.id);
+ }
+ }
+
+ return messages.filter((message) => retainedMessageIds.has(message.id));
+}
+
+function retainThreadActivitiesAfterRevert(
+ activities: ReadonlyArray<Thread["activities"][number]>,
+ retainedTurnIds: ReadonlySet<string>,
+): Thread["activities"] {
+ return activities.filter(
+ (activity) => activity.turnId === null || retainedTurnIds.has(activity.turnId),
+ );
+}
- return mappedProjects
- .map((project, incomingIndex) => {
- const previousIndex =
- previousOrderById.get(project.id) ?? previousOrderByCwd.get(project.cwd);
- const persistedIndex = usePersistedOrder ? persistedOrderByCwd.get(project.cwd) : undefined;
- const orderIndex =
- previousIndex ??
- persistedIndex ??
- (usePersistedOrder ? persistedProjectOrderCwds.length : previous.length) + incomingIndex;
- return { project, incomingIndex, orderIndex };
- })
- .toSorted((a, b) => {
- const byOrder = a.orderIndex - b.orderIndex;
- if (byOrder !== 0) return byOrder;
- return a.incomingIndex - b.incomingIndex;
- })
- .map((entry) => entry.project);
+function retainThreadProposedPlansAfterRevert(
+ proposedPlans: ReadonlyArray<Thread["proposedPlans"][number]>,
+ retainedTurnIds: ReadonlySet<string>,
+): Thread["proposedPlans"] {
+ return proposedPlans.filter(
+ (proposedPlan) => proposedPlan.turnId === null || retainedTurnIds.has(proposedPlan.turnId),
+ );
}
function toLegacySessionStatus(
@@ -234,167 +401,506 @@ function attachmentPreviewRoutePath(attachmentId: string): string {
// ── Pure state transition functions ────────────────────────────────────
export function syncServerReadModel(state: AppState, readModel: OrchestrationReadModel): AppState {
- const projects = mapProjectsFromReadModel(
- readModel.projects.filter((project) => project.deletedAt === null),
- state.projects,
- );
- const existingThreadById = new Map(state.threads.map((thread) => [thread.id, thread] as const));
- const threads = readModel.threads
- .filter((thread) => thread.deletedAt === null)
- .map((thread) => {
- const existing = existingThreadById.get(thread.id);
- return {
- id: thread.id,
- codexThreadId: null,
- projectId: thread.projectId,
- title: thread.title,
- modelSelection: {
- ...thread.modelSelection,
- model: resolveModelSlugForProvider(
- thread.modelSelection.provider,
- thread.modelSelection.model,
- ),
- },
- runtimeMode: thread.runtimeMode,
- interactionMode: thread.interactionMode,
- session: thread.session
- ? {
- provider: toLegacyProvider(thread.session.providerName),
- status: toLegacySessionStatus(thread.session.status),
- orchestrationStatus: thread.session.status,
- activeTurnId: thread.session.activeTurnId ?? undefined,
- createdAt: thread.session.updatedAt,
- updatedAt: thread.session.updatedAt,
- ...(thread.session.lastError ? { lastError: thread.session.lastError } : {}),
- }
- : null,
- messages: thread.messages.map((message) => {
- const attachments = message.attachments?.map((attachment) => ({
- type: "image" as const,
- id: attachment.id,
- name: attachment.name,
- mimeType: attachment.mimeType,
- sizeBytes: attachment.sizeBytes,
- previewUrl: toAttachmentPreviewUrl(attachmentPreviewRoutePath(attachment.id)),
- }));
- const normalizedMessage: ChatMessage = {
- id: message.id,
- role: message.role,
- text: message.text,
- createdAt: message.createdAt,
- streaming: message.streaming,
- ...(message.streaming ? {} : { completedAt: message.updatedAt }),
- ...(attachments && attachments.length > 0 ? { attachments } : {}),
- };
- return normalizedMessage;
- }),
- proposedPlans: thread.proposedPlans.map((proposedPlan) => ({
- id: proposedPlan.id,
- turnId: proposedPlan.turnId,
- planMarkdown: proposedPlan.planMarkdown,
- implementedAt: proposedPlan.implementedAt,
- implementationThreadId: proposedPlan.implementationThreadId,
- createdAt: proposedPlan.createdAt,
- updatedAt: proposedPlan.updatedAt,
- })),
- error: thread.session?.lastError ?? null,
- createdAt: thread.createdAt,
- archivedAt: thread.archivedAt,
- updatedAt: thread.updatedAt,
- latestTurn: thread.latestTurn,
- lastVisitedAt: existing?.lastVisitedAt ?? thread.updatedAt,
- branch: thread.branch,
- worktreePath: thread.worktreePath,
- turnDiffSummaries: thread.checkpoints.map((checkpoint) => ({
- turnId: checkpoint.turnId,
- completedAt: checkpoint.completedAt,
- status: checkpoint.status,
- assistantMessageId: checkpoint.assistantMessageId ?? undefined,
- checkpointTurnCount: checkpoint.checkpointTurnCount,
- checkpointRef: checkpoint.checkpointRef,
- files: checkpoint.files.map((file) => ({ ...file })),
- })),
- activities: thread.activities.map((activity) => ({ ...activity })),
- };
- });
+ const projects = readModel.projects
+ .filter((project) => project.deletedAt === null)
+ .map(mapProject);
+ const threads = readModel.threads.filter((thread) => thread.deletedAt === null).map(mapThread);
return {
...state,
projects,
threads,
- threadsHydrated: true,
+ bootstrapComplete: true,
};
}
-export function markThreadVisited(
- state: AppState,
- threadId: ThreadId,
- visitedAt?: string,
-): AppState {
- const at = visitedAt ?? new Date().toISOString();
- const visitedAtMs = Date.parse(at);
- const threads = updateThread(state.threads, threadId, (thread) => {
- const previousVisitedAtMs = thread.lastVisitedAt ? Date.parse(thread.lastVisitedAt) : NaN;
- if (
- Number.isFinite(previousVisitedAtMs) &&
- Number.isFinite(visitedAtMs) &&
- previousVisitedAtMs >= visitedAtMs
- ) {
- return thread;
+export function applyOrchestrationEvent(state: AppState, event: OrchestrationEvent): AppState {
+ switch (event.type) {
+ case "project.created": {
+ const existingIndex = state.projects.findIndex(
+ (project) =>
+ project.id === event.payload.projectId || project.cwd === event.payload.workspaceRoot,
+ );
+ const nextProject = mapProject({
+ id: event.payload.projectId,
+ title: event.payload.title,
+ workspaceRoot: event.payload.workspaceRoot,
+ defaultModelSelection: event.payload.defaultModelSelection,
+ scripts: event.payload.scripts,
+ createdAt: event.payload.createdAt,
+ updatedAt: event.payload.updatedAt,
+ deletedAt: null,
+ });
+ const projects =
+ existingIndex >= 0
+ ? state.projects.map((project, index) =>
+ index === existingIndex ? nextProject : project,
+ )
+ : [...state.projects, nextProject];
+ return { ...state, projects };
}
- return { ...thread, lastVisitedAt: at };
- });
- return threads === state.threads ? state : { ...state, threads };
-}
-export function markThreadUnread(state: AppState, threadId: ThreadId): AppState {
- const threads = updateThread(state.threads, threadId, (thread) => {
- if (!thread.latestTurn?.completedAt) return thread;
- const latestTurnCompletedAtMs = Date.parse(thread.latestTurn.completedAt);
- if (Number.isNaN(latestTurnCompletedAtMs)) return thread;
- const unreadVisitedAt = new Date(latestTurnCompletedAtMs - 1).toISOString();
- if (thread.lastVisitedAt === unreadVisitedAt) return thread;
- return { ...thread, lastVisitedAt: unreadVisitedAt };
- });
- return threads === state.threads ? state : { ...state, threads };
-}
+ case "project.meta-updated": {
+ const projects = updateProject(state.projects, event.payload.projectId, (project) => ({
+ ...project,
+ ...(event.payload.title !== undefined ? { name: event.payload.title } : {}),
+ ...(event.payload.workspaceRoot !== undefined ? { cwd: event.payload.workspaceRoot } : {}),
+ ...(event.payload.defaultModelSelection !== undefined
+ ? {
+ defaultModelSelection: event.payload.defaultModelSelection
+ ? normalizeModelSelection(event.payload.defaultModelSelection)
+ : null,
+ }
+ : {}),
+ ...(event.payload.scripts !== undefined
+ ? { scripts: mapProjectScripts(event.payload.scripts) }
+ : {}),
+ updatedAt: event.payload.updatedAt,
+ }));
+ return projects === state.projects ? state : { ...state, projects };
+ }
-export function toggleProject(state: AppState, projectId: Project["id"]): AppState {
- return {
- ...state,
- projects: state.projects.map((p) => (p.id === projectId ? { ...p, expanded: !p.expanded } : p)),
- };
-}
+ case "project.deleted": {
+ const projects = state.projects.filter((project) => project.id !== event.payload.projectId);
+ return projects.length === state.projects.length ? state : { ...state, projects };
+ }
-export function setProjectExpanded(
- state: AppState,
- projectId: Project["id"],
- expanded: boolean,
-): AppState {
- let changed = false;
- const projects = state.projects.map((p) => {
- if (p.id !== projectId || p.expanded === expanded) return p;
- changed = true;
- return { ...p, expanded };
- });
- return changed ? { ...state, projects } : state;
+ case "thread.created": {
+ const existing = state.threads.find((thread) => thread.id === event.payload.threadId);
+ const nextThread = mapThread({
+ id: event.payload.threadId,
+ projectId: event.payload.projectId,
+ title: event.payload.title,
+ modelSelection: event.payload.modelSelection,
+ runtimeMode: event.payload.runtimeMode,
+ interactionMode: event.payload.interactionMode,
+ branch: event.payload.branch,
+ worktreePath: event.payload.worktreePath,
+ latestTurn: null,
+ createdAt: event.payload.createdAt,
+ updatedAt: event.payload.updatedAt,
+ archivedAt: null,
+ deletedAt: null,
+ messages: [],
+ proposedPlans: [],
+ activities: [],
+ checkpoints: [],
+ session: null,
+ });
+ const threads = existing
+ ? state.threads.map((thread) => (thread.id === nextThread.id ? nextThread : thread))
+ : [...state.threads, nextThread];
+ return { ...state, threads };
+ }
+
+ case "thread.deleted": {
+ const threads = state.threads.filter((thread) => thread.id !== event.payload.threadId);
+ return threads.length === state.threads.length ? state : { ...state, threads };
+ }
+
+ case "thread.archived": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => ({
+ ...thread,
+ archivedAt: event.payload.archivedAt,
+ updatedAt: event.payload.updatedAt,
+ }));
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.unarchived": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => ({
+ ...thread,
+ archivedAt: null,
+ updatedAt: event.payload.updatedAt,
+ }));
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.meta-updated": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => ({
+ ...thread,
+ ...(event.payload.title !== undefined ? { title: event.payload.title } : {}),
+ ...(event.payload.modelSelection !== undefined
+ ? { modelSelection: normalizeModelSelection(event.payload.modelSelection) }
+ : {}),
+ ...(event.payload.branch !== undefined ? { branch: event.payload.branch } : {}),
+ ...(event.payload.worktreePath !== undefined
+ ? { worktreePath: event.payload.worktreePath }
+ : {}),
+ updatedAt: event.payload.updatedAt,
+ }));
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.runtime-mode-set": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => ({
+ ...thread,
+ runtimeMode: event.payload.runtimeMode,
+ updatedAt: event.payload.updatedAt,
+ }));
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.interaction-mode-set": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => ({
+ ...thread,
+ interactionMode: event.payload.interactionMode,
+ updatedAt: event.payload.updatedAt,
+ }));
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.turn-start-requested": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => ({
+ ...thread,
+ ...(event.payload.modelSelection !== undefined
+ ? { modelSelection: normalizeModelSelection(event.payload.modelSelection) }
+ : {}),
+ runtimeMode: event.payload.runtimeMode,
+ interactionMode: event.payload.interactionMode,
+ pendingSourceProposedPlan: event.payload.sourceProposedPlan,
+ updatedAt: event.occurredAt,
+ }));
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.turn-interrupt-requested": {
+ if (event.payload.turnId === undefined) {
+ return state;
+ }
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => {
+ const latestTurn = thread.latestTurn;
+ if (latestTurn === null || latestTurn.turnId !== event.payload.turnId) {
+ return thread;
+ }
+ return {
+ ...thread,
+ latestTurn: buildLatestTurn({
+ previous: latestTurn,
+ turnId: event.payload.turnId,
+ state: "interrupted",
+ requestedAt: latestTurn.requestedAt,
+ startedAt: latestTurn.startedAt ?? event.payload.createdAt,
+ completedAt: latestTurn.completedAt ?? event.payload.createdAt,
+ assistantMessageId: latestTurn.assistantMessageId,
+ }),
+ updatedAt: event.occurredAt,
+ };
+ });
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.message-sent": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => {
+ const message = mapMessage({
+ id: event.payload.messageId,
+ role: event.payload.role,
+ text: event.payload.text,
+ ...(event.payload.attachments !== undefined
+ ? { attachments: event.payload.attachments }
+ : {}),
+ turnId: event.payload.turnId,
+ streaming: event.payload.streaming,
+ createdAt: event.payload.createdAt,
+ updatedAt: event.payload.updatedAt,
+ });
+ const existingMessage = thread.messages.find((entry) => entry.id === message.id);
+ const messages = existingMessage
+ ? thread.messages.map((entry) =>
+ entry.id !== message.id
+ ? entry
+ : {
+ ...entry,
+ text: message.streaming
+ ? `${entry.text}${message.text}`
+ : message.text.length > 0
+ ? message.text
+ : entry.text,
+ streaming: message.streaming,
+ ...(message.turnId !== undefined ? { turnId: message.turnId } : {}),
+ ...(message.streaming
+ ? entry.completedAt !== undefined
+ ? { completedAt: entry.completedAt }
+ : {}
+ : message.completedAt !== undefined
+ ? { completedAt: message.completedAt }
+ : {}),
+ ...(message.attachments !== undefined
+ ? { attachments: message.attachments }
+ : {}),
+ },
+ )
+ : [...thread.messages, message];
+ const cappedMessages = messages.slice(-MAX_THREAD_MESSAGES);
+ const turnDiffSummaries =
+ event.payload.role === "assistant" && event.payload.turnId !== null
+ ? rebindTurnDiffSummariesForAssistantMessage(
+ thread.turnDiffSummaries,
+ event.payload.turnId,
+ event.payload.messageId,
+ )
+ : thread.turnDiffSummaries;
+ const latestTurn: Thread["latestTurn"] =
+ event.payload.role === "assistant" &&
+ event.payload.turnId !== null &&
+ (thread.latestTurn === null || thread.latestTurn.turnId === event.payload.turnId)
+ ? buildLatestTurn({
+ previous: thread.latestTurn,
+ turnId: event.payload.turnId,
+ state: event.payload.streaming
+ ? "running"
+ : thread.latestTurn?.state === "interrupted"
+ ? "interrupted"
+ : thread.latestTurn?.state === "error"
+ ? "error"
+ : "completed",
+ requestedAt:
+ thread.latestTurn?.turnId === event.payload.turnId
+ ? thread.latestTurn.requestedAt
+ : event.payload.createdAt,
+ startedAt:
+ thread.latestTurn?.turnId === event.payload.turnId
+ ? (thread.latestTurn.startedAt ?? event.payload.createdAt)
+ : event.payload.createdAt,
+ sourceProposedPlan: thread.pendingSourceProposedPlan,
+ completedAt: event.payload.streaming
+ ? thread.latestTurn?.turnId === event.payload.turnId
+ ? (thread.latestTurn.completedAt ?? null)
+ : null
+ : event.payload.updatedAt,
+ assistantMessageId: event.payload.messageId,
+ })
+ : thread.latestTurn;
+ return {
+ ...thread,
+ messages: cappedMessages,
+ turnDiffSummaries,
+ latestTurn,
+ updatedAt: event.occurredAt,
+ };
+ });
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.session-set": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => ({
+ ...thread,
+ session: mapSession(event.payload.session),
+ error: event.payload.session.lastError ?? null,
+ latestTurn:
+ event.payload.session.status === "running" && event.payload.session.activeTurnId !== null
+ ? buildLatestTurn({
+ previous: thread.latestTurn,
+ turnId: event.payload.session.activeTurnId,
+ state: "running",
+ requestedAt:
+ thread.latestTurn?.turnId === event.payload.session.activeTurnId
+ ? thread.latestTurn.requestedAt
+ : event.payload.session.updatedAt,
+ startedAt:
+ thread.latestTurn?.turnId === event.payload.session.activeTurnId
+ ? (thread.latestTurn.startedAt ?? event.payload.session.updatedAt)
+ : event.payload.session.updatedAt,
+ completedAt: null,
+ assistantMessageId:
+ thread.latestTurn?.turnId === event.payload.session.activeTurnId
+ ? thread.latestTurn.assistantMessageId
+ : null,
+ sourceProposedPlan: thread.pendingSourceProposedPlan,
+ })
+ : thread.latestTurn,
+ updatedAt: event.occurredAt,
+ }));
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.session-stop-requested": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) =>
+ thread.session === null
+ ? thread
+ : {
+ ...thread,
+ session: {
+ ...thread.session,
+ status: "closed",
+ orchestrationStatus: "stopped",
+ activeTurnId: undefined,
+ updatedAt: event.payload.createdAt,
+ },
+ updatedAt: event.occurredAt,
+ },
+ );
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.proposed-plan-upserted": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => {
+ const proposedPlan = mapProposedPlan(event.payload.proposedPlan);
+ const proposedPlans = [
+ ...thread.proposedPlans.filter((entry) => entry.id !== proposedPlan.id),
+ proposedPlan,
+ ]
+ .toSorted(
+ (left, right) =>
+ left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id),
+ )
+ .slice(-MAX_THREAD_PROPOSED_PLANS);
+ return {
+ ...thread,
+ proposedPlans,
+ updatedAt: event.occurredAt,
+ };
+ });
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.turn-diff-completed": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => {
+ const checkpoint = mapTurnDiffSummary({
+ turnId: event.payload.turnId,
+ checkpointTurnCount: event.payload.checkpointTurnCount,
+ checkpointRef: event.payload.checkpointRef,
+ status: event.payload.status,
+ files: event.payload.files,
+ assistantMessageId: event.payload.assistantMessageId,
+ completedAt: event.payload.completedAt,
+ });
+ const existing = thread.turnDiffSummaries.find(
+ (entry) => entry.turnId === checkpoint.turnId,
+ );
+ if (existing && existing.status !== "missing" && checkpoint.status === "missing") {
+ return thread;
+ }
+ const turnDiffSummaries = [
+ ...thread.turnDiffSummaries.filter((entry) => entry.turnId !== checkpoint.turnId),
+ checkpoint,
+ ]
+ .toSorted(
+ (left, right) =>
+ (left.checkpointTurnCount ?? Number.MAX_SAFE_INTEGER) -
+ (right.checkpointTurnCount ?? Number.MAX_SAFE_INTEGER),
+ )
+ .slice(-MAX_THREAD_CHECKPOINTS);
+ const latestTurn =
+ thread.latestTurn === null || thread.latestTurn.turnId === event.payload.turnId
+ ? buildLatestTurn({
+ previous: thread.latestTurn,
+ turnId: event.payload.turnId,
+ state: checkpointStatusToLatestTurnState(event.payload.status),
+ requestedAt: thread.latestTurn?.requestedAt ?? event.payload.completedAt,
+ startedAt: thread.latestTurn?.startedAt ?? event.payload.completedAt,
+ completedAt: event.payload.completedAt,
+ assistantMessageId: event.payload.assistantMessageId,
+ sourceProposedPlan: thread.pendingSourceProposedPlan,
+ })
+ : thread.latestTurn;
+ return {
+ ...thread,
+ turnDiffSummaries,
+ latestTurn,
+ updatedAt: event.occurredAt,
+ };
+ });
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.reverted": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => {
+ const turnDiffSummaries = thread.turnDiffSummaries
+ .filter(
+ (entry) =>
+ entry.checkpointTurnCount !== undefined &&
+ entry.checkpointTurnCount <= event.payload.turnCount,
+ )
+ .toSorted(
+ (left, right) =>
+ (left.checkpointTurnCount ?? Number.MAX_SAFE_INTEGER) -
+ (right.checkpointTurnCount ?? Number.MAX_SAFE_INTEGER),
+ )
+ .slice(-MAX_THREAD_CHECKPOINTS);
+ const retainedTurnIds = new Set(turnDiffSummaries.map((entry) => entry.turnId));
+ const messages = retainThreadMessagesAfterRevert(
+ thread.messages,
+ retainedTurnIds,
+ event.payload.turnCount,
+ ).slice(-MAX_THREAD_MESSAGES);
+ const proposedPlans = retainThreadProposedPlansAfterRevert(
+ thread.proposedPlans,
+ retainedTurnIds,
+ ).slice(-MAX_THREAD_PROPOSED_PLANS);
+ const activities = retainThreadActivitiesAfterRevert(thread.activities, retainedTurnIds);
+ const latestCheckpoint = turnDiffSummaries.at(-1) ?? null;
+
+ return {
+ ...thread,
+ turnDiffSummaries,
+ messages,
+ proposedPlans,
+ activities,
+ pendingSourceProposedPlan: undefined,
+ latestTurn:
+ latestCheckpoint === null
+ ? null
+ : {
+ turnId: latestCheckpoint.turnId,
+ state: checkpointStatusToLatestTurnState(
+ (latestCheckpoint.status ?? "ready") as "ready" | "missing" | "error",
+ ),
+ requestedAt: latestCheckpoint.completedAt,
+ startedAt: latestCheckpoint.completedAt,
+ completedAt: latestCheckpoint.completedAt,
+ assistantMessageId: latestCheckpoint.assistantMessageId ?? null,
+ },
+ updatedAt: event.occurredAt,
+ };
+ });
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.activity-appended": {
+ const threads = updateThread(state.threads, event.payload.threadId, (thread) => {
+ const activities = [
+ ...thread.activities.filter((activity) => activity.id !== event.payload.activity.id),
+ { ...event.payload.activity },
+ ]
+ .toSorted(compareActivities)
+ .slice(-MAX_THREAD_ACTIVITIES);
+ return {
+ ...thread,
+ activities,
+ updatedAt: event.occurredAt,
+ };
+ });
+ return threads === state.threads ? state : { ...state, threads };
+ }
+
+ case "thread.approval-response-requested":
+ case "thread.user-input-response-requested":
+ return state;
+ }
+
+ return state;
}
-export function reorderProjects(
+export function applyOrchestrationEvents(
state: AppState,
- draggedProjectId: Project["id"],
- targetProjectId: Project["id"],
+ events: ReadonlyArray<OrchestrationEvent>,
): AppState {
- if (draggedProjectId === targetProjectId) return state;
- const draggedIndex = state.projects.findIndex((project) => project.id === draggedProjectId);
- const targetIndex = state.projects.findIndex((project) => project.id === targetProjectId);
- if (draggedIndex < 0 || targetIndex < 0) return state;
- const projects = [...state.projects];
- const [draggedProject] = projects.splice(draggedIndex, 1);
- if (!draggedProject) return state;
- projects.splice(targetIndex, 0, draggedProject);
- return { ...state, projects };
+ if (events.length === 0) {
+ return state;
+ }
+ return events.reduce((nextState, event) => applyOrchestrationEvent(nextState, event), state);
}
+export const selectProjectById =
+ (projectId: Project["id"] | null | undefined) =>
+ (state: AppState): Project | undefined =>
+ projectId ? state.projects.find((project) => project.id === projectId) : undefined;
+
+export const selectThreadById =
+ (threadId: ThreadId | null | undefined) =>
+ (state: AppState): Thread | undefined =>
+ threadId ? state.threads.find((thread) => thread.id === threadId) : undefined;
+
export function setError(state: AppState, threadId: ThreadId, error: string | null): AppState {
const threads = updateThread(state.threads, threadId, (t) => {
if (t.error === error) return t;
@@ -426,44 +932,18 @@ export function setThreadBranch(
interface AppStore extends AppState {
syncServerReadModel: (readModel: OrchestrationReadModel) => void;
- markThreadVisited: (threadId: ThreadId, visitedAt?: string) => void;
- markThreadUnread: (threadId: ThreadId) => void;
- toggleProject: (projectId: Project["id"]) => void;
- setProjectExpanded: (projectId: Project["id"], expanded: boolean) => void;
- reorderProjects: (draggedProjectId: Project["id"], targetProjectId: Project["id"]) => void;
+ applyOrchestrationEvent: (event: OrchestrationEvent) => void;
+ applyOrchestrationEvents: (events: ReadonlyArray<OrchestrationEvent>) => void;
setError: (threadId: ThreadId, error: string | null) => void;
setThreadBranch: (threadId: ThreadId, branch: string | null, worktreePath: string | null) => void;
}
export const useStore = create<AppStore>((set) => ({
- ...readPersistedState(),
+ ...initialState,
syncServerReadModel: (readModel) => set((state) => syncServerReadModel(state, readModel)),
- markThreadVisited: (threadId, visitedAt) =>
- set((state) => markThreadVisited(state, threadId, visitedAt)),
- markThreadUnread: (threadId) => set((state) => markThreadUnread(state, threadId)),
- toggleProject: (projectId) => set((state) => toggleProject(state, projectId)),
- setProjectExpanded: (projectId, expanded) =>
- set((state) => setProjectExpanded(state, projectId, expanded)),
- reorderProjects: (draggedProjectId, targetProjectId) =>
- set((state) => reorderProjects(state, draggedProjectId, targetProjectId)),
+ applyOrchestrationEvent: (event) => set((state) => applyOrchestrationEvent(state, event)),
+ applyOrchestrationEvents: (events) => set((state) => applyOrchestrationEvents(state, events)),
setError: (threadId, error) => set((state) => setError(state, threadId, error)),
setThreadBranch: (threadId, branch, worktreePath) =>
set((state) => setThreadBranch(state, threadId, branch, worktreePath)),
}));
-
-// Persist state changes with debouncing to avoid localStorage thrashing
-useStore.subscribe((state) => debouncedPersistState.maybeExecute(state));
-
-// Flush pending writes synchronously before page unload to prevent data loss.
-if (typeof window !== "undefined") {
- window.addEventListener("beforeunload", () => {
- debouncedPersistState.flush();
- });
-}
-
-export function StoreProvider({ children }: { children: ReactNode }) {
- useEffect(() => {
- persistState(useStore.getState());
- }, []);
- return createElement(Fragment, null, children);
-}
diff --git a/apps/web/src/storeSelectors.ts b/apps/web/src/storeSelectors.ts
new file mode 100644
index 000000000..271fbb256
--- /dev/null
+++ b/apps/web/src/storeSelectors.ts
@@ -0,0 +1,14 @@
+import { type ThreadId } from "@t3tools/contracts";
+import { useMemo } from "react";
+import { selectProjectById, selectThreadById, useStore } from "./store";
+import { type Project, type Thread } from "./types";
+
+export function useProjectById(projectId: Project["id"] | null | undefined): Project | undefined {
+ const selector = useMemo(() => selectProjectById(projectId), [projectId]);
+ return useStore(selector);
+}
+
+export function useThreadById(threadId: ThreadId | null | undefined): Thread | undefined {
+ const selector = useMemo(() => selectThreadById(threadId), [threadId]);
+ return useStore(selector);
+}
diff --git a/apps/web/src/terminalStateStore.ts b/apps/web/src/terminalStateStore.ts
index 4f51e2ed8..62e088351 100644
--- a/apps/web/src/terminalStateStore.ts
+++ b/apps/web/src/terminalStateStore.ts
@@ -485,6 +485,7 @@ interface TerminalStateStoreState {
hasRunningSubprocess: boolean,
) => void;
clearTerminalState: (threadId: ThreadId) => void;
+ removeTerminalState: (threadId: ThreadId) => void;
removeOrphanedTerminalStates: (activeThreadIds: Set<ThreadId>) => void;
}
@@ -530,6 +531,15 @@ export const useTerminalStateStore = create<TerminalStateStoreState>()(
),
clearTerminalState: (threadId) =>
updateTerminal(threadId, () => createDefaultThreadTerminalState()),
+ removeTerminalState: (threadId) =>
+ set((state) => {
+ if (state.terminalStateByThreadId[threadId] === undefined) {
+ return state;
+ }
+ const next = { ...state.terminalStateByThreadId };
+ delete next[threadId];
+ return { terminalStateByThreadId: next };
+ }),
removeOrphanedTerminalStates: (activeThreadIds) =>
set((state) => {
const orphanedIds = Object.keys(state.terminalStateByThreadId).filter(
diff --git a/apps/web/src/types.ts b/apps/web/src/types.ts
index e6cb1efea..0ebf15031 100644
--- a/apps/web/src/types.ts
+++ b/apps/web/src/types.ts
@@ -45,6 +45,7 @@ export interface ChatMessage {
role: "user" | "assistant" | "system";
text: string;
attachments?: ChatAttachment[];
+ turnId?: TurnId | null;
createdAt: string;
completedAt?: string | undefined;
streaming: boolean;
@@ -82,7 +83,6 @@ export interface Project {
name: string;
cwd: string;
defaultModelSelection: ModelSelection | null;
- expanded: boolean;
createdAt?: string | undefined;
updatedAt?: string | undefined;
scripts: ProjectScript[];
@@ -104,7 +104,7 @@ export interface Thread {
archivedAt: string | null;
updatedAt?: string | undefined;
latestTurn: OrchestrationLatestTurn | null;
- lastVisitedAt?: string | undefined;
+ pendingSourceProposedPlan?: OrchestrationLatestTurn["sourceProposedPlan"];
branch: string | null;
worktreePath: string | null;
turnDiffSummaries: TurnDiffSummary[];
diff --git a/apps/web/src/uiStateStore.test.ts b/apps/web/src/uiStateStore.test.ts
new file mode 100644
index 000000000..b0b19f763
--- /dev/null
+++ b/apps/web/src/uiStateStore.test.ts
@@ -0,0 +1,192 @@
+import { ProjectId, ThreadId } from "@t3tools/contracts";
+import { describe, expect, it } from "vitest";
+
+import {
+ clearThreadUi,
+ markThreadUnread,
+ reorderProjects,
+ setProjectExpanded,
+ syncProjects,
+ syncThreads,
+ type UiState,
+} from "./uiStateStore";
+
+function makeUiState(overrides: Partial<UiState> = {}): UiState {
+ return {
+ projectExpandedById: {},
+ projectOrder: [],
+ threadLastVisitedAtById: {},
+ ...overrides,
+ };
+}
+
+describe("uiStateStore pure functions", () => {
+ it("markThreadUnread moves lastVisitedAt before completion for a completed thread", () => {
+ const threadId = ThreadId.makeUnsafe("thread-1");
+ const latestTurnCompletedAt = "2026-02-25T12:30:00.000Z";
+ const initialState = makeUiState({
+ threadLastVisitedAtById: {
+ [threadId]: "2026-02-25T12:35:00.000Z",
+ },
+ });
+
+ const next = markThreadUnread(initialState, threadId, latestTurnCompletedAt);
+
+ expect(next.threadLastVisitedAtById[threadId]).toBe("2026-02-25T12:29:59.999Z");
+ });
+
+ it("markThreadUnread does not change a thread without a completed turn", () => {
+ const threadId = ThreadId.makeUnsafe("thread-1");
+ const initialState = makeUiState({
+ threadLastVisitedAtById: {
+ [threadId]: "2026-02-25T12:35:00.000Z",
+ },
+ });
+
+ const next = markThreadUnread(initialState, threadId, null);
+
+ expect(next).toBe(initialState);
+ });
+
+ it("reorderProjects moves a project to a target index", () => {
+ const project1 = ProjectId.makeUnsafe("project-1");
+ const project2 = ProjectId.makeUnsafe("project-2");
+ const project3 = ProjectId.makeUnsafe("project-3");
+ const initialState = makeUiState({
+ projectOrder: [project1, project2, project3],
+ });
+
+ const next = reorderProjects(initialState, project1, project3);
+
+ expect(next.projectOrder).toEqual([project2, project3, project1]);
+ });
+
+ it("syncProjects preserves current project order during snapshot recovery", () => {
+ const project1 = ProjectId.makeUnsafe("project-1");
+ const project2 = ProjectId.makeUnsafe("project-2");
+ const project3 = ProjectId.makeUnsafe("project-3");
+ const initialState = makeUiState({
+ projectExpandedById: {
+ [project1]: true,
+ [project2]: false,
+ },
+ projectOrder: [project2, project1],
+ });
+
+ const next = syncProjects(initialState, [
+ { id: project1, cwd: "/tmp/project-1" },
+ { id: project2, cwd: "/tmp/project-2" },
+ { id: project3, cwd: "/tmp/project-3" },
+ ]);
+
+ expect(next.projectOrder).toEqual([project2, project1, project3]);
+ expect(next.projectExpandedById[project2]).toBe(false);
+ });
+
+ it("syncProjects preserves manual order when a project is recreated with the same cwd", () => {
+ const oldProject1 = ProjectId.makeUnsafe("project-1");
+ const oldProject2 = ProjectId.makeUnsafe("project-2");
+ const recreatedProject2 = ProjectId.makeUnsafe("project-2b");
+ const initialState = syncProjects(
+ makeUiState({
+ projectExpandedById: {
+ [oldProject1]: true,
+ [oldProject2]: false,
+ },
+ projectOrder: [oldProject2, oldProject1],
+ }),
+ [
+ { id: oldProject1, cwd: "/tmp/project-1" },
+ { id: oldProject2, cwd: "/tmp/project-2" },
+ ],
+ );
+
+ const next = syncProjects(initialState, [
+ { id: oldProject1, cwd: "/tmp/project-1" },
+ { id: recreatedProject2, cwd: "/tmp/project-2" },
+ ]);
+
+ expect(next.projectOrder).toEqual([recreatedProject2, oldProject1]);
+ expect(next.projectExpandedById[recreatedProject2]).toBe(false);
+ });
+
+ it("syncProjects returns a new state when only project cwd changes", () => {
+ const project1 = ProjectId.makeUnsafe("project-1");
+ const initialState = syncProjects(
+ makeUiState({
+ projectExpandedById: {
+ [project1]: false,
+ },
+ projectOrder: [project1],
+ }),
+ [{ id: project1, cwd: "/tmp/project-1" }],
+ );
+
+ const next = syncProjects(initialState, [{ id: project1, cwd: "/tmp/project-1-renamed" }]);
+
+ expect(next).not.toBe(initialState);
+ expect(next.projectOrder).toEqual([project1]);
+ expect(next.projectExpandedById[project1]).toBe(false);
+ });
+
+ it("syncThreads prunes missing thread UI state", () => {
+ const thread1 = ThreadId.makeUnsafe("thread-1");
+ const thread2 = ThreadId.makeUnsafe("thread-2");
+ const initialState = makeUiState({
+ threadLastVisitedAtById: {
+ [thread1]: "2026-02-25T12:35:00.000Z",
+ [thread2]: "2026-02-25T12:36:00.000Z",
+ },
+ });
+
+ const next = syncThreads(initialState, [{ id: thread1 }]);
+
+ expect(next.threadLastVisitedAtById).toEqual({
+ [thread1]: "2026-02-25T12:35:00.000Z",
+ });
+ });
+
+ it("syncThreads seeds visit state for unseen snapshot threads", () => {
+ const thread1 = ThreadId.makeUnsafe("thread-1");
+ const initialState = makeUiState();
+
+ const next = syncThreads(initialState, [
+ {
+ id: thread1,
+ seedVisitedAt: "2026-02-25T12:35:00.000Z",
+ },
+ ]);
+
+ expect(next.threadLastVisitedAtById).toEqual({
+ [thread1]: "2026-02-25T12:35:00.000Z",
+ });
+ });
+
+ it("setProjectExpanded updates expansion without touching order", () => {
+ const project1 = ProjectId.makeUnsafe("project-1");
+ const initialState = makeUiState({
+ projectExpandedById: {
+ [project1]: true,
+ },
+ projectOrder: [project1],
+ });
+
+ const next = setProjectExpanded(initialState, project1, false);
+
+ expect(next.projectExpandedById[project1]).toBe(false);
+ expect(next.projectOrder).toEqual([project1]);
+ });
+
+ it("clearThreadUi removes visit state for deleted threads", () => {
+ const thread1 = ThreadId.makeUnsafe("thread-1");
+ const initialState = makeUiState({
+ threadLastVisitedAtById: {
+ [thread1]: "2026-02-25T12:35:00.000Z",
+ },
+ });
+
+ const next = clearThreadUi(initialState, thread1);
+
+ expect(next.threadLastVisitedAtById).toEqual({});
+ });
+});
diff --git a/apps/web/src/uiStateStore.ts b/apps/web/src/uiStateStore.ts
new file mode 100644
index 000000000..342f2db18
--- /dev/null
+++ b/apps/web/src/uiStateStore.ts
@@ -0,0 +1,417 @@
+import { Debouncer } from "@tanstack/react-pacer";
+import { type ProjectId, type ThreadId } from "@t3tools/contracts";
+import { create } from "zustand";
+
+const PERSISTED_STATE_KEY = "t3code:ui-state:v1";
+const LEGACY_PERSISTED_STATE_KEYS = [
+ "t3code:renderer-state:v8",
+ "t3code:renderer-state:v7",
+ "t3code:renderer-state:v6",
+ "t3code:renderer-state:v5",
+ "t3code:renderer-state:v4",
+ "t3code:renderer-state:v3",
+ "codething:renderer-state:v4",
+ "codething:renderer-state:v3",
+ "codething:renderer-state:v2",
+ "codething:renderer-state:v1",
+] as const;
+
+interface PersistedUiState {
+ expandedProjectCwds?: string[];
+ projectOrderCwds?: string[];
+}
+
+export interface UiProjectState {
+ projectExpandedById: Record<string, boolean>;
+ projectOrder: ProjectId[];
+}
+
+export interface UiThreadState {
+ threadLastVisitedAtById: Record<string, string>;
+}
+
+export interface UiState extends UiProjectState, UiThreadState {}
+
+export interface SyncProjectInput {
+ id: ProjectId;
+ cwd: string;
+}
+
+export interface SyncThreadInput {
+ id: ThreadId;
+ seedVisitedAt?: string | undefined;
+}
+
+const initialState: UiState = {
+ projectExpandedById: {},
+ projectOrder: [],
+ threadLastVisitedAtById: {},
+};
+
+const persistedExpandedProjectCwds = new Set<string>();
+const persistedProjectOrderCwds: string[] = [];
+const currentProjectCwdById = new Map<ProjectId, string>();
+let legacyKeysCleanedUp = false;
+
+function readPersistedState(): UiState {
+ if (typeof window === "undefined") {
+ return initialState;
+ }
+ try {
+ const raw = window.localStorage.getItem(PERSISTED_STATE_KEY);
+ if (!raw) {
+ for (const legacyKey of LEGACY_PERSISTED_STATE_KEYS) {
+ const legacyRaw = window.localStorage.getItem(legacyKey);
+ if (!legacyRaw) {
+ continue;
+ }
+ hydratePersistedProjectState(JSON.parse(legacyRaw) as PersistedUiState);
+ return initialState;
+ }
+ return initialState;
+ }
+ hydratePersistedProjectState(JSON.parse(raw) as PersistedUiState);
+ return initialState;
+ } catch {
+ return initialState;
+ }
+}
+
+function hydratePersistedProjectState(parsed: PersistedUiState): void {
+ persistedExpandedProjectCwds.clear();
+ persistedProjectOrderCwds.length = 0;
+ for (const cwd of parsed.expandedProjectCwds ?? []) {
+ if (typeof cwd === "string" && cwd.length > 0) {
+ persistedExpandedProjectCwds.add(cwd);
+ }
+ }
+ for (const cwd of parsed.projectOrderCwds ?? []) {
+ if (typeof cwd === "string" && cwd.length > 0 && !persistedProjectOrderCwds.includes(cwd)) {
+ persistedProjectOrderCwds.push(cwd);
+ }
+ }
+}
+
+function persistState(state: UiState): void {
+ if (typeof window === "undefined") {
+ return;
+ }
+ try {
+ const expandedProjectCwds = Object.entries(state.projectExpandedById)
+ .filter(([, expanded]) => expanded)
+ .flatMap(([projectId]) => {
+ const cwd = currentProjectCwdById.get(projectId as ProjectId);
+ return cwd ? [cwd] : [];
+ });
+ const projectOrderCwds = state.projectOrder.flatMap((projectId) => {
+ const cwd = currentProjectCwdById.get(projectId);
+ return cwd ? [cwd] : [];
+ });
+ window.localStorage.setItem(
+ PERSISTED_STATE_KEY,
+ JSON.stringify({
+ expandedProjectCwds,
+ projectOrderCwds,
+ } satisfies PersistedUiState),
+ );
+ if (!legacyKeysCleanedUp) {
+ legacyKeysCleanedUp = true;
+ for (const legacyKey of LEGACY_PERSISTED_STATE_KEYS) {
+ window.localStorage.removeItem(legacyKey);
+ }
+ }
+ } catch {
+ // Ignore quota/storage errors to avoid breaking chat UX.
+ }
+}
+
+const debouncedPersistState = new Debouncer(persistState, { wait: 500 });
+
+function recordsEqual<T>(left: Record<string, T>, right: Record<string, T>): boolean {
+ const leftEntries = Object.entries(left);
+ const rightEntries = Object.entries(right);
+ if (leftEntries.length !== rightEntries.length) {
+ return false;
+ }
+ for (const [key, value] of leftEntries) {
+ if (right[key] !== value) {
+ return false;
+ }
+ }
+ return true;
+}
+
+function projectOrdersEqual(left: readonly ProjectId[], right: readonly ProjectId[]): boolean {
+ return (
+ left.length === right.length && left.every((projectId, index) => projectId === right[index])
+ );
+}
+
+export function syncProjects(state: UiState, projects: readonly SyncProjectInput[]): UiState {
+ const previousProjectCwdById = new Map(currentProjectCwdById);
+ const previousProjectIdByCwd = new Map(
+ [...previousProjectCwdById.entries()].map(([projectId, cwd]) => [cwd, projectId] as const),
+ );
+ currentProjectCwdById.clear();
+ for (const project of projects) {
+ currentProjectCwdById.set(project.id, project.cwd);
+ }
+ const cwdMappingChanged =
+ previousProjectCwdById.size !== currentProjectCwdById.size ||
+ projects.some((project) => previousProjectCwdById.get(project.id) !== project.cwd);
+
+ const nextExpandedById: Record<string, boolean> = {};
+ const previousExpandedById = state.projectExpandedById;
+ const persistedOrderByCwd = new Map(
+ persistedProjectOrderCwds.map((cwd, index) => [cwd, index] as const),
+ );
+ const mappedProjects = projects.map((project, index) => {
+ const previousProjectIdForCwd = previousProjectIdByCwd.get(project.cwd);
+ const expanded =
+ previousExpandedById[project.id] ??
+ (previousProjectIdForCwd ? previousExpandedById[previousProjectIdForCwd] : undefined) ??
+ (persistedExpandedProjectCwds.size > 0
+ ? persistedExpandedProjectCwds.has(project.cwd)
+ : true);
+ nextExpandedById[project.id] = expanded;
+ return {
+ id: project.id,
+ cwd: project.cwd,
+ incomingIndex: index,
+ };
+ });
+
+ const nextProjectOrder =
+ state.projectOrder.length > 0
+ ? (() => {
+ const nextProjectIdByCwd = new Map(
+ mappedProjects.map((project) => [project.cwd, project.id] as const),
+ );
+ const usedProjectIds = new Set<ProjectId>();
+ const orderedProjectIds: ProjectId[] = [];
+
+ for (const projectId of state.projectOrder) {
+ const matchedProjectId =
+ (projectId in nextExpandedById ? projectId : undefined) ??
+ (() => {
+ const previousCwd = previousProjectCwdById.get(projectId);
+ return previousCwd ? nextProjectIdByCwd.get(previousCwd) : undefined;
+ })();
+ if (!matchedProjectId || usedProjectIds.has(matchedProjectId)) {
+ continue;
+ }
+ usedProjectIds.add(matchedProjectId);
+ orderedProjectIds.push(matchedProjectId);
+ }
+
+ for (const project of mappedProjects) {
+ if (usedProjectIds.has(project.id)) {
+ continue;
+ }
+ orderedProjectIds.push(project.id);
+ }
+
+ return orderedProjectIds;
+ })()
+ : mappedProjects
+ .map((project) => ({
+ id: project.id,
+ incomingIndex: project.incomingIndex,
+ orderIndex:
+ persistedOrderByCwd.get(project.cwd) ??
+ persistedProjectOrderCwds.length + project.incomingIndex,
+ }))
+ .toSorted((left, right) => {
+ const byOrder = left.orderIndex - right.orderIndex;
+ if (byOrder !== 0) {
+ return byOrder;
+ }
+ return left.incomingIndex - right.incomingIndex;
+ })
+ .map((project) => project.id);
+
+ if (
+ recordsEqual(state.projectExpandedById, nextExpandedById) &&
+ projectOrdersEqual(state.projectOrder, nextProjectOrder) &&
+ !cwdMappingChanged
+ ) {
+ return state;
+ }
+
+ return {
+ ...state,
+ projectExpandedById: nextExpandedById,
+ projectOrder: nextProjectOrder,
+ };
+}
+
+export function syncThreads(state: UiState, threads: readonly SyncThreadInput[]): UiState {
+ const retainedThreadIds = new Set(threads.map((thread) => thread.id));
+ const nextThreadLastVisitedAtById = Object.fromEntries(
+ Object.entries(state.threadLastVisitedAtById).filter(([threadId]) =>
+ retainedThreadIds.has(threadId as ThreadId),
+ ),
+ );
+ for (const thread of threads) {
+ if (
+ nextThreadLastVisitedAtById[thread.id] === undefined &&
+ thread.seedVisitedAt !== undefined &&
+ thread.seedVisitedAt.length > 0
+ ) {
+ nextThreadLastVisitedAtById[thread.id] = thread.seedVisitedAt;
+ }
+ }
+ if (recordsEqual(state.threadLastVisitedAtById, nextThreadLastVisitedAtById)) {
+ return state;
+ }
+ return {
+ ...state,
+ threadLastVisitedAtById: nextThreadLastVisitedAtById,
+ };
+}
+
+export function markThreadVisited(state: UiState, threadId: ThreadId, visitedAt?: string): UiState {
+ const at = visitedAt ?? new Date().toISOString();
+ const visitedAtMs = Date.parse(at);
+ const previousVisitedAt = state.threadLastVisitedAtById[threadId];
+ const previousVisitedAtMs = previousVisitedAt ? Date.parse(previousVisitedAt) : NaN;
+ if (
+ Number.isFinite(previousVisitedAtMs) &&
+ Number.isFinite(visitedAtMs) &&
+ previousVisitedAtMs >= visitedAtMs
+ ) {
+ return state;
+ }
+ return {
+ ...state,
+ threadLastVisitedAtById: {
+ ...state.threadLastVisitedAtById,
+ [threadId]: at,
+ },
+ };
+}
+
+export function markThreadUnread(
+ state: UiState,
+ threadId: ThreadId,
+ latestTurnCompletedAt: string | null | undefined,
+): UiState {
+ if (!latestTurnCompletedAt) {
+ return state;
+ }
+ const latestTurnCompletedAtMs = Date.parse(latestTurnCompletedAt);
+ if (Number.isNaN(latestTurnCompletedAtMs)) {
+ return state;
+ }
+ const unreadVisitedAt = new Date(latestTurnCompletedAtMs - 1).toISOString();
+ if (state.threadLastVisitedAtById[threadId] === unreadVisitedAt) {
+ return state;
+ }
+ return {
+ ...state,
+ threadLastVisitedAtById: {
+ ...state.threadLastVisitedAtById,
+ [threadId]: unreadVisitedAt,
+ },
+ };
+}
+
+export function clearThreadUi(state: UiState, threadId: ThreadId): UiState {
+ if (!(threadId in state.threadLastVisitedAtById)) {
+ return state;
+ }
+ const nextThreadLastVisitedAtById = { ...state.threadLastVisitedAtById };
+ delete nextThreadLastVisitedAtById[threadId];
+ return {
+ ...state,
+ threadLastVisitedAtById: nextThreadLastVisitedAtById,
+ };
+}
+
+export function toggleProject(state: UiState, projectId: ProjectId): UiState {
+ const expanded = state.projectExpandedById[projectId] ?? true;
+ return {
+ ...state,
+ projectExpandedById: {
+ ...state.projectExpandedById,
+ [projectId]: !expanded,
+ },
+ };
+}
+
+export function setProjectExpanded(
+ state: UiState,
+ projectId: ProjectId,
+ expanded: boolean,
+): UiState {
+ if ((state.projectExpandedById[projectId] ?? true) === expanded) {
+ return state;
+ }
+ return {
+ ...state,
+ projectExpandedById: {
+ ...state.projectExpandedById,
+ [projectId]: expanded,
+ },
+ };
+}
+
+export function reorderProjects(
+ state: UiState,
+ draggedProjectId: ProjectId,
+ targetProjectId: ProjectId,
+): UiState {
+ if (draggedProjectId === targetProjectId) {
+ return state;
+ }
+ const draggedIndex = state.projectOrder.findIndex((projectId) => projectId === draggedProjectId);
+ const targetIndex = state.projectOrder.findIndex((projectId) => projectId === targetProjectId);
+ if (draggedIndex < 0 || targetIndex < 0) {
+ return state;
+ }
+ const projectOrder = [...state.projectOrder];
+ const [draggedProject] = projectOrder.splice(draggedIndex, 1);
+ if (!draggedProject) {
+ return state;
+ }
+ projectOrder.splice(targetIndex, 0, draggedProject);
+ return {
+ ...state,
+ projectOrder,
+ };
+}
+
+interface UiStateStore extends UiState {
+ syncProjects: (projects: readonly SyncProjectInput[]) => void;
+ syncThreads: (threads: readonly SyncThreadInput[]) => void;
+ markThreadVisited: (threadId: ThreadId, visitedAt?: string) => void;
+ markThreadUnread: (threadId: ThreadId, latestTurnCompletedAt: string | null | undefined) => void;
+ clearThreadUi: (threadId: ThreadId) => void;
+ toggleProject: (projectId: ProjectId) => void;
+ setProjectExpanded: (projectId: ProjectId, expanded: boolean) => void;
+ reorderProjects: (draggedProjectId: ProjectId, targetProjectId: ProjectId) => void;
+}
+
+export const useUiStateStore = create<UiStateStore>((set) => ({
+ ...readPersistedState(),
+ syncProjects: (projects) => set((state) => syncProjects(state, projects)),
+ syncThreads: (threads) => set((state) => syncThreads(state, threads)),
+ markThreadVisited: (threadId, visitedAt) =>
+ set((state) => markThreadVisited(state, threadId, visitedAt)),
+ markThreadUnread: (threadId, latestTurnCompletedAt) =>
+ set((state) => markThreadUnread(state, threadId, latestTurnCompletedAt)),
+ clearThreadUi: (threadId) => set((state) => clearThreadUi(state, threadId)),
+ toggleProject: (projectId) => set((state) => toggleProject(state, projectId)),
+ setProjectExpanded: (projectId, expanded) =>
+ set((state) => setProjectExpanded(state, projectId, expanded)),
+ reorderProjects: (draggedProjectId, targetProjectId) =>
+ set((state) => reorderProjects(state, draggedProjectId, targetProjectId)),
+}));
+
+useUiStateStore.subscribe((state) => debouncedPersistState.maybeExecute(state));
+
+if (typeof window !== "undefined") {
+ window.addEventListener("beforeunload", () => {
+ debouncedPersistState.flush();
+ });
+}