perf(desktop): reduce startup load time by ~95%

apps/server/src/checkpointing/Layers/CheckpointDiffQuery.test.ts

@@ -125,6 +125,7 @@ describe("CheckpointDiffQueryLive", () => {
       Layer.provideMerge(Layer.succeed(CheckpointStore, checkpointStore)),
       Layer.provideMerge(
         Layer.succeed(ProjectionSnapshotQuery, {
+          getBootstrapSnapshot: () => Effect.succeed(snapshot),
           getSnapshot: () => Effect.succeed(snapshot),
         }),
       ),
@@ -174,6 +175,13 @@ describe("CheckpointDiffQueryLive", () => {
       Layer.provideMerge(Layer.succeed(CheckpointStore, checkpointStore)),
       Layer.provideMerge(
         Layer.succeed(ProjectionSnapshotQuery, {
+          getBootstrapSnapshot: () =>
+            Effect.succeed({
+              snapshotSequence: 0,
+              projects: [],
+              threads: [],
+              updatedAt: "2026-01-01T00:00:00.000Z",
+            } satisfies OrchestrationReadModel),
           getSnapshot: () =>
             Effect.succeed({
               snapshotSequence: 0,

apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts

@@ -2,32 +2,38 @@ import {
   CheckpointRef,
   CommandId,
   DEFAULT_PROVIDER_INTERACTION_MODE,
+  EventId,
   MessageId,
   ProjectId,
   ThreadId,
   TurnId,
   type OrchestrationEvent,
 } from "@t3tools/contracts";
 import { Effect, Layer, ManagedRuntime, Queue, Stream } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 import { describe, expect, it } from "vitest";
 
 import { PersistenceSqlError } from "../../persistence/Errors.ts";
 import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts";
 import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts";
 import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts";
+import { createEmptyReadModel, projectEvent } from "../projector.ts";
 import {
   OrchestrationEventStore,
   type OrchestrationEventStoreShape,
 } from "../../persistence/Services/OrchestrationEventStore.ts";
 import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
 import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts";
+import { makeProjectionSnapshotQuery } from "./ProjectionSnapshotQuery.ts";
 import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
 import {
   OrchestrationProjectionPipeline,
   type OrchestrationProjectionPipelineShape,
 } from "../Services/ProjectionPipeline.ts";
 import { ServerConfig } from "../../config.ts";
 import * as NodeServices from "@effect/platform-node/NodeServices";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import * as NodePath from "@effect/platform-node/NodePath";
 
 const asProjectId = (value: string): ProjectId => ProjectId.makeUnsafe(value);
 const asMessageId = (value: string): MessageId => MessageId.makeUnsafe(value);
@@ -38,19 +44,48 @@ async function createOrchestrationSystem() {
   const ServerConfigLayer = ServerConfig.layerTest(process.cwd(), {
     prefix: "t3-orchestration-engine-test-",
   });
+  const envLayer = Layer.merge(
+    ServerConfigLayer,
+    Layer.merge(NodeServices.layer, Layer.merge(NodeFileSystem.layer, NodePath.layer)),
+  );
+  const sqlLayer = SqlitePersistenceMemory.pipe(Layer.provideMerge(envLayer));
+  const runtimeDependencies = Layer.merge(envLayer, sqlLayer);
+  const eventStoreLayer = OrchestrationEventStoreLive.pipe(Layer.provideMerge(sqlLayer));
+  const commandReceiptLayer = OrchestrationCommandReceiptRepositoryLive.pipe(
+    Layer.provideMerge(sqlLayer),
+  );
+  const projectionPipelineLayer = OrchestrationProjectionPipelineLive.pipe(
+    Layer.provideMerge(eventStoreLayer),
+    Layer.provideMerge(runtimeDependencies),
+  );
   const orchestrationLayer = OrchestrationEngineLive.pipe(
-    Layer.provide(OrchestrationProjectionPipelineLive),
-    Layer.provide(OrchestrationEventStoreLive),
-    Layer.provide(OrchestrationCommandReceiptRepositoryLive),
-    Layer.provide(SqlitePersistenceMemory),
-    Layer.provideMerge(ServerConfigLayer),
-    Layer.provideMerge(NodeServices.layer),
+    Layer.provideMerge(projectionPipelineLayer),
+    Layer.provideMerge(eventStoreLayer),
+    Layer.provideMerge(commandReceiptLayer),
+    Layer.provideMerge(sqlLayer),
+  );
+  const runtimeLayer = Layer.merge(orchestrationLayer, Layer.merge(eventStoreLayer, sqlLayer)).pipe(
+    Layer.provideMerge(envLayer),
+  );
+  const runtime = ManagedRuntime.make(
+    runtimeLayer as Layer.Layer<
+      Layer.Success<typeof runtimeLayer>,
+      Layer.Error<typeof runtimeLayer>,
+      never
+    >,
   );
-  const runtime = ManagedRuntime.make(orchestrationLayer);
   const engine = await runtime.runPromise(Effect.service(OrchestrationEngineService));
+  const eventStore = await runtime.runPromise(Effect.service(OrchestrationEventStore));
   return {
     engine,
-    run: <A, E>(effect: Effect.Effect<A, E>) => runtime.runPromise(effect),
+    eventStore,
+    run: <A, E>(
+      effect: Effect.Effect<
+        A,
+        E,
+        OrchestrationEngineService | OrchestrationEventStore | SqlClient.SqlClient
+      >,
+    ) => runtime.runPromise(effect),
     dispose: () => runtime.dispose(),
   };
 }
@@ -245,6 +280,214 @@ describe("OrchestrationEngine", () => {
     await system.dispose();
   });
 
+  it("hydrates engine bootstrap state from projections without thread activities", async () => {
+    const system = await createOrchestrationSystem();
+    const { engine, eventStore } = system;
+    const createdAt = now();
+
+    await system.run(
+      engine.dispatch({
+        type: "project.create",
+        commandId: CommandId.makeUnsafe("cmd-project-snapshot-create"),
+        projectId: asProjectId("project-snapshot"),
+        title: "Snapshot Project",
+        workspaceRoot: "/tmp/project-snapshot",
+        defaultModelSelection: {
+          provider: "codex",
+          model: "gpt-5-codex",
+        },
+        createdAt,
+      }),
+    );
+    await system.run(
+      engine.dispatch({
+        type: "thread.create",
+        commandId: CommandId.makeUnsafe("cmd-thread-snapshot-create"),
+        threadId: ThreadId.makeUnsafe("thread-snapshot"),
+        projectId: asProjectId("project-snapshot"),
+        title: "Snapshot Thread",
+        modelSelection: {
+          provider: "codex",
+          model: "gpt-5-codex",
+        },
+        interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+        runtimeMode: "approval-required",
+        branch: null,
+        worktreePath: null,
+        createdAt,
+      }),
+    );
+    await system.run(
+      engine.dispatch({
+        type: "thread.turn.start",
+        commandId: CommandId.makeUnsafe("cmd-thread-snapshot-turn-start"),
+        threadId: ThreadId.makeUnsafe("thread-snapshot"),
+        message: {
+          messageId: asMessageId("msg-snapshot-1"),
+          role: "user",
+          text: "hello snapshot",
+          attachments: [],
+        },
+        interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+        runtimeMode: "approval-required",
+        createdAt,
+      }),
+    );
+
+    let replayedReadModel = createEmptyReadModel(new Date().toISOString());
+    const replayedEvents = await system.run(
+      Stream.runCollect(eventStore.readAll()).pipe(
+        Effect.map((chunk): OrchestrationEvent[] => Array.from(chunk)),
+      ),
+    );
+    for (const event of replayedEvents) {
+      replayedReadModel = await system.run(projectEvent(replayedReadModel, event));
+    }
+
+    const snapshotReadModel = await system.run(
+      Effect.flatMap(makeProjectionSnapshotQuery(), (snapshotQuery) => snapshotQuery.getSnapshot()),
+    );
+    const engineReadModel = await system.run(engine.getReadModel());
+    const replayedReadModelWithoutActivities = {
+      ...replayedReadModel,
+      threads: replayedReadModel.threads.map((thread) => ({
+        ...thread,
+        activities: [],
+      })),
+    };
+
+    expect(snapshotReadModel).toEqual(replayedReadModel);
+    expect(engineReadModel).toEqual(replayedReadModelWithoutActivities);
+    await system.dispose();
+  });
+
+  it("strips historical thread activities when bootstrap falls back to replay", async () => {
+    const createdAt = now();
+    const ServerConfigLayer = ServerConfig.layerTest(process.cwd(), {
+      prefix: "t3-orchestration-engine-test-",
+    });
+    const envLayer = Layer.merge(
+      ServerConfigLayer,
+      Layer.merge(NodeServices.layer, Layer.merge(NodeFileSystem.layer, NodePath.layer)),
+    );
+    const sqlLayer = SqlitePersistenceMemory.pipe(Layer.provideMerge(envLayer));
+    const eventStoreLayer = OrchestrationEventStoreLive.pipe(Layer.provideMerge(sqlLayer));
+    const commandReceiptLayer = OrchestrationCommandReceiptRepositoryLive.pipe(
+      Layer.provideMerge(sqlLayer),
+    );
+    const runtimeDependencies = Layer.merge(envLayer, sqlLayer);
+    const noBootstrapProjectionPipeline: OrchestrationProjectionPipelineShape = {
+      bootstrap: Effect.void,
+      projectEvent: () => Effect.void,
+    };
+    const orchestrationLayer = OrchestrationEngineLive.pipe(
+      Layer.provide(Layer.succeed(OrchestrationProjectionPipeline, noBootstrapProjectionPipeline)),
+      Layer.provideMerge(eventStoreLayer),
+      Layer.provideMerge(commandReceiptLayer),
+      Layer.provideMerge(sqlLayer),
+    );
+
+    const runtimeLayer = Layer.merge(orchestrationLayer, eventStoreLayer).pipe(
+      Layer.provideMerge(runtimeDependencies),
+    );
+    const runtime = ManagedRuntime.make(
+      runtimeLayer as Layer.Layer<
+        Layer.Success<typeof runtimeLayer>,
+        Layer.Error<typeof runtimeLayer>,
+        never
+      >,
+    );
+
+    const eventStore = await runtime.runPromise(Effect.service(OrchestrationEventStore));
+    await runtime.runPromise(
+      eventStore.append({
+        type: "project.created",
+        eventId: EventId.makeUnsafe("evt-replay-bootstrap-project-created"),
+        aggregateKind: "project",
+        aggregateId: asProjectId("project-replay-bootstrap"),
+        occurredAt: createdAt,
+        commandId: CommandId.makeUnsafe("cmd-replay-bootstrap-project-created"),
+        causationEventId: null,
+        correlationId: CommandId.makeUnsafe("cmd-replay-bootstrap-project-created"),
+        metadata: {},
+        payload: {
+          projectId: asProjectId("project-replay-bootstrap"),
+          title: "Replay bootstrap project",
+          workspaceRoot: "/tmp/project-replay-bootstrap",
+          defaultModelSelection: null,
+          scripts: [],
+          createdAt,
+          updatedAt: createdAt,
+        },
+      }),
+    );
+    await runtime.runPromise(
+      eventStore.append({
+        type: "thread.created",
+        eventId: EventId.makeUnsafe("evt-replay-bootstrap-thread-created"),
+        aggregateKind: "thread",
+        aggregateId: ThreadId.makeUnsafe("thread-replay-bootstrap"),
+        occurredAt: createdAt,
+        commandId: CommandId.makeUnsafe("cmd-replay-bootstrap-thread-created"),
+        causationEventId: null,
+        correlationId: CommandId.makeUnsafe("cmd-replay-bootstrap-thread-created"),
+        metadata: {},
+        payload: {
+          threadId: ThreadId.makeUnsafe("thread-replay-bootstrap"),
+          projectId: asProjectId("project-replay-bootstrap"),
+          title: "Replay bootstrap thread",
+          modelSelection: {
+            provider: "codex",
+            model: "gpt-5-codex",
+          },
+          runtimeMode: "approval-required",
+          interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+          branch: null,
+          worktreePath: null,
+          createdAt,
+          updatedAt: createdAt,
+        },
+      }),
+    );
+    await runtime.runPromise(
+      eventStore.append({
+        type: "thread.activity-appended",
+        eventId: EventId.makeUnsafe("evt-replay-bootstrap-activity-appended"),
+        aggregateKind: "thread",
+        aggregateId: ThreadId.makeUnsafe("thread-replay-bootstrap"),
+        occurredAt: createdAt,
+        commandId: CommandId.makeUnsafe("cmd-replay-bootstrap-activity-appended"),
+        causationEventId: null,
+        correlationId: CommandId.makeUnsafe("cmd-replay-bootstrap-activity-appended"),
+        metadata: {},
+        payload: {
+          threadId: ThreadId.makeUnsafe("thread-replay-bootstrap"),
+          activity: {
+            id: EventId.makeUnsafe("activity-replay-bootstrap"),
+            tone: "info",
+            kind: "runtime.warning",
+            summary: "Replay bootstrap activity",
+            payload: {
+              message: "should be stripped from engine bootstrap",
+            },
+            turnId: null,
+            createdAt,
+          },
+        },
+      }),
+    );
+
+    const engine = await runtime.runPromise(Effect.service(OrchestrationEngineService));
+    const readModel = await runtime.runPromise(engine.getReadModel());
+
+    expect(readModel.snapshotSequence).toBe(3);
+    expect(
+      readModel.threads.find((thread) => thread.id === "thread-replay-bootstrap")?.activities,
+    ).toEqual([]);
+
+    await runtime.dispose();
+  });
+
   it("streams persisted domain events in order", async () => {
     const system = await createOrchestrationSystem();
     const { engine } = system;