@devries-cameron20 / t3code Mirror · read-only / commits / 3735eb186d
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, 08:15 UTC

fix(server): look up a run's turn-start items by run, not by walking thread history (#28343)

Behzad Motaghi committed Nov 1, 2026 at 22:51 UTC 3735eb186dbf27dc3d830e16061fd0121b3a2faf
2 files changed +212
apps/server/src/orchestration-v2/ProjectionStore.test.ts
+210
@@ -3439,6 +3439,216 @@ it.layer(layerTest)("ProjectionStoreV2", (it) => {
3439 }),
3440 );
3441
3442 + it.effect("reads a run's turn-start items by thread and run, not by walking thread history", () =>
3443 + Effect.gen(function* () {
3444 + const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
3445 + const sql = yield* SqlClient.SqlClient;
3446 + const now = yield* DateTime.now;
3447 + const nowIso = DateTime.formatIso(now);
3448 + const threadId = ThreadId.make("thread:turn-start-items");
3449 + const otherThreadId = ThreadId.make("thread:turn-start-items:other");
3450 + const selectedRunId = RunId.make("run:turn-start-items:selected");
3451 + const emptyRunId = RunId.make("run:turn-start-items:empty");
3452 + const siblingRunId = RunId.make("run:turn-start-items:sibling");
3453 +
3454 + for (const id of [threadId, otherThreadId]) {
3455 + yield* projectionStore.apply({
3456 + id: EventId.make(`event:${id}:created`),
3457 + type: "thread.created",
3458 + threadId: id,
3459 + occurredAt: now,
3460 + payload: {
3461 + createdBy: "user",
3462 + creationSource: "web",
3463 + id,
3464 + projectId: ProjectId.make("project:turn-start-items"),
3465 + title: id,
3466 + providerInstanceId,
3467 + modelSelection,
3468 + runtimeMode: "full-access",
3469 + interactionMode: "default",
3470 + branch: null,
3471 + worktreePath: null,
3472 + activeProviderThreadId: null,
3473 + lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: id },
3474 + forkedFrom: null,
3475 + createdAt: now,
3476 + updatedAt: now,
3477 + archivedAt: null,
3478 + settledOverride: null,
3479 + settledAt: null,
3480 + lastVisitedAt: null,
3481 + deletedAt: null,
3482 + },
3483 + });
3484 + }
3485 + for (const [ordinal, runId] of [selectedRunId, emptyRunId, siblingRunId].entries()) {
3486 + yield* sql`
3487 + INSERT INTO orchestration_v2_projection_runs (
3488 + run_id, thread_id, ordinal, provider, provider_thread_id, status,
3489 + requested_at, completed_at, payload_json
3490 + ) VALUES (
3491 + ${runId}, ${threadId}, ${ordinal + 1}, 'codex', NULL, 'completed', ${nowIso}, ${nowIso},
3492 + ${encodeUnknownJsonString({
3493 + id: runId,
3494 + threadId,
3495 + ordinal: ordinal + 1,
3496 + providerInstanceId,
3497 + modelSelection,
3498 + providerThreadId: null,
3499 + userMessageId: `message:${runId}`,
3500 + rootNodeId: `node:${runId}`,
3501 + activeAttemptId: null,
3502 + status: "completed",
3503 + requestedAt: nowIso,
3504 + startedAt: nowIso,
3505 + completedAt: nowIso,
3506 + checkpointId: null,
3507 + contextHandoffId: null,
3508 + })}
3509 + )
3510 + `;
3511 + }
3512 +
3513 + const insertItem = (
3514 + id: string,
3515 + itemThreadId: ThreadId,
3516 + runId: string | null,
3517 + ordinal: number,
3518 + ) =>
3519 + sql`
3520 + INSERT INTO orchestration_v2_projection_turn_items (
3521 + turn_item_id, thread_id, run_id, node_id, provider_thread_id, provider_turn_id,
3522 + parent_item_id, ordinal, type, status, updated_at, payload_json
3523 + ) VALUES (
3524 + ${id}, ${itemThreadId}, ${runId}, NULL, NULL, NULL, NULL, ${ordinal},
3525 + 'command_execution', 'completed', ${nowIso},
3526 + ${encodeUnknownJsonString({
3527 + id,
3528 + threadId: itemThreadId,
3529 + runId,
3530 + nodeId: null,
3531 + providerThreadId: null,
3532 + providerTurnId: null,
3533 + nativeItemRef: null,
3534 + parentItemId: null,
3535 + ordinal,
3536 + status: "completed",
3537 + title: id,
3538 + input: "echo",
3539 + output: "ok",
3540 + exitCode: 0,
3541 + startedAt: nowIso,
3542 + completedAt: nowIso,
3543 + updatedAt: nowIso,
3544 + type: "command_execution",
3545 + })}
3546 + )
3547 + `;
3548 + const addHistory = (from: number, to: number) => sql`
3549 + WITH RECURSIVE history(position) AS (
3550 + SELECT ${from} UNION ALL SELECT position + 1 FROM history WHERE position < ${to}
3551 + )
3552 + INSERT INTO orchestration_v2_projection_turn_items (
3553 + turn_item_id, thread_id, run_id, node_id, provider_thread_id, provider_turn_id,
3554 + parent_item_id, ordinal, type, status, updated_at, payload_json
3555 + )
3556 + SELECT 'item:turn-start-items:history:' || position, ${threadId},
3557 + 'run:turn-start-items:history:' || (position % 100), NULL, NULL, NULL, NULL, position,
3558 + 'command_execution', 'completed', ${nowIso},
3559 + json_object(
3560 + 'id', 'item:turn-start-items:history:' || position,
3561 + 'threadId', ${threadId},
3562 + 'runId', 'run:turn-start-items:history:' || (position % 100),
3563 + 'nodeId', NULL, 'providerThreadId', NULL, 'providerTurnId', NULL,
3564 + 'nativeItemRef', NULL, 'parentItemId', NULL, 'ordinal', position,
3565 + 'status', 'completed', 'title', 'history', 'input', 'echo', 'output', 'ok',
3566 + 'exitCode', 0, 'startedAt', ${nowIso}, 'completedAt', ${nowIso},
3567 + 'updatedAt', ${nowIso}, 'type', 'command_execution'
3568 + )
3569 + FROM history
3570 + `;
3571 +
3572 + // Twelve ordinals with two items each, inserted in reverse id order.
3573 + const selectedIds: Array<string> = [];
3574 + for (let slot = 1; slot <= 12; slot += 1) {
3575 + for (const suffix of ["b", "a"]) {
3576 + yield* insertItem(
3577 + `item:turn-start-items:selected:${String(slot).padStart(2, "0")}:${suffix}`,
3578 + threadId,
3579 + selectedRunId,
3580 + slot * 100,
3581 + );
3582 + }
3583 + selectedIds.push(
3584 + `item:turn-start-items:selected:${String(slot).padStart(2, "0")}:a`,
3585 + `item:turn-start-items:selected:${String(slot).padStart(2, "0")}:b`,
3586 + );
3587 + }
3588 + yield* insertItem("item:turn-start-items:no-run", threadId, null, 100);
3589 + yield* insertItem("item:turn-start-items:sibling:1", threadId, siblingRunId, 100);
3590 + yield* insertItem("item:turn-start-items:sibling:2", threadId, siblingRunId, 101);
3591 + yield* insertItem("item:turn-start-items:other-thread:b", otherThreadId, selectedRunId, 100);
3592 + yield* insertItem("item:turn-start-items:other-thread:a", otherThreadId, selectedRunId, 100);
3593 +
3594 + const readItems = Effect.fn("readTurnStartItems")(function* (
3595 + readThreadId: ThreadId,
3596 + readRunId: RunId,
3597 + ) {
3598 + const { statements, tracer } = traceSqlStatements();
3599 + const context = yield* projectionStore
3600 + .getTurnStartContext(readThreadId, readRunId)
3601 + .pipe(Effect.withTracer(tracer));
3602 + const lookups = statements.filter((statement) =>
3603 + statement.includes("FROM orchestration_v2_projection_turn_items"),
3604 + );
3605 + assert.lengthOf(lookups, 1);
3606 + const plan = (yield* sql.unsafe<{ readonly detail: string }>(
3607 + `EXPLAIN QUERY PLAN ${lookups[0]}`,
3608 + [readThreadId, readRunId],
3609 + )).map((row) => row.detail);
3610 + return { ids: context.turnItems.map((item) => item.id), plan };
3611 + });
3612 +
3613 + const lookupPlans: Array<ReadonlyArray<string>> = [];
3614 + for (const [from, to] of [
3615 + [1, 1_000],
3616 + [1_001, 10_000],
3617 + ] as const) {
3618 + yield* addHistory(from, to);
3619 + const { ids, plan } = yield* readItems(threadId, selectedRunId);
3620 + assert.deepEqual(ids, selectedIds);
3621 + lookupPlans.push(plan);
3622 + }
3623 +
3624 + assert.deepEqual((yield* readItems(threadId, emptyRunId)).ids, []);
3625 + assert.deepEqual(
3626 + (yield* readItems(threadId, RunId.make("run:turn-start-items:missing"))).ids,
3627 + [],
3628 + );
3629 + assert.deepEqual((yield* readItems(threadId, siblingRunId)).ids, [
3630 + "item:turn-start-items:sibling:1",
3631 + "item:turn-start-items:sibling:2",
3632 + ]);
3633 + assert.deepEqual((yield* readItems(otherThreadId, selectedRunId)).ids, [
3634 + "item:turn-start-items:other-thread:a",
3635 + "item:turn-start-items:other-thread:b",
3636 + ]);
3637 + assert.deepEqual((yield* readItems(otherThreadId, siblingRunId)).ids, []);
3638 +
3639 + for (const plan of lookupPlans) {
3640 + const lookup = plan.filter((detail) =>
3641 + detail.includes("orchestration_v2_projection_turn_items"),
3642 + );
3643 + assert.lengthOf(lookup, 1);
3644 + assert.match(
3645 + lookup[0]!,
3646 + /^SEARCH .*\((?:thread_id=\? AND )?run_id=\?(?: AND thread_id=\?)?\)$/,
3647 + );
3648 + }
3649 + }),
3650 + );
3651 +
3652 it.effect(
3653 "counts each shell's own runless and live-run items, skipping rolled back and missing runs",
3654 () =>
apps/server/src/orchestration-v2/ProjectionStore.ts
+2
@@ -4315,6 +4315,8 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
4315 `.pipe(Effect.flatMap(decodeRows(decodeContextTransferPayload, threadId)));
4316 const turnItems = yield* sql<PayloadRow>`
4317 SELECT payload_json FROM orchestration_v2_projection_turn_items
4318 + -- Look up one run's items by key, not by walking the thread's whole history in ordinal order.
4319 + INDEXED BY orchestration_v2_projection_turn_items_run_ordinal_idx
4320 WHERE thread_id = ${threadId} AND run_id = ${runId} ORDER BY ordinal ASC, turn_item_id ASC
4321 `.pipe(Effect.flatMap(decodeRows(decodeTurnItemPayload, threadId)));
4322 const providerSessions = yield* sql<PayloadRow>`