sailfork / t3code-github / apps/ server/ integration/ TransferBudgetV2Fixture.integration.ts

import {
  CheckpointId,
  CheckpointScopeId,
  EventId,
  MessageId,
  NodeId,
  ProjectId,
  ProviderInstanceId,
  ProviderThreadId,
  ProviderTurnId,
  RunId,
  ThreadId,
  TurnItemId,
  type ProviderDriverKind,
  type OrchestrationV2DomainEvent,
  type OrchestrationV2TurnItem,
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import {
  diagnosticOutput,
  TRANSFER_HISTORY_TOOLS_PER_TURN,
  TRANSFER_MEASURED_TOOLS,
  TRANSFER_HISTORY_MCP_RESULT_BYTES,
  TRANSFER_MEASURED_MCP_RESULT_BYTES,
} from "./fixtures/transferBudget.ts";

export const THREAD_ID = ThreadId.make("transfer-budget-thread");
type ThreadCreatedEvent = Extract<OrchestrationV2DomainEvent, { readonly type: "thread.created" }>;
export function threadCreated(
  provider: ProviderDriverKind,
  threadId: ThreadId = THREAD_ID,
  overrides: Partial<ThreadCreatedEvent["payload"]> = {},
): ThreadCreatedEvent {
  const now = DateTime.makeUnsafe("2026-06-01T00:00:00Z");
  return {
    id: EventId.make(`thread-created:${threadId}`),
    type: "thread.created",
    threadId,
    occurredAt: now,
    payload: {
      id: threadId,
      projectId: ProjectId.make("transfer-project"),
      title: "Transfer budget",
      providerInstanceId: ProviderInstanceId.make(provider),
      modelSelection: {
        instanceId: ProviderInstanceId.make(provider),
        model: provider === "codex" ? "gpt-5.4" : "claude-sonnet-4-6",
      },
      runtimeMode: "full-access",
      interactionMode: "default",
      branch: null,
      worktreePath: null,
      activeProviderThreadId: null,
      lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
      forkedFrom: null,
      createdBy: "user",
      creationSource: "web",
      createdAt: now,
      updatedAt: now,
      archivedAt: null,
      settledOverride: null,
      settledAt: null,
      lastVisitedAt: null,
      deletedAt: null,
      ...overrides,
    },
  };
}
export function turnEvents(
  provider: ProviderDriverKind,
  index: number,
  measured: boolean,
): ReadonlyArray<OrchestrationV2DomainEvent> {
  const now = DateTime.makeUnsafe(`2026-06-01T00:${String(index + 1).padStart(2, "0")}:00Z`);
  const runId = RunId.make(`run-${index}`);
  const nodeId = NodeId.make(`node-${index}`);
  const userMessageId = MessageId.make(`user-${index}`);
  const providerInstanceId = ProviderInstanceId.make(provider);
  const run = {
    id: runId,
    threadId: THREAD_ID,
    ordinal: index + 1,
    providerInstanceId,
    modelSelection: {
      instanceId: ProviderInstanceId.make(provider),
      model: provider === "codex" ? "gpt-5.4" : "claude-sonnet-4-6",
    },
    providerThreadId: null,
    userMessageId,
    rootNodeId: nodeId,
    activeAttemptId: null,
    status: "running" as const,
    requestedAt: now,
    startedAt: now,
    completedAt: null,
    checkpointId: null,
    contextHandoffId: null,
  };
  const common = {
    threadId: THREAD_ID,
    runId,
    nodeId,
    driver: provider,
    providerInstanceId,
    occurredAt: now,
  };
  const events: OrchestrationV2DomainEvent[] = [
    { ...common, id: EventId.make(`run-${index}`), type: "run.created", payload: run },
  ];
  const answer =
    `Completed ${provider} inspection ${index}. ` +
    "The projection preserves transcript text and bounds tool output. ".repeat(60);
  for (const role of ["user", "assistant"] as const) {
    events.push({
      ...common,
      id: EventId.make(`${role}-${index}`),
      type: "message.updated",
      payload: {
        id: MessageId.make(`${role}-${index}`),
        threadId: THREAD_ID,
        runId,
        nodeId,
        role,
        text: role === "user" ? `Inspect transfer ${index}` : answer,
        attachments: [],
        streaming: false,
        createdAt: now,
        updatedAt: now,
        createdBy: role === "user" ? "user" : "agent",
        creationSource: "web",
      },
    });
  }
  const toolCount = measured ? TRANSFER_MEASURED_TOOLS : TRANSFER_HISTORY_TOOLS_PER_TURN;
  const item = (id: string, ordinal: number, title: string | null) => ({
    id: TurnItemId.make(id),
    threadId: THREAD_ID,
    runId,
    nodeId,
    providerThreadId: null,
    providerTurnId: null,
    nativeItemRef: null,
    parentItemId: null,
    ordinal,
    status: "completed" as const,
    title,
    startedAt: now,
    completedAt: now,
    updatedAt: now,
  });
  for (let tool = 0; tool <= toolCount; tool++) {
    const mcp = tool === toolCount;
    const output = diagnosticOutput({
      provider,
      turnIndex: index,
      toolIndex: tool,
      targetBytes: mcp
        ? measured
          ? TRANSFER_MEASURED_MCP_RESULT_BYTES
          : TRANSFER_HISTORY_MCP_RESULT_BYTES
        : 4096,
    });
    const base = item(
      `item-${index}-${tool}`,
      tool + 1,
      mcp ? "MCP search" : `Inspect source ${tool}`,
    );
    events.push({
      ...common,
      id: EventId.make(`tool-${index}-${tool}`),
      type: "turn-item.updated",
      payload: mcp
        ? {
            ...base,
            type: "dynamic_tool",
            toolName: "mcp__test__search",
            input: { query: "transfer" },
            output: { text: output },
          }
        : {
            ...base,
            type: "command_execution",
            input: `cat src/module-${tool}.ts`,
            output,
            exitCode: 0,
          },
    });
  }
  // The live turn repeats its answer in a turn item, as adapters do, so live dedupe has work.
  // History turns skip it to keep the fallback thread snapshot under its wire ceiling.
  if (measured)
    events.push({
      ...common,
      id: EventId.make(`answer-item-${index}`),
      type: "turn-item.updated",
      payload: {
        ...item(`item-${index}-answer`, toolCount + 2, null),
        type: "assistant_message",
        messageId: MessageId.make(`assistant-${index}`),
        text: answer,
        streaming: false,
      },
    });
  events.push({
    ...common,
    id: EventId.make(`complete-${index}`),
    type: "run.updated",
    payload: { ...run, status: "completed", completedAt: now },
  });
  return events;
}

export const LONG_TURN_THREAD_ID = ThreadId.make("transfer-budget-long-turn");
export const LONG_TURN_WORK_ROWS = 900;

/**
 * Three short user turns, then one agent turn far longer than a cold-open
 * window, with the item kinds a long agent run produces. One batch per turn.
 * Run, node, provider and item IDs follow the composite shapes the Claude
 * adapter stores, and every assistant message has its record, as real threads do.
 */
export function longTurnThreadBatches(
  provider: ProviderDriverKind,
): ReadonlyArray<ReadonlyArray<OrchestrationV2DomainEvent>> {
  const threadId = LONG_TURN_THREAD_ID;
  const providerInstanceId = ProviderInstanceId.make(provider);
  const modelSelection = {
    instanceId: providerInstanceId,
    model: provider === "codex" ? "gpt-5.4" : "claude-sonnet-4-6",
  };
  let ordinal = 0;
  const text = (turn: number, row: number, targetBytes: number) =>
    diagnosticOutput({ provider, turnIndex: 100 + turn, toolIndex: row, targetBytes });

  const turn = (index: number, workRows: number): OrchestrationV2DomainEvent[] => {
    const now = DateTime.makeUnsafe(`2026-06-02T00:${String(index).padStart(2, "0")}:00Z`);
    const runId = RunId.make(`run:thread:${threadId}:ordinal:${index + 1}`);
    const nodeId = NodeId.make(`node:run:${encodeURIComponent(runId)}:root`);
    const providerThreadId = ProviderThreadId.make(
      `provider-thread:provider:${provider}:native-thread:${encodeURIComponent(`pending:${runId}`)}`,
    );
    const providerTurnId = ProviderTurnId.make(
      `provider-turn:provider:${provider}:native-turn:${encodeURIComponent(`turn:run-attempt:${encodeURIComponent(runId)}:attempt:1`)}`,
    );
    const common = {
      threadId,
      runId,
      nodeId,
      driver: provider,
      providerInstanceId,
      occurredAt: now,
    };
    const messageId = (role: "user" | "assistant", row: string) =>
      MessageId.make(
        `message:provider:${provider}:native-item:msg_01LongTurn${role}${index}x${row}`,
      );
    const run = {
      id: runId,
      threadId,
      ordinal: index + 1,
      providerInstanceId,
      modelSelection,
      providerThreadId: null,
      userMessageId: messageId("user", "prompt"),
      rootNodeId: nodeId,
      activeAttemptId: null,
      status: "running" as const,
      requestedAt: now,
      startedAt: now,
      completedAt: null,
      checkpointId: null,
      contextHandoffId: null,
    };
    const base = (row: string, title: string | null) => {
      ordinal += 1;
      const nativeId = `toolu_01LongTurn${index}x${row}`;
      return {
        id: TurnItemId.make(`turn-item:provider:${provider}:native-item:${nativeId}`),
        threadId,
        runId,
        nodeId,
        providerThreadId,
        providerTurnId,
        nativeItemRef: { driver: provider, nativeId, strength: "strong" as const },
        parentItemId: null,
        ordinal,
        status: "completed" as const,
        title,
        startedAt: now,
        completedAt: now,
        updatedAt: now,
      };
    };
    const events: OrchestrationV2DomainEvent[] = [
      { ...common, id: EventId.make(`long-turn-run-${index}`), type: "run.created", payload: run },
    ];
    const message = (role: "user" | "assistant", row: string, messageText: string) => {
      const id = messageId(role, row);
      const createdBy = role === "user" ? ("user" as const) : ("agent" as const);
      events.push(
        {
          ...common,
          id: EventId.make(`long-turn-message-${index}-${row}`),
          type: "message.updated",
          payload: {
            id,
            threadId,
            runId,
            nodeId,
            role,
            text: messageText,
            attachments: [],
            streaming: false,
            createdAt: now,
            updatedAt: now,
            createdBy,
            creationSource: "web",
          },
        },
        {
          ...common,
          id: EventId.make(`long-turn-item-event-${index}-${row}`),
          type: "turn-item.updated",
          payload:
            role === "user"
              ? {
                  ...base(row, null),
                  type: "user_message",
                  createdBy,
                  creationSource: "web",
                  messageId: id,
                  inputIntent: "turn_start",
                  text: messageText,
                  attachments: [],
                }
              : {
                  ...base(row, null),
                  type: "assistant_message",
                  messageId: id,
                  text: messageText,
                  streaming: false,
                },
        },
      );
    };
    const workItem = (row: number): OrchestrationV2TurnItem => {
      if (row % 100 === 50) {
        return {
          ...base(String(row), "Checkpoint"),
          type: "checkpoint",
          checkpointId: CheckpointId.make(`long-turn-checkpoint-${index}-${row}`),
          scopeId: CheckpointScopeId.make(`long-turn-scope-${index}`),
          files: Array.from({ length: 40 }, (_, file) => ({
            path: `src/feature/module-${row}-${file}.ts`,
            kind: "modified",
            additions: file + 1,
            deletions: file,
          })),
        };
      }
      if (row % 100 === 99) {
        return {
          ...base(String(row), "Subagent"),
          type: "subagent",
          subagentId: NodeId.make(`long-turn-subagent-${index}-${row}`),
          origin: "app_owned",
          driver: provider,
          providerInstanceId,
          childThreadId: null,
          prompt: text(index, row, 2_048),
          result: text(index, row + 1, 3_072),
        };
      }
      switch (row % 8) {
        case 0:
        case 7:
          return {
            ...base(String(row), "Reasoning"),
            type: "reasoning",
            text: text(index, row, 1_536),
            streaming: false,
          };
        case 3:
          return {
            ...base(String(row), `Edit module ${row}`),
            type: "file_change",
            fileName: `src/feature/module-${row}.ts`,
            additions: 12,
            deletions: 4,
            diffStr: text(index, row, 2_048),
          };
        case 4:
          return {
            ...base(String(row), "MCP search"),
            type: "dynamic_tool",
            toolName: "mcp__test__search",
            input: { query: `module ${row}` },
            output: { text: text(index, row, 6_144) },
          };
        default:
          return {
            ...base(String(row), `Run check ${row}`),
            type: "command_execution",
            input: `vp test run src/feature/module-${row}.test.ts`,
            output: text(index, row, 4_096),
            exitCode: 0,
          };
      }
    };

    message("user", "prompt", `Continue the feature work, step ${index}.`);
    for (let row = 0; row < workRows; row++) {
      if (row % 8 === 5) {
        message("assistant", String(row), text(index, row, 1_500));
        continue;
      }
      events.push({
        ...common,
        id: EventId.make(`long-turn-work-${index}-${row}`),
        type: "turn-item.updated",
        payload: workItem(row),
      });
    }
    message("assistant", "answer", text(index, workRows, 1_200));
    events.push({
      ...common,
      id: EventId.make(`long-turn-complete-${index}`),
      type: "run.updated",
      payload: { ...run, status: "completed", completedAt: now },
    });
    return events;
  };

  return [
    [threadCreated(provider, threadId)],
    turn(0, 4),
    turn(1, 4),
    turn(2, 4),
    turn(3, LONG_TURN_WORK_ROWS),
  ];
}

export const SHELL_SETTLED_THREADS = 100;
export const SHELL_IDLE_SUBAGENTS = 40;

/**
 * A busy sidebar: settled top-level threads, settled a minute apart, with idle subagent children
 * under the newest ones. Opted-in cold connects skip the children and all but 25 settled threads.
 */
export function shellFleetEvents(
  provider: ProviderDriverKind,
): ReadonlyArray<OrchestrationV2DomainEvent> {
  return Array.from({ length: SHELL_SETTLED_THREADS }, (_, index) => {
    const threadId = ThreadId.make(`transfer-budget-settled-${index}`);
    const settledAt = DateTime.makeUnsafe(Date.UTC(2026, 5, 3, 0, index));
    const settled = threadCreated(provider, threadId, {
      title: `Settled transfer thread ${index}`,
      branch: `feature/settled-${index}`,
      settledOverride: "settled",
      settledAt,
      updatedAt: settledAt,
    });
    if (index < SHELL_SETTLED_THREADS - SHELL_IDLE_SUBAGENTS) return [settled];
    const childId = ThreadId.make(`transfer-budget-settled-${index}-subagent`);
    return [
      settled,
      threadCreated(provider, childId, {
        title: `Subagent of settled thread ${index}`,
        createdBy: "agent",
        lineage: {
          parentThreadId: threadId,
          relationshipToParent: "subagent",
          rootThreadId: threadId,
        },
      }),
    ];
  }).flat();
}