sailfork / t3code-github / apps/ server/ src/ orchestration-v2/ CheckpointScopeOwnership.test.ts

import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import { assert, it } from "@effect/vitest";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import {
  CheckpointId,
  EventId,
  MessageId,
  NodeId,
  ProjectId,
  ProviderInstanceId,
  ProviderThreadId,
  RunId,
  ThreadId,
} from "@t3tools/contracts";
import * as CheckpointDiffQuery from "../checkpointing/CheckpointDiffQuery.ts";
import * as CheckpointStore from "../checkpointing/CheckpointStore.ts";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import { checkpointRefForScopeOrdinal } from "./CheckpointService.ts";
import * as ProjectionStore from "./ProjectionStore.ts";
import * as ThreadManagement from "./ThreadManagementService.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
const layerProjection = Layer.mergeAll(
  ProjectionStore.layer.pipe(Layer.provideMerge(SqlitePersistence.layerMemory)),
  SqlitePersistence.layerMemory,
  IdAllocator.layer,
  NodeCrypto.layer,
);
it.effect("resolves the thread baseline after a second root run replaces scope ownership", () =>
  Effect.gen(function* () {
    const ids = yield* IdAllocator.IdAllocatorV2;
    const projections = yield* ProjectionStore.ProjectionStoreV2;
    const now = DateTime.makeUnsafe("2026-09-08T12:00:00.000Z");
    const threadId = ThreadId.make("thread:audit-root-scope");
    const firstRunId = RunId.make("run:audit-root-scope:1");
    const secondRunId = RunId.make("run:audit-root-scope:2");
    const firstNodeId = NodeId.make("node:audit-root-scope:1");
    const secondNodeId = NodeId.make("node:audit-root-scope:2");
    const providerThreadId = ProviderThreadId.make("provider-thread:audit-root-scope");
    const providerInstanceId = ProviderInstanceId.make("codex");
    const scopeId = yield* ids.allocate.checkpointScope({ threadId, name: "root" });
    const checkpointRefs = [
      yield* checkpointRefForScopeOrdinal({ scopeId, ordinalWithinScope: 0 }),
      yield* checkpointRefForScopeOrdinal({ scopeId, ordinalWithinScope: 1 }),
      yield* checkpointRefForScopeOrdinal({ scopeId, ordinalWithinScope: 2 }),
    ];
    const baselineId = CheckpointId.make("checkpoint:audit-root-scope:0");
    const firstCheckpointId = CheckpointId.make("checkpoint:audit-root-scope:1");
    const secondCheckpointId = CheckpointId.make("checkpoint:audit-root-scope:2");
    const modelSelection = { instanceId: providerInstanceId, model: "gpt-5.4" } as const;

    yield* projections.apply({
      id: EventId.make("event:audit-root-scope:thread"),
      type: "thread.created",
      threadId,
      providerInstanceId,
      occurredAt: now,
      payload: {
        createdBy: "user",
        creationSource: "web",
        id: threadId,
        projectId: ProjectId.make("project:audit-root-scope"),
        title: "Checkpoint scope probe",
        providerInstanceId,
        modelSelection,
        runtimeMode: "full-access",
        interactionMode: "default",
        branch: null,
        worktreePath: null,
        activeProviderThreadId: providerThreadId,
        lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
        forkedFrom: null,
        createdAt: now,
        updatedAt: now,
        archivedAt: null,
        settledOverride: null,
        settledAt: null,
        lastVisitedAt: null,
        deletedAt: null,
      },
    });

    const applyRun = (input: {
      readonly runId: RunId;
      readonly nodeId: NodeId;
      readonly ordinal: number;
      readonly checkpointId: CheckpointId;
    }) =>
      projections.apply({
        id: EventId.make(`event:audit-root-scope:run:${input.ordinal}`),
        type: "run.updated",
        threadId,
        runId: input.runId,
        nodeId: input.nodeId,
        providerInstanceId,
        occurredAt: now,
        payload: {
          id: input.runId,
          threadId,
          ordinal: input.ordinal,
          providerInstanceId,
          modelSelection,
          providerThreadId,
          userMessageId: MessageId.make(`message:audit-root-scope:${input.ordinal}`),
          rootNodeId: input.nodeId,
          activeAttemptId: null,
          status: "completed" as const,
          requestedAt: now,
          startedAt: now,
          completedAt: now,
          checkpointId: input.checkpointId,
          contextHandoffId: null,
        },
      });
    const applyScope = (runId: RunId, nodeId: NodeId, ordinal: number) =>
      projections.apply({
        id: EventId.make(`event:audit-root-scope:scope:${ordinal}`),
        type: "checkpoint-scope.created",
        threadId,
        runId,
        nodeId,
        providerInstanceId,
        occurredAt: now,
        payload: {
          id: scopeId,
          threadId,
          runId,
          nodeId,
          parentScopeId: null,
          providerThreadId,
          kind: "root_run" as const,
          ordinalWithinParent: 0,
          advancesAppRunCount: true,
          cwd: ordinal === 1 ? "/repo" : "/prepared-repo",
          createdAt: now,
        },
      });
    const applyCheckpoint = (input: {
      readonly id: CheckpointId;
      readonly runId: RunId | null;
      readonly nodeId: NodeId;
      readonly ordinal: number;
      readonly appRunOrdinal: number | null;
    }) =>
      projections.apply({
        id: EventId.make(`event:audit-root-scope:checkpoint:${input.ordinal}`),
        type: "checkpoint.captured",
        threadId,
        ...(input.runId === null ? {} : { runId: input.runId }),
        nodeId: input.nodeId,
        providerInstanceId,
        occurredAt: now,
        payload: {
          id: input.id,
          scopeId,
          threadId,
          runId: input.runId,
          nodeId: input.nodeId,
          parentCheckpointId:
            input.ordinal === 0 ? null : input.ordinal === 1 ? baselineId : firstCheckpointId,
          ordinalWithinScope: input.ordinal,
          appRunOrdinal: input.appRunOrdinal,
          ref: checkpointRefs[input.ordinal]!,
          status: "ready" as const,
          files: [],
          capturedAt: now,
        },
      });

    yield* applyRun({
      runId: firstRunId,
      nodeId: firstNodeId,
      ordinal: 1,
      checkpointId: firstCheckpointId,
    });
    yield* applyScope(firstRunId, firstNodeId, 1);
    yield* applyCheckpoint({
      id: baselineId,
      runId: null,
      nodeId: firstNodeId,
      ordinal: 0,
      appRunOrdinal: null,
    });
    yield* applyCheckpoint({
      id: firstCheckpointId,
      runId: firstRunId,
      nodeId: firstNodeId,
      ordinal: 1,
      appRunOrdinal: 1,
    });
    yield* applyRun({
      runId: secondRunId,
      nodeId: secondNodeId,
      ordinal: 2,
      checkpointId: secondCheckpointId,
    });
    yield* applyScope(secondRunId, secondNodeId, 2);
    yield* applyCheckpoint({
      id: secondCheckpointId,
      runId: secondRunId,
      nodeId: secondNodeId,
      ordinal: 2,
      appRunOrdinal: 2,
    });

    const context = yield* projections.getCheckpointContext(threadId);
    assert.deepEqual(
      context.checkpoints.map((checkpoint) => checkpoint.appRunOrdinal),
      [null, 1, 2],
    );
    assert.equal(context.checkpointScopes.length, 1);
    assert.equal(context.checkpointScopes[0]?.runId, secondRunId);

    const layerQuery = CheckpointDiffQuery.layer.pipe(
      Layer.provide(
        Layer.mergeAll(
          Layer.mock(ThreadManagement.ThreadManagementService)({
            getCheckpointContext: () => Effect.succeed(context),
          }),
          Layer.mock(CheckpointStore.CheckpointStore)({
            listAuthoredPaths: () => Effect.succeed(null),
            diffCheckpoints: (input) => {
              assert.equal(input.cwd, "/prepared-repo");
              assert.equal(input.fromCheckpointRef, checkpointRefs[0]);
              assert.equal(input.toCheckpointRef, checkpointRefs[2]);
              return Effect.succeed("two-run diff");
            },
          }),
        ),
      ),
    );
    const result = yield* Effect.gen(function* () {
      const query = yield* CheckpointDiffQuery.CheckpointDiffQuery;
      return yield* query.getFullThreadDiff({ threadId, toTurnCount: 2 });
    }).pipe(Effect.provide(layerQuery));
    assert.equal(result.diff, "two-run diff");
  }).pipe(Effect.provide(layerProjection)),
);