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

import {
  MessageId,
  NodeId,
  RunId,
  RuntimeRequestId,
  ThreadId,
  TurnItemId,
  type OrchestrationV2ProjectedTurnItem,
  type OrchestrationV2TurnItem,
} from "@t3tools/contracts";
import { describe, expect, it } from "@effect/vitest";
import * as DateTime from "effect/DateTime";

import {
  buildBoundedThreadProjection,
  deferWorkHistoryRows,
  boundedTimelineEncodedBytes,
  computeLatestLocalTurnOrdinal,
  decodeThreadHistoryCursor,
  encodeThreadHistoryCursor,
  projectedRowBoundedSnapshotEncodedBytes,
  projectedRowEncodedBytes,
  selectHistoryPageFromCursor,
  selectDeferredWorkPage,
  selectRecentTimelineWindow,
  THREAD_HISTORY_PAGE_POLICY,
} from "./threadHistoryPaging.ts";
import { projectThreadProjectionForWire } from "./WireProjection.ts";

const NOW = DateTime.makeUnsafe("2026-06-20T00:00:00.000Z");
const THREAD = ThreadId.make("thread-1");
const RUN = RunId.make("run-interrupt-1");
const NODE = NodeId.make("node-interrupt-1");

function makeRow(
  index: number,
  options?: { readonly outputBytes?: number },
): OrchestrationV2ProjectedTurnItem {
  const id = TurnItemId.make(`item-${index}`);
  const output =
    options?.outputBytes !== undefined ? "x".repeat(options.outputBytes) : `output-${index}`;
  return {
    position: index,
    visibility: "local",
    sourceThreadId: THREAD,
    sourceItemId: id,
    item: {
      id,
      type: "command_execution",
      threadId: THREAD,
      runId: null,
      nodeId: null,
      providerThreadId: null,
      providerTurnId: null,
      nativeItemRef: null,
      parentItemId: null,
      ordinal: index + 1,
      status: "completed",
      title: `Command ${index}`,
      input: `cmd-${index}`,
      output,
      exitCode: 0,
      startedAt: NOW,
      completedAt: NOW,
      updatedAt: NOW,
    },
  };
}

function makeTurnStart(
  index: number,
  createdBy: "user" | "agent",
): OrchestrationV2ProjectedTurnItem {
  const row = makeRow(index);
  return {
    ...row,
    item: {
      ...row.item,
      type: "user_message",
      createdBy,
      creationSource: "provider",
      inputIntent: "turn_start",
      messageId: MessageId.make(`prompt-${index}`),
      text: `Prompt ${index}`,
      attachments: [],
    },
  } as OrchestrationV2ProjectedTurnItem;
}

function interruptItem(
  id: string,
  type: "run_interrupt_request" | "run_interrupt_result",
  ordinal: number,
): OrchestrationV2TurnItem {
  return {
    id: TurnItemId.make(id),
    type,
    threadId: THREAD,
    runId: RUN,
    nodeId: NODE,
    providerThreadId: null,
    providerTurnId: null,
    nativeItemRef: null,
    parentItemId: null,
    ordinal,
    status: "completed",
    title: type,
    message: type === "run_interrupt_request" ? "Stopping" : "Stopped",
    startedAt: NOW,
    completedAt: NOW,
    updatedAt: NOW,
  } as OrchestrationV2TurnItem;
}

function interruptRow(
  index: number,
  type: "run_interrupt_request" | "run_interrupt_result",
): OrchestrationV2ProjectedTurnItem {
  const item = interruptItem(
    type === "run_interrupt_request" ? "interrupt-req" : "interrupt-res",
    type,
    index + 1,
  );
  return {
    position: index,
    visibility: "local",
    sourceThreadId: THREAD,
    sourceItemId: item.id,
    item,
  };
}

function makeProjection(visibleTurnItems: OrchestrationV2ProjectedTurnItem[]) {
  return {
    thread: {
      id: THREAD,
      projectId: "project-1",
      title: "Thread",
      providerInstanceId: "codex",
      modelSelection: { instanceId: "codex", model: "gpt-5" },
      runtimeMode: "full-access",
      interactionMode: "default",
      branch: null,
      worktreePath: null,
      activeProviderThreadId: null,
      lineage: {
        parentThreadId: null,
        relationshipToParent: null,
        rootThreadId: THREAD,
      },
      forkedFrom: null,
      createdBy: "user",
      creationSource: "web",
      createdAt: NOW,
      updatedAt: NOW,
      archivedAt: null,
      deletedAt: null,
      settledOverride: null,
      settledAt: null,
    },
    runs: [{ id: "run-1" }],
    attempts: [{ id: "attempt-1" }],
    nodes: [],
    subagents: [],
    providerSessions: [],
    providerThreads: [],
    providerTurns: [],
    runtimeRequests: [{ id: "req-1" }],
    messages: [],
    plans: [],
    turnItems: visibleTurnItems.map((row) => row.item),
    checkpointScopes: [],
    checkpoints: [],
    contextHandoffs: [],
    contextTransfers: [],
    visibleTurnItems,
    updatedAt: NOW,
  } as unknown as Parameters<typeof buildBoundedThreadProjection>[0]["projection"];
}

describe("threadHistoryPaging", () => {
  it("defers completed work above 150 items and keeps conversation and persistent rows", () => {
    const work = Array.from({ length: 151 }, (_, index) => {
      const row = makeRow(index);
      return { ...row, item: { ...row.item, runId: RUN, runStatus: "completed" } };
    });
    expect(deferWorkHistoryRows(work.slice(0, 150))).toHaveLength(150);
    const deferredWork = deferWorkHistoryRows(work)[0]!.item.deferredWork!;
    expect(deferredWork.itemCount).toBe(151);
    expect(decodeThreadHistoryCursor(deferredWork.cursor).p).toBe(151);
    const superseded = work.map((row) => ({
      ...row,
      item: { ...row.item, runStatus: "running", attemptId: "old", attemptStatus: "superseded" },
    }));
    const active = work.map((row, index) => ({
      ...row,
      sourceItemId: TurnItemId.make(`active-${index}`),
      position: row.position + work.length,
      item: { ...row.item, runStatus: "running", attemptId: "active", attemptStatus: "running" },
    }));
    const attempts = deferWorkHistoryRows([...superseded, ...active]);
    expect(attempts[0]?.item.deferredWork?.itemCount).toBe(151);
    expect(attempts.slice(1)).toEqual(active);
    const compaction = {
      ...work[0]!,
      sourceItemId: TurnItemId.make("compaction"),
      item: {
        ...work[0]!.item,
        type: "compaction" as const,
      },
    };
    const persistent = {
      ...work[0]!,
      sourceItemId: TurnItemId.make("render"),
      item: {
        ...work[0]!.item,
        type: "dynamic_tool" as const,
        persistentOutput: true,
      },
    };
    const deferred = deferWorkHistoryRows([
      ...work.slice(0, 30),
      compaction,
      persistent,
      ...work.slice(30),
    ]);
    expect(deferred.map((row) => row.sourceItemId)).toEqual(["item-0", "compaction", "render"]);
    expect(deferred[0]?.item.deferredWork?.itemCount).toBe(151);
    for (const runStatus of ["running", "failed", "interrupted", "cancelled"]) {
      expect(
        deferWorkHistoryRows(work.map((row) => ({ ...row, item: { ...row.item, runStatus } }))),
      ).toHaveLength(151);
    }
    const interrupted = {
      ...compaction,
      item: { ...compaction.item, type: "run_interrupt_result" as const },
    };
    expect(deferWorkHistoryRows([...work, interrupted])).toHaveLength(152);
    const failed = {
      ...compaction,
      item: {
        ...compaction.item,
        type: "error" as const,
        status: "failed" as const,
        nodeId: "root-node",
        parentItemId: null,
      },
    };
    expect(deferWorkHistoryRows([...work, failed])).toHaveLength(152);
  });

  it("keeps a human turn whole up to the turn row budget and pages a longer one from inside", () => {
    const humanTurn = (length: number) => {
      const items = Array.from({ length }, (_, index) => makeRow(index));
      items[0] = {
        ...items[0]!,
        item: {
          ...items[0]!.item,
          type: "user_message",
          createdBy: "user",
          creationSource: "web",
          inputIntent: "turn_start",
          messageId: MessageId.make("long-human-turn"),
          text: "Continue",
          attachments: [],
        },
      } as OrchestrationV2ProjectedTurnItem;
      return items;
    };

    const whole = selectRecentTimelineWindow({ items: humanTurn(180), snapshotSequence: 1 });
    expect(whole.items).toHaveLength(180);
    expect(whole.hasMoreHistory).toBe(false);

    const items = humanTurn(THREAD_HISTORY_PAGE_POLICY.maxTurnItems + 100);
    const recent = selectRecentTimelineWindow({ items, snapshotSequence: 1 });
    expect(recent.items).toHaveLength(THREAD_HISTORY_PAGE_POLICY.maxItems);
    const loaded = [...recent.items];
    let cursor = recent.nextCursor;
    for (let pages = 0; cursor !== null; pages += 1) {
      expect(pages).toBeLessThan(items.length);
      const page = selectHistoryPageFromCursor({ items, cursor, snapshotSequence: 1 });
      expect(page.items.length).toBeGreaterThan(0);
      expect(page.items.length).toBeLessThanOrEqual(
        page.items[0]?.item.type === "user_message"
          ? THREAD_HISTORY_PAGE_POLICY.maxTurnItems
          : THREAD_HISTORY_PAGE_POLICY.maxItems,
      );
      loaded.unshift(...page.items);
      cursor = page.nextCursor;
    }
    expect(loaded.map((row) => row.sourceItemId)).toEqual(items.map((row) => row.sourceItemId));

    const large = items
      .slice(0, 12)
      .map((row) =>
        row.item.type === "command_execution"
          ? { ...row, item: { ...row.item, output: "x".repeat(200_000) } }
          : row,
      );
    const bounded = buildBoundedThreadProjection({
      projection: makeProjection(large),
      snapshotSequence: 1,
    });
    expect(bounded.projection.visibleTurnItems.length).toBeLessThan(large.length);
    expect(boundedTimelineEncodedBytes(bounded.projection)).toBeLessThanOrEqual(
      THREAD_HISTORY_PAGE_POLICY.maxEncodedBytes,
    );
  });

  it("keeps background turns with user turns, with main's 150-turn fan-out ceiling", () => {
    const items = Array.from({ length: 161 }, (_, turn) => {
      const row = makeRow(turn * 2);
      if (row.item.type !== "command_execution") throw new Error("Expected command fixture");
      const prompt: OrchestrationV2ProjectedTurnItem = {
        ...row,
        item: {
          ...row.item,
          type: "user_message",
          createdBy: turn === 0 ? "user" : "agent",
          creationSource: "provider",
          inputIntent: "turn_start",
          messageId: MessageId.make(`prompt-${turn}`),
          text: `Prompt ${turn}`,
          attachments: [],
        },
      };
      return [prompt, makeRow(turn * 2 + 1)];
    }).flat();
    const policy = { ...THREAD_HISTORY_PAGE_POLICY, maxItems: 1_000, maxEncodedBytes: 10_000_000 };
    const first = selectRecentTimelineWindow({ items, snapshotSequence: 1, policy });
    expect(first.items).toHaveLength(300);
    expect(first.items[0]?.sourceItemId).toBe("item-22");
    const older = selectHistoryPageFromCursor({
      items,
      cursor: first.nextCursor!,
      snapshotSequence: 1,
      policy,
    });
    expect(older.items).toHaveLength(22);
    expect(older.hasMoreHistory).toBe(false);
    expect([...older.items, ...first.items].map((row) => row.sourceItemId)).toEqual(
      items.map((row) => row.sourceItemId),
    );
  });

  it("counts runs that a notification started toward the 150-turn ceiling", () => {
    const inRun = (index: number, run: number, item: object = {}) => {
      const row = makeRow(index);
      return {
        ...row,
        item: { ...row.item, runId: RunId.make(`run-${run}`), ...item },
      } as OrchestrationV2ProjectedTurnItem;
    };
    const notification = (summary: string) => ({
      type: "notification",
      source: { kind: "monitor" },
      outcome: "completed",
      summary,
    });
    const items = Array.from({ length: 161 }, (_, run) => [
      inRun(run * 4, run),
      inRun(
        run * 4 + 1,
        run,
        run === 0
          ? {
              type: "user_message",
              createdBy: "user",
              creationSource: "web",
              inputIntent: "turn_start",
              messageId: MessageId.make("prompt-0"),
              text: "Prompt 0",
              attachments: [],
            }
          : notification(`Wake ${run}`),
      ),
      inRun(run * 4 + 2, run, notification(`Steer ${run}`)),
      inRun(run * 4 + 3, run),
    ]).flat();
    const policy = {
      ...THREAD_HISTORY_PAGE_POLICY,
      maxItems: 1_000,
      maxTurnItems: 1_000,
      maxEncodedBytes: 10_000_000,
    };
    const first = selectRecentTimelineWindow({ items, snapshotSequence: 1, policy });
    expect(first.items).toHaveLength(150 * 4 - 1);
    expect(first.items[0]?.sourceItemId).toBe(`item-${11 * 4 + 1}`);
    const older = selectHistoryPageFromCursor({
      items,
      cursor: first.nextCursor!,
      snapshotSequence: 1,
      policy,
    });
    expect([...older.items, ...first.items].map((row) => row.sourceItemId)).toEqual(
      items.map((row) => row.sourceItemId),
    );
  });

  it("pages agent-only child transcripts instead of dropping their earlier activity", () => {
    const commandRows = Array.from({ length: 90 }, (_, index) => makeRow(index + 1));
    const first = makeRow(0);
    const prompt = {
      ...first,
      item: {
        ...first.item,
        type: "user_message" as const,
        createdBy: "agent" as const,
        creationSource: "provider" as const,
        inputIntent: "turn_start" as const,
        messageId: MessageId.make("child-prompt"),
        text: "Inspect this project",
        attachments: [],
      },
    } as OrchestrationV2ProjectedTurnItem;
    const items = [prompt, ...commandRows];
    const recent = selectRecentTimelineWindow({ items, snapshotSequence: 1 });

    expect(recent.items).toHaveLength(THREAD_HISTORY_PAGE_POLICY.maxItems);
    expect(recent.hasMoreHistory).toBe(true);
    const older = selectHistoryPageFromCursor({
      items,
      cursor: recent.nextCursor!,
      snapshotSequence: 1,
    });
    expect(older.items[0]?.item.type).toBe("user_message");
    expect([...older.items, ...recent.items]).toHaveLength(items.length);
  });

  it("always includes at least one pathological oversized item", () => {
    for (const humanTurn of [false, true]) {
      const oversized = makeRow(0, { outputBytes: 2_000_000 });
      const items = [
        humanTurn
          ? ({
              ...oversized,
              item: {
                ...oversized.item,
                type: "user_message",
                createdBy: "user",
                creationSource: "web",
                inputIntent: "turn_start",
                messageId: MessageId.make("oversized-human-turn"),
                text: "x".repeat(2_000_000),
                attachments: [],
              },
            } as OrchestrationV2ProjectedTurnItem)
          : oversized,
        makeRow(1, { outputBytes: 10 }),
      ];
      const policy = { ...THREAD_HISTORY_PAGE_POLICY, maxItems: 50, maxEncodedBytes: 1_024 };
      const page = selectRecentTimelineWindow({ items, snapshotSequence: 1, policy });
      expect(page.items).toHaveLength(1);
      expect(page.items[0]?.sourceItemId).toBe("item-1");
      expect(page.hasMoreHistory).toBe(true);

      const older = selectHistoryPageFromCursor({
        items,
        cursor: page.nextCursor!,
        snapshotSequence: 1,
        policy,
      });
      expect(older.items).toHaveLength(1);
      expect(older.items[0]?.sourceItemId).toBe("item-0");
      expect(older.hasMoreHistory).toBe(false);
      expect(older.nextCursor).toBeNull();
      expect([...older.items, ...page.items].map((row) => row.sourceItemId)).toEqual(
        items.map((row) => row.sourceItemId),
      );
    }
  });

  it.each([
    {
      name: "item ceiling",
      items: Array.from({ length: 5 }, (_, index) => makeRow(index)),
      policy: { maxItems: 3, maxEncodedBytes: 1_000 },
      admitted: 3,
      measured: 3,
    },
    {
      name: "user turn ceiling",
      items: [makeRow(0), makeTurnStart(1, "user"), makeRow(2)],
      policy: { maxUserTurns: 1, maxItems: 100, maxEncodedBytes: 1_000 },
      admitted: 2,
      measured: 2,
    },
    {
      name: "raw turn ceiling",
      items: [
        makeTurnStart(0, "user"),
        ...Array.from({ length: 151 }, (_, index) => makeTurnStart(index + 1, "agent")),
      ],
      policy: { maxUserTurns: 10, maxItems: 1_000, maxEncodedBytes: 1_000_000 },
      admitted: 150,
      measured: 150,
    },
    {
      name: "byte budget, which still admits an exact fit",
      items: Array.from({ length: 5 }, (_, index) => makeRow(index)),
      policy: { maxItems: 100, maxEncodedBytes: 20 },
      admitted: 2,
      measured: 3,
    },
    {
      name: "byte budget, which still admits an oversized first row",
      items: Array.from({ length: 5 }, (_, index) => makeRow(index)),
      policy: { maxItems: 100, maxEncodedBytes: 5 },
      admitted: 1,
      measured: 2,
    },
  ])("measures only the rows needed to stop at the $name", (testCase) => {
    const measured: OrchestrationV2ProjectedTurnItem[] = [];
    const page = selectRecentTimelineWindow({
      items: testCase.items,
      snapshotSequence: 1,
      policy: testCase.policy,
      rowEncodedBytes: (row) => {
        measured.push(row);
        return 10;
      },
    });

    expect(page.items.map((row) => row.sourceItemId)).toEqual(
      testCase.items.slice(-testCase.admitted).map((row) => row.sourceItemId),
    );
    expect(measured).toHaveLength(testCase.measured);
    expect(page.hasMoreHistory).toBe(true);
    expect(decodeThreadHistoryCursor(page.nextCursor!).si).toBe(page.items[0]?.sourceItemId);
  });

  it("recovers identity-miss cursors when position is past a shrunken timeline", () => {
    const items = Array.from({ length: 5 }, (_, index) => makeRow(index));
    const cursor = encodeThreadHistoryCursor({
      snapshotSequence: 3,
      sourceThreadId: THREAD,
      sourceItemId: TurnItemId.make("item-deleted-long-ago"),
      position: 40,
    });
    const page = selectHistoryPageFromCursor({
      items,
      cursor,
      snapshotSequence: 3,
      policy: { maxItems: 2, maxEncodedBytes: 10_000_000 },
    });
    expect(page.items.map((row) => row.sourceItemId)).toEqual(["item-3", "item-4"]);
    expect(page.hasMoreHistory).toBe(true);
    expect(page.nextCursor).not.toBeNull();
    const sparse = [makeRow(0), makeRow(10), makeRow(20)];
    const middle = selectHistoryPageFromCursor({
      items: sparse,
      cursor: encodeThreadHistoryCursor({
        snapshotSequence: 3,
        sourceThreadId: THREAD,
        sourceItemId: "item-hidden",
        position: 15,
      }),
      snapshotSequence: 3,
    });
    expect(middle.items.map((row) => row.sourceItemId)).toEqual(["item-0", "item-10"]);
    const work = Array.from({ length: 80 }, (_, index) => {
      const row = makeRow(index);
      return { ...row, item: { ...row.item, runId: RUN, ordinal: index + 100 } };
    });
    const tail = work[75]!;
    const deferred = selectDeferredWorkPage({
      items: work.filter((row) => row !== tail).map((row, position) => ({ ...row, position })),
      cursor: encodeThreadHistoryCursor({
        snapshotSequence: 3,
        sourceThreadId: THREAD,
        sourceItemId: tail.sourceItemId,
        position: tail.item.ordinal,
        inclusive: true,
      }),
      throughEntryId: work[0]!.sourceItemId,
      snapshotSequence: 3,
    });
    expect(deferred.items.map((row) => row.sourceItemId)).toEqual(
      work.slice(0, 75).map((row) => row.sourceItemId),
    );
    expect(deferred.nextCursor).toBeNull();
  });

  it("keeps cursor resolution stable when newer items append", () => {
    const initial = Array.from({ length: 20 }, (_, index) => makeRow(index));
    const recent = selectRecentTimelineWindow({
      items: initial,
      snapshotSequence: 2,
      policy: { maxItems: 5, maxEncodedBytes: 10_000_000 },
    });
    const cursor = recent.nextCursor!;
    const grown = [...initial, makeRow(20), makeRow(21)];
    const older = selectHistoryPageFromCursor({
      items: grown,
      cursor,
      snapshotSequence: 5,
      policy: { maxItems: 5, maxEncodedBytes: 10_000_000 },
    });
    expect(older.items.map((row) => row.sourceItemId)).toEqual([
      "item-10",
      "item-11",
      "item-12",
      "item-13",
      "item-14",
    ]);
    expect(older.hasMoreHistory).toBe(true);
  });

  it("builds a bounded projection that preserves non-timeline control state", () => {
    const full = makeProjection(Array.from({ length: 40 }, (_, index) => makeRow(index)));
    const bounded = buildBoundedThreadProjection({
      projection: full,
      snapshotSequence: 7,
      policy: { maxItems: 5, maxEncodedBytes: 10_000_000 },
    });
    expect(bounded.projection.runs).toEqual(full.runs);
    expect(bounded.projection.runtimeRequests).toEqual(full.runtimeRequests);
    expect(bounded.projection.attempts).toEqual(full.attempts);
    expect(bounded.projection.visibleTurnItems).toHaveLength(5);
    expect(bounded.projection.turnItems).toHaveLength(5);
    expect(bounded.hasMoreHistory).toBe(true);
    expect(bounded.historyCursor).not.toBeNull();
    expect(bounded.projection.visibleTurnItems.map((row) => row.position)).toEqual([0, 1, 2, 3, 4]);
    expect(bounded.latestLocalTurnOrdinal).toBe(40);
    expect(computeLatestLocalTurnOrdinal(full.turnItems)).toBe(40);
  });

  it("carries a full-projection watermark when the bounded window is inherited-only", () => {
    const localOlder = makeRow(0);
    const localMid = makeRow(1);
    const inherited = {
      ...makeRow(2),
      visibility: "inherited" as const,
      sourceThreadId: ThreadId.make("parent-thread"),
      item: {
        ...makeRow(2).item,
        threadId: ThreadId.make("parent-thread"),
      },
    };
    const full = makeProjection([localOlder, localMid, inherited]);
    const inheritedOnly = {
      ...full,
      visibleTurnItems: [inherited],
      turnItems: [localOlder.item, localMid.item],
    };
    const bounded = buildBoundedThreadProjection({
      projection: inheritedOnly,
      snapshotSequence: 2,
      policy: { maxItems: 1, maxEncodedBytes: 10_000_000 },
    });
    expect(bounded.projection.visibleTurnItems.map((row) => String(row.sourceItemId))).toEqual([
      String(inherited.sourceItemId),
    ]);
    expect(bounded.latestLocalTurnOrdinal).toBe(2);
    expect(computeLatestLocalTurnOrdinal([])).toBeNull();
  });

  it("retains an out-of-window run_interrupt_request needed by a visible result", () => {
    const request = interruptRow(0, "run_interrupt_request");
    const filler = makeRow(1);
    const result = interruptRow(2, "run_interrupt_result");
    const full = makeProjection([request, filler, result]);
    const bounded = buildBoundedThreadProjection({
      projection: full,
      snapshotSequence: 3,
      policy: { maxItems: 1, maxEncodedBytes: 10_000_000 },
    });

    expect(bounded.projection.visibleTurnItems.map((row) => String(row.sourceItemId))).toEqual([
      "interrupt-res",
    ]);
    expect(bounded.projection.turnItems.map((item) => String(item.id)).sort()).toEqual([
      "interrupt-req",
      "interrupt-res",
    ]);
    expect(bounded.hasMoreHistory).toBe(true);
  });

  it("charges local row.item duplication when measuring bounded timeline bytes", () => {
    const rows = Array.from({ length: 8 }, (_, index) => makeRow(index, { outputBytes: 2_000 }));
    const full = makeProjection(rows);
    const maxEncodedBytes = 12_000;
    const bounded = buildBoundedThreadProjection({
      projection: full,
      snapshotSequence: 1,
      policy: { maxItems: 50, maxEncodedBytes },
    });

    const contribution = boundedTimelineEncodedBytes({
      visibleTurnItems: bounded.projection.visibleTurnItems,
      turnItems: bounded.projection.turnItems,
    });
    expect(contribution).toBeLessThanOrEqual(maxEncodedBytes);
    expect(bounded.projection.visibleTurnItems.length).toBeGreaterThan(0);
    expect(bounded.projection.visibleTurnItems.length).toBeLessThan(rows.length);

    const historyPage = selectRecentTimelineWindow({
      items: rows,
      snapshotSequence: 1,
      policy: { maxItems: 50, maxEncodedBytes },
    });
    const historyBytes = historyPage.items.reduce(
      (sum, row) => sum + projectedRowEncodedBytes(row),
      0,
    );
    expect(historyBytes).toBeLessThanOrEqual(maxEncodedBytes);
    expect(historyPage.items.length).toBeGreaterThan(bounded.projection.visibleTurnItems.length);

    const sample = rows[0]!;
    expect(projectedRowBoundedSnapshotEncodedBytes(sample, THREAD)).toBeGreaterThan(
      projectedRowEncodedBytes(sample),
    );
  });

  it("does not carry the full duplicated message table into a bounded snapshot", () => {
    const projection = makeProjection(Array.from({ length: 120 }, (_, index) => makeRow(index)));
    const full = {
      ...projection,
      messages: Array.from({ length: 2_000 }, (_, index) => ({
        id: MessageId.make(`message-${index}`),
        threadId: THREAD,
        runId: RunId.make(`old-run-${index}`),
        nodeId: null,
        role: "assistant" as const,
        text: "x".repeat(1_000),
        attachments: [],
        streaming: false,
        createdBy: "agent" as const,
        creationSource: "provider" as const,
        createdAt: NOW,
        updatedAt: NOW,
      })),
    } as typeof projection;

    const bounded = buildBoundedThreadProjection({
      projection: full,
      snapshotSequence: 9,
    });

    expect(bounded.projection.messages).toEqual([]);
    expect(Buffer.byteLength(JSON.stringify(bounded.projection), "utf8")).toBeLessThan(
      THREAD_HISTORY_PAGE_POLICY.maxEncodedBytes + 100_000,
    );
  });

  it("keeps a workflow coordinator's script outside the bounded window", () => {
    const projection = makeProjection(Array.from({ length: 120 }, (_, index) => makeRow(index)));
    const message = (index: number, workflowScript?: boolean) => ({
      id: MessageId.make(`message-${index}`),
      threadId: THREAD,
      runId: RunId.make(`old-run-${index}`),
      nodeId: null,
      role: "user" as const,
      text: `message ${index}`,
      attachments: [],
      streaming: false,
      createdBy: "agent" as const,
      creationSource: "provider" as const,
      createdAt: NOW,
      updatedAt: NOW,
      ...(workflowScript === undefined ? {} : { workflowScript }),
    });
    const full = {
      ...projection,
      messages: [message(0, true), message(1, false), message(2)],
    } as typeof projection;

    const bounded = buildBoundedThreadProjection({ projection: full, snapshotSequence: 9 });

    expect(bounded.projection.messages.map((retained) => retained.id)).toEqual([
      MessageId.make("message-0"),
    ]);
  });

  it("omits historical control details that remain available from history items", () => {
    const projection = makeProjection(Array.from({ length: 200 }, (_, index) => makeRow(index)));
    const populated = {
      ...projection,
      plans: Array.from({ length: 120 }, (_, index) => ({
        id: `plan-${index}`,
        threadId: THREAD,
        runId: null,
        nodeId: `node-${index}`,
        status: "completed",
        kind: "proposed_plan",
        markdown: "p".repeat(2_097_152),
      })),
      contextHandoffs: Array.from({ length: 120 }, (_, index) => ({
        id: `handoff-${index}`,
        threadId: THREAD,
        targetRunId: "run-1",
        fromProviderThreadIds: [],
        toProviderThreadId: "provider-thread-1",
        coveredRunOrdinals: { from: 1, to: 1 },
        strategy: "manual_context",
        status: "superseded",
        summaryMessageId: null,
        summaryText: "h".repeat(2_097_152),
        createdByProviderInstanceId: null,
        createdAt: NOW,
        updatedAt: NOW,
      })),
    } as unknown as typeof projection;

    const bounded = buildBoundedThreadProjection({
      projection: projectThreadProjectionForWire(populated),
      snapshotSequence: 9,
    });
    const serializedBytes = Buffer.byteLength(JSON.stringify(bounded.projection), "utf8");

    expect(serializedBytes).toBeLessThanOrEqual(THREAD_HISTORY_PAGE_POLICY.maxEncodedBytes);
    expect(bounded.projection.plans).toEqual([]);
    expect(bounded.projection.contextHandoffs).toEqual([]);
    expect(populated.plans).toHaveLength(120);
    expect(
      populated.plans[0]?.kind === "proposed_plan" ? populated.plans[0].markdown.length : 0,
    ).toBe(2_097_152);
  });

  it.each([40_000, 80_000])(
    "reserves pending question cards before visible history: %s bytes",
    (questionBytes) => {
      const rows = Array.from({ length: 20 }, (_, index) =>
        makeRow(index + 1, { outputBytes: 1_500 }),
      );
      const requestId = RuntimeRequestId.make("pending-question");
      const card: OrchestrationV2TurnItem = {
        id: TurnItemId.make("pending-question-card"),
        type: "user_input_request",
        threadId: THREAD,
        runId: null,
        nodeId: NODE,
        providerThreadId: null,
        providerTurnId: null,
        nativeItemRef: null,
        parentItemId: null,
        ordinal: 1,
        status: "completed",
        title: null,
        requestId,
        responseMode: "message",
        questions: [
          { id: "scope", header: "Scope", question: "q".repeat(questionBytes), options: [] },
        ],
        startedAt: NOW,
        completedAt: NOW,
        updatedAt: NOW,
      };
      const projection = {
        ...makeProjection(rows),
        turnItems: [card, ...rows.map((row) => row.item)],
        runtimeRequests: [
          {
            id: requestId,
            nodeId: NODE,
            providerTurnId: null,
            nativeRequestRef: null,
            kind: "user_input" as const,
            status: "pending" as const,
            responseCapability: { type: "message" as const },
            createdAt: NOW,
            resolvedAt: null,
          },
        ],
      };
      const policy = { ...THREAD_HISTORY_PAGE_POLICY, maxEncodedBytes: 64_000 };

      const bounded = buildBoundedThreadProjection({ projection, snapshotSequence: 9, policy });

      expect(bounded.projection.turnItems).toContain(card);
      expect(bounded.projection.visibleTurnItems.length).toBeGreaterThan(0);
      expect(bounded.hasMoreHistory).toBe(true);
      if (questionBytes < policy.maxEncodedBytes) {
        expect(Buffer.byteLength(JSON.stringify(bounded.projection), "utf8")).toBeLessThanOrEqual(
          policy.maxEncodedBytes,
        );
      } else {
        expect(bounded.projection.visibleTurnItems).toHaveLength(1);
      }
    },
  );

  it("preserves oversized actionable state", () => {
    const projection = makeProjection([makeRow(0)]);
    const actionable = {
      ...projection,
      plans: [
        {
          id: "plan-actionable",
          threadId: THREAD,
          runId: null,
          nodeId: "node-actionable",
          status: "active",
          kind: "proposed_plan",
          markdown: "a".repeat(2_097_152),
        },
      ],
    } as unknown as typeof projection;

    const bounded = buildBoundedThreadProjection({ projection: actionable, snapshotSequence: 9 });

    expect(bounded.projection.plans[0]).toEqual(actionable.plans[0]);
    expect(bounded.projection.visibleTurnItems).toEqual(actionable.visibleTurnItems);
  });

  it.each([false, true])(
    "keeps agent-only turns visible when checkpoint file lists fill the byte budget (stored interrupt request: %s)",
    (withInterruptRequest) => {
      const items = Array.from({ length: 3 }, (_, turn) => {
        const first = makeRow(turn * 5);
        const prompt = {
          ...first,
          item: {
            ...first.item,
            type: "user_message" as const,
            createdBy: "agent" as const,
            creationSource: "provider" as const,
            inputIntent: "turn_start" as const,
            messageId: MessageId.make(`agent-prompt-${turn}`),
            text: `Step ${turn}`,
            attachments: [],
          },
        } as OrchestrationV2ProjectedTurnItem;
        return [prompt, ...Array.from({ length: 4 }, (_, index) => makeRow(turn * 5 + index + 1))];
      }).flat();
      const files = Array.from(
        { length: 15_000 },
        (_, index) =>
          `work/ws-${index % 40}/.jj/repo/store/extra/${index.toString(16).padStart(40, "0")}`,
      );
      const base = makeProjection(items);
      const projection = {
        ...base,
        turnItems: withInterruptRequest
          ? [interruptItem("old-interrupt-req", "run_interrupt_request", 0), ...base.turnItems]
          : base.turnItems,
        checkpoints: [{ id: "checkpoint-1", files }],
      } as unknown as ReturnType<typeof makeProjection>;

      const bounded = buildBoundedThreadProjection({ projection, snapshotSequence: 1 });

      expect(bounded.projection.visibleTurnItems).toHaveLength(items.length);
      expect(bounded.hasMoreHistory).toBe(false);
    },
  );

  it("keeps paged historical plan detail in the turn item and only status in its artifact", () => {
    const detail = "Implement the historical plan exactly.\n".repeat(1_000);
    const item = {
      ...makeRow(0).item,
      type: "proposed_plan",
      planId: "plan-historical-visible",
      markdown: detail,
      streaming: false,
    } as OrchestrationV2TurnItem;
    const row = {
      ...makeRow(0),
      sourceItemId: item.id,
      item,
    } as OrchestrationV2ProjectedTurnItem;
    const base = makeProjection([row]);
    const projection = {
      ...base,
      plans: [
        {
          id: "plan-historical-visible",
          threadId: THREAD,
          runId: null,
          nodeId: "node-historical-visible",
          status: "completed",
          kind: "proposed_plan",
          markdown: detail,
        },
      ],
    } as unknown as typeof base;

    const bounded = buildBoundedThreadProjection({ projection, snapshotSequence: 9 });

    expect(bounded.projection.visibleTurnItems[0]?.item).toMatchObject({
      type: "proposed_plan",
      markdown: detail,
    });
    expect(bounded.projection.plans[0]).toMatchObject({
      status: "completed",
      markdown: "",
      detailInTurnItem: true,
    });
  });
});