sailfork / t3code-github / packages/ client-runtime/ src/ state/ threadHistoryMerge.test.ts

import type { OrchestrationV2ProjectedTurnItem } from "@t3tools/contracts";
import { describe, expect, it } from "@effect/vitest";
import * as DateTime from "effect/DateTime";

import { v2Projection, v2ThreadId } from "./orchestrationV2TestFixtures.ts";
import { mergeOlderHistoryIntoProjection } from "./threadHistoryMerge.ts";
import { applyOrchestrationV2ProjectionEvent } from "./orchestrationV2Projection.ts";
import { derivePendingThreadRequests } from "./threadRequests.ts";

const NOW = DateTime.makeUnsafe("2026-06-20T00:00:00.000Z");

function row(index: number): OrchestrationV2ProjectedTurnItem {
  const id = `item-${index}` as never;
  return {
    position: index,
    visibility: "local",
    sourceThreadId: v2ThreadId,
    sourceItemId: id,
    item: {
      id,
      type: "command_execution",
      threadId: v2ThreadId,
      runId: null,
      nodeId: null,
      providerThreadId: null,
      providerTurnId: null,
      nativeItemRef: null,
      parentItemId: null,
      ordinal: index + 1,
      status: "completed",
      title: `Command ${index}`,
      input: `cmd-${index}`,
      output: `out-${index}`,
      exitCode: 0,
      startedAt: NOW,
      completedAt: NOW,
      updatedAt: NOW,
    },
  };
}

describe("threadHistoryMerge", () => {
  it("fills activity around partial messages in canonical order and preserves live edits", () => {
    const initial = { ...v2Projection, turnItems: [row(4).item], visibleTurnItems: [row(4)] };
    const preview = [row(1), row(3)];
    const partial = mergeOlderHistoryIntoProjection(initial, preview);
    const updated = { ...row(1), item: { ...row(1).item, title: "newer live title" } };
    const live = {
      ...partial,
      visibleTurnItems: partial.visibleTurnItems.map((entry) =>
        entry.sourceItemId === updated.sourceItemId ? updated : entry,
      ),
      turnItems: partial.turnItems.map((item) =>
        item.id === updated.item.id ? updated.item : item,
      ),
    };
    const complete = mergeOlderHistoryIntoProjection(live, [row(0), row(1), row(2), row(3)]);
    expect(complete.visibleTurnItems.map((entry) => entry.sourceItemId)).toEqual([
      "item-0",
      "item-1",
      "item-2",
      "item-3",
      "item-4",
    ]);
    expect(complete.visibleTurnItems[1]?.item).toBe(updated.item);
    expect(complete.visibleTurnItems.map((entry) => entry.position)).toEqual([0, 1, 2, 3, 4]);
    expect(new Set(complete.turnItems.map((item) => item.id)).size).toBe(5);
    const anchorItem = {
      ...updated.item,
      deferredWork: { cursor: "work", itemCount: 4, lastOrdinal: 5 },
    };
    const deferred = {
      ...live,
      turnItems: live.turnItems.map((item) => (item.id === anchorItem.id ? anchorItem : item)),
      visibleTurnItems: live.visibleTurnItems.map((entry) =>
        entry.item.id === anchorItem.id ? { ...entry, item: anchorItem } : entry,
      ),
    };
    const loadedWork = mergeOlderHistoryIntoProjection(deferred, [row(1), row(2), row(3)], {
      anchorId: anchorItem.id,
      nextCursor: null,
    });
    expect(loadedWork.visibleTurnItems.map((entry) => entry.sourceItemId)).toEqual([
      "item-1",
      "item-2",
      "item-3",
      "item-4",
    ]);
    expect(loadedWork.visibleTurnItems[0]?.item.title).toBe("newer live title");
    expect(loadedWork.visibleTurnItems[0]?.item.deferredWork).toBeUndefined();
    const hidden = {
      ...partial,
      visibleTurnItems: partial.visibleTurnItems.filter(
        (entry) => entry.sourceItemId !== preview[0]!.sourceItemId,
      ),
    };
    const hiddenComplete = mergeOlderHistoryIntoProjection(hidden, [
      row(0),
      row(1),
      row(2),
      row(3),
    ]);
    expect(hiddenComplete.visibleTurnItems.map((entry) => entry.sourceItemId)).toEqual([
      "item-0",
      "item-2",
      "item-3",
      "item-4",
    ]);
  });

  it("prepends older rows and dedupes by source identity", () => {
    const recent = [row(2), row(3)];
    const projection = {
      ...v2Projection,
      turnItems: recent.map((entry) => entry.item),
      visibleTurnItems: recent.map((entry, position) => ({ ...entry, position })),
    };
    const older = [row(0), row(1), row(2)];
    const merged = mergeOlderHistoryIntoProjection(projection, older);
    expect(merged.visibleTurnItems.map((entry) => entry.sourceItemId)).toEqual([
      "item-0",
      "item-1",
      "item-2",
      "item-3",
    ]);
    expect(merged.visibleTurnItems.map((entry) => entry.position)).toEqual([0, 1, 2, 3]);
    expect(merged.turnItems.map((item) => item.id)).toEqual([
      "item-2",
      "item-3",
      "item-0",
      "item-1",
    ]);
  });

  it("fills inherited activity without confusing identical item IDs from different source threads", () => {
    const inherited = (index: number) => ({
      ...row(index),
      visibility: "inherited" as const,
      sourceThreadId: "fork-source" as never,
    });
    const local = row(1);
    const preview = { ...inherited(1), item: { ...row(1).item, title: "newer inherited title" } };
    const projection = {
      ...v2Projection,
      turnItems: [local.item],
      visibleTurnItems: [preview, local],
    };
    const merged = mergeOlderHistoryIntoProjection(projection, [inherited(0), inherited(1)]);
    expect(
      merged.visibleTurnItems.map((entry) => [entry.sourceThreadId, entry.sourceItemId]),
    ).toEqual([
      ["fork-source", "item-0"],
      ["fork-source", "item-1"],
      [v2ThreadId, "item-1"],
    ]);
    expect(merged.visibleTurnItems[1]?.item).toBe(preview.item);
    expect(merged.turnItems).toEqual([local.item]);
    expect(mergeOlderHistoryIntoProjection(merged, [inherited(0), inherited(1)])).toBe(merged);
  });

  it("retains live rows that arrived after the older page was fetched", () => {
    const live = [row(5), row(6)];
    const projection = {
      ...v2Projection,
      turnItems: live.map((entry) => entry.item),
      visibleTurnItems: live.map((entry, position) => ({ ...entry, position })),
    };
    const older = [row(3), row(4)];
    const merged = mergeOlderHistoryIntoProjection(projection, older);
    expect(merged.visibleTurnItems.map((entry) => entry.sourceItemId)).toEqual([
      "item-3",
      "item-4",
      "item-5",
      "item-6",
    ]);
  });

  it("does not resurrect a local item hidden while an older page was in flight", () => {
    const stalePageRow = row(1);
    const currentItem = {
      ...stalePageRow.item,
      output: "newer live output",
      updatedAt: DateTime.makeUnsafe("2026-06-20T00:00:01.000Z"),
    };
    const projection = {
      ...v2Projection,
      turnItems: [currentItem],
      visibleTurnItems: [],
    };

    const merged = mergeOlderHistoryIntoProjection(projection, [stalePageRow]);

    expect(merged).toBe(projection);
    expect(merged.turnItems).toEqual([currentItem]);
    expect(merged.visibleTurnItems).toEqual([]);
  });

  it("retains merged older rows when a live turn-item update arrives", () => {
    const recent = [row(2), row(3)];
    const projection = {
      ...v2Projection,
      turnItems: recent.map((entry) => entry.item),
      visibleTurnItems: recent.map((entry, position) => ({ ...entry, position })),
    };
    const merged = mergeOlderHistoryIntoProjection(projection, [row(0), row(1)]);
    const liveItem = {
      ...row(3).item,
      output: "streamed",
    };
    const next = applyOrchestrationV2ProjectionEvent(merged, {
      id: "event-live-item" as never,
      type: "turn-item.updated",
      threadId: v2ThreadId,
      occurredAt: NOW,
      payload: liveItem,
    } as never);
    expect(next?.visibleTurnItems.map((entry) => entry.sourceItemId)).toEqual([
      "item-0",
      "item-1",
      "item-2",
      "item-3",
    ]);
    expect(next?.visibleTurnItems[3]?.item).toEqual(liveItem);
  });

  // regression: #25806 a pending question card retained outside the window shows when paged in
  it.each(["completed", "rolled_back"] as const)(
    "keeps a pending question actionable when paging a %s run",
    (status) => {
      const recent = row(5);
      const runId = "question-run" as never;
      const nodeId = "question-node" as never;
      const card = {
        id: "item-question" as never,
        type: "user_input_request" as const,
        threadId: v2ThreadId,
        runId,
        nodeId,
        providerThreadId: null,
        providerTurnId: null,
        nativeItemRef: null,
        parentItemId: null,
        ordinal: 1,
        status: "running" as const,
        title: null,
        requestId: "request-question" as never,
        responseMode: "message" as const,
        questions: [{ id: "scope", header: "Scope", question: "Which scope?", options: [] }],
        startedAt: NOW,
        completedAt: null,
        updatedAt: NOW,
      };
      const coldOpen = {
        ...v2Projection,
        runs: [
          {
            id: runId,
            threadId: v2ThreadId,
            ordinal: 1,
            providerInstanceId: v2Projection.thread.providerInstanceId,
            modelSelection: v2Projection.thread.modelSelection,
            providerThreadId: null,
            userMessageId: "question-message" as never,
            rootNodeId: nodeId,
            activeAttemptId: null,
            status,
            requestedAt: NOW,
            startedAt: NOW,
            completedAt: NOW,
            checkpointId: null,
            contextHandoffId: null,
          },
        ],
        runtimeRequests: [
          {
            id: card.requestId,
            nodeId,
            providerTurnId: null,
            nativeRequestRef: null,
            kind: "user_input" as const,
            status: "pending" as const,
            responseCapability: { type: "message" as const },
            createdAt: NOW,
            resolvedAt: null,
          },
        ],
        turnItems: [card, recent.item],
        visibleTurnItems: [{ ...recent, position: 0 }],
      };

      const merged = mergeOlderHistoryIntoProjection(coldOpen, [
        { ...row(0), position: 0 },
        {
          position: 1,
          visibility: "local",
          sourceThreadId: v2ThreadId,
          sourceItemId: card.id,
          item: card,
        },
      ]);

      expect(merged.visibleTurnItems.map((entry) => String(entry.sourceItemId))).toEqual(
        status === "rolled_back" ? ["item-0", "item-5"] : ["item-0", "item-question", "item-5"],
      );
      expect(merged.turnItems).toContain(card);
      const pending = derivePendingThreadRequests(merged).userInputs;
      expect(pending).toEqual(derivePendingThreadRequests(coldOpen).userInputs);
      expect(pending).toHaveLength(1);
      expect(pending[0]).toMatchObject({
        requestId: card.requestId,
        dismissible: true,
        questions: card.questions.map((question) => ({ ...question, multiSelect: false })),
      });
    },
  );

  it("keeps a history-page interrupt result visible when its request was retained at cold open", () => {
    const runId = "run-interrupt-cold" as never;
    const nodeId = "node-interrupt-cold" as never;
    const recent = row(5);
    const requestItem = {
      id: "item-interrupt-request" as never,
      type: "run_interrupt_request" as const,
      threadId: v2ThreadId,
      runId,
      nodeId,
      providerThreadId: null,
      providerTurnId: null,
      nativeItemRef: null,
      parentItemId: null,
      ordinal: 1,
      status: "completed" as const,
      title: null,
      message: "Stopping",
      startedAt: NOW,
      completedAt: NOW,
      updatedAt: NOW,
    };
    const resultItem = {
      id: "item-interrupt-result" as never,
      type: "run_interrupt_result" as const,
      threadId: v2ThreadId,
      runId,
      nodeId,
      providerThreadId: null,
      providerTurnId: null,
      nativeItemRef: null,
      parentItemId: null,
      ordinal: 2,
      status: "completed" as const,
      title: null,
      message: "Stopped",
      startedAt: NOW,
      completedAt: NOW,
      updatedAt: NOW,
    };
    const resultRow = {
      position: 0,
      visibility: "local" as const,
      sourceThreadId: v2ThreadId,
      sourceItemId: resultItem.id,
      item: resultItem,
    };
    const coldOpen = {
      ...v2Projection,
      runs: [
        {
          id: runId,
          threadId: v2ThreadId,
          ordinal: 1,
          providerInstanceId: "codex" as never,
          modelSelection: { instanceId: "codex" as never, model: "gpt-5" },
          providerThreadId: null,
          userMessageId: "message-1" as never,
          rootNodeId: nodeId,
          activeAttemptId: null,
          status: "running" as const,
          requestedAt: NOW,
          startedAt: NOW,
          completedAt: null,
          checkpointId: null,
          contextHandoffId: null,
        },
      ],
      attempts: [
        {
          id: "attempt-1" as never,
          runId,
          attemptOrdinal: 1,
          rootNodeId: nodeId,
          providerInstanceId: "codex" as never,
          providerThreadId: "provider-thread-1" as never,
          providerTurnId: null,
          reason: "initial" as const,
          status: "running" as const,
          startedAt: NOW,
          completedAt: null,
        },
      ],
      turnItems: [requestItem, recent.item],
      visibleTurnItems: [{ ...recent, position: 0 }],
    };

    const requestMerged = mergeOlderHistoryIntoProjection(coldOpen, [
      {
        position: 0,
        visibility: "local",
        sourceThreadId: v2ThreadId,
        sourceItemId: requestItem.id,
        item: requestItem,
      },
    ]);
    expect(requestMerged.visibleTurnItems.map((entry) => String(entry.sourceItemId))).toEqual([
      "item-interrupt-request",
      "item-5",
    ]);

    const rolledBackRequestMerged = mergeOlderHistoryIntoProjection(
      {
        ...coldOpen,
        runs: coldOpen.runs.map((run) => ({
          ...run,
          status: "rolled_back" as const,
          completedAt: NOW,
        })),
      },
      [
        {
          position: 0,
          visibility: "local",
          sourceThreadId: v2ThreadId,
          sourceItemId: requestItem.id,
          item: requestItem,
        },
      ],
    );
    expect(
      rolledBackRequestMerged.visibleTurnItems.map((entry) => String(entry.sourceItemId)),
    ).toEqual(["item-5"]);

    const merged = mergeOlderHistoryIntoProjection(coldOpen, [resultRow]);
    expect(merged.visibleTurnItems.map((entry) => String(entry.sourceItemId))).toEqual([
      "item-interrupt-result",
      "item-5",
    ]);
    expect(merged.turnItems.some((item) => item.type === "run_interrupt_request")).toBe(true);
    expect(merged.turnItems.some((item) => item.type === "run_interrupt_result")).toBe(true);

    const attemptSuperseded = applyOrchestrationV2ProjectionEvent(
      merged,
      {
        id: "event-attempt-superseded" as never,
        type: "run-attempt.updated",
        threadId: v2ThreadId,
        runId,
        occurredAt: NOW,
        payload: {
          id: "attempt-1" as never,
          runId,
          attemptOrdinal: 1,
          rootNodeId: nodeId,
          providerInstanceId: "codex" as never,
          providerThreadId: "provider-thread-1" as never,
          providerTurnId: null,
          reason: "initial",
          status: "superseded",
          startedAt: NOW,
          completedAt: NOW,
        },
      } as never,
      { partialTimeline: true },
    );

    expect(attemptSuperseded?.visibleTurnItems.map((entry) => String(entry.sourceItemId))).toEqual([
      "item-interrupt-result",
      "item-5",
    ]);

    const withoutRequest = {
      ...merged,
      turnItems: merged.turnItems.filter((item) => item.type !== "run_interrupt_request"),
    };
    const hidden = applyOrchestrationV2ProjectionEvent(
      withoutRequest,
      {
        id: "event-attempt-superseded-missing" as never,
        type: "run-attempt.updated",
        threadId: v2ThreadId,
        runId,
        occurredAt: NOW,
        payload: {
          id: "attempt-1" as never,
          runId,
          attemptOrdinal: 1,
          rootNodeId: nodeId,
          providerInstanceId: "codex" as never,
          providerThreadId: "provider-thread-1" as never,
          providerTurnId: null,
          reason: "initial",
          status: "superseded",
          startedAt: NOW,
          completedAt: NOW,
        },
      } as never,
      { partialTimeline: true },
    );
    expect(hidden?.visibleTurnItems.map((entry) => String(entry.sourceItemId))).toEqual(["item-5"]);
  });
});