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.
Add shell snapshot queries for orchestration state (#1973)
Julius Marmingef7fa62aaf90d
diff --git a/apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts b/apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.tsindex 21cbe1509..e6c53dd06 100644--- a/apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts+++ b/apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts@@ -82,10 +82,15 @@ describe("CheckpointDiffQueryLive", () => {Layer.succeed(ProjectionSnapshotQuery, {getSnapshot: () =>Effect.die("CheckpointDiffQuery should not request the full orchestration snapshot"),+ getShellSnapshot: () =>+ Effect.die("CheckpointDiffQuery should not request the orchestration shell snapshot"),getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),+ getProjectShellById: () => Effect.succeed(Option.none()),getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),getThreadCheckpointContext: () => Effect.succeed(Option.some(threadCheckpointContext)),+ getThreadShellById: () => Effect.succeed(Option.none()),+ getThreadDetailById: () => Effect.succeed(Option.none()),}),),);@@ -136,10 +141,15 @@ describe("CheckpointDiffQueryLive", () => {Layer.succeed(ProjectionSnapshotQuery, {getSnapshot: () =>Effect.die("CheckpointDiffQuery should not request the full orchestration snapshot"),+ getShellSnapshot: () =>+ Effect.die("CheckpointDiffQuery should not request the orchestration shell snapshot"),getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),+ getProjectShellById: () => Effect.succeed(Option.none()),getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),getThreadCheckpointContext: () => Effect.succeed(Option.none()),+ getThreadShellById: () => Effect.succeed(Option.none()),+ getThreadDetailById: () => Effect.succeed(Option.none()),}),),);diff --git a/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts b/apps/server/src/orchestration/Layers/OrchestrationEngine.test.tsindex eaf66f397..b61664f16 100644--- a/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts+++ b/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts@@ -144,10 +144,20 @@ describe("OrchestrationEngine", () => {Layer.provide(Layer.succeed(ProjectionSnapshotQuery, {getSnapshot: () => Effect.succeed(projectionSnapshot),+ getShellSnapshot: () =>+ Effect.succeed({+ snapshotSequence: projectionSnapshot.snapshotSequence,+ projects: [],+ threads: [],+ updatedAt: projectionSnapshot.updatedAt,+ }),getCounts: () => Effect.succeed({ projectCount: 1, threadCount: 1 }),getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),+ getProjectShellById: () => Effect.succeed(Option.none()),getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),getThreadCheckpointContext: () => Effect.succeed(Option.none()),+ getThreadShellById: () => Effect.succeed(Option.none()),+ getThreadDetailById: () => Effect.succeed(Option.none()),}),),Layer.provide(diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.tsindex bdc6fac6d..d7e62c39b 100644--- a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts+++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts@@ -2,6 +2,7 @@ import {ApprovalRequestId,type ChatAttachment,type OrchestrationEvent,+ ThreadId,} from "@t3tools/contracts";import { Effect, FileSystem, Layer, Option, Path, Stream } from "effect";import * as SqlClient from "effect/unstable/sql/SqlClient";@@ -89,6 +90,77 @@ function extractActivityRequestId(payload: unknown): ApprovalRequestId | null {return typeof requestId === "string" ? ApprovalRequestId.make(requestId) : null;}+function derivePendingUserInputCountFromActivities(+ activities: ReadonlyArray<ProjectionThreadActivity>,+): number {+ const openRequestIds = new Set<string>();+ const ordered = [...activities].toSorted(+ (left, right) =>+ left.createdAt.localeCompare(right.createdAt) ||+ left.activityId.localeCompare(right.activityId),+ );++ for (const activity of ordered) {+ const requestId = extractActivityRequestId(activity.payload);+ if (requestId === null) {+ continue;+ }+ const payload =+ typeof activity.payload === "object" && activity.payload !== null+ ? (activity.payload as Record<string, unknown>)+ : null;+ const detail = typeof payload?.detail === "string" ? payload.detail.toLowerCase() : null;++ if (activity.kind === "user-input.requested") {+ openRequestIds.add(requestId);+ continue;+ }++ if (activity.kind === "user-input.resolved") {+ openRequestIds.delete(requestId);+ continue;+ }++ if (+ activity.kind === "provider.user-input.respond.failed" &&+ detail !== null &&+ (detail.includes("stale pending user-input request") ||+ detail.includes("unknown pending user-input request"))+ ) {+ openRequestIds.delete(requestId);+ }+ }++ return openRequestIds.size;+}++function deriveHasActionableProposedPlan(input: {+ readonly latestTurnId: string | null;+ readonly proposedPlans: ReadonlyArray<ProjectionThreadProposedPlan>;+}): boolean {+ const sorted = [...input.proposedPlans].toSorted(+ (left, right) =>+ left.updatedAt.localeCompare(right.updatedAt) || left.planId.localeCompare(right.planId),+ );++ let latestForTurn: ProjectionThreadProposedPlan | null = null;+ if (input.latestTurnId !== null) {+ for (let index = sorted.length - 1; index >= 0; index -= 1) {+ const plan = sorted[index];+ if (plan?.turnId === input.latestTurnId) {+ latestForTurn = plan;+ break;+ }+ }+ }+ if (latestForTurn !== null) {+ return latestForTurn.implementedAt === null;+ }++ const latestPlan = sorted.at(-1) ?? null;+ return latestPlan !== null && latestPlan.implementedAt === null;+}+function retainProjectionMessagesAfterRevert(messages: ReadonlyArray<ProjectionThreadMessage>,turns: ReadonlyArray<ProjectionTurn>,@@ -432,6 +504,48 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti}});+ const refreshThreadShellSummary = Effect.fn("refreshThreadShellSummary")(function* (+ threadId: ThreadId,+ ) {+ const existingRow = yield* projectionThreadRepository.getById({+ threadId,+ });+ if (Option.isNone(existingRow)) {+ return;+ }++ const [messages, proposedPlans, activities, pendingApprovals] = yield* Effect.all([+ projectionThreadMessageRepository.listByThreadId({ threadId }),+ projectionThreadProposedPlanRepository.listByThreadId({ threadId }),+ projectionThreadActivityRepository.listByThreadId({ threadId }),+ projectionPendingApprovalRepository.listByThreadId({ threadId }),+ ]);++ const latestUserMessageAt =+ messages+ .filter((message) => message.role === "user")+ .map((message) => message.createdAt)+ .toSorted()+ .at(-1) ?? null;++ const pendingApprovalCount = pendingApprovals.filter(+ (approval) => approval.status === "pending",+ ).length;+ const pendingUserInputCount = derivePendingUserInputCountFromActivities(activities);+ const hasActionableProposedPlan = deriveHasActionableProposedPlan({+ latestTurnId: existingRow.value.latestTurnId,+ proposedPlans,+ });++ yield* projectionThreadRepository.upsert({+ ...existingRow.value,+ latestUserMessageAt,+ pendingApprovalCount,+ pendingUserInputCount,+ hasActionableProposedPlan: hasActionableProposedPlan ? 1 : 0,+ });+ });+const applyThreadsProjection: ProjectorDefinition["apply"] = Effect.fn("applyThreadsProjection",)(function* (event, attachmentSideEffects) {@@ -450,6 +564,10 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecticreatedAt: event.payload.createdAt,updatedAt: event.payload.updatedAt,archivedAt: null,+ latestUserMessageAt: null,+ pendingApprovalCount: 0,+ pendingUserInputCount: 0,+ hasActionableProposedPlan: 0,deletedAt: null,});return;@@ -554,7 +672,9 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecticase "thread.message-sent":case "thread.proposed-plan-upserted":- case "thread.activity-appended": {+ case "thread.activity-appended":+ case "thread.approval-response-requested":+ case "thread.user-input-response-requested": {const existingRow = yield* projectionThreadRepository.getById({threadId: event.payload.threadId,});@@ -565,6 +685,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti...existingRow.value,updatedAt: event.occurredAt,});+ yield* refreshThreadShellSummary(event.payload.threadId);return;}@@ -580,6 +701,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjectilatestTurnId: event.payload.session.activeTurnId,updatedAt: event.occurredAt,});+ yield* refreshThreadShellSummary(event.payload.threadId);return;}@@ -595,6 +717,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjectilatestTurnId: event.payload.turnId,updatedAt: event.occurredAt,});+ yield* refreshThreadShellSummary(event.payload.threadId);return;}@@ -610,6 +733,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjectilatestTurnId: null,updatedAt: event.occurredAt,});+ yield* refreshThreadShellSummary(event.payload.threadId);return;}diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.tsindex 0eb312cbf..9f0d63545 100644--- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts+++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts@@ -62,9 +62,15 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {project_id,title,model_selection_json,+ runtime_mode,+ interaction_mode,branch,worktree_path,latest_turn_id,+ latest_user_message_at,+ pending_approval_count,+ pending_user_input_count,+ has_actionable_proposed_plan,created_at,updated_at,deleted_at@@ -74,9 +80,15 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {'project-1','Thread 1','{"provider":"codex","model":"gpt-5-codex"}',+ 'full-access',+ 'default',NULL,NULL,'turn-1',+ '2026-02-24T00:00:04.000Z',+ 1,+ 0,+ 0,'2026-02-24T00:00:02.000Z','2026-02-24T00:00:03.000Z',NULL@@ -341,6 +353,81 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {},},]);++ const shellSnapshot = yield* snapshotQuery.getShellSnapshot();+ assert.equal(shellSnapshot.snapshotSequence, 5);+ assert.deepEqual(shellSnapshot.projects, [+ {+ id: asProjectId("project-1"),+ title: "Project 1",+ workspaceRoot: "/tmp/project-1",+ repositoryIdentity: null,+ defaultModelSelection: {+ provider: "codex",+ model: "gpt-5-codex",+ },+ scripts: [+ {+ id: "script-1",+ name: "Build",+ command: "bun run build",+ icon: "build",+ runOnWorktreeCreate: false,+ },+ ],+ createdAt: "2026-02-24T00:00:00.000Z",+ updatedAt: "2026-02-24T00:00:01.000Z",+ },+ ]);+ assert.deepEqual(shellSnapshot.threads, [+ {+ id: ThreadId.make("thread-1"),+ projectId: asProjectId("project-1"),+ title: "Thread 1",+ modelSelection: {+ provider: "codex",+ model: "gpt-5-codex",+ },+ interactionMode: "default",+ runtimeMode: "full-access",+ branch: null,+ worktreePath: null,+ latestTurn: {+ turnId: asTurnId("turn-1"),+ state: "completed",+ requestedAt: "2026-02-24T00:00:08.000Z",+ startedAt: "2026-02-24T00:00:08.000Z",+ completedAt: "2026-02-24T00:00:08.000Z",+ assistantMessageId: asMessageId("message-1"),+ sourceProposedPlan: {+ threadId: ThreadId.make("thread-1"),+ planId: "plan-1",+ },+ },+ createdAt: "2026-02-24T00:00:02.000Z",+ updatedAt: "2026-02-24T00:00:03.000Z",+ archivedAt: null,+ session: {+ threadId: ThreadId.make("thread-1"),+ status: "running",+ providerName: "codex",+ runtimeMode: "approval-required",+ activeTurnId: asTurnId("turn-1"),+ lastError: null,+ updatedAt: "2026-02-24T00:00:07.000Z",+ },+ latestUserMessageAt: "2026-02-24T00:00:04.000Z",+ hasPendingApprovals: true,+ hasPendingUserInput: false,+ hasActionableProposedPlan: false,+ },+ ]);++ const threadDetail = yield* snapshotQuery.getThreadDetailById(ThreadId.make("thread-1"));+ assert.equal(threadDetail._tag, "Some");+ if (threadDetail._tag === "Some") {+ assert.deepEqual(threadDetail.value, snapshot.threads[0]);+ }}),);@@ -629,4 +716,309 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {}}),);++ it.effect("keeps thread detail activity ordering consistent with shell snapshot ordering", () =>+ Effect.gen(function* () {+ const snapshotQuery = yield* ProjectionSnapshotQuery;+ const sql = yield* SqlClient.SqlClient;++ yield* sql`DELETE FROM projection_projects`;+ yield* sql`DELETE FROM projection_threads`;+ yield* sql`DELETE FROM projection_thread_activities`;+ yield* sql`DELETE FROM projection_state`;++ yield* sql`+ INSERT INTO projection_projects (+ project_id,+ title,+ workspace_root,+ default_model_selection_json,+ scripts_json,+ created_at,+ updated_at,+ deleted_at+ )+ VALUES (+ 'project-1',+ 'Project 1',+ '/tmp/project-1',+ '{"provider":"codex","model":"gpt-5-codex"}',+ '[]',+ '2026-04-01T00:00:00.000Z',+ '2026-04-01T00:00:01.000Z',+ NULL+ )+ `;++ yield* sql`+ INSERT INTO projection_threads (+ thread_id,+ project_id,+ title,+ model_selection_json,+ runtime_mode,+ interaction_mode,+ branch,+ worktree_path,+ latest_turn_id,+ latest_user_message_at,+ pending_approval_count,+ pending_user_input_count,+ has_actionable_proposed_plan,+ created_at,+ updated_at,+ deleted_at+ )+ VALUES (+ 'thread-1',+ 'project-1',+ 'Thread 1',+ '{"provider":"codex","model":"gpt-5-codex"}',+ 'full-access',+ 'default',+ NULL,+ NULL,+ NULL,+ NULL,+ 0,+ 0,+ 0,+ '2026-04-01T00:00:02.000Z',+ '2026-04-01T00:00:03.000Z',+ NULL+ )+ `;++ yield* sql`+ INSERT INTO projection_thread_activities (+ activity_id,+ thread_id,+ turn_id,+ tone,+ kind,+ summary,+ payload_json,+ sequence,+ created_at+ )+ VALUES+ (+ 'activity-unsequenced',+ 'thread-1',+ NULL,+ 'info',+ 'runtime.note',+ 'unsequenced first',+ '{"source":"unsequenced"}',+ NULL,+ '2026-04-01T00:00:06.000Z'+ ),+ (+ 'activity-sequence-2',+ 'thread-1',+ NULL,+ 'info',+ 'runtime.note',+ 'sequence two',+ '{"source":"sequence-2"}',+ 2,+ '2026-04-01T00:00:04.000Z'+ ),+ (+ 'activity-sequence-1',+ 'thread-1',+ NULL,+ 'info',+ 'runtime.note',+ 'sequence one',+ '{"source":"sequence-1"}',+ 1,+ '2026-04-01T00:00:05.000Z'+ )+ `;++ const snapshot = yield* snapshotQuery.getSnapshot();+ const threadDetail = yield* snapshotQuery.getThreadDetailById(ThreadId.make("thread-1"));++ assert.equal(threadDetail._tag, "Some");+ if (threadDetail._tag === "Some") {+ assert.deepEqual(threadDetail.value.activities, snapshot.threads[0]?.activities ?? []);+ }++ assert.deepEqual(snapshot.threads[0]?.activities ?? [], [+ {+ id: asEventId("activity-unsequenced"),+ tone: "info",+ kind: "runtime.note",+ summary: "unsequenced first",+ payload: { source: "unsequenced" },+ turnId: null,+ createdAt: "2026-04-01T00:00:06.000Z",+ },+ {+ id: asEventId("activity-sequence-1"),+ tone: "info",+ kind: "runtime.note",+ summary: "sequence one",+ payload: { source: "sequence-1" },+ turnId: null,+ sequence: 1,+ createdAt: "2026-04-01T00:00:05.000Z",+ },+ {+ id: asEventId("activity-sequence-2"),+ tone: "info",+ kind: "runtime.note",+ summary: "sequence two",+ payload: { source: "sequence-2" },+ turnId: null,+ sequence: 2,+ createdAt: "2026-04-01T00:00:04.000Z",+ },+ ]);+ }),+ );++ it.effect("uses projection_threads.latest_turn_id for targeted thread latest turn queries", () =>+ Effect.gen(function* () {+ const snapshotQuery = yield* ProjectionSnapshotQuery;+ const sql = yield* SqlClient.SqlClient;++ yield* sql`DELETE FROM projection_projects`;+ yield* sql`DELETE FROM projection_threads`;+ yield* sql`DELETE FROM projection_turns`;++ yield* sql`+ INSERT INTO projection_projects (+ project_id,+ title,+ workspace_root,+ default_model_selection_json,+ scripts_json,+ created_at,+ updated_at,+ deleted_at+ )+ VALUES (+ 'project-1',+ 'Project 1',+ '/tmp/project-1',+ '{"provider":"codex","model":"gpt-5-codex"}',+ '[]',+ '2026-04-02T00:00:00.000Z',+ '2026-04-02T00:00:01.000Z',+ NULL+ )+ `;++ yield* sql`+ INSERT INTO projection_threads (+ thread_id,+ project_id,+ title,+ model_selection_json,+ runtime_mode,+ interaction_mode,+ branch,+ worktree_path,+ latest_turn_id,+ latest_user_message_at,+ pending_approval_count,+ pending_user_input_count,+ has_actionable_proposed_plan,+ created_at,+ updated_at,+ archived_at,+ deleted_at+ )+ VALUES (+ 'thread-1',+ 'project-1',+ 'Thread 1',+ '{"provider":"codex","model":"gpt-5-codex"}',+ 'full-access',+ 'default',+ NULL,+ NULL,+ 'turn-running',+ '2026-04-02T00:00:04.000Z',+ 0,+ 0,+ 0,+ '2026-04-02T00:00:02.000Z',+ '2026-04-02T00:00:03.000Z',+ NULL,+ NULL+ )+ `;++ yield* sql`+ INSERT INTO projection_turns (+ thread_id,+ turn_id,+ pending_message_id,+ source_proposed_plan_thread_id,+ source_proposed_plan_id,+ assistant_message_id,+ state,+ requested_at,+ started_at,+ completed_at,+ checkpoint_turn_count,+ checkpoint_ref,+ checkpoint_status,+ checkpoint_files_json+ )+ VALUES+ (+ 'thread-1',+ 'turn-completed',+ 'message-user-1',+ NULL,+ NULL,+ 'message-assistant-1',+ 'completed',+ '2026-04-02T00:00:05.000Z',+ '2026-04-02T00:00:06.000Z',+ '2026-04-02T00:00:20.000Z',+ 5,+ 'checkpoint-5',+ 'ready',+ '[]'+ ),+ (+ 'thread-1',+ 'turn-running',+ 'message-user-2',+ NULL,+ NULL,+ NULL,+ 'running',+ '2026-04-02T00:00:30.000Z',+ '2026-04-02T00:00:30.000Z',+ NULL,+ NULL,+ NULL,+ NULL,+ '[]'+ )+ `;++ const threadShell = yield* snapshotQuery.getThreadShellById(ThreadId.make("thread-1"));+ assert.equal(threadShell._tag, "Some");+ if (threadShell._tag === "Some") {+ assert.equal(threadShell.value.latestTurn?.turnId, asTurnId("turn-running"));+ assert.equal(threadShell.value.latestTurn?.state, "running");+ assert.equal(threadShell.value.latestTurn?.startedAt, "2026-04-02T00:00:30.000Z");+ }++ const threadDetail = yield* snapshotQuery.getThreadDetailById(ThreadId.make("thread-1"));+ assert.equal(threadDetail._tag, "Some");+ if (threadDetail._tag === "Some") {+ assert.equal(threadDetail.value.latestTurn?.turnId, asTurnId("turn-running"));+ assert.equal(threadDetail.value.latestTurn?.state, "running");+ assert.equal(threadDetail.value.latestTurn?.startedAt, "2026-04-02T00:00:30.000Z");+ }+ }),+ );});diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.tsindex b0f883f94..07645571b 100644--- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts+++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts@@ -6,16 +6,19 @@ import {OrchestrationCheckpointFile,OrchestrationProposedPlanId,OrchestrationReadModel,+ OrchestrationShellSnapshot,+ OrchestrationThread,ProjectScript,TurnId,type OrchestrationCheckpointSummary,type OrchestrationLatestTurn,type OrchestrationMessage,+ type OrchestrationProjectShell,type OrchestrationProposedPlan,type OrchestrationProject,type OrchestrationSession,- type OrchestrationThread,type OrchestrationThreadActivity,+ type OrchestrationThreadShell,ModelSelection,ProjectId,ThreadId,@@ -48,6 +51,8 @@ import {} from "../Services/ProjectionSnapshotQuery.ts";const decodeReadModel = Schema.decodeUnknownEffect(OrchestrationReadModel);+const decodeShellSnapshot = Schema.decodeUnknownEffect(OrchestrationShellSnapshot);+const decodeThread = Schema.decodeUnknownEffect(OrchestrationThread);const ProjectionProjectDbRowSchema = ProjectionProject.mapFields(Struct.assign({defaultModelSelection: Schema.NullOr(Schema.fromJsonString(ModelSelection)),@@ -155,6 +160,64 @@ function computeSnapshotSequence(return Number.isFinite(minSequence) ? minSequence : 0;}+function mapLatestTurn(+ row: Schema.Schema.Type<typeof ProjectionLatestTurnDbRowSchema>,+): OrchestrationLatestTurn {+ return {+ turnId: row.turnId,+ state:+ row.state === "error"+ ? "error"+ : row.state === "interrupted"+ ? "interrupted"+ : row.state === "completed"+ ? "completed"+ : "running",+ requestedAt: row.requestedAt,+ startedAt: row.startedAt,+ completedAt: row.completedAt,+ assistantMessageId: row.assistantMessageId,+ ...(row.sourceProposedPlanThreadId !== null && row.sourceProposedPlanId !== null+ ? {+ sourceProposedPlan: {+ threadId: row.sourceProposedPlanThreadId,+ planId: row.sourceProposedPlanId,+ },+ }+ : {}),+ };+}++function mapSessionRow(+ row: Schema.Schema.Type<typeof ProjectionThreadSessionDbRowSchema>,+): OrchestrationSession {+ return {+ threadId: row.threadId,+ status: row.status,+ providerName: row.providerName,+ runtimeMode: row.runtimeMode,+ activeTurnId: row.activeTurnId,+ lastError: row.lastError,+ updatedAt: row.updatedAt,+ };+}++function mapProjectShellRow(+ row: Schema.Schema.Type<typeof ProjectionProjectDbRowSchema>,+ repositoryIdentity: OrchestrationProject["repositoryIdentity"],+): OrchestrationProjectShell {+ return {+ id: row.projectId,+ title: row.title,+ workspaceRoot: row.workspaceRoot,+ repositoryIdentity,+ defaultModelSelection: row.defaultModelSelection,+ scripts: row.scripts,+ createdAt: row.createdAt,+ updatedAt: row.updatedAt,+ };+}+function toPersistenceSqlOrDecodeError(sqlOperation: string, decodeOperation: string) {return (cause: unknown): ProjectionRepositoryError =>Schema.isSchemaError(cause)@@ -204,6 +267,10 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {created_at AS "createdAt",updated_at AS "updatedAt",archived_at AS "archivedAt",+ latest_user_message_at AS "latestUserMessageAt",+ pending_approval_count AS "pendingApprovalCount",+ pending_user_input_count AS "pendingUserInputCount",+ has_actionable_proposed_plan AS "hasActionableProposedPlan",deleted_at AS "deletedAt"FROM projection_threadsORDER BY created_at ASC, thread_id ASC@@ -381,6 +448,27 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {`,});+ const getActiveProjectRowById = SqlSchema.findOneOption({+ Request: ProjectIdLookupInput,+ Result: ProjectionProjectLookupRowSchema,+ execute: ({ projectId }) =>+ sql`+ SELECT+ project_id AS "projectId",+ title,+ workspace_root AS "workspaceRoot",+ default_model_selection_json AS "defaultModelSelection",+ scripts_json AS "scripts",+ created_at AS "createdAt",+ updated_at AS "updatedAt",+ deleted_at AS "deletedAt"+ FROM projection_projects+ WHERE project_id = ${projectId}+ AND deleted_at IS NULL+ LIMIT 1+ `,+ });+const getFirstActiveThreadIdByProject = SqlSchema.findOneOption({Request: ProjectIdLookupInput,Result: ProjectionThreadIdLookupRowSchema,@@ -415,6 +503,146 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {`,});+ const getActiveThreadRowById = SqlSchema.findOneOption({+ Request: ThreadIdLookupInput,+ Result: ProjectionThreadDbRowSchema,+ execute: ({ threadId }) =>+ sql`+ SELECT+ thread_id AS "threadId",+ project_id AS "projectId",+ title,+ model_selection_json AS "modelSelection",+ runtime_mode AS "runtimeMode",+ interaction_mode AS "interactionMode",+ branch,+ worktree_path AS "worktreePath",+ latest_turn_id AS "latestTurnId",+ created_at AS "createdAt",+ updated_at AS "updatedAt",+ archived_at AS "archivedAt",+ latest_user_message_at AS "latestUserMessageAt",+ pending_approval_count AS "pendingApprovalCount",+ pending_user_input_count AS "pendingUserInputCount",+ has_actionable_proposed_plan AS "hasActionableProposedPlan",+ deleted_at AS "deletedAt"+ FROM projection_threads+ WHERE thread_id = ${threadId}+ AND deleted_at IS NULL+ LIMIT 1+ `,+ });++ const listThreadMessageRowsByThread = SqlSchema.findAll({+ Request: ThreadIdLookupInput,+ Result: ProjectionThreadMessageDbRowSchema,+ execute: ({ threadId }) =>+ sql`+ SELECT+ message_id AS "messageId",+ thread_id AS "threadId",+ turn_id AS "turnId",+ role,+ text,+ attachments_json AS "attachments",+ is_streaming AS "isStreaming",+ created_at AS "createdAt",+ updated_at AS "updatedAt"+ FROM projection_thread_messages+ WHERE thread_id = ${threadId}+ ORDER BY created_at ASC, message_id ASC+ `,+ });++ const listThreadProposedPlanRowsByThread = SqlSchema.findAll({+ Request: ThreadIdLookupInput,+ Result: ProjectionThreadProposedPlanDbRowSchema,+ execute: ({ threadId }) =>+ sql`+ SELECT+ plan_id AS "planId",+ thread_id AS "threadId",+ turn_id AS "turnId",+ plan_markdown AS "planMarkdown",+ implemented_at AS "implementedAt",+ implementation_thread_id AS "implementationThreadId",+ created_at AS "createdAt",+ updated_at AS "updatedAt"+ FROM projection_thread_proposed_plans+ WHERE thread_id = ${threadId}+ ORDER BY created_at ASC, plan_id ASC+ `,+ });++ const listThreadActivityRowsByThread = SqlSchema.findAll({+ Request: ThreadIdLookupInput,+ Result: ProjectionThreadActivityDbRowSchema,+ execute: ({ threadId }) =>+ sql`+ SELECT+ activity_id AS "activityId",+ thread_id AS "threadId",+ turn_id AS "turnId",+ tone,+ kind,+ summary,+ payload_json AS "payload",+ sequence,+ created_at AS "createdAt"+ FROM projection_thread_activities+ WHERE thread_id = ${threadId}+ ORDER BY+ CASE WHEN sequence IS NULL THEN 0 ELSE 1 END ASC,+ sequence ASC,+ created_at ASC,+ activity_id ASC+ `,+ });++ const getThreadSessionRowByThread = SqlSchema.findOneOption({+ Request: ThreadIdLookupInput,+ Result: ProjectionThreadSessionDbRowSchema,+ execute: ({ threadId }) =>+ sql`+ SELECT+ thread_id AS "threadId",+ status,+ provider_name AS "providerName",+ runtime_mode AS "runtimeMode",+ active_turn_id AS "activeTurnId",+ last_error AS "lastError",+ updated_at AS "updatedAt"+ FROM projection_thread_sessions+ WHERE thread_id = ${threadId}+ LIMIT 1+ `,+ });++ const getLatestTurnRowByThread = SqlSchema.findOneOption({+ Request: ThreadIdLookupInput,+ Result: ProjectionLatestTurnDbRowSchema,+ execute: ({ threadId }) =>+ sql`+ SELECT+ turns.thread_id AS "threadId",+ turns.turn_id AS "turnId",+ turns.state,+ turns.requested_at AS "requestedAt",+ turns.started_at AS "startedAt",+ turns.completed_at AS "completedAt",+ turns.assistant_message_id AS "assistantMessageId",+ turns.source_proposed_plan_thread_id AS "sourceProposedPlanThreadId",+ turns.source_proposed_plan_id AS "sourceProposedPlanId"+ FROM projection_threads threads+ JOIN projection_turns turns+ ON turns.thread_id = threads.thread_id+ AND turns.turn_id = threads.latest_turn_id+ WHERE threads.thread_id = ${threadId}+ AND threads.deleted_at IS NULL+ LIMIT 1+ `,+ });+const listCheckpointRowsByThread = SqlSchema.findAll({Request: ThreadIdLookupInput,Result: ProjectionCheckpointDbRowSchema,@@ -724,6 +952,145 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {}),);+ const getShellSnapshot: ProjectionSnapshotQueryShape["getShellSnapshot"] = () =>+ sql+ .withTransaction(+ Effect.all([+ listProjectRows(undefined).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getShellSnapshot:listProjects:query",+ "ProjectionSnapshotQuery.getShellSnapshot:listProjects:decodeRows",+ ),+ ),+ ),+ listThreadRows(undefined).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getShellSnapshot:listThreads:query",+ "ProjectionSnapshotQuery.getShellSnapshot:listThreads:decodeRows",+ ),+ ),+ ),+ listThreadSessionRows(undefined).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getShellSnapshot:listThreadSessions:query",+ "ProjectionSnapshotQuery.getShellSnapshot:listThreadSessions:decodeRows",+ ),+ ),+ ),+ listLatestTurnRows(undefined).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getShellSnapshot:listLatestTurns:query",+ "ProjectionSnapshotQuery.getShellSnapshot:listLatestTurns:decodeRows",+ ),+ ),+ ),+ listProjectionStateRows(undefined).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getShellSnapshot:listProjectionState:query",+ "ProjectionSnapshotQuery.getShellSnapshot:listProjectionState:decodeRows",+ ),+ ),+ ),+ ]),+ )+ .pipe(+ Effect.flatMap(([projectRows, threadRows, sessionRows, latestTurnRows, stateRows]) =>+ Effect.gen(function* () {+ let updatedAt: string | null = null;+ for (const row of projectRows) {+ updatedAt = maxIso(updatedAt, row.updatedAt);+ }+ for (const row of threadRows) {+ updatedAt = maxIso(updatedAt, row.updatedAt);+ }+ for (const row of sessionRows) {+ updatedAt = maxIso(updatedAt, row.updatedAt);+ }+ for (const row of latestTurnRows) {+ updatedAt = maxIso(updatedAt, row.requestedAt);+ if (row.startedAt !== null) {+ updatedAt = maxIso(updatedAt, row.startedAt);+ }+ if (row.completedAt !== null) {+ updatedAt = maxIso(updatedAt, row.completedAt);+ }+ }+ for (const row of stateRows) {+ updatedAt = maxIso(updatedAt, row.updatedAt);+ }++ const repositoryIdentities = new Map(+ yield* Effect.forEach(+ projectRows,+ (row) =>+ repositoryIdentityResolver+ .resolve(row.workspaceRoot)+ .pipe(Effect.map((identity) => [row.projectId, identity] as const)),+ { concurrency: repositoryIdentityResolutionConcurrency },+ ),+ );+ const latestTurnByThread = new Map(+ latestTurnRows.map((row) => [row.threadId, mapLatestTurn(row)] as const),+ );+ const sessionByThread = new Map(+ sessionRows.map((row) => [row.threadId, mapSessionRow(row)] as const),+ );++ const snapshot = {+ snapshotSequence: computeSnapshotSequence(stateRows),+ projects: projectRows+ .filter((row) => row.deletedAt === null)+ .map((row) =>+ mapProjectShellRow(row, repositoryIdentities.get(row.projectId) ?? null),+ ),+ threads: threadRows+ .filter((row) => row.deletedAt === null)+ .map(+ (row): OrchestrationThreadShell => ({+ id: row.threadId,+ projectId: row.projectId,+ title: row.title,+ modelSelection: row.modelSelection,+ runtimeMode: row.runtimeMode,+ interactionMode: row.interactionMode,+ branch: row.branch,+ worktreePath: row.worktreePath,+ latestTurn: latestTurnByThread.get(row.threadId) ?? null,+ createdAt: row.createdAt,+ updatedAt: row.updatedAt,+ archivedAt: row.archivedAt,+ session: sessionByThread.get(row.threadId) ?? null,+ latestUserMessageAt: row.latestUserMessageAt,+ hasPendingApprovals: row.pendingApprovalCount > 0,+ hasPendingUserInput: row.pendingUserInputCount > 0,+ hasActionableProposedPlan: row.hasActionableProposedPlan > 0,+ }),+ ),+ updatedAt: updatedAt ?? new Date(0).toISOString(),+ };++ return yield* decodeShellSnapshot(snapshot).pipe(+ Effect.mapError(+ toPersistenceDecodeError(+ "ProjectionSnapshotQuery.getShellSnapshot:decodeShellSnapshot",+ ),+ ),+ );+ }),+ ),+ Effect.mapError((error) => {+ if (isPersistenceError(error)) {+ return error;+ }+ return toPersistenceSqlError("ProjectionSnapshotQuery.getShellSnapshot:query")(error);+ }),+ );+const getCounts: ProjectionSnapshotQueryShape["getCounts"] = () =>readProjectionCounts(undefined).pipe(Effect.mapError(@@ -770,6 +1137,27 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {),);+ const getProjectShellById: ProjectionSnapshotQueryShape["getProjectShellById"] = (projectId) =>+ getActiveProjectRowById({ projectId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getProjectShellById:query",+ "ProjectionSnapshotQuery.getProjectShellById:decodeRow",+ ),+ ),+ Effect.flatMap((option) =>+ Option.isNone(option)+ ? Effect.succeed(Option.none<OrchestrationProjectShell>())+ : repositoryIdentityResolver+ .resolve(option.value.workspaceRoot)+ .pipe(+ Effect.map((repositoryIdentity) =>+ Option.some(mapProjectShellRow(option.value, repositoryIdentity)),+ ),+ ),+ ),+ );+const getFirstActiveThreadIdByProjectId: ProjectionSnapshotQueryShape["getFirstActiveThreadIdByProjectId"] =(projectId) =>getFirstActiveThreadIdByProject({ projectId }).pipe(@@ -826,12 +1214,217 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {});});+ const getThreadShellById: ProjectionSnapshotQueryShape["getThreadShellById"] = (threadId) =>+ Effect.gen(function* () {+ const [threadRow, latestTurnRow, sessionRow] = yield* Effect.all([+ getActiveThreadRowById({ threadId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getThreadShellById:getThread:query",+ "ProjectionSnapshotQuery.getThreadShellById:getThread:decodeRow",+ ),+ ),+ ),+ getLatestTurnRowByThread({ threadId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getThreadShellById:getLatestTurn:query",+ "ProjectionSnapshotQuery.getThreadShellById:getLatestTurn:decodeRow",+ ),+ ),+ ),+ getThreadSessionRowByThread({ threadId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getThreadShellById:getSession:query",+ "ProjectionSnapshotQuery.getThreadShellById:getSession:decodeRow",+ ),+ ),+ ),+ ]);++ if (Option.isNone(threadRow)) {+ return Option.none<OrchestrationThreadShell>();+ }++ return Option.some({+ id: threadRow.value.threadId,+ projectId: threadRow.value.projectId,+ title: threadRow.value.title,+ modelSelection: threadRow.value.modelSelection,+ runtimeMode: threadRow.value.runtimeMode,+ interactionMode: threadRow.value.interactionMode,+ branch: threadRow.value.branch,+ worktreePath: threadRow.value.worktreePath,+ latestTurn: Option.isSome(latestTurnRow) ? mapLatestTurn(latestTurnRow.value) : null,+ createdAt: threadRow.value.createdAt,+ updatedAt: threadRow.value.updatedAt,+ archivedAt: threadRow.value.archivedAt,+ session: Option.isSome(sessionRow) ? mapSessionRow(sessionRow.value) : null,+ latestUserMessageAt: threadRow.value.latestUserMessageAt,+ hasPendingApprovals: threadRow.value.pendingApprovalCount > 0,+ hasPendingUserInput: threadRow.value.pendingUserInputCount > 0,+ hasActionableProposedPlan: threadRow.value.hasActionableProposedPlan > 0,+ } satisfies OrchestrationThreadShell);+ });++ const getThreadDetailById: ProjectionSnapshotQueryShape["getThreadDetailById"] = (threadId) =>+ Effect.gen(function* () {+ const [+ threadRow,+ messageRows,+ proposedPlanRows,+ activityRows,+ checkpointRows,+ latestTurnRow,+ sessionRow,+ ] = yield* Effect.all([+ getActiveThreadRowById({ threadId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getThreadDetailById:getThread:query",+ "ProjectionSnapshotQuery.getThreadDetailById:getThread:decodeRow",+ ),+ ),+ ),+ listThreadMessageRowsByThread({ threadId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getThreadDetailById:listMessages:query",+ "ProjectionSnapshotQuery.getThreadDetailById:listMessages:decodeRows",+ ),+ ),+ ),+ listThreadProposedPlanRowsByThread({ threadId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getThreadDetailById:listPlans:query",+ "ProjectionSnapshotQuery.getThreadDetailById:listPlans:decodeRows",+ ),+ ),+ ),+ listThreadActivityRowsByThread({ threadId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getThreadDetailById:listActivities:query",+ "ProjectionSnapshotQuery.getThreadDetailById:listActivities:decodeRows",+ ),+ ),+ ),+ listCheckpointRowsByThread({ threadId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getThreadDetailById:listCheckpoints:query",+ "ProjectionSnapshotQuery.getThreadDetailById:listCheckpoints:decodeRows",+ ),+ ),+ ),+ getLatestTurnRowByThread({ threadId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getThreadDetailById:getLatestTurn:query",+ "ProjectionSnapshotQuery.getThreadDetailById:getLatestTurn:decodeRow",+ ),+ ),+ ),+ getThreadSessionRowByThread({ threadId }).pipe(+ Effect.mapError(+ toPersistenceSqlOrDecodeError(+ "ProjectionSnapshotQuery.getThreadDetailById:getSession:query",+ "ProjectionSnapshotQuery.getThreadDetailById:getSession:decodeRow",+ ),+ ),+ ),+ ]);++ if (Option.isNone(threadRow)) {+ return Option.none<OrchestrationThread>();+ }++ const thread = {+ id: threadRow.value.threadId,+ projectId: threadRow.value.projectId,+ title: threadRow.value.title,+ modelSelection: threadRow.value.modelSelection,+ runtimeMode: threadRow.value.runtimeMode,+ interactionMode: threadRow.value.interactionMode,+ branch: threadRow.value.branch,+ worktreePath: threadRow.value.worktreePath,+ latestTurn: Option.isSome(latestTurnRow) ? mapLatestTurn(latestTurnRow.value) : null,+ createdAt: threadRow.value.createdAt,+ updatedAt: threadRow.value.updatedAt,+ archivedAt: threadRow.value.archivedAt,+ deletedAt: null,+ messages: messageRows.map((row) => {+ const message = {+ id: row.messageId,+ role: row.role,+ text: row.text,+ turnId: row.turnId,+ streaming: row.isStreaming === 1,+ createdAt: row.createdAt,+ updatedAt: row.updatedAt,+ };+ if (row.attachments !== null) {+ return Object.assign(message, { attachments: row.attachments });+ }+ return message;+ }),+ proposedPlans: proposedPlanRows.map((row) => ({+ id: row.planId,+ turnId: row.turnId,+ planMarkdown: row.planMarkdown,+ implementedAt: row.implementedAt,+ implementationThreadId: row.implementationThreadId,+ createdAt: row.createdAt,+ updatedAt: row.updatedAt,+ })),+ activities: activityRows.map((row) => {+ const activity = {+ id: row.activityId,+ tone: row.tone,+ kind: row.kind,+ summary: row.summary,+ payload: row.payload,+ turnId: row.turnId,+ createdAt: row.createdAt,+ };+ if (row.sequence !== null) {+ return Object.assign(activity, { sequence: row.sequence });+ }+ return activity;+ }),+ checkpoints: checkpointRows.map((row) => ({+ turnId: row.turnId,+ checkpointTurnCount: row.checkpointTurnCount,+ checkpointRef: row.checkpointRef,+ status: row.status,+ files: row.files,+ assistantMessageId: row.assistantMessageId,+ completedAt: row.completedAt,+ })),+ session: Option.isSome(sessionRow) ? mapSessionRow(sessionRow.value) : null,+ };++ return Option.some(+ yield* decodeThread(thread).pipe(+ Effect.mapError(+ toPersistenceDecodeError("ProjectionSnapshotQuery.getThreadDetailById:decodeThread"),+ ),+ ),+ );+ });+return {getSnapshot,+ getShellSnapshot,getCounts,getActiveProjectByWorkspaceRoot,+ getProjectShellById,getFirstActiveThreadIdByProjectId,getThreadCheckpointContext,+ getThreadShellById,+ getThreadDetailById,} satisfies ProjectionSnapshotQueryShape;});diff --git a/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts b/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.tsindex 36bbf5028..be81dcbb3 100644--- a/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts+++ b/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts@@ -9,7 +9,11 @@import type {OrchestrationCheckpointSummary,OrchestrationProject,+ OrchestrationProjectShell,OrchestrationReadModel,+ OrchestrationShellSnapshot,+ OrchestrationThread,+ OrchestrationThreadShell,ProjectId,ThreadId,} from "@t3tools/contracts";@@ -44,6 +48,17 @@ export interface ProjectionSnapshotQueryShape {*/readonly getSnapshot: () => Effect.Effect<OrchestrationReadModel, ProjectionRepositoryError>;+ /**+ * Read the latest orchestration shell snapshot.+ *+ * Returns only projects and thread shell summaries so clients can bootstrap+ * lightweight navigation state without hydrating every thread body.+ */+ readonly getShellSnapshot: () => Effect.Effect<+ OrchestrationShellSnapshot,+ ProjectionRepositoryError+ >;+/*** Read aggregate projection counts without hydrating the full read model.*/@@ -56,6 +71,13 @@ export interface ProjectionSnapshotQueryShape {workspaceRoot: string,) => Effect.Effect<Option.Option<OrchestrationProject>, ProjectionRepositoryError>;+ /**+ * Read a single active project shell row by id.+ */+ readonly getProjectShellById: (+ projectId: ProjectId,+ ) => Effect.Effect<Option.Option<OrchestrationProjectShell>, ProjectionRepositoryError>;+/*** Read the earliest active thread for a project.*/@@ -69,6 +91,20 @@ export interface ProjectionSnapshotQueryShape {readonly getThreadCheckpointContext: (threadId: ThreadId,) => Effect.Effect<Option.Option<ProjectionThreadCheckpointContext>, ProjectionRepositoryError>;++ /**+ * Read a single active thread shell row by id.+ */+ readonly getThreadShellById: (+ threadId: ThreadId,+ ) => Effect.Effect<Option.Option<OrchestrationThreadShell>, ProjectionRepositoryError>;++ /**+ * Read a single active thread detail snapshot by id.+ */+ readonly getThreadDetailById: (+ threadId: ThreadId,+ ) => Effect.Effect<Option.Option<OrchestrationThread>, ProjectionRepositoryError>;}/**diff --git a/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts b/apps/server/src/persistence/Layers/ProjectionRepositories.test.tsindex 08bc24812..d42be6994 100644--- a/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts+++ b/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts@@ -88,6 +88,10 @@ projectionRepositoriesLayer("Projection repositories", (it) => {createdAt: "2026-03-24T00:00:00.000Z",updatedAt: "2026-03-24T00:00:00.000Z",archivedAt: null,+ latestUserMessageAt: null,+ pendingApprovalCount: 0,+ pendingUserInputCount: 0,+ hasActionableProposedPlan: 0,deletedAt: null,});diff --git a/apps/server/src/persistence/Layers/ProjectionThreads.ts b/apps/server/src/persistence/Layers/ProjectionThreads.tsindex 48dd51fdc..57fb88c37 100644--- a/apps/server/src/persistence/Layers/ProjectionThreads.ts+++ b/apps/server/src/persistence/Layers/ProjectionThreads.ts@@ -40,6 +40,10 @@ const makeProjectionThreadRepository = Effect.gen(function* () {created_at,updated_at,archived_at,+ latest_user_message_at,+ pending_approval_count,+ pending_user_input_count,+ has_actionable_proposed_plan,deleted_at)VALUES (@@ -55,6 +59,10 @@ const makeProjectionThreadRepository = Effect.gen(function* () {${row.createdAt},${row.updatedAt},${row.archivedAt},+ ${row.latestUserMessageAt},+ ${row.pendingApprovalCount},+ ${row.pendingUserInputCount},+ ${row.hasActionableProposedPlan},${row.deletedAt})ON CONFLICT (thread_id)@@ -70,6 +78,10 @@ const makeProjectionThreadRepository = Effect.gen(function* () {created_at = excluded.created_at,updated_at = excluded.updated_at,archived_at = excluded.archived_at,+ latest_user_message_at = excluded.latest_user_message_at,+ pending_approval_count = excluded.pending_approval_count,+ pending_user_input_count = excluded.pending_user_input_count,+ has_actionable_proposed_plan = excluded.has_actionable_proposed_plan,deleted_at = excluded.deleted_at`,});@@ -92,6 +104,10 @@ const makeProjectionThreadRepository = Effect.gen(function* () {created_at AS "createdAt",updated_at AS "updatedAt",archived_at AS "archivedAt",+ latest_user_message_at AS "latestUserMessageAt",+ pending_approval_count AS "pendingApprovalCount",+ pending_user_input_count AS "pendingUserInputCount",+ has_actionable_proposed_plan AS "hasActionableProposedPlan",deleted_at AS "deletedAt"FROM projection_threadsWHERE thread_id = ${threadId}@@ -116,6 +132,10 @@ const makeProjectionThreadRepository = Effect.gen(function* () {created_at AS "createdAt",updated_at AS "updatedAt",archived_at AS "archivedAt",+ latest_user_message_at AS "latestUserMessageAt",+ pending_approval_count AS "pendingApprovalCount",+ pending_user_input_count AS "pendingUserInputCount",+ has_actionable_proposed_plan AS "hasActionableProposedPlan",deleted_at AS "deletedAt"FROM projection_threadsWHERE project_id = ${projectId}diff --git a/apps/server/src/persistence/Migrations.ts b/apps/server/src/persistence/Migrations.tsindex 8c9fe4d9f..6c2885a37 100644--- a/apps/server/src/persistence/Migrations.ts+++ b/apps/server/src/persistence/Migrations.ts@@ -35,6 +35,7 @@ import Migration0019 from "./Migrations/019_ProjectionSnapshotLookupIndexes.ts";import Migration0020 from "./Migrations/020_AuthAccessManagement.ts";import Migration0021 from "./Migrations/021_AuthSessionClientMetadata.ts";import Migration0022 from "./Migrations/022_AuthSessionLastConnectedAt.ts";+import Migration0023 from "./Migrations/023_ProjectionThreadShellSummary.ts";/*** Migration loader with all migrations defined inline.@@ -69,6 +70,7 @@ export const migrationEntries = [[20, "AuthAccessManagement", Migration0020],[21, "AuthSessionClientMetadata", Migration0021],[22, "AuthSessionLastConnectedAt", Migration0022],+ [23, "ProjectionThreadShellSummary", Migration0023],] as const;export const makeMigrationLoader = (throughId?: number) =>diff --git a/apps/server/src/persistence/Migrations/023_ProjectionThreadShellSummary.ts b/apps/server/src/persistence/Migrations/023_ProjectionThreadShellSummary.tsnew file mode 100644index 000000000..759f87e8a--- /dev/null+++ b/apps/server/src/persistence/Migrations/023_ProjectionThreadShellSummary.ts@@ -0,0 +1,26 @@+import * as SqlClient from "effect/unstable/sql/SqlClient";+import * as Effect from "effect/Effect";++export default Effect.gen(function* () {+ const sql = yield* SqlClient.SqlClient;++ yield* sql`+ ALTER TABLE projection_threads+ ADD COLUMN latest_user_message_at TEXT+ `.pipe(Effect.catch(() => Effect.void));++ yield* sql`+ ALTER TABLE projection_threads+ ADD COLUMN pending_approval_count INTEGER NOT NULL DEFAULT 0+ `.pipe(Effect.catch(() => Effect.void));++ yield* sql`+ ALTER TABLE projection_threads+ ADD COLUMN pending_user_input_count INTEGER NOT NULL DEFAULT 0+ `.pipe(Effect.catch(() => Effect.void));++ yield* sql`+ ALTER TABLE projection_threads+ ADD COLUMN has_actionable_proposed_plan INTEGER NOT NULL DEFAULT 0+ `.pipe(Effect.catch(() => Effect.void));+});diff --git a/apps/server/src/persistence/Services/ProjectionThreads.ts b/apps/server/src/persistence/Services/ProjectionThreads.tsindex 31ec00a6e..7afdab2d5 100644--- a/apps/server/src/persistence/Services/ProjectionThreads.ts+++ b/apps/server/src/persistence/Services/ProjectionThreads.ts@@ -9,6 +9,7 @@import {IsoDateTime,ModelSelection,+ NonNegativeInt,ProjectId,ProviderInteractionMode,RuntimeMode,@@ -33,6 +34,10 @@ export const ProjectionThread = Schema.Struct({createdAt: IsoDateTime,updatedAt: IsoDateTime,archivedAt: Schema.NullOr(IsoDateTime),+ latestUserMessageAt: Schema.NullOr(IsoDateTime),+ pendingApprovalCount: NonNegativeInt,+ pendingUserInputCount: NonNegativeInt,+ hasActionableProposedPlan: NonNegativeInt,deletedAt: Schema.NullOr(IsoDateTime),});export type ProjectionThread = typeof ProjectionThread.Type;diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.tsindex fbbab1c84..c1188495d 100644--- a/apps/server/src/server.test.ts+++ b/apps/server/src/server.test.ts@@ -31,6 +31,7 @@ import {FileSystem,Layer,ManagedRuntime,+ Option,Path,Stream,} from "effect";@@ -68,7 +69,6 @@ import {ProjectionSnapshotQuery,type ProjectionSnapshotQueryShape,} from "./orchestration/Services/ProjectionSnapshotQuery.ts";-import { PersistenceSqlError } from "./persistence/Errors.ts";import { SqlitePersistenceMemory } from "./persistence/Layers/Sqlite.ts";import {ProviderRegistry,@@ -410,6 +410,20 @@ const buildAppUnderTest = (options?: {Layer.provide(Layer.mock(ProjectionSnapshotQuery)({getSnapshot: () => Effect.succeed(makeDefaultOrchestrationReadModel()),+ getShellSnapshot: () =>+ Effect.succeed({+ snapshotSequence: 0,+ projects: [],+ threads: [],+ updatedAt: new Date(0).toISOString(),+ }),+ getProjectShellById: () => Effect.succeed(Option.none()),+ getThreadShellById: () => Effect.succeed(Option.none()),+ getThreadDetailById: () => Effect.succeed(Option.none()),+ getCounts: () => Effect.succeed({ projectCount: 0, threadCount: 0 }),+ getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),+ getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),+ getThreadCheckpointContext: () => Effect.succeed(Option.none()),...options?.layers?.projectionSnapshotQuery,}),),@@ -2748,11 +2762,6 @@ it.layer(NodeServices.layer)("server router seam", (it) => {});const wsUrl = yield* getWsServerUrl("/ws");- const snapshotResult = yield* Effect.scoped(- withWsRpcClient(wsUrl, (client) => client[ORCHESTRATION_WS_METHODS.getSnapshot]({})),- );- assert.equal(snapshotResult.snapshotSequence, 1);-const dispatchResult = yield* Effect.scoped(withWsRpcClient(wsUrl, (client) =>client[ORCHESTRATION_WS_METHODS.dispatchCommand]({@@ -3306,234 +3315,6 @@ it.layer(NodeServices.layer)("server router seam", (it) => {}).pipe(Effect.provide(NodeHttpServer.layerTest)),);- it.effect(- "routes websocket rpc subscribeOrchestrationDomainEvents with replay/live overlap resilience",- () =>- Effect.gen(function* () {- const now = new Date().toISOString();- const threadId = ThreadId.make("thread-1");- let replayCursor: number | null = null;- const makeEvent = (sequence: number): OrchestrationEvent =>- ({- sequence,- eventId: `event-${sequence}`,- aggregateKind: "thread",- aggregateId: threadId,- occurredAt: now,- commandId: null,- causationEventId: null,- correlationId: null,- metadata: {},- type: "thread.reverted",- payload: {- threadId,- turnCount: sequence,- },- }) as OrchestrationEvent;-- yield* buildAppUnderTest({- layers: {- orchestrationEngine: {- getReadModel: () =>- Effect.succeed({- ...makeDefaultOrchestrationReadModel(),- snapshotSequence: 1,- }),- readEvents: (fromSequenceExclusive) => {- replayCursor = fromSequenceExclusive;- return Stream.make(makeEvent(2), makeEvent(3));- },- streamDomainEvents: Stream.make(makeEvent(3), makeEvent(4)),- },- },- });-- const wsUrl = yield* getWsServerUrl("/ws");- const events = yield* Effect.scoped(- withWsRpcClient(wsUrl, (client) =>- client[WS_METHODS.subscribeOrchestrationDomainEvents]({}).pipe(- Stream.take(3),- Stream.runCollect,- ),- ),- );-- assert.equal(replayCursor, 1);- assert.deepEqual(- Array.from(events).map((event) => event.sequence),- [2, 3, 4],- );- }).pipe(Effect.provide(NodeHttpServer.layerTest)),- );-- it.effect("enriches replayed project events only once before streaming them to subscribers", () =>- Effect.gen(function* () {- let resolveCalls = 0;- const repositoryIdentity = {- canonicalKey: "github.com/t3tools/t3code",- locator: {- source: "git-remote" as const,- remoteName: "origin",- remoteUrl: "[email protected]:t3tools/t3code.git",- },- displayName: "t3tools/t3code",- provider: "github" as const,- owner: "t3tools",- name: "t3code",- };-- yield* buildAppUnderTest({- layers: {- orchestrationEngine: {- getReadModel: () =>- Effect.succeed({- ...makeDefaultOrchestrationReadModel(),- snapshotSequence: 0,- }),- readEvents: () =>- Stream.make({- sequence: 1,- eventId: EventId.make("event-1"),- aggregateKind: "project",- aggregateId: defaultProjectId,- occurredAt: "2026-04-06T00:00:00.000Z",- commandId: null,- causationEventId: null,- correlationId: null,- metadata: {},- type: "project.meta-updated",- payload: {- projectId: defaultProjectId,- title: "Replayed Project",- updatedAt: "2026-04-06T00:00:00.000Z",- },- } satisfies Extract<OrchestrationEvent, { type: "project.meta-updated" }>),- streamDomainEvents: Stream.empty,- },- repositoryIdentityResolver: {- resolve: () => {- resolveCalls += 1;- return Effect.succeed(repositoryIdentity);- },- },- },- });-- const wsUrl = yield* getWsServerUrl("/ws");- const events = yield* Effect.scoped(- withWsRpcClient(wsUrl, (client) =>- client[WS_METHODS.subscribeOrchestrationDomainEvents]({}).pipe(- Stream.take(1),- Stream.runCollect,- ),- ),- );-- const event = Array.from(events)[0];- assert.equal(resolveCalls, 1);- assert.equal(event?.type, "project.meta-updated");- assert.deepEqual(- event && event.type === "project.meta-updated" ? event.payload.repositoryIdentity : null,- repositoryIdentity,- );- }).pipe(Effect.provide(NodeHttpServer.layerTest)),- );-- it.effect("enriches subscribed project meta updates with repository identity metadata", () =>- Effect.gen(function* () {- const repositoryIdentity = {- canonicalKey: "github.com/t3tools/t3code",- locator: {- source: "git-remote" as const,- remoteName: "upstream",- remoteUrl: "[email protected]:T3Tools/t3code.git",- },- displayName: "T3Tools/t3code",- provider: "github",- owner: "T3Tools",- name: "t3code",- };-- yield* buildAppUnderTest({- layers: {- orchestrationEngine: {- getReadModel: () =>- Effect.succeed({- ...makeDefaultOrchestrationReadModel(),- snapshotSequence: 0,- }),- streamDomainEvents: Stream.make({- sequence: 1,- eventId: EventId.make("event-1"),- aggregateKind: "project",- aggregateId: defaultProjectId,- occurredAt: "2026-04-05T00:00:00.000Z",- commandId: null,- causationEventId: null,- correlationId: null,- metadata: {},- type: "project.meta-updated",- payload: {- projectId: defaultProjectId,- title: "Renamed Project",- updatedAt: "2026-04-05T00:00:00.000Z",- },- } satisfies Extract<OrchestrationEvent, { type: "project.meta-updated" }>),- },- repositoryIdentityResolver: {- resolve: () => Effect.succeed(repositoryIdentity),- },- },- });-- const wsUrl = yield* getWsServerUrl("/ws");- const events = yield* Effect.scoped(- withWsRpcClient(wsUrl, (client) =>- client[WS_METHODS.subscribeOrchestrationDomainEvents]({}).pipe(- Stream.take(1),- Stream.runCollect,- ),- ),- );-- const event = Array.from(events)[0];- assert.equal(event?.type, "project.meta-updated");- assert.deepEqual(- event && event.type === "project.meta-updated" ? event.payload.repositoryIdentity : null,- repositoryIdentity,- );- }).pipe(Effect.provide(NodeHttpServer.layerTest)),- );-- it.effect("routes websocket rpc orchestration.getSnapshot errors", () =>- Effect.gen(function* () {- yield* buildAppUnderTest({- layers: {- projectionSnapshotQuery: {- getSnapshot: () =>- Effect.fail(- new PersistenceSqlError({- operation: "ProjectionSnapshotQuery.getSnapshot",- detail: "projection unavailable",- }),- ),- },- },- });-- const wsUrl = yield* getWsServerUrl("/ws");- const result = yield* Effect.scoped(- withWsRpcClient(wsUrl, (client) => client[ORCHESTRATION_WS_METHODS.getSnapshot]({})).pipe(- Effect.result,- ),- );-- assertTrue(result._tag === "Failure");- assertTrue(result.failure._tag === "OrchestrationGetSnapshotError");- assertInclude(result.failure.message, "Failed to load orchestration snapshot");- }).pipe(Effect.provide(NodeHttpServer.layerTest)),- );-it.effect("routes websocket rpc terminal methods", () =>Effect.gen(function* () {const snapshot = {diff --git a/apps/server/src/serverRuntimeStartup.test.ts b/apps/server/src/serverRuntimeStartup.test.tsindex c3159cc9d..7e8c0e14b 100644--- a/apps/server/src/serverRuntimeStartup.test.ts+++ b/apps/server/src/serverRuntimeStartup.test.ts@@ -70,6 +70,7 @@ it.effect("launchStartupHeartbeat does not block the caller while counts are loayield* launchStartupHeartbeat.pipe(Effect.provideService(ProjectionSnapshotQuery, {getSnapshot: () => Effect.die("unused"),+ getShellSnapshot: () => Effect.die("unused"),getCounts: () =>Deferred.await(releaseCounts).pipe(Effect.as({@@ -78,8 +79,11 @@ it.effect("launchStartupHeartbeat does not block the caller while counts are loa}),),getActiveProjectByWorkspaceRoot: () => Effect.succeed(Option.none()),+ getProjectShellById: () => Effect.succeed(Option.none()),getFirstActiveThreadIdByProjectId: () => Effect.succeed(Option.none()),getThreadCheckpointContext: () => Effect.succeed(Option.none()),+ getThreadShellById: () => Effect.succeed(Option.none()),+ getThreadDetailById: () => Effect.succeed(Option.none()),}),Effect.provideService(AnalyticsService, {record: () => Effect.void,diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.tsindex 3ef4a8646..c3672226e 100644--- a/apps/server/src/ws.ts+++ b/apps/server/src/ws.ts@@ -1,4 +1,4 @@-import { Cause, Effect, Layer, Queue, Ref, Schema, Stream } from "effect";+import { Cause, Effect, Layer, Option, Queue, Ref, Schema, Stream } from "effect";import {type AuthAccessStreamEvent,AuthSessionId,@@ -9,6 +9,7 @@ import {type GitManagerServiceError,OrchestrationDispatchCommandError,type OrchestrationEvent,+ type OrchestrationShellStreamEvent,OrchestrationGetFullThreadDiffError,OrchestrationGetSnapshotError,OrchestrationGetTurnDiffError,@@ -62,6 +63,28 @@ import {} from "./auth/Services/SessionCredentialService";import { respondToAuthError } from "./auth/http";+function isThreadDetailEvent(event: OrchestrationEvent): event is Extract<+ OrchestrationEvent,+ {+ type:+ | "thread.message-sent"+ | "thread.proposed-plan-upserted"+ | "thread.activity-appended"+ | "thread.turn-diff-completed"+ | "thread.reverted"+ | "thread.session-set";+ }+> {+ return (+ event.type === "thread.message-sent" ||+ event.type === "thread.proposed-plan-upserted" ||+ event.type === "thread.activity-appended" ||+ event.type === "thread.turn-diff-completed" ||+ event.type === "thread.reverted" ||+ event.type === "thread.session-set"+ );+}+function toAuthAccessStreamEvent(change: BootstrapCredentialChange | SessionCredentialChange,revision: number,@@ -222,6 +245,57 @@ const makeWsRpcLayer = (currentSessionId: AuthSessionId) =>const enrichOrchestrationEvents = (events: ReadonlyArray<OrchestrationEvent>) =>Effect.forEach(events, enrichProjectEvent, { concurrency: 4 });+ const toShellStreamEvent = (+ event: OrchestrationEvent,+ ): Effect.Effect<Option.Option<OrchestrationShellStreamEvent>, never, never> => {+ switch (event.type) {+ case "project.created":+ case "project.meta-updated":+ return projectionSnapshotQuery.getProjectShellById(event.payload.projectId).pipe(+ Effect.map((project) =>+ Option.map(project, (nextProject) => ({+ kind: "project-upserted" as const,+ sequence: event.sequence,+ project: nextProject,+ })),+ ),+ Effect.catch(() => Effect.succeed(Option.none())),+ );+ case "project.deleted":+ return Effect.succeed(+ Option.some({+ kind: "project-removed" as const,+ sequence: event.sequence,+ projectId: event.payload.projectId,+ }),+ );+ case "thread.deleted":+ return Effect.succeed(+ Option.some({+ kind: "thread-removed" as const,+ sequence: event.sequence,+ threadId: event.payload.threadId,+ }),+ );+ default:+ if (event.aggregateKind !== "thread") {+ return Effect.succeed(Option.none());+ }+ return projectionSnapshotQuery+ .getThreadShellById(ThreadId.make(event.aggregateId))+ .pipe(+ Effect.map((thread) =>+ Option.map(thread, (nextThread) => ({+ kind: "thread-upserted" as const,+ sequence: event.sequence,+ thread: nextThread,+ })),+ ),+ Effect.catch(() => Effect.succeed(Option.none())),+ );+ }+ };+const dispatchBootstrapTurnStart = (command: Extract<OrchestrationCommand, { type: "thread.turn.start" }>,): Effect.Effect<{ readonly sequence: number }, OrchestrationDispatchCommandError> =>@@ -467,20 +541,6 @@ const makeWsRpcLayer = (currentSessionId: AuthSessionId) =>.pipe(Effect.ignoreCause({ log: true }), Effect.forkDetach, Effect.asVoid);return WsRpcGroup.of({- [ORCHESTRATION_WS_METHODS.getSnapshot]: (_input) =>- observeRpcEffect(- ORCHESTRATION_WS_METHODS.getSnapshot,- projectionSnapshotQuery.getSnapshot().pipe(- Effect.mapError(- (cause) =>- new OrchestrationGetSnapshotError({- message: "Failed to load orchestration snapshot",- cause,- }),- ),- ),- { "rpc.aggregate": "orchestration" },- ),[ORCHESTRATION_WS_METHODS.dispatchCommand]: (command) =>observeRpcEffect(ORCHESTRATION_WS_METHODS.dispatchCommand,@@ -561,65 +621,85 @@ const makeWsRpcLayer = (currentSessionId: AuthSessionId) =>),{ "rpc.aggregate": "orchestration" },),- [WS_METHODS.subscribeOrchestrationDomainEvents]: (_input) =>+ [ORCHESTRATION_WS_METHODS.subscribeShell]: (_input) =>observeRpcStreamEffect(- WS_METHODS.subscribeOrchestrationDomainEvents,+ ORCHESTRATION_WS_METHODS.subscribeShell,Effect.gen(function* () {- const snapshot = yield* orchestrationEngine.getReadModel();- const fromSequenceExclusive = snapshot.snapshotSequence;- const replayEvents: Array<OrchestrationEvent> = yield* Stream.runCollect(- orchestrationEngine.readEvents(fromSequenceExclusive),- ).pipe(- Effect.map((events) => Array.from(events)),- Effect.flatMap(enrichOrchestrationEvents),- Effect.catch(() => Effect.succeed([] as Array<OrchestrationEvent>)),+ const snapshot = yield* projectionSnapshotQuery.getShellSnapshot().pipe(+ Effect.mapError(+ (cause) =>+ new OrchestrationGetSnapshotError({+ message: "Failed to load orchestration shell snapshot",+ cause,+ }),+ ),);- const replayStream = Stream.fromIterable(replayEvents);+const liveStream = orchestrationEngine.streamDomainEvents.pipe(- Stream.mapEffect(enrichProjectEvent),+ Stream.mapEffect(toShellStreamEvent),+ Stream.flatMap((event) =>+ Option.isSome(event) ? Stream.succeed(event.value) : Stream.empty,+ ),);- const source = Stream.merge(replayStream, liveStream);- type SequenceState = {- readonly nextSequence: number;- readonly pendingBySequence: Map<number, OrchestrationEvent>;- };- const state = yield* Ref.make<SequenceState>({- nextSequence: fromSequenceExclusive + 1,- pendingBySequence: new Map<number, OrchestrationEvent>(),- });- return source.pipe(- Stream.mapEffect((event) =>- Ref.modify(- state,- ({- nextSequence,- pendingBySequence,- }): [Array<OrchestrationEvent>, SequenceState] => {- if (event.sequence < nextSequence || pendingBySequence.has(event.sequence)) {- return [[], { nextSequence, pendingBySequence }];- }-- const updatedPending = new Map(pendingBySequence);- updatedPending.set(event.sequence, event);-- const emit: Array<OrchestrationEvent> = [];- let expected = nextSequence;- for (;;) {- const expectedEvent = updatedPending.get(expected);- if (!expectedEvent) {- break;- }- emit.push(expectedEvent);- updatedPending.delete(expected);- expected += 1;- }-- return [emit, { nextSequence: expected, pendingBySequence: updatedPending }];- },+ return Stream.concat(+ Stream.make({+ kind: "snapshot" as const,+ snapshot,+ }),+ liveStream,+ );+ }),+ { "rpc.aggregate": "orchestration" },+ ),+ [ORCHESTRATION_WS_METHODS.subscribeThread]: (input) =>+ observeRpcStreamEffect(+ ORCHESTRATION_WS_METHODS.subscribeThread,+ Effect.gen(function* () {+ const [threadDetail, snapshotSequence] = yield* Effect.all([+ projectionSnapshotQuery.getThreadDetailById(input.threadId).pipe(+ Effect.mapError(+ (cause) =>+ new OrchestrationGetSnapshotError({+ message: `Failed to load thread ${input.threadId}`,+ cause,+ }),),),- Stream.flatMap((events) => Stream.fromIterable(events)),+ orchestrationEngine+ .getReadModel()+ .pipe(Effect.map((readModel) => readModel.snapshotSequence)),+ ]);++ if (Option.isNone(threadDetail)) {+ return yield* new OrchestrationGetSnapshotError({+ message: `Thread ${input.threadId} was not found`,+ cause: input.threadId,+ });+ }++ const liveStream = orchestrationEngine.streamDomainEvents.pipe(+ Stream.filter(+ (event) =>+ event.aggregateKind === "thread" &&+ event.aggregateId === input.threadId &&+ isThreadDetailEvent(event),+ ),+ Stream.map((event) => ({+ kind: "event" as const,+ event,+ })),+ );++ return Stream.concat(+ Stream.make({+ kind: "snapshot" as const,+ snapshot: {+ snapshotSequence,+ thread: threadDetail.value,+ },+ }),+ liveStream,);}),{ "rpc.aggregate": "orchestration" },diff --git a/apps/web/src/authBootstrap.test.ts b/apps/web/src/authBootstrap.test.tsindex f86d7c5a7..b06c4248f 100644--- a/apps/web/src/authBootstrap.test.ts+++ b/apps/web/src/authBootstrap.test.ts@@ -424,7 +424,7 @@ describe("resolveInitialServerAuthGateState", () => {expect(fetchMock.mock.calls[3]?.[0]).toBe("http://localhost:3773/api/auth/session");});- it("revalidates the server session state after a previous authenticated result", async () => {+ it("memoizes the authenticated gate state after the first successful read", async () => {const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce(@@ -459,15 +459,9 @@ describe("resolveInitialServerAuthGateState", () => {status: "authenticated",});await expect(resolveInitialServerAuthGateState()).resolves.toEqual({- status: "requires-auth",- auth: {- policy: "loopback-browser",- bootstrapMethods: ["one-time-token"],- sessionMethods: ["browser-session-cookie"],- sessionCookieName: "t3_session",- },+ status: "authenticated",});- expect(fetchMock).toHaveBeenCalledTimes(2);+ expect(fetchMock).toHaveBeenCalledTimes(1);});it("creates a pairing credential from the authenticated auth endpoint", async () => {diff --git a/apps/web/src/components/ChatView.browser.tsx b/apps/web/src/components/ChatView.browser.tsxindex 48c628491..0b49f1d7d 100644--- a/apps/web/src/components/ChatView.browser.tsx+++ b/apps/web/src/components/ChatView.browser.tsx@@ -6,7 +6,6 @@ import {ORCHESTRATION_WS_METHODS,EnvironmentId,type MessageId,- type OrchestrationEvent,type OrchestrationReadModel,type ProjectId,type ServerConfig,@@ -112,6 +111,7 @@ const COMPACT_FOOTER_VIEWPORT: ViewportSpec = {textTolerancePx: 56,attachmentTolerancePx: 56,};+interface MountedChatView {[Symbol.asyncDispose]: () => Promise<void>;cleanup: () => Promise<void>;@@ -385,74 +385,94 @@ function addThreadToSnapshot(};}-function createThreadCreatedEvent(threadId: ThreadId, sequence: number): OrchestrationEvent {+function toShellThread(thread: OrchestrationReadModel["threads"][number]) {return {- sequence,- eventId: EventId.make(`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,- },+ id: thread.id,+ projectId: thread.projectId,+ title: thread.title,+ modelSelection: thread.modelSelection,+ runtimeMode: thread.runtimeMode,+ interactionMode: thread.interactionMode,+ branch: thread.branch,+ worktreePath: thread.worktreePath,+ latestTurn: thread.latestTurn,+ createdAt: thread.createdAt,+ updatedAt: thread.updatedAt,+ archivedAt: thread.archivedAt,+ session: thread.session,+ latestUserMessageAt:+ thread.messages.findLast((message) => message.role === "user")?.createdAt ?? null,+ hasPendingApprovals: false,+ hasPendingUserInput: false,+ hasActionableProposedPlan: false,};}-function createThreadSessionSetEvent(threadId: ThreadId, sequence: number): OrchestrationEvent {+function toShellSnapshot(snapshot: OrchestrationReadModel) {return {- sequence,- eventId: EventId.make(`event-thread-session-set-${sequence}`),- aggregateKind: "thread",- aggregateId: threadId,- occurredAt: NOW_ISO,- commandId: null,- causationEventId: null,- correlationId: null,- metadata: {},- type: "thread.session-set",- payload: {- threadId,- session: {- threadId,- status: "running",- providerName: "codex",- runtimeMode: "full-access",- activeTurnId: `turn-${threadId}` as TurnId,- lastError: null,- updatedAt: NOW_ISO,- },- },+ snapshotSequence: snapshot.snapshotSequence,+ projects: snapshot.projects.map((project) => ({+ id: project.id,+ title: project.title,+ workspaceRoot: project.workspaceRoot,+ repositoryIdentity: project.repositoryIdentity ?? null,+ defaultModelSelection: project.defaultModelSelection,+ scripts: project.scripts,+ createdAt: project.createdAt,+ updatedAt: project.updatedAt,+ })),+ threads: snapshot.threads.map(toShellThread),+ updatedAt: snapshot.updatedAt,};}-function sendOrchestrationDomainEvent(event: OrchestrationEvent): void {- rpcHarness.emitStreamValue(WS_METHODS.subscribeOrchestrationDomainEvents, event);+function updateThreadSessionInSnapshot(+ snapshot: OrchestrationReadModel,+ threadId: ThreadId,+ session: OrchestrationReadModel["threads"][number]["session"],+): OrchestrationReadModel {+ return {+ ...snapshot,+ snapshotSequence: snapshot.snapshotSequence + 1,+ threads: snapshot.threads.map((thread) =>+ thread.id === threadId+ ? {+ ...thread,+ session,+ updatedAt: NOW_ISO,+ }+ : thread,+ ),+ };+}++function sendShellThreadUpsert(+ threadId: ThreadId,+ options?: {+ readonly session?: OrchestrationReadModel["threads"][number]["session"];+ },+): void {+ const thread = fixture.snapshot.threads.find((entry) => entry.id === threadId);+ if (!thread) {+ throw new Error(`Expected thread ${threadId} in snapshot.`);+ }++ const shellThread =+ options?.session !== undefined+ ? toShellThread({ ...thread, session: options.session })+ : toShellThread(thread);+ rpcHarness.emitStreamValue(ORCHESTRATION_WS_METHODS.subscribeShell, {+ kind: "thread-upserted",+ sequence: fixture.snapshot.snapshotSequence,+ thread: shellThread,+ });}async function waitForWsClient(): Promise<void> {await vi.waitFor(() => {expect(- wsRequests.some(- (request) => request._tag === WS_METHODS.subscribeOrchestrationDomainEvents,- ),+ wsRequests.some((request) => request._tag === ORCHESTRATION_WS_METHODS.subscribeShell),).toBe(true);expect(wsRequests.some((request) => request._tag === WS_METHODS.subscribeServerLifecycle),@@ -512,15 +532,21 @@ async function waitForAppBootstrap(): Promise<void> {async function materializePromotedDraftThreadViaDomainEvent(threadId: ThreadId): Promise<void> {await waitForWsClient();fixture.snapshot = addThreadToSnapshot(fixture.snapshot, threadId);- sendOrchestrationDomainEvent(- createThreadCreatedEvent(threadId, fixture.snapshot.snapshotSequence),- );+ fixture.snapshot = updateThreadSessionInSnapshot(fixture.snapshot, threadId, null);+ sendShellThreadUpsert(threadId, { session: null });}async function startPromotedServerThreadViaDomainEvent(threadId: ThreadId): Promise<void> {- sendOrchestrationDomainEvent(- createThreadSessionSetEvent(threadId, fixture.snapshot.snapshotSequence + 1),- );+ fixture.snapshot = updateThreadSessionInSnapshot(fixture.snapshot, threadId, {+ threadId,+ status: "running",+ providerName: "codex",+ runtimeMode: "full-access",+ activeTurnId: `turn-${threadId}` as TurnId,+ lastError: null,+ updatedAt: NOW_ISO,+ });+ sendShellThreadUpsert(threadId);}async function promoteDraftThreadViaDomainEvent(threadId: ThreadId): Promise<void> {@@ -871,9 +897,6 @@ function resolveWsRpc(body: NormalizedWsRpcRequestBody): unknown {return customResult;}const tag = body._tag;- if (tag === ORCHESTRATION_WS_METHODS.getSnapshot) {- return fixture.snapshot;- }if (tag === WS_METHODS.serverGetConfig) {return fixture.serverConfig;}@@ -1469,6 +1492,28 @@ describe("ChatView timeline estimator parity (full app)", () => {},];}+ if (request._tag === ORCHESTRATION_WS_METHODS.subscribeShell) {+ return [+ {+ kind: "snapshot",+ snapshot: toShellSnapshot(fixture.snapshot),+ },+ ];+ }+ if (request._tag === ORCHESTRATION_WS_METHODS.subscribeThread) {+ const thread = fixture.snapshot.threads.find((entry) => entry.id === request.threadId);+ return thread+ ? [+ {+ kind: "snapshot",+ snapshot: {+ snapshotSequence: fixture.snapshot.snapshotSequence,+ thread,+ },+ },+ ]+ : [];+ }return [];},});@@ -1510,7 +1555,6 @@ describe("ChatView timeline estimator parity (full app)", () => {customWsRpcResolver = null;document.body.innerHTML = "";});-it("re-expands the bootstrap project using its scoped key", async () => {useUiStateStore.setState({projectExpandedById: {diff --git a/apps/web/src/components/ChatView.logic.test.ts b/apps/web/src/components/ChatView.logic.test.tsindex 1b96265a4..37bf41b5b 100644--- a/apps/web/src/components/ChatView.logic.test.ts+++ b/apps/web/src/components/ChatView.logic.test.ts@@ -530,6 +530,142 @@ describe("hasServerAcknowledgedLocalDispatch", () => {).toBe(true);});+ it("does not clear local dispatch while the session is running a newer turn than latestTurn", () => {+ const localDispatch = createLocalDispatchSnapshot({+ id: ThreadId.make("thread-1"),+ environmentId: localEnvironmentId,+ 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: "running",+ latestTurn: previousLatestTurn,+ session: {+ ...previousSession,+ status: "running",+ orchestrationStatus: "running",+ activeTurnId: TurnId.make("turn-2"),+ updatedAt: "2026-03-29T00:01:00.000Z",+ },+ hasPendingApproval: false,+ hasPendingUserInput: false,+ threadError: null,+ }),+ ).toBe(false);+ });++ it("does not clear local dispatch while the session is running but latestTurn has not advanced yet", () => {+ const localDispatch = createLocalDispatchSnapshot({+ id: ThreadId.make("thread-1"),+ environmentId: localEnvironmentId,+ 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: "running",+ latestTurn: previousLatestTurn,+ session: {+ ...previousSession,+ status: "running",+ orchestrationStatus: "running",+ activeTurnId: undefined,+ updatedAt: "2026-03-29T00:01:00.000Z",+ },+ hasPendingApproval: false,+ hasPendingUserInput: false,+ threadError: null,+ }),+ ).toBe(false);+ });++ it("clears local dispatch once the running latestTurn matches the active session turn", () => {+ const localDispatch = createLocalDispatchSnapshot({+ id: ThreadId.make("thread-1"),+ environmentId: localEnvironmentId,+ 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: "running",+ latestTurn: {+ ...previousLatestTurn,+ turnId: TurnId.make("turn-2"),+ state: "running",+ requestedAt: "2026-03-29T00:01:00.000Z",+ startedAt: "2026-03-29T00:01:01.000Z",+ completedAt: null,+ },+ session: {+ ...previousSession,+ status: "running",+ orchestrationStatus: "running",+ activeTurnId: TurnId.make("turn-2"),+ updatedAt: "2026-03-29T00:01:01.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.make("thread-1"),diff --git a/apps/web/src/components/ChatView.logic.ts b/apps/web/src/components/ChatView.logic.tsindex a753a71b3..510fef6d3 100644--- a/apps/web/src/components/ChatView.logic.ts+++ b/apps/web/src/components/ChatView.logic.ts@@ -322,23 +322,37 @@ export function hasServerAcknowledgedLocalDispatch(input: {if (!input.localDispatch) {return false;}- if (- input.phase === "running" ||- input.hasPendingApproval ||- input.hasPendingUserInput ||- Boolean(input.threadError)- ) {+ if (input.hasPendingApproval || input.hasPendingUserInput || Boolean(input.threadError)) {return true;}const latestTurn = input.latestTurn ?? null;const session = input.session ?? null;-- return (+ const latestTurnChanged =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.latestTurnCompletedAt !== (latestTurn?.completedAt ?? null);++ if (input.phase === "running") {+ if (!latestTurnChanged) {+ return false;+ }+ if (latestTurn?.startedAt === null || latestTurn === null) {+ return false;+ }+ if (+ session?.activeTurnId !== undefined &&+ session.activeTurnId !== null &&+ latestTurn?.turnId !== session.activeTurnId+ ) {+ return false;+ }+ return true;+ }++ return (+ latestTurnChanged ||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.tsxindex 93198f942..0bb0e408b 100644--- a/apps/web/src/components/ChatView.tsx+++ b/apps/web/src/components/ChatView.tsx@@ -169,6 +169,7 @@ import {useServerKeybindings,} from "~/rpc/serverState";import { sanitizeThreadErrorMessage } from "~/rpc/transportError";+import { retainThreadDetailSubscription } from "../environments/runtime/service";const IMAGE_ONLY_BOOTSTRAP_PROMPT ="[User attached one or more images without additional text. Respond using the conversation context and the attached image(s).]";@@ -825,6 +826,13 @@ export default function ChatView(props: ChatViewProps) {useMemo(() => createProjectSelectorByRef(activeProjectRef), [activeProjectRef]),);+ useEffect(() => {+ if (routeKind !== "server") {+ return;+ }+ return retainThreadDetailSubscription(environmentId, threadId);+ }, [environmentId, routeKind, threadId]);+// Compute the list of environments this logical project spans, used to// drive the environment picker in BranchToolbar.const allProjects = useStore(useShallow(selectProjectsAcrossEnvironments));diff --git a/apps/web/src/components/KeybindingsToast.browser.tsx b/apps/web/src/components/KeybindingsToast.browser.tsxindex 223f5d8eb..92ba61aa5 100644--- a/apps/web/src/components/KeybindingsToast.browser.tsx+++ b/apps/web/src/components/KeybindingsToast.browser.tsx@@ -169,6 +169,43 @@ function createMinimalSnapshot(): OrchestrationReadModel {};}+function toShellSnapshot(snapshot: OrchestrationReadModel) {+ return {+ snapshotSequence: snapshot.snapshotSequence,+ projects: snapshot.projects.map((project) => ({+ id: project.id,+ title: project.title,+ workspaceRoot: project.workspaceRoot,+ repositoryIdentity: project.repositoryIdentity ?? null,+ defaultModelSelection: project.defaultModelSelection,+ scripts: project.scripts,+ createdAt: project.createdAt,+ updatedAt: project.updatedAt,+ })),+ threads: snapshot.threads.map((thread) => ({+ id: thread.id,+ projectId: thread.projectId,+ title: thread.title,+ modelSelection: thread.modelSelection,+ runtimeMode: thread.runtimeMode,+ interactionMode: thread.interactionMode,+ branch: thread.branch,+ worktreePath: thread.worktreePath,+ latestTurn: thread.latestTurn,+ createdAt: thread.createdAt,+ updatedAt: thread.updatedAt,+ archivedAt: thread.archivedAt,+ session: thread.session,+ latestUserMessageAt:+ thread.messages.findLast((message) => message.role === "user")?.createdAt ?? null,+ hasPendingApprovals: false,+ hasPendingUserInput: false,+ hasActionableProposedPlan: false,+ })),+ updatedAt: snapshot.updatedAt,+ };+}+function buildFixture(): TestFixture {return {snapshot: createMinimalSnapshot(),@@ -190,9 +227,6 @@ function buildFixture(): TestFixture {}function resolveWsRpc(tag: string): unknown {- if (tag === ORCHESTRATION_WS_METHODS.getSnapshot) {- return fixture.snapshot;- }if (tag === WS_METHODS.serverGetConfig) {return fixture.serverConfig;}@@ -429,6 +463,28 @@ describe("Keybindings update toast", () => {},];}+ if (request._tag === ORCHESTRATION_WS_METHODS.subscribeShell) {+ return [+ {+ kind: "snapshot",+ snapshot: toShellSnapshot(fixture.snapshot),+ },+ ];+ }+ if (+ request._tag === ORCHESTRATION_WS_METHODS.subscribeThread &&+ request.threadId === THREAD_ID+ ) {+ return [+ {+ kind: "snapshot",+ snapshot: {+ snapshotSequence: fixture.snapshot.snapshotSequence,+ thread: fixture.snapshot.threads[0],+ },+ },+ ];+ }return [];},});diff --git a/apps/web/src/environmentApi.ts b/apps/web/src/environmentApi.tsindex 5f23a53a7..06fce4ea6 100644--- a/apps/web/src/environmentApi.ts+++ b/apps/web/src/environmentApi.ts@@ -32,16 +32,13 @@ export function createEnvironmentApi(rpcClient: WsRpcClient): EnvironmentApi {preparePullRequestThread: rpcClient.git.preparePullRequestThread,},orchestration: {- getSnapshot: rpcClient.orchestration.getSnapshot,dispatchCommand: rpcClient.orchestration.dispatchCommand,getTurnDiff: rpcClient.orchestration.getTurnDiff,getFullThreadDiff: rpcClient.orchestration.getFullThreadDiff,- replayEvents: (fromSequenceExclusive) =>- rpcClient.orchestration- .replayEvents({ fromSequenceExclusive })- .then((events) => [...events]),- onDomainEvent: (callback, options) =>- rpcClient.orchestration.onDomainEvent(callback, options),+ subscribeShell: (callback, options) =>+ rpcClient.orchestration.subscribeShell(callback, options),+ subscribeThread: (input, callback, options) =>+ rpcClient.orchestration.subscribeThread(input, callback, options),},};}diff --git a/apps/web/src/environments/primary/auth.ts b/apps/web/src/environments/primary/auth.tsindex ae2d6bd64..42eaa821c 100644--- a/apps/web/src/environments/primary/auth.ts+++ b/apps/web/src/environments/primary/auth.ts@@ -57,6 +57,7 @@ type ServerAuthGateState =};let bootstrapPromise: Promise<ServerAuthGateState> | null = null;+let resolvedAuthenticatedGateState: ServerAuthGateState | null = null;const AUTH_SESSION_ESTABLISH_TIMEOUT_MS = 2_000;const AUTH_SESSION_ESTABLISH_STEP_MS = 100;@@ -224,6 +225,7 @@ export async function submitServerAuthCredential(credential: string): Promise<vothrow new Error("Enter a pairing token to continue.");}+ resolvedAuthenticatedGateState = null;await exchangeBootstrapCredential(trimmedCredential);bootstrapPromise = null;stripPairingTokenFromUrl();@@ -341,19 +343,31 @@ export async function revokeOtherServerClientSessions(): Promise<number> {}export async function resolveInitialServerAuthGateState(): Promise<ServerAuthGateState> {+ if (resolvedAuthenticatedGateState?.status === "authenticated") {+ return resolvedAuthenticatedGateState;+ }+if (bootstrapPromise) {return bootstrapPromise;}const nextPromise = bootstrapServerAuth();bootstrapPromise = nextPromise;- return nextPromise.finally(() => {- if (bootstrapPromise === nextPromise) {- bootstrapPromise = null;- }- });+ return nextPromise+ .then((result) => {+ if (result.status === "authenticated") {+ resolvedAuthenticatedGateState = result;+ }+ return result;+ })+ .finally(() => {+ if (bootstrapPromise === nextPromise) {+ bootstrapPromise = null;+ }+ });}export function __resetServerAuthBootstrapForTests() {bootstrapPromise = null;+ resolvedAuthenticatedGateState = null;}diff --git a/apps/web/src/environments/runtime/connection.test.ts b/apps/web/src/environments/runtime/connection.test.tsindex 4dc650154..57f232414 100644--- a/apps/web/src/environments/runtime/connection.test.ts+++ b/apps/web/src/environments/runtime/connection.test.ts@@ -4,29 +4,18 @@ import { describe, expect, it, vi } from "vitest";import { createEnvironmentConnection } from "./connection";import type { WsRpcClient } from "~/rpc/wsRpcClient";-function createTestClient(options?: {- readonly getSnapshot?: () => Promise<{ readonly snapshotSequence: number }>;- readonly replayEvents?: () => Promise<ReadonlyArray<any>>;-}) {+function createTestClient() {const lifecycleListeners = new Set<(event: any) => void>();const configListeners = new Set<(event: any) => void>();const terminalListeners = new Set<(event: any) => void>();- let domainResubscribe: (() => void) | undefined;-- const getSnapshot = vi.fn(- options?.getSnapshot ??- (async () =>- ({- snapshotSequence: 1,- projects: [],- threads: [],- }) as any),- );- const replayEvents = vi.fn(options?.replayEvents ?? (async () => []));+ const shellListeners = new Set<(event: any) => void>();+ let shellResubscribe: (() => void) | undefined;const client = {dispose: vi.fn(async () => undefined),- reconnect: vi.fn(async () => undefined),+ reconnect: vi.fn(async () => {+ shellResubscribe?.();+ }),server: {getConfig: vi.fn(async () => ({environment: {@@ -48,19 +37,33 @@ function createTestClient(options?: {updateSettings: vi.fn(async () => undefined),},orchestration: {- getSnapshot,dispatchCommand: vi.fn(async () => undefined),getTurnDiff: vi.fn(async () => undefined),getFullThreadDiff: vi.fn(async () => undefined),- replayEvents,- onDomainEvent: vi.fn((_: (event: any) => void, options?: { onResubscribe?: () => void }) => {- domainResubscribe = options?.onResubscribe;- return () => {- if (domainResubscribe === options?.onResubscribe) {- domainResubscribe = undefined;- }- };- }),+ subscribeShell: vi.fn(+ (listener: (event: any) => void, options?: { onResubscribe?: () => void }) => {+ shellListeners.add(listener);+ shellResubscribe = options?.onResubscribe;+ queueMicrotask(() => {+ listener({+ kind: "snapshot",+ snapshot: {+ snapshotSequence: 1,+ projects: [],+ threads: [],+ updatedAt: "2026-04-12T00:00:00.000Z",+ },+ });+ });+ return () => {+ shellListeners.delete(listener);+ if (shellResubscribe === options?.onResubscribe) {+ shellResubscribe = undefined;+ }+ };+ },+ ),+ subscribeThread: vi.fn(() => () => undefined),},terminal: {open: vi.fn(async () => undefined),@@ -99,8 +102,6 @@ function createTestClient(options?: {return {client,- getSnapshot,- replayEvents,emitWelcome: (environmentId: EnvironmentId) => {for (const listener of lifecycleListeners) {listener({@@ -125,17 +126,27 @@ function createTestClient(options?: {});}},- triggerDomainResubscribe: () => {- domainResubscribe?.();+ emitShellSnapshot: (snapshotSequence: number) => {+ for (const listener of shellListeners) {+ listener({+ kind: "snapshot",+ snapshot: {+ snapshotSequence,+ projects: [],+ threads: [],+ updatedAt: "2026-04-12T00:00:00.000Z",+ },+ });+ }},};}describe("createEnvironmentConnection", () => {- it("bootstraps a snapshot immediately for a new connection", async () => {+ it("bootstraps from the shell subscription snapshot", async () => {const environmentId = EnvironmentId.make("env-1");- const { client, getSnapshot } = createTestClient();- const syncSnapshot = vi.fn();+ const { client } = createTestClient();+ const syncShellSnapshot = vi.fn();const connection = createEnvironmentConnection({kind: "saved",@@ -150,16 +161,14 @@ describe("createEnvironmentConnection", () => {environmentId,},client,- applyEventBatch: vi.fn(),- syncSnapshot,+ applyShellEvent: vi.fn(),+ syncShellSnapshot,applyTerminalEvent: vi.fn(),});- await Promise.resolve();- await Promise.resolve();+ await connection.ensureBootstrapped();- expect(getSnapshot).toHaveBeenCalledTimes(1);- expect(syncSnapshot).toHaveBeenCalledWith(+ expect(syncShellSnapshot).toHaveBeenCalledWith(expect.objectContaining({ snapshotSequence: 1 }),environmentId,);@@ -184,8 +193,8 @@ describe("createEnvironmentConnection", () => {environmentId,},client,- applyEventBatch: vi.fn(),- syncSnapshot: vi.fn(),+ applyShellEvent: vi.fn(),+ syncShellSnapshot: vi.fn(),applyTerminalEvent: vi.fn(),});@@ -196,58 +205,10 @@ describe("createEnvironmentConnection", () => {await connection.dispose();});- it("rejects ensureBootstrapped when snapshot recovery fails", async () => {+ it("waits for a fresh shell snapshot after reconnect", async () => {const environmentId = EnvironmentId.make("env-1");- const snapshotError = new Error("snapshot failed");- const { client } = createTestClient({- getSnapshot: async () => {- throw snapshotError;- },- });-- const connection = createEnvironmentConnection({- kind: "saved",- knownEnvironment: {- id: "env-1",- label: "Remote env",- source: "manual",- target: {- httpBaseUrl: "http://example.test",- wsBaseUrl: "ws://example.test",- },- environmentId,- },- client,- applyEventBatch: vi.fn(),- syncSnapshot: vi.fn(),- applyTerminalEvent: vi.fn(),- });-- await expect(connection.ensureBootstrapped()).rejects.toThrow("snapshot failed");-- await connection.dispose();- });-- it("retries replay recovery after transport disconnects during resubscribe", async () => {- const environmentId = EnvironmentId.make("env-1");- let replayAttempts = 0;- const applyEventBatch = vi.fn();- const { client, replayEvents, triggerDomainResubscribe } = createTestClient({- replayEvents: async () => {- replayAttempts += 1;- if (replayAttempts === 1) {- throw new Error("SocketCloseError: 1006");- }-- return [- {- sequence: 2,- type: "thread.created",- payload: {},- },- ];- },- });+ const { client, emitShellSnapshot } = createTestClient();+ const syncShellSnapshot = vi.fn();const connection = createEnvironmentConnection({kind: "saved",@@ -262,85 +223,26 @@ describe("createEnvironmentConnection", () => {environmentId,},client,- applyEventBatch,- syncSnapshot: vi.fn(),+ applyShellEvent: vi.fn(),+ syncShellSnapshot,applyTerminalEvent: vi.fn(),});- await Promise.resolve();- await Promise.resolve();-- triggerDomainResubscribe();-- await vi.waitFor(() => {- expect(replayEvents).toHaveBeenCalledTimes(2);- expect(applyEventBatch).toHaveBeenCalledWith(- [- expect.objectContaining({- sequence: 2,- }),- ],- environmentId,- );- });-- await connection.dispose();- });- it("swallows replay recovery failures triggered by resubscribe", async () => {- const environmentId = EnvironmentId.make("env-1");- const snapshotError = new Error("snapshot failed");- let snapshotCalls = 0;- const { client, triggerDomainResubscribe } = createTestClient({- getSnapshot: async () => {- snapshotCalls += 1;- if (snapshotCalls === 1) {- return {- snapshotSequence: 1,- projects: [],- threads: [],- } as any;- }-- throw snapshotError;- },- replayEvents: async () => {- throw new Error("SocketCloseError: 1006");- },- });-- const connection = createEnvironmentConnection({- kind: "saved",- knownEnvironment: {- id: "env-1",- label: "Remote env",- source: "manual",- target: {- httpBaseUrl: "http://example.test",- wsBaseUrl: "ws://example.test",- },- environmentId,- },- client,- applyEventBatch: vi.fn(),- syncSnapshot: vi.fn(),- applyTerminalEvent: vi.fn(),- });+ await connection.ensureBootstrapped();+ const reconnectPromise = connection.reconnect();await Promise.resolve();- await Promise.resolve();-- const onUnhandledRejection = vi.fn();- process.on("unhandledRejection", onUnhandledRejection);+ expect(syncShellSnapshot).toHaveBeenCalledTimes(1);- try {- triggerDomainResubscribe();- await new Promise((resolve) => setTimeout(resolve, 0));- await new Promise((resolve) => setTimeout(resolve, 0));- } finally {- process.off("unhandledRejection", onUnhandledRejection);- }+ emitShellSnapshot(2);+ await reconnectPromise;- expect(onUnhandledRejection).not.toHaveBeenCalled();+ expect(client.reconnect).toHaveBeenCalledTimes(1);+ expect(syncShellSnapshot).toHaveBeenCalledTimes(2);+ expect(syncShellSnapshot).toHaveBeenLastCalledWith(+ expect.objectContaining({ snapshotSequence: 2 }),+ environmentId,+ );await connection.dispose();});diff --git a/apps/web/src/environments/runtime/connection.ts b/apps/web/src/environments/runtime/connection.tsindex ef79d3fce..9f3465dfe 100644--- a/apps/web/src/environments/runtime/connection.ts+++ b/apps/web/src/environments/runtime/connection.ts@@ -1,29 +1,15 @@import type {EnvironmentId,- OrchestrationEvent,- OrchestrationReadModel,+ OrchestrationShellSnapshot,+ OrchestrationShellStreamEvent,ServerConfig,ServerLifecycleWelcomePayload,TerminalEvent,} from "@t3tools/contracts";import type { KnownEnvironment } from "@t3tools/client-runtime";-import {- deriveReplayRetryDecision,- type OrchestrationRecoveryReason,-} from "../../orchestrationRecovery";-import {- createOrchestrationRecoveryCoordinator,- type ReplayRetryTracker,-} from "../../orchestrationRecovery";-import { isTransportConnectionErrorMessage } from "~/rpc/transportError";import type { WsRpcClient } from "~/rpc/wsRpcClient";-const REPLAY_RECOVERY_RETRY_DELAY_MS = 100;-const MAX_NO_PROGRESS_REPLAY_RETRIES = 3;-const RECOVERY_TRANSPORT_RETRY_DELAY_MS = 250;-const MAX_RECOVERY_TRANSPORT_RETRIES = 20;-export interface EnvironmentConnection {readonly kind: "primary" | "saved";readonly environmentId: EnvironmentId;@@ -35,11 +21,14 @@ export interface EnvironmentConnection {}interface OrchestrationHandlers {- readonly applyEventBatch: (- events: ReadonlyArray<OrchestrationEvent>,+ readonly applyShellEvent: (+ event: OrchestrationShellStreamEvent,+ environmentId: EnvironmentId,+ ) => void;+ readonly syncShellSnapshot: (+ snapshot: OrchestrationShellSnapshot,environmentId: EnvironmentId,) => void;- readonly syncSnapshot: (snapshot: OrchestrationReadModel, environmentId: EnvironmentId) => void;readonly applyTerminalEvent: (event: TerminalEvent, environmentId: EnvironmentId) => void;}@@ -52,33 +41,31 @@ interface EnvironmentConnectionInput extends OrchestrationHandlers {readonly onWelcome?: (payload: ServerLifecycleWelcomePayload) => void;}-function createSnapshotBootstrapController(input: {- readonly isBootstrapped: () => boolean;- readonly runSnapshotRecovery: (- reason: Extract<OrchestrationRecoveryReason, "bootstrap" | "replay-failed">,- ) => Promise<void>;-}) {- let inFlight: Promise<void> | null = null;+function createBootstrapGate() {+ let resolve: (() => void) | null = null;+ let reject: ((error: unknown) => void) | null = null;+ let promise = new Promise<void>((nextResolve, nextReject) => {+ resolve = nextResolve;+ reject = nextReject;+ });return {- ensureSnapshotRecovery(- reason: Extract<OrchestrationRecoveryReason, "bootstrap" | "replay-failed">,- ): Promise<void> {- if (input.isBootstrapped()) {- return Promise.resolve();- }-- if (inFlight !== null) {- return inFlight;- }-- const nextInFlight = input.runSnapshotRecovery(reason).finally(() => {- if (inFlight === nextInFlight) {- inFlight = null;- }+ wait: () => promise,+ resolve: () => {+ resolve?.();+ resolve = null;+ reject = null;+ },+ reject: (error: unknown) => {+ reject?.(error);+ resolve = null;+ reject = null;+ },+ reset: () => {+ promise = new Promise<void>((nextResolve, nextReject) => {+ resolve = nextResolve;+ reject = nextReject;});- inFlight = nextInFlight;- return inFlight;},};}@@ -86,10 +73,6 @@ function createSnapshotBootstrapController(input: {export function createEnvironmentConnection(input: EnvironmentConnectionInput,): EnvironmentConnection {- const recovery = createOrchestrationRecoveryCoordinator();- let replayRetryTracker: ReplayRetryTracker | null = null;- const pendingDomainEvents: OrchestrationEvent[] = [];- let flushPendingDomainEventsScheduled = false;const environmentId = input.knownEnvironment.environmentId;if (!environmentId) {@@ -99,6 +82,7 @@ export function createEnvironmentConnection(}let disposed = false;+ const bootstrapGate = createBootstrapGate();const observeEnvironmentIdentity = (nextEnvironmentId: EnvironmentId, source: string) => {if (environmentId !== nextEnvironmentId) {@@ -108,148 +92,6 @@ export function createEnvironmentConnection(}};- const flushPendingDomainEvents = () => {- flushPendingDomainEventsScheduled = false;- if (disposed || pendingDomainEvents.length === 0) {- return;- }-- const events = pendingDomainEvents.splice(0, pendingDomainEvents.length);- const nextEvents = recovery.markEventBatchApplied(events);- if (nextEvents.length === 0) {- return;- }- input.applyEventBatch(nextEvents, environmentId);- };-- const schedulePendingDomainEventFlush = () => {- if (flushPendingDomainEventsScheduled) {- return;- }-- flushPendingDomainEventsScheduled = true;- queueMicrotask(flushPendingDomainEvents);- };-- const retryTransportRecoveryOperation = async <T>(operation: () => Promise<T>): Promise<T> => {- for (let attempt = 0; ; attempt += 1) {- try {- return await operation();- } catch (error) {- const message = error instanceof Error ? error.message : String(error);- if (- disposed ||- !isTransportConnectionErrorMessage(message) ||- attempt >= MAX_RECOVERY_TRANSPORT_RETRIES - 1- ) {- throw error;- }-- await new Promise<void>((resolve) => {- setTimeout(resolve, RECOVERY_TRANSPORT_RETRY_DELAY_MS);- });-- if (disposed) {- throw error;- }- }- }- };- const scheduleReplayRecovery = (reason: "sequence-gap" | "resubscribe") => {- void runReplayRecovery(reason).catch(() => undefined);- };-- const runReplayRecovery = async (reason: "sequence-gap" | "resubscribe"): Promise<void> => {- if (!recovery.beginReplayRecovery(reason)) {- return;- }-- const fromSequenceExclusive = recovery.getState().latestSequence;- try {- const events = await retryTransportRecoveryOperation(() =>- input.client.orchestration.replayEvents({ fromSequenceExclusive }),- );- if (!disposed) {- const nextEvents = recovery.markEventBatchApplied(events);- if (nextEvents.length > 0) {- input.applyEventBatch(nextEvents, environmentId);- }- }- } catch {- replayRetryTracker = null;- recovery.failReplayRecovery();- if (disposed) {- return;- }- await snapshotBootstrap.ensureSnapshotRecovery("replay-failed");- return;- }-- if (disposed) {- return;- }-- const replayCompletion = recovery.completeReplayRecovery();- const retryDecision = deriveReplayRetryDecision({- previousTracker: replayRetryTracker,- completion: replayCompletion,- recoveryState: recovery.getState(),- baseDelayMs: REPLAY_RECOVERY_RETRY_DELAY_MS,- maxNoProgressRetries: MAX_NO_PROGRESS_REPLAY_RETRIES,- });- replayRetryTracker = retryDecision.tracker;-- if (retryDecision.shouldRetry) {- if (retryDecision.delayMs > 0) {- await new Promise<void>((resolve) => {- setTimeout(resolve, retryDecision.delayMs);- });- if (disposed) {- return;- }- }- scheduleReplayRecovery(reason);- } else if (replayCompletion.shouldReplay && import.meta.env.MODE !== "test") {- console.warn(- "[orchestration-recovery]",- "Stopping replay recovery after no-progress retries.",- {- environmentId,- state: recovery.getState(),- },- );- }- };-- const runSnapshotRecovery = async (- reason: Extract<OrchestrationRecoveryReason, "bootstrap" | "replay-failed">,- ): Promise<void> => {- const started = recovery.beginSnapshotRecovery(reason);- if (!started) {- return;- }-- try {- const snapshot = await retryTransportRecoveryOperation(() =>- input.client.orchestration.getSnapshot(),- );- if (!disposed) {- input.syncSnapshot(snapshot, environmentId);- if (recovery.completeSnapshotRecovery(snapshot.snapshotSequence)) {- scheduleReplayRecovery("sequence-gap");- }- }- } catch (error) {- recovery.failSnapshotRecovery();- throw error;- }- };-- const snapshotBootstrap = createSnapshotBootstrapController({- isBootstrapped: () => recovery.getState().bootstrapped,- runSnapshotRecovery,- });-const unsubLifecycle = input.client.server.subscribeLifecycle((event: Parameters<Parameters<WsRpcClient["server"]["subscribeLifecycle"]>[0]>[0]) => {if (event.type !== "welcome") {@@ -273,26 +115,21 @@ export function createEnvironmentConnection(},);- const unsubDomainEvent = input.client.orchestration.onDomainEvent(- (event: Parameters<Parameters<WsRpcClient["orchestration"]["onDomainEvent"]>[0]>[0]) => {- const action = recovery.classifyDomainEvent(event.sequence);- if (action === "apply") {- pendingDomainEvents.push(event);- schedulePendingDomainEventFlush();+ const unsubShell = input.client.orchestration.subscribeShell(+ (item: Parameters<Parameters<WsRpcClient["orchestration"]["subscribeShell"]>[0]>[0]) => {+ if (item.kind === "snapshot") {+ input.syncShellSnapshot(item.snapshot, environmentId);+ bootstrapGate.resolve();return;}- if (action === "recover") {- flushPendingDomainEvents();- scheduleReplayRecovery("sequence-gap");- }+ input.applyShellEvent(item, environmentId);},{onResubscribe: () => {if (disposed) {return;}- flushPendingDomainEvents();- scheduleReplayRecovery("resubscribe");+ bootstrapGate.reset();},},);@@ -303,13 +140,9 @@ export function createEnvironmentConnection(},);- void snapshotBootstrap.ensureSnapshotRecovery("bootstrap").catch(() => undefined);-const cleanup = () => {disposed = true;- flushPendingDomainEventsScheduled = false;- pendingDomainEvents.length = 0;- unsubDomainEvent();+ unsubShell();unsubTerminalEvent();unsubLifecycle();unsubConfig();@@ -320,11 +153,17 @@ export function createEnvironmentConnection(environmentId,knownEnvironment: input.knownEnvironment,client: input.client,- ensureBootstrapped: () => snapshotBootstrap.ensureSnapshotRecovery("bootstrap"),+ ensureBootstrapped: () => bootstrapGate.wait(),reconnect: async () => {- await input.client.reconnect();- await input.refreshMetadata?.();- await snapshotBootstrap.ensureSnapshotRecovery("bootstrap");+ bootstrapGate.reset();+ try {+ await input.client.reconnect();+ await input.refreshMetadata?.();+ await bootstrapGate.wait();+ } catch (error) {+ bootstrapGate.reject(error);+ throw error;+ }},dispose: async () => {cleanup();diff --git a/apps/web/src/environments/runtime/service.threadSubscriptions.test.ts b/apps/web/src/environments/runtime/service.threadSubscriptions.test.tsnew file mode 100644index 000000000..a5ebc36ca--- /dev/null+++ b/apps/web/src/environments/runtime/service.threadSubscriptions.test.ts@@ -0,0 +1,151 @@+import { QueryClient } from "@tanstack/react-query";+import { EnvironmentId, ThreadId } from "@t3tools/contracts";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";++const mockSubscribeThread = vi.fn();+const mockThreadUnsubscribe = vi.fn();+const mockCreateEnvironmentConnection = vi.fn();+const mockCreateWsRpcClient = vi.fn();+const mockWaitForSavedEnvironmentRegistryHydration = vi.fn();+const mockListSavedEnvironmentRecords = vi.fn();+const mockSavedEnvironmentRegistrySubscribe = vi.fn();++function MockWsTransport() {+ return undefined;+}++vi.mock("../primary", () => ({+ getPrimaryKnownEnvironment: vi.fn(() => ({+ id: "env-1",+ label: "Primary environment",+ source: "window-origin",+ target: {+ httpBaseUrl: "http://127.0.0.1:3000/",+ wsBaseUrl: "ws://127.0.0.1:3000/",+ },+ environmentId: EnvironmentId.make("env-1"),+ })),+}));++vi.mock("./catalog", () => ({+ getSavedEnvironmentRecord: vi.fn(),+ hasSavedEnvironmentRegistryHydrated: vi.fn(() => true),+ listSavedEnvironmentRecords: mockListSavedEnvironmentRecords,+ persistSavedEnvironmentRecord: vi.fn(),+ readSavedEnvironmentBearerToken: vi.fn(),+ removeSavedEnvironmentBearerToken: vi.fn(),+ useSavedEnvironmentRegistryStore: {+ subscribe: mockSavedEnvironmentRegistrySubscribe,+ getState: () => ({+ upsert: vi.fn(),+ remove: vi.fn(),+ markConnected: vi.fn(),+ }),+ },+ useSavedEnvironmentRuntimeStore: {+ getState: () => ({+ ensure: vi.fn(),+ patch: vi.fn(),+ clear: vi.fn(),+ }),+ },+ waitForSavedEnvironmentRegistryHydration: mockWaitForSavedEnvironmentRegistryHydration,+ writeSavedEnvironmentBearerToken: vi.fn(),+}));++vi.mock("./connection", () => ({+ createEnvironmentConnection: mockCreateEnvironmentConnection,+}));++vi.mock("../../rpc/wsRpcClient", () => ({+ createWsRpcClient: mockCreateWsRpcClient,+}));++vi.mock("../../rpc/wsTransport", () => ({+ WsTransport: MockWsTransport,+}));++describe("retainThreadDetailSubscription", () => {+ beforeEach(() => {+ vi.useFakeTimers();+ vi.resetModules();+ vi.clearAllMocks();++ mockThreadUnsubscribe.mockImplementation(() => undefined);+ mockSubscribeThread.mockImplementation(() => mockThreadUnsubscribe);+ mockCreateWsRpcClient.mockReturnValue({+ orchestration: {+ subscribeThread: mockSubscribeThread,+ },+ });+ mockCreateEnvironmentConnection.mockImplementation((input) => ({+ kind: input.kind,+ environmentId: input.knownEnvironment.environmentId,+ knownEnvironment: input.knownEnvironment,+ client: input.client,+ ensureBootstrapped: vi.fn(async () => undefined),+ reconnect: vi.fn(async () => undefined),+ dispose: vi.fn(async () => undefined),+ }));+ mockSavedEnvironmentRegistrySubscribe.mockReturnValue(() => undefined);+ mockWaitForSavedEnvironmentRegistryHydration.mockResolvedValue(undefined);+ mockListSavedEnvironmentRecords.mockReturnValue([]);+ });++ afterEach(async () => {+ const { resetEnvironmentServiceForTests } = await import("./service");+ await resetEnvironmentServiceForTests();+ vi.useRealTimers();+ });++ it("keeps thread detail subscriptions warm across releases until idle eviction", async () => {+ const {+ retainThreadDetailSubscription,+ startEnvironmentConnectionService,+ resetEnvironmentServiceForTests,+ } = await import("./service");++ const stop = startEnvironmentConnectionService(new QueryClient());+ const environmentId = EnvironmentId.make("env-1");+ const threadId = ThreadId.make("thread-1");++ const releaseFirst = retainThreadDetailSubscription(environmentId, threadId);+ expect(mockSubscribeThread).toHaveBeenCalledTimes(1);++ releaseFirst();+ expect(mockThreadUnsubscribe).not.toHaveBeenCalled();++ const releaseSecond = retainThreadDetailSubscription(environmentId, threadId);+ expect(mockSubscribeThread).toHaveBeenCalledTimes(1);++ releaseSecond();+ await vi.advanceTimersByTimeAsync(2 * 60 * 1000 - 1);+ expect(mockThreadUnsubscribe).not.toHaveBeenCalled();++ await vi.advanceTimersByTimeAsync(1);+ expect(mockThreadUnsubscribe).toHaveBeenCalledTimes(1);++ stop();+ await resetEnvironmentServiceForTests();+ });++ it("disposes cached thread detail subscriptions when the environment service resets", async () => {+ const {+ retainThreadDetailSubscription,+ startEnvironmentConnectionService,+ resetEnvironmentServiceForTests,+ } = await import("./service");++ const stop = startEnvironmentConnectionService(new QueryClient());+ const environmentId = EnvironmentId.make("env-1");+ const threadId = ThreadId.make("thread-2");++ const release = retainThreadDetailSubscription(environmentId, threadId);+ release();++ await resetEnvironmentServiceForTests();+ expect(mockThreadUnsubscribe).toHaveBeenCalledTimes(1);++ stop();+ });+});diff --git a/apps/web/src/environments/runtime/service.ts b/apps/web/src/environments/runtime/service.tsindex 5c8d2daca..0e72607d9 100644--- a/apps/web/src/environments/runtime/service.ts+++ b/apps/web/src/environments/runtime/service.ts@@ -2,7 +2,8 @@ import {type AuthSessionRole,type EnvironmentId,type OrchestrationEvent,- type OrchestrationReadModel,+ type OrchestrationShellSnapshot,+ type OrchestrationShellStreamEvent,type ServerConfig,type TerminalEvent,ThreadId,@@ -68,12 +69,206 @@ type EnvironmentServiceState = {stop: () => void;};+type ThreadDetailSubscriptionEntry = {+ readonly environmentId: EnvironmentId;+ readonly threadId: ThreadId;+ unsubscribe: () => void;+ unsubscribeConnectionListener: (() => void) | null;+ refCount: number;+ lastAccessedAt: number;+ evictionTimeoutId: ReturnType<typeof setTimeout> | null;+};+const environmentConnections = new Map<EnvironmentId, EnvironmentConnection>();const environmentConnectionListeners = new Set<() => void>();+const threadDetailSubscriptions = new Map<string, ThreadDetailSubscriptionEntry>();let activeService: EnvironmentServiceState | null = null;let needsProviderInvalidation = false;+const THREAD_DETAIL_SUBSCRIPTION_IDLE_EVICTION_MS = 2 * 60 * 1000;+const MAX_CACHED_THREAD_DETAIL_SUBSCRIPTIONS = 8;+const NOOP = () => undefined;++function getThreadDetailSubscriptionKey(environmentId: EnvironmentId, threadId: ThreadId): string {+ return scopedThreadKey(scopeThreadRef(environmentId, threadId));+}++function clearThreadDetailSubscriptionEviction(+ entry: ThreadDetailSubscriptionEntry,+): ThreadDetailSubscriptionEntry {+ if (entry.evictionTimeoutId !== null) {+ clearTimeout(entry.evictionTimeoutId);+ entry.evictionTimeoutId = null;+ }+ return entry;+}++function attachThreadDetailSubscription(entry: ThreadDetailSubscriptionEntry): boolean {+ if (entry.unsubscribeConnectionListener !== null) {+ entry.unsubscribeConnectionListener();+ entry.unsubscribeConnectionListener = null;+ }+ if (entry.unsubscribe !== NOOP) {+ return true;+ }++ const connection = readEnvironmentConnection(entry.environmentId);+ if (!connection) {+ return false;+ }++ entry.unsubscribe = connection.client.orchestration.subscribeThread(+ { threadId: entry.threadId },+ (item) => {+ if (item.kind === "snapshot") {+ useStore.getState().syncServerThreadDetail(item.snapshot.thread, entry.environmentId);+ return;+ }+ applyEnvironmentThreadDetailEvent(item.event, entry.environmentId);+ },+ );+ return true;+}++function watchThreadDetailSubscriptionConnection(entry: ThreadDetailSubscriptionEntry): void {+ if (entry.unsubscribeConnectionListener !== null) {+ return;+ }++ entry.unsubscribeConnectionListener = subscribeEnvironmentConnections(() => {+ if (attachThreadDetailSubscription(entry)) {+ entry.lastAccessedAt = Date.now();+ }+ });+ attachThreadDetailSubscription(entry);+}++function disposeThreadDetailSubscriptionByKey(key: string): boolean {+ const entry = threadDetailSubscriptions.get(key);+ if (!entry) {+ return false;+ }++ clearThreadDetailSubscriptionEviction(entry);+ entry.unsubscribeConnectionListener?.();+ entry.unsubscribeConnectionListener = null;+ threadDetailSubscriptions.delete(key);+ entry.unsubscribe();+ entry.unsubscribe = NOOP;+ return true;+}++function disposeThreadDetailSubscriptionsForEnvironment(environmentId: EnvironmentId): void {+ for (const [key, entry] of threadDetailSubscriptions) {+ if (entry.environmentId === environmentId) {+ disposeThreadDetailSubscriptionByKey(key);+ }+ }+}++function reconcileThreadDetailSubscriptionsForEnvironment(+ environmentId: EnvironmentId,+ threadIds: ReadonlyArray<ThreadId>,+): void {+ const activeThreadIds = new Set(threadIds);+ for (const [key, entry] of threadDetailSubscriptions) {+ if (entry.environmentId === environmentId && !activeThreadIds.has(entry.threadId)) {+ disposeThreadDetailSubscriptionByKey(key);+ }+ }+}++function scheduleThreadDetailSubscriptionEviction(entry: ThreadDetailSubscriptionEntry): void {+ clearThreadDetailSubscriptionEviction(entry);+ entry.evictionTimeoutId = setTimeout(() => {+ const currentEntry = threadDetailSubscriptions.get(+ getThreadDetailSubscriptionKey(entry.environmentId, entry.threadId),+ );+ if (!currentEntry || currentEntry.refCount > 0) {+ return;+ }+ disposeThreadDetailSubscriptionByKey(+ getThreadDetailSubscriptionKey(entry.environmentId, entry.threadId),+ );+ }, THREAD_DETAIL_SUBSCRIPTION_IDLE_EVICTION_MS);+}++function evictIdleThreadDetailSubscriptionsToCapacity(): void {+ if (threadDetailSubscriptions.size <= MAX_CACHED_THREAD_DETAIL_SUBSCRIPTIONS) {+ return;+ }++ const idleEntries = [...threadDetailSubscriptions.entries()]+ .filter(([, entry]) => entry.refCount === 0)+ .toSorted(([, left], [, right]) => left.lastAccessedAt - right.lastAccessedAt);++ for (const [key] of idleEntries) {+ if (threadDetailSubscriptions.size <= MAX_CACHED_THREAD_DETAIL_SUBSCRIPTIONS) {+ return;+ }+ disposeThreadDetailSubscriptionByKey(key);+ }+}++export function retainThreadDetailSubscription(+ environmentId: EnvironmentId,+ threadId: ThreadId,+): () => void {+ const key = getThreadDetailSubscriptionKey(environmentId, threadId);+ const existing = threadDetailSubscriptions.get(key);+ if (existing) {+ clearThreadDetailSubscriptionEviction(existing);+ existing.refCount += 1;+ existing.lastAccessedAt = Date.now();+ if (!attachThreadDetailSubscription(existing)) {+ watchThreadDetailSubscriptionConnection(existing);+ }+ let released = false;+ return () => {+ if (released) {+ return;+ }+ released = true;+ existing.refCount = Math.max(0, existing.refCount - 1);+ existing.lastAccessedAt = Date.now();+ if (existing.refCount === 0) {+ scheduleThreadDetailSubscriptionEviction(existing);+ evictIdleThreadDetailSubscriptionsToCapacity();+ }+ };+ }++ const entry: ThreadDetailSubscriptionEntry = {+ environmentId,+ threadId,+ unsubscribe: NOOP,+ unsubscribeConnectionListener: null,+ refCount: 1,+ lastAccessedAt: Date.now(),+ evictionTimeoutId: null,+ };+ threadDetailSubscriptions.set(key, entry);+ if (!attachThreadDetailSubscription(entry)) {+ watchThreadDetailSubscriptionConnection(entry);+ }+ evictIdleThreadDetailSubscriptionsToCapacity();++ let released = false;+ return () => {+ if (released) {+ return;+ }+ released = true;+ entry.refCount = Math.max(0, entry.refCount - 1);+ entry.lastAccessedAt = Date.now();+ if (entry.refCount === 0) {+ scheduleThreadDetailSubscriptionEviction(entry);+ evictIdleThreadDetailSubscriptionsToCapacity();+ }+ };+}+function emitEnvironmentConnectionRegistryChange() {for (const listener of environmentConnectionListeners) {listener();@@ -169,17 +364,18 @@ function coalesceOrchestrationUiEvents(return coalesced;}-function reconcileSnapshotDerivedState() {- const storeState = useStore.getState();- const threads = selectThreadsAcrossEnvironments(storeState);- const projects = selectProjectsAcrossEnvironments(storeState);-+function syncProjectUiFromStore() {+ const projects = selectProjectsAcrossEnvironments(useStore.getState());useUiStateStore.getState().syncProjects(projects.map((project) => ({key: scopedProjectKey(scopeProjectRef(project.environmentId, project.id)),cwd: project.cwd,})),);+}++function syncThreadUiFromStore() {+ const threads = selectThreadsAcrossEnvironments(useStore.getState());useUiStateStore.getState().syncThreads(threads.map((thread) => ({key: scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),@@ -189,7 +385,13 @@ function reconcileSnapshotDerivedState() {markPromotedDraftThreadsByRef(threads.map((thread) => scopeThreadRef(thread.environmentId, thread.id)),);+}++function reconcileSnapshotDerivedState() {+ syncProjectUiFromStore();+ syncThreadUiFromStore();+ const threads = selectThreadsAcrossEnvironments(useStore.getState());const activeThreadKeys = collectActiveTerminalThreadIds({snapshotThreads: threads.map((thread) => ({key: scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),@@ -273,11 +475,60 @@ function applyRecoveredEventBatch(}}+export function applyEnvironmentThreadDetailEvent(+ event: OrchestrationEvent,+ environmentId: EnvironmentId,+) {+ applyRecoveredEventBatch([event], environmentId);+}++function applyShellEvent(event: OrchestrationShellStreamEvent, environmentId: EnvironmentId) {+ const threadId =+ event.kind === "thread-upserted"+ ? event.thread.id+ : event.kind === "thread-removed"+ ? event.threadId+ : null;+ const threadRef = threadId ? scopeThreadRef(environmentId, threadId) : null;+ const previousThread = threadRef ? selectThreadByRef(useStore.getState(), threadRef) : undefined;++ useStore.getState().applyShellEvent(event, environmentId);++ switch (event.kind) {+ case "project-upserted":+ case "project-removed":+ syncProjectUiFromStore();+ return;+ case "thread-upserted":+ syncThreadUiFromStore();+ if (!previousThread && threadRef) {+ markPromotedDraftThreadByRef(threadRef);+ }+ if (previousThread?.archivedAt === null && event.thread.archivedAt !== null && threadRef) {+ useTerminalStateStore.getState().removeTerminalState(threadRef);+ }+ return;+ case "thread-removed":+ if (threadRef) {+ disposeThreadDetailSubscriptionByKey(scopedThreadKey(threadRef));+ useComposerDraftStore.getState().clearDraftThread(threadRef);+ useUiStateStore.getState().clearThreadUi(scopedThreadKey(threadRef));+ useTerminalStateStore.getState().removeTerminalState(threadRef);+ }+ syncThreadUiFromStore();+ return;+ }+}+function createEnvironmentConnectionHandlers() {return {- applyEventBatch: applyRecoveredEventBatch,- syncSnapshot: (snapshot: OrchestrationReadModel, environmentId: EnvironmentId) => {- useStore.getState().syncServerReadModel(snapshot, environmentId);+ applyShellEvent,+ syncShellSnapshot: (snapshot: OrchestrationShellSnapshot, environmentId: EnvironmentId) => {+ useStore.getState().syncServerShellSnapshot(snapshot, environmentId);+ reconcileThreadDetailSubscriptionsForEnvironment(+ environmentId,+ snapshot.threads.map((thread) => thread.id),+ );reconcileSnapshotDerivedState();},applyTerminalEvent: (event: TerminalEvent, environmentId: EnvironmentId) => {@@ -386,6 +637,7 @@ async function removeConnection(environmentId: EnvironmentId): Promise<boolean>return false;}+ disposeThreadDetailSubscriptionsForEnvironment(environmentId);environmentConnections.delete(environmentId);emitEnvironmentConnectionRegistryChange();await connection.dispose();@@ -714,6 +966,9 @@ export function startEnvironmentConnectionService(queryClient: QueryClient): ()export async function resetEnvironmentServiceForTests(): Promise<void> {stopActiveService();+ for (const key of Array.from(threadDetailSubscriptions.keys())) {+ disposeThreadDetailSubscriptionByKey(key);+ }await Promise.all([...environmentConnections.keys()].map((environmentId) => removeConnection(environmentId)),);diff --git a/apps/web/src/lib/gitStatusState.test.ts b/apps/web/src/lib/gitStatusState.test.tsindex b5317d9ec..2e17cd155 100644--- a/apps/web/src/lib/gitStatusState.test.ts+++ b/apps/web/src/lib/gitStatusState.test.ts@@ -123,12 +123,11 @@ function createRegisteredGitStatusClient(environmentId: EnvironmentId) {subscribeAuthAccess: vi.fn(() => () => undefined),},orchestration: {- getSnapshot: vi.fn(async () => ({ snapshotSequence: 1, projects: [], threads: [] }) as any),dispatchCommand: vi.fn(async () => undefined),getTurnDiff: vi.fn(async () => undefined),getFullThreadDiff: vi.fn(async () => undefined),- replayEvents: vi.fn(async () => []),- onDomainEvent: vi.fn(() => () => undefined),+ subscribeShell: vi.fn(() => () => undefined),+ subscribeThread: vi.fn(() => () => undefined),},} as unknown as WsRpcClient;diff --git a/apps/web/src/localApi.test.ts b/apps/web/src/localApi.test.tsindex 3883d77c8..0e169efb2 100644--- a/apps/web/src/localApi.test.ts+++ b/apps/web/src/localApi.test.ts@@ -3,10 +3,9 @@ import {DEFAULT_SERVER_SETTINGS,type DesktopBridge,EnvironmentId,- EventId,type GitStatusResult,ProjectId,- type OrchestrationEvent,+ type OrchestrationShellStreamItem,type ServerConfig,type ServerProvider,type TerminalEvent,@@ -32,7 +31,7 @@ function registerListener<T>(listeners: Set<(event: T) => void>, listener: (even}const terminalEventListeners = new Set<(event: TerminalEvent) => void>();-const orchestrationEventListeners = new Set<(event: OrchestrationEvent) => void>();+const shellStreamListeners = new Set<(event: OrchestrationShellStreamItem) => void>();const gitStatusListeners = new Set<(event: GitStatusResult) => void>();const rpcClientMock = {@@ -82,14 +81,13 @@ const rpcClientMock = {subscribeAuthAccess: vi.fn(),},orchestration: {- getSnapshot: vi.fn(),dispatchCommand: vi.fn(),getTurnDiff: vi.fn(),getFullThreadDiff: vi.fn(),- replayEvents: vi.fn(),- onDomainEvent: vi.fn((listener: (event: OrchestrationEvent) => void) =>- registerListener(orchestrationEventListeners, listener),+ subscribeShell: vi.fn((listener: (event: OrchestrationShellStreamItem) => void) =>+ registerListener(shellStreamListeners, listener),),+ subscribeThread: vi.fn(() => () => undefined),},};@@ -269,7 +267,7 @@ beforeEach(() => {vi.clearAllMocks();showContextMenuFallbackMock.mockReset();terminalEventListeners.clear();- orchestrationEventListeners.clear();+ shellStreamListeners.clear();gitStatusListeners.clear();const testWindow = getWindowForTest();Reflect.deleteProperty(testWindow, "desktopBridge");@@ -296,15 +294,15 @@ describe("wsApi", () => {expect(rpcClientMock.server.subscribeLifecycle).not.toHaveBeenCalled();});- it("forwards terminal and orchestration stream events", async () => {+ it("forwards terminal and shell stream events", async () => {const { createEnvironmentApi } = await import("./environmentApi");const api = createEnvironmentApi(rpcClientMock as never);const onTerminalEvent = vi.fn();- const onDomainEvent = vi.fn();+ const onShellEvent = vi.fn();api.terminal.onEvent(onTerminalEvent);- api.orchestration.onDomainEvent(onDomainEvent);+ api.orchestration.subscribeShell(onShellEvent);const terminalEvent = {threadId: "thread-1",@@ -315,19 +313,11 @@ describe("wsApi", () => {} as const;emitEvent(terminalEventListeners, terminalEvent);- const orchestrationEvent = {+ const shellEvent = {+ kind: "project-upserted" as const,sequence: 1,- eventId: EventId.make("event-1"),- aggregateKind: "project",- aggregateId: ProjectId.make("project-1"),- occurredAt: "2026-02-24T00:00:00.000Z",- commandId: null,- causationEventId: null,- correlationId: null,- metadata: {},- type: "project.created",- payload: {- projectId: ProjectId.make("project-1"),+ project: {+ id: ProjectId.make("project-1"),title: "Project",workspaceRoot: "/tmp/workspace",defaultModelSelection: {@@ -338,11 +328,11 @@ describe("wsApi", () => {createdAt: "2026-02-24T00:00:00.000Z",updatedAt: "2026-02-24T00:00:00.000Z",},- } satisfies Extract<OrchestrationEvent, { type: "project.created" }>;- emitEvent(orchestrationEventListeners, orchestrationEvent);+ } satisfies OrchestrationShellStreamItem;+ emitEvent(shellStreamListeners, shellEvent);expect(onTerminalEvent).toHaveBeenCalledWith(terminalEvent);- expect(onDomainEvent).toHaveBeenCalledWith(orchestrationEvent);+ expect(onShellEvent).toHaveBeenCalledWith(shellEvent);});it("forwards git status stream events", async () => {@@ -371,16 +361,16 @@ describe("wsApi", () => {expect(rpcClientMock.git.refreshStatus).toHaveBeenCalledWith({ cwd: "/repo" });});- it("forwards orchestration stream subscription options to the RPC client", async () => {+ it("forwards shell stream subscription options to the RPC client", async () => {const { createEnvironmentApi } = await import("./environmentApi");const api = createEnvironmentApi(rpcClientMock as never);- const onDomainEvent = vi.fn();+ const onShellEvent = vi.fn();const onResubscribe = vi.fn();- api.orchestration.onDomainEvent(onDomainEvent, { onResubscribe });+ api.orchestration.subscribeShell(onShellEvent, { onResubscribe });- expect(rpcClientMock.orchestration.onDomainEvent).toHaveBeenCalledWith(onDomainEvent, {+ expect(rpcClientMock.orchestration.subscribeShell).toHaveBeenCalledWith(onShellEvent, {onResubscribe,});});diff --git a/apps/web/src/routes/_chat.tsx b/apps/web/src/routes/_chat.tsxindex b72e504fa..fb8191f44 100644--- a/apps/web/src/routes/_chat.tsx+++ b/apps/web/src/routes/_chat.tsx@@ -2,10 +2,6 @@ import { Outlet, createFileRoute, redirect } from "@tanstack/react-router";import { useEffect } from "react";import { useCommandPaletteStore } from "../commandPaletteStore";-import {- ensurePrimaryEnvironmentReady,- resolveInitialServerAuthGateState,-} from "../environments/primary";import { useHandleNewThread } from "../hooks/useHandleNewThread";import {startNewLocalThreadFromContext,@@ -111,12 +107,8 @@ function ChatRouteLayout() {}export const Route = createFileRoute("/_chat")({- beforeLoad: async () => {- const [, authGateState] = await Promise.all([- ensurePrimaryEnvironmentReady(),- resolveInitialServerAuthGateState(),- ]);- if (authGateState.status !== "authenticated") {+ beforeLoad: async ({ context }) => {+ if (context.authGateState.status !== "authenticated") {throw redirect({ to: "/pair", replace: true });}},diff --git a/apps/web/src/routes/pair.tsx b/apps/web/src/routes/pair.tsxindex 053816bd7..6925dac69 100644--- a/apps/web/src/routes/pair.tsx+++ b/apps/web/src/routes/pair.tsx@@ -1,17 +1,10 @@import { createFileRoute, redirect, useNavigate } from "@tanstack/react-router";import { PairingPendingSurface, PairingRouteSurface } from "../components/auth/PairingRouteSurface";-import {- ensurePrimaryEnvironmentReady,- resolveInitialServerAuthGateState,-} from "../environments/primary";export const Route = createFileRoute("/pair")({- beforeLoad: async () => {- const [, authGateState] = await Promise.all([- ensurePrimaryEnvironmentReady(),- resolveInitialServerAuthGateState(),- ]);+ beforeLoad: async ({ context }) => {+ const { authGateState } = context;if (authGateState.status === "authenticated") {throw redirect({ to: "/", replace: true });}diff --git a/apps/web/src/routes/settings.tsx b/apps/web/src/routes/settings.tsxindex 090554236..482a56b68 100644--- a/apps/web/src/routes/settings.tsx+++ b/apps/web/src/routes/settings.tsx@@ -2,10 +2,6 @@ import { RotateCcwIcon } from "lucide-react";import { Outlet, createFileRoute, redirect } from "@tanstack/react-router";import { useEffect, useState } from "react";-import {- ensurePrimaryEnvironmentReady,- resolveInitialServerAuthGateState,-} from "../environments/primary";import { useSettingsRestore } from "../components/settings/SettingsPanels";import { Button } from "../components/ui/button";import { SidebarInset, SidebarTrigger } from "../components/ui/sidebar";@@ -87,12 +83,8 @@ function SettingsRouteLayout() {}export const Route = createFileRoute("/settings")({- beforeLoad: async ({ location }) => {- const [, authGateState] = await Promise.all([- ensurePrimaryEnvironmentReady(),- resolveInitialServerAuthGateState(),- ]);- if (authGateState.status !== "authenticated") {+ beforeLoad: async ({ context, location }) => {+ if (context.authGateState.status !== "authenticated") {throw redirect({ to: "/pair", replace: true });}diff --git a/apps/web/src/rpc/wsRpcClient.ts b/apps/web/src/rpc/wsRpcClient.tsindex b714889b7..42c2c64bd 100644--- a/apps/web/src/rpc/wsRpcClient.ts+++ b/apps/web/src/rpc/wsRpcClient.ts@@ -39,6 +39,15 @@ type RpcStreamMethod<TTag extends RpcTag> =? (listener: (event: TEvent) => void, options?: StreamSubscriptionOptions) => () => void: never;+type RpcInputStreamMethod<TTag extends RpcTag> =+ RpcMethod<TTag> extends (input: any, options?: any) => Stream.Stream<infer TEvent, any, any>+ ? (+ input: RpcInput<TTag>,+ listener: (event: TEvent) => void,+ options?: StreamSubscriptionOptions,+ ) => () => void+ : never;+interface GitRunStackedActionOptions {readonly onProgress?: (event: GitActionProgressEvent) => void;}@@ -101,12 +110,11 @@ export interface WsRpcClient {readonly subscribeAuthAccess: RpcStreamMethod<typeof WS_METHODS.subscribeAuthAccess>;};readonly orchestration: {- readonly getSnapshot: RpcUnaryNoArgMethod<typeof ORCHESTRATION_WS_METHODS.getSnapshot>;readonly dispatchCommand: RpcUnaryMethod<typeof ORCHESTRATION_WS_METHODS.dispatchCommand>;readonly getTurnDiff: RpcUnaryMethod<typeof ORCHESTRATION_WS_METHODS.getTurnDiff>;readonly getFullThreadDiff: RpcUnaryMethod<typeof ORCHESTRATION_WS_METHODS.getFullThreadDiff>;- readonly replayEvents: RpcUnaryMethod<typeof ORCHESTRATION_WS_METHODS.replayEvents>;- readonly onDomainEvent: RpcStreamMethod<typeof WS_METHODS.subscribeOrchestrationDomainEvents>;+ readonly subscribeShell: RpcStreamMethod<typeof ORCHESTRATION_WS_METHODS.subscribeShell>;+ readonly subscribeThread: RpcInputStreamMethod<typeof ORCHESTRATION_WS_METHODS.subscribeThread>;};}@@ -219,21 +227,21 @@ export function createWsRpcClient(transport: WsTransport): WsRpcClient {),},orchestration: {- getSnapshot: () =>- transport.request((client) => client[ORCHESTRATION_WS_METHODS.getSnapshot]({})),dispatchCommand: (input) =>transport.request((client) => client[ORCHESTRATION_WS_METHODS.dispatchCommand](input)),getTurnDiff: (input) =>transport.request((client) => client[ORCHESTRATION_WS_METHODS.getTurnDiff](input)),getFullThreadDiff: (input) =>transport.request((client) => client[ORCHESTRATION_WS_METHODS.getFullThreadDiff](input)),- replayEvents: (input) =>- transport- .request((client) => client[ORCHESTRATION_WS_METHODS.replayEvents](input))- .then((events) => [...events]),- onDomainEvent: (listener, options) =>+ subscribeShell: (listener, options) =>+ transport.subscribe(+ (client) => client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),+ listener,+ options,+ ),+ subscribeThread: (input, listener, options) =>transport.subscribe(- (client) => client[WS_METHODS.subscribeOrchestrationDomainEvents]({}),+ (client) => client[ORCHESTRATION_WS_METHODS.subscribeThread](input),listener,options,),diff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.tsindex d3fd30434..21ab1590d 100644--- a/apps/web/src/session-logic.test.ts+++ b/apps/web/src/session-logic.test.ts@@ -1227,6 +1227,19 @@ describe("deriveActiveWorkStartedAt", () => {).toBe("2026-02-27T21:10:00.000Z");});+ it("uses the new send start while the session is running a different turn", () => {+ expect(+ deriveActiveWorkStartedAt(+ latestTurn,+ {+ orchestrationStatus: "running",+ activeTurnId: TurnId.make("turn-2"),+ },+ "2026-02-27T21:11:00.000Z",+ ),+ ).toBe("2026-02-27T21:11:00.000Z");+ });+it("falls back to sendStartedAt once the latest turn is settled", () => {expect(deriveActiveWorkStartedAt(diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.tsindex 54e84c883..b03f1c541 100644--- a/apps/web/src/session-logic.ts+++ b/apps/web/src/session-logic.ts@@ -145,6 +145,14 @@ export function deriveActiveWorkStartedAt(session: SessionActivityState | null,sendStartedAt: string | null,): string | null {+ const runningTurnId =+ session?.orchestrationStatus === "running" ? (session.activeTurnId ?? null) : null;+ if (runningTurnId !== null) {+ if (latestTurn?.turnId === runningTurnId) {+ return latestTurn.startedAt ?? sendStartedAt;+ }+ return sendStartedAt;+ }if (!isLatestTurnSettled(latestTurn, session)) {return latestTurn?.startedAt ?? sendStartedAt;}diff --git a/apps/web/src/store.test.ts b/apps/web/src/store.test.tsindex 951830dbb..0673f48c2 100644--- a/apps/web/src/store.test.ts+++ b/apps/web/src/store.test.ts@@ -5,6 +5,7 @@ import {EnvironmentId,EventId,MessageId,+ type OrchestrationShellSnapshot,ProjectId,ThreadId,TurnId,@@ -23,6 +24,7 @@ import {setThreadBranch,selectThreadsAcrossEnvironments,syncServerReadModel,+ syncServerShellSnapshot,type AppState,type EnvironmentState,} from "./store";@@ -496,6 +498,83 @@ describe("store read model sync", () => {expect(localEnvironmentStateOf(next).bootstrapComplete).toBe(true);});+ it("updates shell state without discarding hydrated thread detail", () => {+ const initialState = makeState(+ makeThread({+ title: "Initial thread",+ messages: [+ {+ id: MessageId.make("message-1"),+ role: "assistant",+ text: "hydrated body",+ createdAt: "2026-02-13T00:00:01.000Z",+ completedAt: "2026-02-13T00:00:01.000Z",+ streaming: false,+ },+ ],+ }),+ );+ const shellSnapshot: OrchestrationShellSnapshot = {+ snapshotSequence: 2,+ projects: [+ {+ id: ProjectId.make("project-1"),+ title: "Project",+ workspaceRoot: "/tmp/project",+ repositoryIdentity: null,+ defaultModelSelection: {+ provider: "codex",+ model: "gpt-5-codex",+ },+ scripts: [],+ createdAt: "2026-02-13T00:00:00.000Z",+ updatedAt: "2026-02-13T00:00:00.000Z",+ },+ ],+ threads: [+ {+ id: ThreadId.make("thread-1"),+ projectId: ProjectId.make("project-1"),+ title: "Renamed thread",+ modelSelection: {+ provider: "codex",+ model: "gpt-5-codex",+ },+ runtimeMode: "full-access",+ interactionMode: "default",+ branch: "feature/renamed",+ worktreePath: null,+ latestTurn: null,+ createdAt: "2026-02-13T00:00:00.000Z",+ updatedAt: "2026-02-13T00:00:02.000Z",+ archivedAt: null,+ session: null,+ latestUserMessageAt: null,+ hasPendingApprovals: false,+ hasPendingUserInput: false,+ hasActionableProposedPlan: false,+ },+ ],+ updatedAt: "2026-02-13T00:00:02.000Z",+ };++ const next = syncServerShellSnapshot(initialState, shellSnapshot, localEnvironmentId);+ const thread = selectThreadByRef(+ next,+ scopeThreadRef(localEnvironmentId, ThreadId.make("thread-1")),+ );++ expect(thread?.title).toBe("Renamed thread");+ expect(thread?.branch).toBe("feature/renamed");+ expect(thread?.messages).toEqual([+ expect.objectContaining({+ id: MessageId.make("message-1"),+ text: "hydrated body",+ }),+ ]);+ expect(localEnvironmentStateOf(next).bootstrapComplete).toBe(true);+ });+it("preserves claude model slugs without an active session", () => {const initialState = makeState(makeThread());const readModel = makeReadModel(diff --git a/apps/web/src/store.ts b/apps/web/src/store.tsindex 58a0697c7..092593b06 100644--- a/apps/web/src/store.ts+++ b/apps/web/src/store.ts@@ -6,9 +6,12 @@ import type {OrchestrationMessage,OrchestrationProposedPlan,OrchestrationReadModel,+ OrchestrationShellSnapshot,+ OrchestrationShellStreamEvent,OrchestrationSession,OrchestrationSessionStatus,OrchestrationThread,+ OrchestrationThreadShell,OrchestrationThreadActivity,ProjectId,ProviderKind,@@ -175,7 +178,9 @@ function mapTurnDiffSummary(checkpoint: OrchestrationCheckpointSummary): TurnDif}function mapProject(- project: OrchestrationReadModel["projects"][number],+ project:+ | OrchestrationReadModel["projects"][number]+ | OrchestrationShellSnapshot["projects"][number],environmentId: EnvironmentId,): Project {return {@@ -219,6 +224,62 @@ function mapThread(thread: OrchestrationThread, environmentId: EnvironmentId): T};}+function mapThreadShell(+ thread: OrchestrationThreadShell,+ environmentId: EnvironmentId,+): {+ shell: ThreadShell;+ session: ThreadSession | null;+ turnState: ThreadTurnState;+ summary: SidebarThreadSummary;+} {+ const shell: ThreadShell = {+ id: thread.id,+ environmentId,+ codexThreadId: null,+ projectId: thread.projectId,+ title: thread.title,+ modelSelection: normalizeModelSelection(thread.modelSelection),+ runtimeMode: thread.runtimeMode,+ interactionMode: thread.interactionMode,+ error: sanitizeThreadErrorMessage(thread.session?.lastError),+ createdAt: thread.createdAt,+ archivedAt: thread.archivedAt,+ updatedAt: thread.updatedAt,+ branch: thread.branch,+ worktreePath: thread.worktreePath,+ };+ const session = thread.session ? mapSession(thread.session) : null;+ const turnState: ThreadTurnState = {+ latestTurn: thread.latestTurn,+ pendingSourceProposedPlan: thread.latestTurn?.sourceProposedPlan,+ };+ const summary: SidebarThreadSummary = {+ id: thread.id,+ environmentId,+ projectId: thread.projectId,+ title: thread.title,+ interactionMode: thread.interactionMode,+ session,+ createdAt: thread.createdAt,+ archivedAt: thread.archivedAt,+ updatedAt: thread.updatedAt,+ latestTurn: thread.latestTurn,+ branch: thread.branch,+ worktreePath: thread.worktreePath,+ latestUserMessageAt: thread.latestUserMessageAt,+ hasPendingApprovals: thread.hasPendingApprovals,+ hasPendingUserInput: thread.hasPendingUserInput,+ hasActionableProposedPlan: thread.hasActionableProposedPlan,+ };+ return {+ shell,+ session,+ turnState,+ summary,+ };+}+function toThreadShell(thread: Thread): ThreadShell {return {id: thread.id,@@ -562,6 +623,120 @@ function writeThreadState(return nextState;}+function writeThreadShellState(+ state: EnvironmentState,+ nextThread: {+ shell: ThreadShell;+ session: ThreadSession | null;+ turnState: ThreadTurnState;+ summary: SidebarThreadSummary;+ },+): EnvironmentState {+ let nextState = state;+ const previousShell = state.threadShellById[nextThread.shell.id];+ const previousProjectId = previousShell?.projectId;+ const nextProjectId = nextThread.shell.projectId;++ if (!state.threadIds.includes(nextThread.shell.id)) {+ nextState = {+ ...nextState,+ threadIds: [...nextState.threadIds, nextThread.shell.id],+ };+ }++ if (previousProjectId !== nextProjectId) {+ let threadIdsByProjectId = nextState.threadIdsByProjectId;+ if (previousProjectId) {+ const previousIds = threadIdsByProjectId[previousProjectId] ?? EMPTY_THREAD_IDS;+ const nextIds = removeId(previousIds, nextThread.shell.id);+ if (nextIds.length === 0) {+ const { [previousProjectId]: _removed, ...rest } = threadIdsByProjectId;+ threadIdsByProjectId = rest as Record<ProjectId, ThreadId[]>;+ } else if (!arraysEqual(previousIds, nextIds)) {+ threadIdsByProjectId = {+ ...threadIdsByProjectId,+ [previousProjectId]: nextIds,+ };+ }+ }++ const projectThreadIds = threadIdsByProjectId[nextProjectId] ?? EMPTY_THREAD_IDS;+ const nextProjectThreadIds = appendId(projectThreadIds, nextThread.shell.id);+ if (!arraysEqual(projectThreadIds, nextProjectThreadIds)) {+ threadIdsByProjectId = {+ ...threadIdsByProjectId,+ [nextProjectId]: nextProjectThreadIds,+ };+ }+ if (threadIdsByProjectId !== nextState.threadIdsByProjectId) {+ nextState = {+ ...nextState,+ threadIdsByProjectId,+ };+ }+ }++ if (!threadShellsEqual(previousShell, nextThread.shell)) {+ nextState = {+ ...nextState,+ threadShellById: {+ ...nextState.threadShellById,+ [nextThread.shell.id]: nextThread.shell,+ },+ };+ }++ if ((state.threadSessionById[nextThread.shell.id] ?? null) !== nextThread.session) {+ nextState = {+ ...nextState,+ threadSessionById: {+ ...nextState.threadSessionById,+ [nextThread.shell.id]: nextThread.session,+ },+ };+ }++ if (+ !threadTurnStatesEqual(state.threadTurnStateById[nextThread.shell.id], nextThread.turnState)+ ) {+ nextState = {+ ...nextState,+ threadTurnStateById: {+ ...nextState.threadTurnStateById,+ [nextThread.shell.id]: nextThread.turnState,+ },+ };+ }++ if (+ !sidebarThreadSummariesEqual(+ state.sidebarThreadSummaryById[nextThread.shell.id],+ nextThread.summary,+ )+ ) {+ nextState = {+ ...nextState,+ sidebarThreadSummaryById: {+ ...nextState.sidebarThreadSummaryById,+ [nextThread.shell.id]: nextThread.summary,+ },+ };+ }++ return nextState;+}++function retainThreadScopedRecord<T>(+ record: Record<ThreadId, T>,+ nextThreadIds: ReadonlySet<ThreadId>,+): Record<ThreadId, T> {+ return Object.fromEntries(+ Object.entries(record).flatMap(([threadId, value]) =>+ nextThreadIds.has(threadId as ThreadId) ? [[threadId, value] as const] : [],+ ),+ ) as Record<ThreadId, T>;+}+function removeThreadState(state: EnvironmentState, threadId: ThreadId): EnvironmentState {const shell = state.threadShellById[threadId];if (!shell) {@@ -960,6 +1135,46 @@ function syncEnvironmentReadModel(};}+function syncEnvironmentShellSnapshot(+ state: EnvironmentState,+ snapshot: OrchestrationShellSnapshot,+ environmentId: EnvironmentId,+): EnvironmentState {+ const nextProjects = snapshot.projects.map((project) => mapProject(project, environmentId));+ const nextThreadIds = new Set(snapshot.threads.map((thread) => thread.id));+ let nextState: EnvironmentState = {+ ...state,+ ...buildProjectState(nextProjects),+ threadIds: [],+ threadIdsByProjectId: {},+ threadShellById: {},+ threadSessionById: {},+ threadTurnStateById: {},+ sidebarThreadSummaryById: {},+ messageIdsByThreadId: retainThreadScopedRecord(state.messageIdsByThreadId, nextThreadIds),+ messageByThreadId: retainThreadScopedRecord(state.messageByThreadId, nextThreadIds),+ activityIdsByThreadId: retainThreadScopedRecord(state.activityIdsByThreadId, nextThreadIds),+ activityByThreadId: retainThreadScopedRecord(state.activityByThreadId, nextThreadIds),+ proposedPlanIdsByThreadId: retainThreadScopedRecord(+ state.proposedPlanIdsByThreadId,+ nextThreadIds,+ ),+ proposedPlanByThreadId: retainThreadScopedRecord(state.proposedPlanByThreadId, nextThreadIds),+ turnDiffIdsByThreadId: retainThreadScopedRecord(state.turnDiffIdsByThreadId, nextThreadIds),+ turnDiffSummaryByThreadId: retainThreadScopedRecord(+ state.turnDiffSummaryByThreadId,+ nextThreadIds,+ ),+ bootstrapComplete: true,+ };++ for (const thread of snapshot.threads) {+ nextState = writeThreadShellState(nextState, mapThreadShell(thread, environmentId));+ }++ return nextState;+}+export function syncServerReadModel(state: AppState,readModel: OrchestrationReadModel,@@ -976,6 +1191,36 @@ export function syncServerReadModel();}+export function syncServerShellSnapshot(+ state: AppState,+ snapshot: OrchestrationShellSnapshot,+ environmentId: EnvironmentId,+): AppState {+ return commitEnvironmentState(+ state,+ environmentId,+ syncEnvironmentShellSnapshot(+ getStoredEnvironmentState(state, environmentId),+ snapshot,+ environmentId,+ ),+ );+}++export function syncServerThreadDetail(+ state: AppState,+ thread: OrchestrationThread,+ environmentId: EnvironmentId,+): AppState {+ const environmentState = getStoredEnvironmentState(state, environmentId);+ const previousThread = getThreadFromEnvironmentState(environmentState, thread.id);+ return commitEnvironmentState(+ state,+ environmentId,+ writeThreadState(environmentState, mapThread(thread, environmentId), previousThread),+ );+}+function applyEnvironmentOrchestrationEvent(state: EnvironmentState,event: OrchestrationEvent,@@ -1466,6 +1711,67 @@ function applyEnvironmentOrchestrationEvent(return state;}+function applyEnvironmentShellEvent(+ state: EnvironmentState,+ event: OrchestrationShellStreamEvent,+ environmentId: EnvironmentId,+): EnvironmentState {+ switch (event.kind) {+ case "project-upserted": {+ const nextProject = mapProject(event.project, environmentId);+ const existingProjectId =+ state.projectIds.find(+ (projectId) =>+ projectId === event.project.id ||+ state.projectById[projectId]?.cwd === event.project.workspaceRoot,+ ) ?? null;+ let projectById = state.projectById;+ let projectIds = state.projectIds;++ if (existingProjectId !== null && existingProjectId !== nextProject.id) {+ const { [existingProjectId]: _removedProject, ...restProjectById } = state.projectById;+ projectById = {+ ...restProjectById,+ [nextProject.id]: nextProject,+ };+ projectIds = state.projectIds.map((projectId) =>+ projectId === existingProjectId ? nextProject.id : projectId,+ );+ } else {+ projectById = {+ ...state.projectById,+ [nextProject.id]: nextProject,+ };+ projectIds =+ existingProjectId === null && !state.projectIds.includes(nextProject.id)+ ? [...state.projectIds, nextProject.id]+ : state.projectIds;+ }++ return {+ ...state,+ projectById,+ projectIds,+ };+ }+ case "project-removed": {+ if (!state.projectById[event.projectId]) {+ return state;+ }+ const { [event.projectId]: _removedProject, ...projectById } = state.projectById;+ return {+ ...state,+ projectById,+ projectIds: removeId(state.projectIds, event.projectId),+ };+ }+ case "thread-upserted":+ return writeThreadShellState(state, mapThreadShell(event.thread, environmentId));+ case "thread-removed":+ return removeThreadState(state, event.threadId);+ }+}+export function applyOrchestrationEvents(state: AppState,events: ReadonlyArray<OrchestrationEvent>,@@ -1649,6 +1955,22 @@ export function applyOrchestrationEvent();}+export function applyShellEvent(+ state: AppState,+ event: OrchestrationShellStreamEvent,+ environmentId: EnvironmentId,+): AppState {+ return commitEnvironmentState(+ state,+ environmentId,+ applyEnvironmentShellEvent(+ getStoredEnvironmentState(state, environmentId),+ event,+ environmentId,+ ),+ );+}+export function setActiveEnvironmentId(state: AppState, environmentId: EnvironmentId): AppState {if (state.activeEnvironmentId === environmentId) {return state;@@ -1686,11 +2008,17 @@ export function setThreadBranch(interface AppStore extends AppState {setActiveEnvironmentId: (environmentId: EnvironmentId) => void;syncServerReadModel: (readModel: OrchestrationReadModel, environmentId: EnvironmentId) => void;+ syncServerShellSnapshot: (+ snapshot: OrchestrationShellSnapshot,+ environmentId: EnvironmentId,+ ) => void;+ syncServerThreadDetail: (thread: OrchestrationThread, environmentId: EnvironmentId) => void;applyOrchestrationEvent: (event: OrchestrationEvent, environmentId: EnvironmentId) => void;applyOrchestrationEvents: (events: ReadonlyArray<OrchestrationEvent>,environmentId: EnvironmentId,) => void;+ applyShellEvent: (event: OrchestrationShellStreamEvent, environmentId: EnvironmentId) => void;setError: (threadId: ThreadId, error: string | null) => void;setThreadBranch: (threadRef: ScopedThreadRef,@@ -1705,10 +2033,16 @@ export const useStore = create<AppStore>((set) => ({set((state) => setActiveEnvironmentId(state, environmentId)),syncServerReadModel: (readModel, environmentId) =>set((state) => syncServerReadModel(state, readModel, environmentId)),+ syncServerShellSnapshot: (snapshot, environmentId) =>+ set((state) => syncServerShellSnapshot(state, snapshot, environmentId)),+ syncServerThreadDetail: (thread, environmentId) =>+ set((state) => syncServerThreadDetail(state, thread, environmentId)),applyOrchestrationEvent: (event, environmentId) =>set((state) => applyOrchestrationEvent(state, event, environmentId)),applyOrchestrationEvents: (events, environmentId) =>set((state) => applyOrchestrationEvents(state, events, environmentId)),+ applyShellEvent: (event, environmentId) =>+ set((state) => applyShellEvent(state, event, environmentId)),setError: (threadId, error) => set((state) => setError(state, threadId, error)),setThreadBranch: (threadRef, branch, worktreePath) =>set((state) => setThreadBranch(state, threadRef, branch, worktreePath)),diff --git a/apps/web/test/wsRpcHarness.ts b/apps/web/test/wsRpcHarness.tsindex f5d86a501..56711f4ad 100644--- a/apps/web/test/wsRpcHarness.ts+++ b/apps/web/test/wsRpcHarness.ts@@ -1,5 +1,5 @@import { Effect, Exit, PubSub, Scope, Stream } from "effect";-import { WS_METHODS, WsRpcGroup } from "@t3tools/contracts";+import { ORCHESTRATION_WS_METHODS, WS_METHODS, WsRpcGroup } from "@t3tools/contracts";import { RpcMessage, RpcSerialization, RpcServer } from "effect/unstable/rpc";type RpcServerInstance = RpcServer.RpcServer<any>;@@ -23,9 +23,10 @@ interface BrowserWsRpcHarnessOptions {}const STREAM_METHODS = new Set<string>([+ ORCHESTRATION_WS_METHODS.subscribeShell,+ ORCHESTRATION_WS_METHODS.subscribeThread,WS_METHODS.gitRunStackedAction,WS_METHODS.subscribeGitStatus,- WS_METHODS.subscribeOrchestrationDomainEvents,WS_METHODS.subscribeTerminalEvents,WS_METHODS.subscribeServerConfig,WS_METHODS.subscribeServerLifecycle,diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.tsindex 31e869380..a657526d6 100644--- a/packages/contracts/src/ipc.ts+++ b/packages/contracts/src/ipc.ts@@ -46,8 +46,9 @@ import type {OrchestrationGetFullThreadDiffResult,OrchestrationGetTurnDiffInput,OrchestrationGetTurnDiffResult,- OrchestrationEvent,- OrchestrationReadModel,+ OrchestrationShellStreamItem,+ OrchestrationSubscribeThreadInput,+ OrchestrationThreadStreamItem,} from "./orchestration";import type { EnvironmentId } from "./baseSchemas";import { EditorId } from "./editor";@@ -249,15 +250,20 @@ export interface EnvironmentApi {) => () => void;};orchestration: {- getSnapshot: () => Promise<OrchestrationReadModel>;dispatchCommand: (command: ClientOrchestrationCommand) => Promise<{ sequence: number }>;getTurnDiff: (input: OrchestrationGetTurnDiffInput) => Promise<OrchestrationGetTurnDiffResult>;getFullThreadDiff: (input: OrchestrationGetFullThreadDiffInput,) => Promise<OrchestrationGetFullThreadDiffResult>;- replayEvents: (fromSequenceExclusive: number) => Promise<OrchestrationEvent[]>;- onDomainEvent: (- callback: (event: OrchestrationEvent) => void,+ subscribeShell: (+ callback: (event: OrchestrationShellStreamItem) => void,+ options?: {+ onResubscribe?: () => void;+ },+ ) => () => void;+ subscribeThread: (+ input: OrchestrationSubscribeThreadInput,+ callback: (event: OrchestrationThreadStreamItem) => void,options?: {onResubscribe?: () => void;},diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.tsindex c80367d15..0c26a4225 100644--- a/packages/contracts/src/orchestration.ts+++ b/packages/contracts/src/orchestration.ts@@ -17,11 +17,12 @@ import {} from "./baseSchemas";export const ORCHESTRATION_WS_METHODS = {- getSnapshot: "orchestration.getSnapshot",dispatchCommand: "orchestration.dispatchCommand",getTurnDiff: "orchestration.getTurnDiff",getFullThreadDiff: "orchestration.getFullThreadDiff",replayEvents: "orchestration.replayEvents",+ subscribeShell: "orchestration.subscribeShell",+ subscribeThread: "orchestration.subscribeThread",} as const;export const ProviderKind = Schema.Literals(["codex", "claudeAgent"]);@@ -308,6 +309,93 @@ export const OrchestrationReadModel = Schema.Struct({});export type OrchestrationReadModel = typeof OrchestrationReadModel.Type;+export const OrchestrationProjectShell = Schema.Struct({+ id: ProjectId,+ title: TrimmedNonEmptyString,+ workspaceRoot: TrimmedNonEmptyString,+ repositoryIdentity: Schema.optional(Schema.NullOr(RepositoryIdentity)),+ defaultModelSelection: Schema.NullOr(ModelSelection),+ scripts: Schema.Array(ProjectScript),+ createdAt: IsoDateTime,+ updatedAt: IsoDateTime,+});+export type OrchestrationProjectShell = typeof OrchestrationProjectShell.Type;++export const OrchestrationThreadShell = Schema.Struct({+ id: ThreadId,+ projectId: ProjectId,+ title: TrimmedNonEmptyString,+ modelSelection: ModelSelection,+ runtimeMode: RuntimeMode,+ interactionMode: ProviderInteractionMode.pipe(+ Schema.withDecodingDefault(Effect.succeed(DEFAULT_PROVIDER_INTERACTION_MODE)),+ ),+ branch: Schema.NullOr(TrimmedNonEmptyString),+ worktreePath: Schema.NullOr(TrimmedNonEmptyString),+ latestTurn: Schema.NullOr(OrchestrationLatestTurn),+ createdAt: IsoDateTime,+ updatedAt: IsoDateTime,+ archivedAt: Schema.NullOr(IsoDateTime).pipe(Schema.withDecodingDefault(Effect.succeed(null))),+ session: Schema.NullOr(OrchestrationSession),+ latestUserMessageAt: Schema.NullOr(IsoDateTime),+ hasPendingApprovals: Schema.Boolean,+ hasPendingUserInput: Schema.Boolean,+ hasActionableProposedPlan: Schema.Boolean,+});+export type OrchestrationThreadShell = typeof OrchestrationThreadShell.Type;++export const OrchestrationShellSnapshot = Schema.Struct({+ snapshotSequence: NonNegativeInt,+ projects: Schema.Array(OrchestrationProjectShell),+ threads: Schema.Array(OrchestrationThreadShell),+ updatedAt: IsoDateTime,+});+export type OrchestrationShellSnapshot = typeof OrchestrationShellSnapshot.Type;++export const OrchestrationShellStreamEvent = Schema.Union([+ Schema.Struct({+ kind: Schema.Literal("project-upserted"),+ sequence: NonNegativeInt,+ project: OrchestrationProjectShell,+ }),+ Schema.Struct({+ kind: Schema.Literal("project-removed"),+ sequence: NonNegativeInt,+ projectId: ProjectId,+ }),+ Schema.Struct({+ kind: Schema.Literal("thread-upserted"),+ sequence: NonNegativeInt,+ thread: OrchestrationThreadShell,+ }),+ Schema.Struct({+ kind: Schema.Literal("thread-removed"),+ sequence: NonNegativeInt,+ threadId: ThreadId,+ }),+]);+export type OrchestrationShellStreamEvent = typeof OrchestrationShellStreamEvent.Type;++export const OrchestrationShellStreamItem = Schema.Union([+ Schema.Struct({+ kind: Schema.Literal("snapshot"),+ snapshot: OrchestrationShellSnapshot,+ }),+ OrchestrationShellStreamEvent,+]);+export type OrchestrationShellStreamItem = typeof OrchestrationShellStreamItem.Type;++export const OrchestrationSubscribeThreadInput = Schema.Struct({+ threadId: ThreadId,+});+export type OrchestrationSubscribeThreadInput = typeof OrchestrationSubscribeThreadInput.Type;++export const OrchestrationThreadDetailSnapshot = Schema.Struct({+ snapshotSequence: NonNegativeInt,+ thread: OrchestrationThread,+});+export type OrchestrationThreadDetailSnapshot = typeof OrchestrationThreadDetailSnapshot.Type;+export const ProjectCreateCommand = Schema.Struct({type: Schema.Literal("project.create"),commandId: CommandId,@@ -955,6 +1043,18 @@ export const OrchestrationEvent = Schema.Union([]);export type OrchestrationEvent = typeof OrchestrationEvent.Type;+export const OrchestrationThreadStreamItem = Schema.Union([+ Schema.Struct({+ kind: Schema.Literal("snapshot"),+ snapshot: OrchestrationThreadDetailSnapshot,+ }),+ Schema.Struct({+ kind: Schema.Literal("event"),+ event: OrchestrationEvent,+ }),+]);+export type OrchestrationThreadStreamItem = typeof OrchestrationThreadStreamItem.Type;+export const OrchestrationCommandReceiptStatus = Schema.Literals(["accepted", "rejected"]);export type OrchestrationCommandReceiptStatus = typeof OrchestrationCommandReceiptStatus.Type;@@ -1019,11 +1119,6 @@ export const DispatchResult = Schema.Struct({});export type DispatchResult = typeof DispatchResult.Type;-export const OrchestrationGetSnapshotInput = Schema.Struct({});-export type OrchestrationGetSnapshotInput = typeof OrchestrationGetSnapshotInput.Type;-const OrchestrationGetSnapshotResult = OrchestrationReadModel;-export type OrchestrationGetSnapshotResult = typeof OrchestrationGetSnapshotResult.Type;-export const OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(Struct.assign({ threadId: ThreadId }),{ unsafePreserveChecks: true },@@ -1051,10 +1146,6 @@ const OrchestrationReplayEventsResult = Schema.Array(OrchestrationEvent);export type OrchestrationReplayEventsResult = typeof OrchestrationReplayEventsResult.Type;export const OrchestrationRpcSchemas = {- getSnapshot: {- input: OrchestrationGetSnapshotInput,- output: OrchestrationGetSnapshotResult,- },dispatchCommand: {input: ClientOrchestrationCommand,output: DispatchResult,@@ -1071,6 +1162,14 @@ export const OrchestrationRpcSchemas = {input: OrchestrationReplayEventsInput,output: OrchestrationReplayEventsResult,},+ subscribeThread: {+ input: OrchestrationSubscribeThreadInput,+ output: OrchestrationThreadStreamItem,+ },+ subscribeShell: {+ input: Schema.Struct({}),+ output: OrchestrationShellStreamItem,+ },} as const;export class OrchestrationGetSnapshotError extends Schema.TaggedErrorClass<OrchestrationGetSnapshotError>()(diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.tsindex f47b427bc..b3809d965 100644--- a/packages/contracts/src/rpc.ts+++ b/packages/contracts/src/rpc.ts@@ -32,13 +32,11 @@ import {import { KeybindingsConfigError } from "./keybindings";import {ClientOrchestrationCommand,- OrchestrationEvent,ORCHESTRATION_WS_METHODS,OrchestrationDispatchCommandError,OrchestrationGetFullThreadDiffError,OrchestrationGetFullThreadDiffInput,OrchestrationGetSnapshotError,- OrchestrationGetSnapshotInput,OrchestrationGetTurnDiffError,OrchestrationGetTurnDiffInput,OrchestrationReplayEventsError,@@ -115,7 +113,6 @@ export const WS_METHODS = {// Streaming subscriptionssubscribeGitStatus: "subscribeGitStatus",- subscribeOrchestrationDomainEvents: "subscribeOrchestrationDomainEvents",subscribeTerminalEvents: "subscribeTerminalEvents",subscribeServerConfig: "subscribeServerConfig",subscribeServerLifecycle: "subscribeServerLifecycle",@@ -272,12 +269,6 @@ export const WsTerminalCloseRpc = Rpc.make(WS_METHODS.terminalClose, {error: TerminalError,});-export const WsOrchestrationGetSnapshotRpc = Rpc.make(ORCHESTRATION_WS_METHODS.getSnapshot, {- payload: OrchestrationGetSnapshotInput,- success: OrchestrationRpcSchemas.getSnapshot.output,- error: OrchestrationGetSnapshotError,-});-export const WsOrchestrationDispatchCommandRpc = Rpc.make(ORCHESTRATION_WS_METHODS.dispatchCommand,{@@ -308,11 +299,19 @@ export const WsOrchestrationReplayEventsRpc = Rpc.make(ORCHESTRATION_WS_METHODS.error: OrchestrationReplayEventsError,});-export const WsSubscribeOrchestrationDomainEventsRpc = Rpc.make(- WS_METHODS.subscribeOrchestrationDomainEvents,+export const WsOrchestrationSubscribeShellRpc = Rpc.make(ORCHESTRATION_WS_METHODS.subscribeShell, {+ payload: OrchestrationRpcSchemas.subscribeShell.input,+ success: OrchestrationRpcSchemas.subscribeShell.output,+ error: OrchestrationGetSnapshotError,+ stream: true,+});++export const WsOrchestrationSubscribeThreadRpc = Rpc.make(+ ORCHESTRATION_WS_METHODS.subscribeThread,{- payload: Schema.Struct({}),- success: OrchestrationEvent,+ payload: OrchestrationRpcSchemas.subscribeThread.input,+ success: OrchestrationRpcSchemas.subscribeThread.output,+ error: OrchestrationGetSnapshotError,stream: true,},);@@ -369,14 +368,14 @@ export const WsRpcGroup = RpcGroup.make(WsTerminalClearRpc,WsTerminalRestartRpc,WsTerminalCloseRpc,- WsSubscribeOrchestrationDomainEventsRpc,WsSubscribeTerminalEventsRpc,WsSubscribeServerConfigRpc,WsSubscribeServerLifecycleRpc,WsSubscribeAuthAccessRpc,- WsOrchestrationGetSnapshotRpc,WsOrchestrationDispatchCommandRpc,WsOrchestrationGetTurnDiffRpc,WsOrchestrationGetFullThreadDiffRpc,WsOrchestrationReplayEventsRpc,+ WsOrchestrationSubscribeShellRpc,+ WsOrchestrationSubscribeThreadRpc,);