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

import { describe, expect, it } from "@effect/vitest";
import {
  DEFAULT_SERVER_SETTINGS,
  EventId,
  MessageId,
  type OrchestrationV2ThreadProjection,
  NodeId,
  ProjectId,
  ProviderDriverKind,
  ProviderInstanceId,
  ProviderThreadId,
  ProviderTurnId,
  RunId,
  ThreadId,
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Stream from "effect/Stream";
import * as Tracer from "effect/Tracer";
import * as TestClock from "effect/testing/TestClock";

import * as ServerSettings from "../serverSettings.ts";
import * as IdleCompactionService from "./IdleCompactionService.ts";
import * as Orchestrator from "./Orchestrator.ts";
import * as ProjectionStore from "./ProjectionStore.ts";

import { idleCompactionWindow, type IdleCompactionRecords } from "./IdleCompaction.ts";

const NOW_MS = Date.parse("2026-10-19T12:00:00.000Z");
const MINUTE_MS = 60_000;
const at = (offset = 0) => DateTime.makeUnsafe(NOW_MS + offset);
const threadId = ThreadId.make("idle-thread");
const runId = RunId.make("run-1");
const instanceId = ProviderInstanceId.make("claudeAgent");
const providerThreadId = ProviderThreadId.make("provider-thread");
const modelSelection = { instanceId, model: "claude-opus-5-5" };

function records(
  usage: { readonly usedTokens?: number; readonly cacheExpiresInMs?: number } = {},
): { -readonly [Key in keyof IdleCompactionRecords]: IdleCompactionRecords[Key] } {
  const messageId = MessageId.make("message-1");
  const nodeId = NodeId.make("root-node");
  return {
    thread: {
      id: threadId,
      projectId: ProjectId.make("project"),
      title: "Idle thread",
      createdBy: "user",
      creationSource: "web",
      providerInstanceId: instanceId,
      modelSelection,
      runtimeMode: "full-access",
      interactionMode: "default",
      branch: null,
      worktreePath: null,
      activeProviderThreadId: providerThreadId,
      lineage: { rootThreadId: threadId, parentThreadId: null, relationshipToParent: null },
      forkedFrom: null,
      createdAt: at(-MINUTE_MS),
      updatedAt: at(),
      archivedAt: null,
      settledOverride: null,
      settledAt: null,
      lastVisitedAt: at(),
      deletedAt: null,
    },
    runs: [
      {
        id: runId,
        threadId,
        ordinal: 1,
        providerInstanceId: instanceId,
        modelSelection,
        providerThreadId,
        userMessageId: messageId,
        rootNodeId: nodeId,
        activeAttemptId: null,
        status: "completed",
        requestedAt: at(-MINUTE_MS),
        startedAt: at(-MINUTE_MS),
        completedAt: at(),
        checkpointId: null,
        contextHandoffId: null,
      },
    ],
    messages: [
      {
        id: messageId,
        threadId,
        runId,
        nodeId,
        role: "user",
        text: "Explain this code",
        attachments: [],
        streaming: false,
        createdBy: "user",
        creationSource: "web",
        createdAt: at(-MINUTE_MS),
        updatedAt: at(-MINUTE_MS),
      },
    ],
    providerThreads: [
      {
        id: providerThreadId,
        driver: ProviderDriverKind.make("claudeAgent"),
        providerInstanceId: instanceId,
        providerSessionId: null,
        appThreadId: threadId,
        ownerNodeId: nodeId,
        nativeThreadRef: null,
        nativeConversationHeadRef: null,
        status: "idle",
        firstRunOrdinal: 1,
        lastRunOrdinal: 1,
        handoffIds: [],
        forkedFrom: null,
        pendingBackgroundTasks: [],
        createdAt: at(-MINUTE_MS),
        updatedAt: at(),
      },
    ],
    providerTurns: [
      {
        id: ProviderTurnId.make("provider-turn-1"),
        providerThreadId,
        nodeId,
        runAttemptId: null,
        nativeTurnRef: null,
        ordinal: 1,
        status: "completed",
        startedAt: at(-MINUTE_MS),
        completedAt: at(),
        tokenUsage: {
          usedTokens: usage.usedTokens ?? 250_000,
          ...(usage.cacheExpiresInMs === undefined
            ? {}
            : { promptCacheExpiresAt: DateTime.formatIso(at(usage.cacheExpiresInMs)) }),
          updatedAt: DateTime.formatIso(at()),
        },
      },
    ],
    runtimeRequests: [],
    turnItems: [],
    contextTransfers: [],
  };
}

describe("idleCompactionWindow", () => {
  it("skips small contexts, unknown expiry, other providers, switched threads, compactions, and side chats", () => {
    const cache = { cacheExpiresInMs: 60 * MINUTE_MS };
    expect(idleCompactionWindow(records({ ...cache, usedTokens: 199_999 }), NOW_MS)).toBeNull();
    expect(idleCompactionWindow(records(), NOW_MS)).toBeNull();
    const codex = records(cache);
    codex.providerThreads = [
      { ...codex.providerThreads[0]!, driver: ProviderDriverKind.make("codex") },
    ];
    expect(idleCompactionWindow(codex, NOW_MS)).toBeNull();
    const switched = records(cache);
    switched.thread = { ...switched.thread, providerInstanceId: ProviderInstanceId.make("codex") };
    expect(idleCompactionWindow(switched, NOW_MS)).toBeNull();
    const compacted = records(cache);
    compacted.messages = [{ ...compacted.messages[0]!, text: "/compact" }];
    expect(idleCompactionWindow(compacted, NOW_MS)).toBeNull();
    const steered = records(cache);
    steered.runs = [
      ...steered.runs,
      {
        ...steered.runs[0]!,
        id: RunId.make("run-2"),
        ordinal: 2,
        userMessageId: MessageId.make("message-2"),
        status: "cancelled",
        startedAt: null,
      },
    ];
    expect(idleCompactionWindow(steered, NOW_MS)?.runId).toBe(runId);
    // A turn Claude itself reported as cancelled did run, so it stays the latest.
    steered.runs = steered.runs.map((run) => ({ ...run, startedAt: at(-MINUTE_MS) }));
    expect(idleCompactionWindow(steered, NOW_MS)).toBeNull();
    const archived = records(cache);
    archived.thread = { ...archived.thread, archivedAt: at() };
    expect(idleCompactionWindow(archived, NOW_MS)).toBeNull();
    const sideChat = records(cache);
    expect(idleCompactionWindow(sideChat, NOW_MS)).not.toBeNull();
    sideChat.thread = {
      ...sideChat.thread,
      lineage: { ...sideChat.thread.lineage, relationshipToParent: "fork", sideChat: true },
    };
    expect(idleCompactionWindow(sideChat, NOW_MS)).toBeNull();
  });
});

describe("IdleCompactionService", () => {
  it.effect.each([
    { mode: "onReturn", reads: 0 },
    { mode: "off", reads: 0 },
    { mode: "beforeCacheExpires", reads: 1 },
    { mode: "beforeCacheExpires", override: "off", reads: 0 },
    { mode: "onReturn", override: "beforeCacheExpires", reads: 1 },
    { mode: "beforeCacheExpires", projectDisabled: true, reads: 0 },
    { mode: "beforeCacheExpires", enabled: false, reads: 0 },
    { mode: "beforeCacheExpires", driver: "codex", instance: "codex", reads: 0 },
    { mode: "beforeCacheExpires", driver: "codex", instance: "custom-codex", reads: 0 },
    { mode: "beforeCacheExpires", driver: "claudeAgent", instance: "custom-claude", reads: 1 },
    { mode: "beforeCacheExpires", unconfigured: true, reads: 1 },
  ] as const)(
    "loads history only for eligible idle compaction: $mode/$override/$enabled/$projectDisabled/$instance/$unconfigured",
    (scenario) => {
      const test = {
        override: "default",
        enabled: true,
        projectDisabled: false,
        ...scenario,
      } as const;
      return Effect.scoped(
        Effect.gen(function* () {
          yield* TestClock.setTime(NOW_MS);
          const selectedInstance = ProviderInstanceId.make(
            "instance" in test ? test.instance : "claudeAgent",
          );
          const driver = ProviderDriverKind.make("driver" in test ? test.driver : "claudeAgent");
          const base = records({ cacheExpiresInMs: 2 * MINUTE_MS });
          const data: OrchestrationV2ThreadProjection = {
            ...base,
            thread: {
              ...base.thread,
              providerInstanceId: selectedInstance,
              modelSelection: { ...base.thread.modelSelection, instanceId: selectedInstance },
            },
            runs: base.runs.map((run) => ({
              ...run,
              providerInstanceId: selectedInstance,
              modelSelection: { ...run.modelSelection, instanceId: selectedInstance },
            })),
            providerThreads: base.providerThreads.map((thread) => ({
              ...thread,
              driver,
              providerInstanceId: selectedInstance,
            })),
            attempts: [],
            nodes: [],
            subagents: [],
            providerSessions: [],
            plans: [],
            checkpointScopes: [],
            checkpoints: [],
            contextHandoffs: [],
            visibleTurnItems: [],
            updatedAt: at(),
          };
          let historyReads = 0;
          let dispatches = 0;
          const done = yield* Deferred.make<void>();
          const tracer = Tracer.make({
            span(options) {
              const span = new Tracer.NativeSpan(options);
              const end = span.end.bind(span);
              span.end = (...args) => {
                end(...args);
                if (span.name === "IdleCompactionService.compactWhenDue")
                  Deferred.doneUnsafe(done, Effect.void);
              };
              return span;
            },
          });
          const dependencies = Layer.mergeAll(
            Layer.mock(Orchestrator.OrchestratorV2)({
              streamDomainEvents: Stream.make({
                id: EventId.make("idle-completed"),
                type: "run.updated",
                threadId,
                runId,
                occurredAt: at(),
                payload: data.runs[0]!,
              }),
              dispatch: () =>
                Effect.sync(() => {
                  dispatches++;
                  return { sequence: 1, storedEvents: [] };
                }),
            }),
            Layer.mock(ProjectionStore.ProjectionStoreV2)({
              getThread: () => Effect.succeed(data.thread),
              getThreadRecords: () =>
                Effect.sync(() => {
                  historyReads++;
                  return data;
                }),
            }),
            Layer.mock(ServerSettings.ServerSettingsService)({
              getSettings: Effect.succeed({
                ...DEFAULT_SERVER_SETTINGS,
                idleCompaction: test.mode,
                providerInstances:
                  "unconfigured" in test
                    ? {}
                    : {
                        [selectedInstance]: {
                          driver,
                          enabled: test.enabled,
                          config: { idleCompaction: test.override },
                        },
                      },
                projectSettingsOverrides: test.projectDisabled
                  ? {
                      [data.thread.projectId]: {
                        providerInstances: { [selectedInstance]: { enabled: false } },
                      },
                    }
                  : {},
              }),
            }),
          );
          yield* Effect.gen(function* () {
            const service = yield* IdleCompactionService.make;
            yield* service.start();
            yield* Deferred.await(done);
          }).pipe(Effect.provide(dependencies), Effect.withTracer(tracer));
          expect(historyReads).toBe(test.reads);
          expect(dispatches).toBe(test.reads);
        }),
      );
    },
  );

  it.effect("keeps the latest run's compaction when an earlier run reports completed again", () =>
    Effect.scoped(
      Effect.gen(function* () {
        yield* TestClock.setTime(NOW_MS);
        const base = records({ cacheExpiresInMs: 10 * MINUTE_MS });
        const laterRunId = RunId.make("run-2");
        const laterMessageId = MessageId.make("message-2");
        const earlierRun = base.runs[0]!;
        const laterRun = {
          ...earlierRun,
          id: laterRunId,
          ordinal: 2,
          userMessageId: laterMessageId,
        };
        const cancelledRun = {
          ...earlierRun,
          id: RunId.make("run-3"),
          ordinal: 3,
          userMessageId: MessageId.make("message-3"),
          status: "cancelled" as const,
          startedAt: null,
        };
        const data: OrchestrationV2ThreadProjection = {
          ...base,
          runs: [earlierRun, laterRun, cancelledRun],
          messages: [
            ...base.messages,
            { ...base.messages[0]!, id: laterMessageId, runId: laterRunId, text: "Keep going" },
          ],
          providerThreads: [{ ...base.providerThreads[0]!, lastRunOrdinal: 2 }],
          attempts: [],
          nodes: [],
          subagents: [],
          providerSessions: [],
          plans: [],
          checkpointScopes: [],
          checkpoints: [],
          contextHandoffs: [],
          visibleTurnItems: [],
          updatedAt: at(),
        };
        const completed = (run: typeof earlierRun) => ({
          id: EventId.make(`completed-${run.id}`),
          type: "run.updated" as const,
          threadId,
          runId: run.id,
          occurredAt: at(),
          payload: run,
        });
        const dispatched: Array<string> = [];
        const streamDone = yield* Deferred.make<void>();
        const dependencies = Layer.mergeAll(
          Layer.mock(Orchestrator.OrchestratorV2)({
            // A delegated completion on the earlier run lands after the later run completed.
            streamDomainEvents: Stream.make(completed(laterRun), completed(earlierRun)).pipe(
              Stream.ensuring(Deferred.succeed(streamDone, undefined)),
            ),
            dispatch: (command) =>
              Effect.sync(() => {
                dispatched.push(command.commandId);
                return { sequence: 1, storedEvents: [] };
              }),
          }),
          Layer.mock(ProjectionStore.ProjectionStoreV2)({
            getThread: () => Effect.succeed(data.thread),
            getThreadRecords: (_threadId, _keys, options) =>
              Effect.succeed({
                ...data,
                messages: data.messages.filter(
                  (message) =>
                    options?.messageRunIds === undefined ||
                    (message.runId !== null && options.messageRunIds.includes(message.runId)),
                ),
              }),
          }),
          Layer.mock(ServerSettings.ServerSettingsService)({
            getSettings: Effect.succeed({
              ...DEFAULT_SERVER_SETTINGS,
              idleCompaction: "beforeCacheExpires",
            }),
          }),
        );
        yield* Effect.gen(function* () {
          const service = yield* IdleCompactionService.make;
          yield* service.start();
          yield* Deferred.await(streamDone);
          yield* TestClock.adjust(9 * MINUTE_MS);
        }).pipe(Effect.provide(dependencies));
        expect(dispatched).toEqual(["server:idle-compact:idle-thread:run-2"]);
      }),
    ),
  );
});