Skip to content
TypeScript

fix(server): route missing read-only queries to readers

Yash Singhaee76a8b4736
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.test.ts b/apps/server/src/orchestration-v2/ProjectionStore.test.ts
index f453dec9567..14bb72e3c78 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.test.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.test.ts
@@ -31,11 +31,14 @@ import {
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
+import * as Deferred from "effect/Deferred";
+import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import * as Tracer from "effect/Tracer";
import * as SqlClient from "effect/sql/SqlClient";
+import * as Statement from "effect/sql/Statement";
import { projectThreadAwarenessV2 } from "@t3tools/shared/agentAwareness";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
@@ -51,6 +54,8 @@ import {
} from "./threadHistoryPaging.ts";
import { limitRecoveryCommand } from "./UsageLimitRecoveryWorker.ts";
+import { layerReaderDatabase, traceSqlRouting } from "../persistence/testkit/SqliteRouting.ts";
+
const layerTest = Layer.mergeAll(
ProjectionStore.layer.pipe(Layer.provideMerge(SqlitePersistence.layerMemory)),
SqlitePersistence.layerMemory,
@@ -226,6 +231,93 @@ const addRolledBackRecoveryCandidate = Effect.fn("addRolledBackRecoveryCandidate
return threadId;
});
+it.effect("routes full projection reads to readers and retains uncommitted writer state", () =>
+ Effect.gen(function* () {
+ const store = yield* ProjectionStore.ProjectionStoreV2;
+ const sql = yield* SqlClient.SqlClient;
+ const parentId = yield* addRolledBackRecoveryCandidate("reader-routing");
+ const parent = yield* store.getThreadProjection(parentId);
+ const threadId = ThreadId.make("thread:reader-routing:fork");
+ yield* store.apply({
+ id: EventId.make("event:reader-routing:fork"),
+ type: "thread.created",
+ threadId,
+ occurredAt: parent.thread.createdAt,
+ payload: {
+ ...parent.thread,
+ id: threadId,
+ forkedFrom: { type: "run", threadId: parentId, runId: parent.runs[0]!.id },
+ },
+ });
+ const { queries, trace } = traceSqlRouting();
+ const projection = yield* store.getThreadProjection(threadId).pipe(trace);
+ assert.equal(projection.thread.id, threadId);
+ assert.deepEqual(
+ projection.visibleTurnItems
+ .filter((row) => row.visibility === "inherited")
+ .map((row) => row.sourceItemId),
+ parent.turnItems.map((item) => item.id),
+ );
+ assert.isAbove(queries.length, 1);
+ assert.deepEqual([...new Set(queries.map((row) => row.connection))], ["reader"]);
+ const commitRequested = yield* Deferred.make<void>();
+ const writer = yield* Deferred.await(commitRequested).pipe(
+ Effect.andThen(
+ sql.withTransaction(
+ Effect.gen(function* () {
+ yield* sql`
+ UPDATE orchestration_v2_projection_threads
+ SET payload_json = json_set(payload_json, '$.title', 'Committed title')
+ WHERE thread_id = ${threadId}
+ `;
+ yield* sql`
+ UPDATE orchestration_v2_projection_turn_items
+ SET payload_json = json_set(payload_json, '$.title', 'Committed command')
+ WHERE thread_id = ${parentId}
+ `;
+ }),
+ ),
+ ),
+ Effect.forkChild,
+ );
+ let commitInjected = false;
+ const duringCommit = yield* store.getThreadProjection(threadId).pipe(
+ Effect.provideService(Statement.CurrentTransformer, (statement) => {
+ const [query] = statement.compile();
+ if (!commitInjected && query.includes("FROM orchestration_v2_projection_turn_items")) {
+ commitInjected = true;
+ return Deferred.succeed(commitRequested, undefined).pipe(
+ Effect.andThen(Fiber.join(writer).pipe(Effect.orDie)),
+ Effect.as(statement),
+ );
+ }
+ return Effect.succeed(statement);
+ }),
+ );
+ assert.isTrue(commitInjected);
+ assert.deepEqual(duringCommit, projection);
+ const afterCommit = yield* store.getThreadProjection(threadId);
+ assert.equal(afterCommit.thread.title, "Committed title");
+ assert.equal(
+ afterCommit.visibleTurnItems.find((row) => row.visibility === "inherited")?.item.title,
+ "Committed command",
+ );
+ yield* sql.withTransaction(
+ Effect.gen(function* () {
+ yield* sql`
+ UPDATE orchestration_v2_projection_threads
+ SET payload_json = json_set(payload_json, '$.title', 'Uncommitted title')
+ WHERE thread_id = ${threadId}
+ `;
+ assert.equal(
+ (yield* store.getThreadProjection(threadId)).thread.title,
+ "Uncommitted title",
+ );
+ }),
+ );
+ }).pipe(Effect.provide(ProjectionStore.layer.pipe(Layer.provideMerge(layerReaderDatabase)))),
+);
+
it.effect("record reads restrict provider histories to delivery identities", () =>
Effect.gen(function* () {
const store = yield* ProjectionStore.ProjectionStoreV2;
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.ts b/apps/server/src/orchestration-v2/ProjectionStore.ts
index 8726799153c..3e6ca0d75a1 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.ts
@@ -4522,7 +4522,15 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
);
const getThreadProjection: ProjectionStoreV2Shape["getThreadProjection"] = (threadId) =>
- readProjection(threadId, new Set());
+ sql
+ .withTransaction(readProjection(threadId, new Set()))
+ .pipe(
+ Effect.mapError((cause) =>
+ isProjectionStoreThreadNotFoundError(cause) || isProjectionStoreReadError(cause)
+ ? cause
+ : new ProjectionStoreReadError({ threadId, cause }),
+ ),
+ );
const getRuntimeRecoveryProjection: ProjectionStoreV2Shape["getRuntimeRecoveryProjection"] =
Effect.fn("ProjectionStore.getRuntimeRecoveryProjection")(
@@ -7252,7 +7260,7 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
getThreadsWithPullRequests: readOnReader(getThreadsWithPullRequests),
getThreadWorktreePaths: readOnReader(getThreadWorktreePaths),
getOpenRemoteDelegatedTasks: getOpenRemoteDelegatedTasks.pipe(NodeSqliteClient.readOnly),
- getThreadProjection,
+ getThreadProjection: readOnReader(getThreadProjection),
getTurnStartContext: readOnReader(getTurnStartContext),
getTurnStartHistory: readOnReader(getTurnStartHistory),
getRuntimeRecoveryProjection: readOnReader(getRuntimeRecoveryProjection),
diff --git a/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.test.ts b/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.test.ts
index 50671194d46..a50b3ed3c19 100644
--- a/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.test.ts
+++ b/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.test.ts
@@ -14,7 +14,6 @@ import * as Layer from "effect/Layer";
import * as SqlClient from "effect/sql/SqlClient";
import * as Statement from "effect/sql/Statement";
-import * as SqlitePersistence from "../../persistence/Sqlite.ts";
import { listLinkedPullRequestThreads } from "../../pullRequest/linkedThreads.ts";
import * as EventSink from "../EventSink.ts";
import * as EventStore from "../EventStore.ts";
@@ -22,7 +21,9 @@ import * as LegacyV1ThreadImporter from "./LegacyV1ThreadImporter.ts";
import * as ProjectionReplay from "../testkit/ProjectionReplay.ts";
import * as ProjectionStore from "../ProjectionStore.ts";
-const layerDatabase = SqlitePersistence.layerMemory;
+import { layerReaderDatabase, traceSqlRouting } from "../../persistence/testkit/SqliteRouting.ts";
+
+const layerDatabase = layerReaderDatabase;
const layerEventStoreProvided = EventStore.layer.pipe(Layer.provideMerge(layerDatabase));
const layerProjectionStoreProvided = ProjectionStore.layer.pipe(Layer.provideMerge(layerDatabase));
const layerStoresProvided = Layer.mergeAll(
@@ -80,6 +81,72 @@ const seedPendingTranscripts = Effect.gen(function* () {
yield* importer.reconcileShells;
});
+it.effect("routes shell selectors to readers while imports stay writable", () =>
+ Effect.gen(function* () {
+ const importer = yield* LegacyV1ThreadImporter.LegacyV1ThreadImporter;
+ const sql = yield* SqlClient.SqlClient;
+ const { queries, trace } = traceSqlRouting();
+ yield* seedPendingTranscripts.pipe(trace);
+ const selectors = queries.filter(
+ ({ query }) =>
+ query.includes("FROM projection_threads AS thread") ||
+ query.includes("FROM orchestration_v2_legacy_imports AS legacy_import") ||
+ query.includes("FROM projection_thread_messages AS message"),
+ );
+ assert.lengthOf(selectors, 6);
+ assert.deepEqual([...new Set(selectors.map((row) => row.connection))], ["reader"]);
+ assert.deepEqual(yield* importer.reconcileShells, {
+ importedThreadCount: 0,
+ importedMessageCount: 0,
+ });
+ yield* sql.withTransaction(
+ Effect.gen(function* () {
+ yield* sql`
+ INSERT INTO projection_threads (
+ thread_id, project_id, title, model_selection_json, runtime_mode,
+ interaction_mode, created_at, updated_at
+ ) VALUES (
+ 'thread:uncommitted', 'project:background', 'Uncommitted legacy title',
+ '{"instanceId":"codex","model":"gpt-5.4"}', 'full-access', 'default',
+ '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z'
+ )
+ `;
+ yield* sql`
+ INSERT INTO projection_thread_messages (
+ message_id, thread_id, role, text, is_streaming, created_at, updated_at
+ ) VALUES (
+ 'message:uncommitted', 'thread:uncommitted', 'user', 'Uncommitted preview', 0,
+ '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z'
+ )
+ `;
+ yield* sql`
+ UPDATE orchestration_v2_projection_threads
+ SET payload_json = json_remove(payload_json, '$.pinnedAt')
+ WHERE thread_id = 'thread:first'
+ `;
+ yield* sql`
+ UPDATE projection_threads SET pinned_at = '2026-01-01T00:00:00.000Z'
+ WHERE thread_id = 'thread:first'
+ `;
+ const result = yield* importer.reconcileShells;
+ assert.deepEqual(result, { importedThreadCount: 2, importedMessageCount: 1 });
+ const projections = yield* ProjectionStore.ProjectionStoreV2;
+ const repaired = yield* projections.getThreadProjection(ThreadId.make("thread:first"));
+ assert.equal(DateTime.formatIso(repaired.thread.pinnedAt!), "2026-01-01T00:00:00.000Z");
+ const imported = yield* projections.getThreadProjection(
+ ThreadId.make("thread:uncommitted"),
+ );
+ assert.equal(imported.messages[0]?.text, "Uncommitted preview");
+ assert.equal(
+ (yield* projections.getThreadProjection(ThreadId.make("thread:uncommitted"))).thread
+ .title,
+ "Uncommitted legacy title",
+ );
+ }),
+ );
+ }).pipe(Effect.provide(layerTest)),
+);
+
it.effect(
"keeps hydrating later transcripts after a defect and leaves the failed thread pending",
() =>
diff --git a/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts b/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts
index d82a9e80a23..8c134d3b57d 100644
--- a/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts
+++ b/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts
@@ -394,7 +394,7 @@ const make = Effect.gen(function* () {
AND message.role IN ('user', 'assistant')
ORDER BY message.created_at DESC, message.message_id DESC
LIMIT 1
- `;
+ `.pipe(NodeSqliteClient.readOnly);
const latestUser = yield* sql<LegacyMessageRow>`
SELECT
message.message_id,
@@ -424,7 +424,7 @@ const make = Effect.gen(function* () {
AND message.role = 'user'
ORDER BY message.created_at DESC, message.message_id DESC
LIMIT 1
- `;
+ `.pipe(NodeSqliteClient.readOnly);
return [latestUser[0], latest[0]].filter(
(message, index, selected): message is LegacyMessageRow =>
message !== undefined &&
@@ -476,7 +476,7 @@ const make = Effect.gen(function* () {
OR json_type(projection.payload_json, '$.branchPullRequest') IS NULL
OR json_type(projection.payload_json, '$.activeOrderKey') IS NULL
ORDER BY thread.created_at ASC, thread.thread_id ASC
- `;
+ `.pipe(NodeSqliteClient.readOnly);
let repairedThreadCount = 0;
for (const row of repairRows) {
const decoded = decodeStoredThread(row.payload_json);
@@ -574,7 +574,7 @@ const make = Effect.gen(function* () {
AND event.event_type = 'thread.created'
)
ORDER BY thread.created_at ASC, thread.thread_id ASC
- `;
+ `.pipe(NodeSqliteClient.readOnly);
let importedThreadCount = repairedThreadCount;
let importedMessageCount = 0;
for (const row of rows) {
diff --git a/apps/server/src/peer/PeerLinks.test.ts b/apps/server/src/peer/PeerLinks.test.ts
index 3c510c35e69..a99cb7f9051 100644
--- a/apps/server/src/peer/PeerLinks.test.ts
+++ b/apps/server/src/peer/PeerLinks.test.ts
@@ -36,6 +36,8 @@ import {
} from "./PeerLinks.testkit.ts";
import * as PeerMcpClient from "./PeerMcpClient.ts";
+import { layerReaderDatabase, traceSqlRouting } from "../persistence/testkit/SqliteRouting.ts";
+
/** What B's probe saw: the calling client and the modes it may start work with. */
const Probe = Schema.Struct({ caller: Schema.String, modes: Schema.String });
@@ -115,6 +117,47 @@ const serveApart = (descriptor: ExecutionEnvironmentDescriptor) =>
Effect.flatMap((server) => serveB(descriptor).pipe(Effect.provideContext(server))),
);
+it.effect("routes peer reads to readers and sees uncommitted link updates", () =>
+ Effect.scoped(
+ Effect.gen(function* () {
+ const context = yield* layerLinkingEnvironment(
+ laptop,
+ ServerSecretStore.layer,
+ layerReaderDatabase,
+ ).pipe(Layer.build);
+ const links = Context.get(context, PeerLinks.PeerLinks);
+ const sql = Context.get(context, SqlClient.SqlClient);
+ yield* sql`
+ INSERT INTO peer_environment_links (
+ environment_id, secret_name, label, urls_json, access, linked_at, expires_at, fenced
+ ) VALUES (
+ ${box.environmentId}, 'test-secret', 'Box', '[]', 'auto',
+ '2026-01-01T00:00:00.000Z', '2026-01-02T00:00:00.000Z', 1
+ )
+ `;
+ const { queries, trace } = traceSqlRouting();
+ yield* links.list.pipe(trace);
+ expect(Option.getOrThrow(yield* links.get(box.environmentId).pipe(trace)).label).toBe("Box");
+ const reads = queries.filter(({ query }) =>
+ query.includes("SELECT * FROM peer_environment_links"),
+ );
+ expect(reads).toHaveLength(2);
+ expect(reads.map((row) => row.connection)).toEqual(["reader", "reader"]);
+ yield* sql.withTransaction(
+ Effect.gen(function* () {
+ yield* sql`UPDATE peer_environment_links SET label = 'Uncommitted box'`;
+ expect(Option.getOrThrow(yield* links.get(box.environmentId)).label).toBe(
+ "Uncommitted box",
+ );
+ expect((yield* links.list)[0]?.label).toBe("Uncommitted box");
+ }),
+ );
+ expect(yield* links.unlink(box.environmentId)).toBe(true);
+ expect(yield* links.list).toEqual([]);
+ }),
+ ),
+);
+
it.effect("links with a pairing code, and the peer holds its agents to the limits they carry", () =>
Effect.scoped(
Effect.gen(function* () {
diff --git a/apps/server/src/peer/PeerLinks.testkit.ts b/apps/server/src/peer/PeerLinks.testkit.ts
index c72c5ba8c81..1ff940af9b3 100644
--- a/apps/server/src/peer/PeerLinks.testkit.ts
+++ b/apps/server/src/peer/PeerLinks.testkit.ts
@@ -21,6 +21,7 @@ import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
import * as AuthHttp from "../auth/http.ts";
import * as McpOAuth from "../auth/McpOAuth.ts";
import * as McpOAuthHttp from "../auth/mcpOAuthHttp.ts";
+import type * as SqlClient from "effect/sql/SqlClient";
import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
import * as ServerConfig from "../config.ts";
import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
@@ -154,14 +155,18 @@ export type ServedPeer = Effect.Success<ReturnType<typeof servePeer>>;
* The environment that links: its own database and secret store, reaching
* peers over plain HTTP. Provide it to anything built on its links.
*/
-export const layerLinkingEnvironment = (
+export const layerLinkingEnvironment = <E = never>(
descriptor: ExecutionEnvironmentDescriptor,
secrets: typeof ServerSecretStore.layer = ServerSecretStore.layer,
+ database: Layer.Layer<
+ SqlClient.SqlClient,
+ E | Layer.Error<typeof Sqlite.layerMemory>
+ > = Sqlite.layerMemory,
) =>
PeerMcpClient.layer.pipe(
Layer.provideMerge(PeerLinks.layer),
Layer.provideMerge(ServerSettings.layerTest({ linkedEnvironmentsEnabled: true })),
- Layer.provideMerge(Sqlite.layerMemory),
+ Layer.provideMerge(database),
Layer.provide(Layer.mergeAll(secrets, FetchHttpClient.layer)),
// Services that act for this environment, such as delegation, name it too.
Layer.provideMerge(
diff --git a/apps/server/src/peer/PeerLinks.ts b/apps/server/src/peer/PeerLinks.ts
index adbc8cbd1ed..70aa68d25cc 100644
--- a/apps/server/src/peer/PeerLinks.ts
+++ b/apps/server/src/peer/PeerLinks.ts
@@ -12,6 +12,7 @@ import {
type PeerLinkStatus,
type PeerLinkSummary,
} from "@t3tools/contracts";
+import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";
import * as Context from "effect/Context";
import * as Digest from "effect/crypto/Digest";
import * as SecureRandom from "effect/crypto/SecureRandom";
@@ -222,12 +223,13 @@ const make = Effect.gen(function* () {
const readRows = sql<PeerLinkRow>`
SELECT * FROM peer_environment_links ORDER BY label, environment_id
- `.pipe(Effect.catch(failStorage));
+ `.pipe(NodeSqliteClient.readOnly, Effect.catch(failStorage));
const readRow = (environmentId: EnvironmentId) =>
sql<PeerLinkRow>`
SELECT * FROM peer_environment_links WHERE environment_id = ${environmentId}
`.pipe(
+ NodeSqliteClient.readOnly,
Effect.catch(failStorage),
Effect.map((rows) => Option.fromNullishOr(rows[0])),
);
diff --git a/apps/server/src/persistence/testkit/SqliteRouting.ts b/apps/server/src/persistence/testkit/SqliteRouting.ts
new file mode 100644
index 00000000000..2dcd65ec2b2
--- /dev/null
+++ b/apps/server/src/persistence/testkit/SqliteRouting.ts
@@ -0,0 +1,52 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Statement from "effect/sql/Statement";
+import * as Tracer from "effect/Tracer";
+
+import * as Sqlite from "../Sqlite.ts";
+
+export const layerReaderDatabase = Layer.unwrap(
+ Effect.gen(function* () {
+ const fs = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const directory = yield* fs.makeTempDirectoryScoped({ prefix: "t3-routing-" });
+ return Sqlite.layerFromPath(path.join(directory, "state.sqlite"));
+ }),
+).pipe(Layer.provide(NodeServices.layer));
+
+export const traceSqlRouting = () => {
+ const queries: Array<{ query: string; connection: unknown }> = [];
+ const tracer = Tracer.make({
+ span(options) {
+ const span = new Tracer.NativeSpan(options);
+ const end = span.end.bind(span);
+ span.end = (endTime, exit) => {
+ end(endTime, exit);
+ const query = span.attributes.get("db.query.text");
+ if (typeof query === "string") {
+ let owner: Tracer.AnySpan | undefined = span;
+ let connection: unknown;
+ while (owner?._tag === "Span") {
+ connection = owner.attributes.get("db.connection");
+ if (connection !== undefined) break;
+ owner = Option.getOrUndefined(owner.parent);
+ }
+ queries.push({ query, connection });
+ }
+ };
+ return span;
+ },
+ });
+ return {
+ queries,
+ trace: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+ effect.pipe(
+ Effect.withTracer(tracer),
+ Effect.provideService(Statement.SpanPropagationEnabled, true),
+ ),
+ };
+};