@devries-cameron20 / t3code Mirror · read-only / commits / d833184115
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 07:00 UTC

perf(server): bound runtime recovery reads by thread ownership (#29429)

Yash Singh committed Nov 2, 2026 at 10:35 UTC d833184115ec823825c2cc6f612443cd3a1c1b2c
2 files changed +160 -12
apps/server/src/orchestration-v2/ProjectionRecovery.test.ts
+146
@@ -22,6 +22,7 @@ import * as DateTime from "effect/DateTime";
22 import * as Effect from "effect/Effect";
23 import * as Layer from "effect/Layer";
24 import * as SqlClient from "effect/sql/SqlClient";
25 +import * as Statement from "effect/sql/Statement";
26
27 import * as SqlitePersistence from "../persistence/Sqlite.ts";
28 import * as ServerSettings from "../serverSettings.ts";
@@ -657,6 +658,151 @@ it.effect("includes shared sessions and provider-owned background rosters in rec
658 }).pipe(Effect.provide(layerTest)),
659 );
660
661 +it.effect("bounds runtime provider-thread reads by ownership and preserves recovery liveness", () =>
662 + Effect.gen(function* () {
663 + const projections = yield* ProjectionStore.ProjectionStoreV2;
664 + const sql = yield* SqlClient.SqlClient;
665 + const now = yield* DateTime.now;
666 + const threadId = yield* createThread("ownership");
667 + const other = yield* createThread("other-owner");
668 + const ownerNodeId = NodeId.make("node:recovery:owner");
669 + yield* projections.apply({
670 + id: EventId.make("event:recovery:owner"),
671 + type: "node.updated",
672 + threadId,
673 + nodeId: ownerNodeId,
674 + driver,
675 + occurredAt: now,
676 + payload: {
677 + id: ownerNodeId,
678 + threadId,
679 + runId: null,
680 + parentNodeId: null,
681 + rootNodeId: ownerNodeId,
682 + kind: "root_turn",
683 + status: "completed",
684 + countsForRun: false,
685 + providerThreadId: null,
686 + providerTurnId: null,
687 + nativeItemRef: null,
688 + runtimeRequestId: null,
689 + checkpointScopeId: null,
690 + startedAt: now,
691 + completedAt: now,
692 + },
693 + });
694 + const cases = [
695 + { name: "direct", ownership: "direct", status: "active", ordinal: 2, included: true },
696 + { name: "owner", ownership: "owner", status: "active", ordinal: null, included: true },
697 + { name: "owner-only", ownership: "owner", status: "active", ordinal: 1, included: true },
698 + { name: "subagent", ownership: "subagent", status: "active", ordinal: 1, included: true },
699 + { name: "duplicate", ownership: "all", status: "active", ordinal: 1, included: true },
700 + { name: "roster", ownership: "direct", status: "idle", ordinal: 3, included: true },
701 + { name: "run", ownership: "owner", status: "idle", ordinal: 4, included: true },
702 + { name: "item", ownership: "subagent", status: "idle", ordinal: 5, included: true },
703 + { name: "waiting-run", ownership: "direct", status: "idle", ordinal: 6, included: true },
704 + { name: "settled", ownership: "all", status: "idle", ordinal: 7, included: false },
705 + { name: "unrelated", ownership: "none", status: "active", ordinal: 8, included: false },
706 + { name: "unrelated-run", ownership: "none", status: "idle", ordinal: 9, included: false },
707 + ] as const;
708 + for (const entry of cases) {
709 + const id = ProviderThreadId.make(`provider-thread:ownership:${entry.name}`);
710 + yield* projections.apply({
711 + id: EventId.make(`event:${id}`),
712 + type: "provider-thread.updated",
713 + threadId,
714 + driver,
715 + providerInstanceId,
716 + occurredAt: now,
717 + payload: {
718 + id,
719 + appThreadId:
720 + entry.name === "owner-only"
721 + ? null
722 + : entry.ownership === "direct" || entry.ownership === "all"
723 + ? threadId
724 + : other,
725 + ownerNodeId:
726 + entry.ownership === "owner" || entry.ownership === "all" ? ownerNodeId : null,
727 + driver,
728 + providerInstanceId,
729 + providerSessionId: null,
730 + nativeThreadRef: null,
731 + nativeConversationHeadRef: null,
732 + status: entry.status,
733 + firstRunOrdinal: entry.ordinal,
734 + lastRunOrdinal: entry.ordinal,
735 + handoffIds: [],
736 + forkedFrom: null,
737 + createdAt: now,
738 + updatedAt: now,
739 + pendingBackgroundTasks:
740 + entry.name === "roster"
741 + ? [{ taskId: "shell", description: "background", kind: "command" }]
742 + : [],
743 + },
744 + });
745 + if (entry.ownership === "subagent" || entry.ownership === "all") {
746 + for (const suffix of ["a", "b"]) {
747 + yield* sql`
748 + INSERT INTO orchestration_v2_projection_subagents
749 + (subagent_id, thread_id, parent_node_id, provider, provider_thread_id,
750 + origin, status, updated_at, payload_json)
751 + VALUES (${`${id}:${suffix}`}, ${threadId}, ${ownerNodeId}, 'codex', ${id},
752 + 'provider_native', 'completed', '', '{}')
753 + `;
754 + }
755 + }
756 + if (entry.name === "run" || entry.name === "unrelated-run") {
757 + yield* createRun(threadId, "waiting", { ordinal: entry.ordinal, providerThreadId: id });
758 + }
759 + }
760 + const waitingProviderThreadId = ProviderThreadId.make("provider-thread:ownership:waiting-run");
761 + const waitingRunId = yield* createRun(threadId, "completed", {
762 + ordinal: 6,
763 + providerThreadId: waitingProviderThreadId,
764 + });
765 + yield* sql`
766 + INSERT INTO orchestration_v2_projection_turn_items
767 + (turn_item_id, thread_id, run_id, node_id, provider_thread_id, ordinal, type,
768 + status, updated_at, payload_json)
769 + VALUES ('item:ownership', ${threadId}, ${waitingRunId}, ${ownerNodeId},
770 + ${ProviderThreadId.make("provider-thread:ownership:item")}, 1, 'assistant_message', 'waiting', '', '{}')
771 + `;
772 + const statements: Array<ReturnType<Statement.Statement<unknown>["compile"]>> = [];
773 + const observe: Statement.Transformer = (statement) => {
774 + const compiled = statement.compile();
775 + if (compiled[0].includes("SELECT provider_thread.payload_json")) statements.push(compiled);
776 + return Effect.succeed(statement);
777 + };
778 + const projection = yield* projections
779 + .getRuntimeRecoveryProjection(threadId)
780 + .pipe(Effect.provideService(Statement.CurrentTransformer, observe));
781 + assert.deepEqual(
782 + projection.providerThreads.map((row) => row.id),
783 + cases
784 + .filter((entry) => entry.included)
785 + .toSorted((a, b) => (a.ordinal ?? 0) - (b.ordinal ?? 0) || a.name.localeCompare(b.name))
786 + .map((entry) => ProviderThreadId.make(`provider-thread:ownership:${entry.name}`)),
787 + );
788 + assert.equal(statements.length, 1);
789 + const [query, params] = statements[0]!;
790 + const plan = yield* sql.unsafe<{ detail: string }>(`EXPLAIN QUERY PLAN ${query}`, params);
791 + assert.isFalse(
792 + plan.some((row) => /^SCAN provider_thread(?:$| )/.test(row.detail)),
793 + JSON.stringify(plan),
794 + );
795 + assert.isTrue(
796 + plan.some((row) => row.detail.includes("provider_threads_owner_idx")),
797 + JSON.stringify(plan),
798 + );
799 + assert.isFalse(
800 + plan.some((row) => /SEARCH (owner|n) USING INDEX .*nodes_thread/.test(row.detail)),
801 + JSON.stringify(plan),
802 + );
803 + }).pipe(Effect.provide(layerTest)),
804 +);
805 +
806 it.effect("reads the run that owns a background roster, not a queued or resumed one", () =>
807 Effect.gen(function* () {
808 const projections = yield* ProjectionStore.ProjectionStoreV2;
apps/server/src/orchestration-v2/ProjectionStore.ts
+14 -12
@@ -4586,18 +4586,20 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
4586 sql<PayloadRow>`
4587 SELECT provider_thread.payload_json
4588 FROM orchestration_v2_projection_provider_threads AS provider_thread
4589 - WHERE (
4590 - provider_thread.thread_id = ${threadId}
4591 - OR EXISTS (
4592 - SELECT 1 FROM orchestration_v2_projection_nodes AS owner
4593 - WHERE owner.node_id = provider_thread.owner_node_id
4594 - AND owner.thread_id = ${threadId}
4595 - )
4596 - OR EXISTS (
4597 - SELECT 1 FROM orchestration_v2_projection_subagents AS subagent
4598 - WHERE subagent.provider_thread_id = provider_thread.provider_thread_id
4599 - AND subagent.thread_id = ${threadId}
4600 - )
4589 + WHERE provider_thread.provider_thread_id IN (
4590 + SELECT provider_thread_id FROM orchestration_v2_projection_provider_threads
4591 + WHERE thread_id = ${threadId}
4592 + UNION
4593 + -- Start with non-null owners; a thread can have a large settled node history.
4594 + SELECT owned.provider_thread_id
4595 + FROM orchestration_v2_projection_provider_threads AS owned
4596 + INDEXED BY orchestration_v2_projection_provider_threads_owner_idx
4597 + CROSS JOIN orchestration_v2_projection_nodes AS owner
4598 + ON owner.node_id = owned.owner_node_id
4599 + WHERE owned.owner_node_id IS NOT NULL AND owner.thread_id = ${threadId}
4600 + UNION
4601 + SELECT provider_thread_id FROM orchestration_v2_projection_subagents
4602 + WHERE thread_id = ${threadId} AND provider_thread_id IS NOT NULL
4603 )
4604 AND (
4605 provider_thread.status = 'active'