Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

28.1 KB
Raw Blame
/**
 * messageStreamRenderWindowIntegration.test.ts
 * ---------------------------------------------------------------------------
 * Render-window 改到 render-item 轴后,在"消息层 + render-item 层 + viewport-fill
 * 决策层"这三层叠加下的集成不变量。补 buildRenderItemsKeyStability.test.ts 单测
 * 之外的横向 case:
 *
 *  - Scenario 1: buildRenderItems(messages) 在 N=100/500/1000/2000/5000 量级的耗时
 *                上界,锁住"全量 build 在 flake-free 限度内"(防 perf 回归)
 *  - Scenario 2: U1 短 session(50 条全 tool_use+tool_result 折叠成单 segment)
 *                走完整二段式 trace:visible 覆盖全部 → load-from-db → DB prepend
 *                让 allRenderItems 增长 → windowAtTop 反转 → expand-window 触发,
 *                跟 viewportFillDetect.test.ts 的"two-stage trace replay"互补
 *                (那里用纯数字 fixture,这里用真消息序列,锁住 build → 决策 端到端)
 *  - Scenario 3: U2 末尾混合丢弃类型 + valid message 的现实序列,验证 allRenderItems
 *                末尾 = valid item,visible slice(-INITIAL_ITEMS) 非空,decideAutoFillAction
 *                在 scrollH===clientH 时正常返 'load-from-db' 而非卡死
 *
 * 默认 perf case 使用宽松固定上界,避免把本机 baseline 绑定到所有环境。
 * 50k stress 是 focused-only,用于手动追踪大规模样本的本机趋势。
 * 复核命令:
 *   pnpm --filter desktop test messageStreamRenderWindowIntegration.test.ts -t "50k"
 * 更新 50k 本地基线时先在同一机器、同一命令下连续跑 3 次,取稳定 median 写回
 * LOCAL_BASELINE_50K_MS;预算固定为 baseline × 1.2,避免把一次抖动当回归。
 *
 * Node 环境(buildRenderItems 是纯函数,跟 prevMessageJumpChip 同款 pattern)。
 */

import { describe, it, expect } from 'vitest';
import {
  buildRenderItems,
  groupWorkRuns,
  snapRenderWindowStartIdx,
  resolveSavedViewportKey,
  resolveRestoredRenderWindow,
  restoreClientIdFromKey,
  restoreClientIdForItem,
  viewportRestoreNeedsMoreContent,
  resolveAnchoredWindowItemCount,
  resolveDefaultWindowStartIdx,
  shouldBoostDefaultWindow,
  clampTailWindowStartByBudget,
  estimateRenderItemMountCost,
  RENDER_WINDOW_INITIAL_ITEMS,
  RENDER_WINDOW_FIRST_PAINT_ITEMS,
  RENDER_WINDOW_FIRST_PAINT_BUDGET,
} from '../components/chat/MessageStream';
import {
  decideAutoFillAction,
  shouldAutoExpandRenderWindow,
  shouldAutoLoadMoreHistory,
} from '../components/chat/viewportFillDetect';
import type { ChatMessage } from '@/lib/makerChatStore';

// ── 工厂 ───────────────────────────────────────────────────────────────────

const DEFAULT_PERF_BUDGET_MS = 100;
const LOCAL_BASELINE_50K_MS = 13;
const BASELINE_REGRESSION_FACTOR = 1.2;

type VitestWorkerState = {
  config?: {
    testNamePattern?: RegExp | string;
  };
};

function is50kStressFocused(): boolean {
  const worker = (globalThis as typeof globalThis & { __vitest_worker__?: VitestWorkerState })
    .__vitest_worker__;
  // Vitest worker 进程拿不到 CLI argv;这里读它自己的测试名筛选配置。
  return String(worker?.config?.testNamePattern ?? '').includes('50k');
}

const RUN_50K_STRESS = is50kStressFocused();

const mkUser = (id: string, content = '...'): ChatMessage => ({
  clientId: id,
  role: 'user',
  content,
});

const mkAssistant = (id: string, content = 'ok'): ChatMessage => ({
  clientId: id,
  role: 'assistant',
  content,
});

const mkTool = (id: string, toolName = 'Bash', toolInput: unknown = { command: 'ls' }): ChatMessage => ({
  clientId: id,
  role: 'tool_use',
  content: '',
  toolUseId: `tu-${id}`,
  toolName,
  toolInput,
});

const mkResult = (id: string, toolUseId: string, content = 'ok'): ChatMessage => ({
  clientId: id,
  role: 'tool_result',
  content,
  toolUseId,
});

const mkAskUser = (id: string): ChatMessage => ({
  clientId: id,
  role: 'ask_user',
  content: '',
});

/**
 * 构造一个"现实风格"的消息序列:user → (thinking → assistant text → tool_use × k → tool_result × k) × turn
 * 用于 perf 微基准,模拟真实 session 形态。
 */
function buildRealisticSession(approxMessageCount: number): ChatMessage[] {
  const msgs: ChatMessage[] = [];
  let id = 0;
  const next = () => `m${id++}`;

  while (msgs.length < approxMessageCount) {
    msgs.push(mkUser(next(), 'user turn'));
    msgs.push(mkAssistant(next(), 'thinking text'));
    // 每个 turn 5–8 个 tool calls,模拟现实 agent 行为
    const k = 5 + (msgs.length % 4);
    for (let i = 0; i < k && msgs.length < approxMessageCount; i++) {
      const tuId = next();
      msgs.push(mkTool(tuId, i % 2 === 0 ? 'Bash' : 'Read'));
      msgs.push(mkResult(next(), `tu-${tuId}`, 'tool output'));
    }
    if (msgs.length < approxMessageCount) {
      msgs.push(mkAssistant(next(), 'turn closing text'));
    }
  }
  return msgs;
}

// ── Scenario 1: buildRenderItems perf 上界 ────────────────────────────────

describe('Scenario 1 — buildRenderItems perf bounds', () => {
  // 注:Node 环境 wall clock 抖动较大,默认用宽松固定上界(< 100ms),目的是抓住
  // 10× 量级的性能回归(例如错误改成 O(n²) 或加了 IPC 调用)。流式中每 token
  // 都会触发一次 build,实际预算应该远低于这个上界。

  function median(times: number[]): number {
    const sorted = [...times].sort((a, b) => a - b);
    return sorted[Math.floor(sorted.length / 2)];
  }

  function benchmark(messageCount: number, runs = 5, warmupRuns = 3): number {
    const messages = buildRealisticSession(messageCount);
    const times: number[] = [];
    // focused 运行不会先跑小 N 用例,这里显式预热,避免把 JIT/模块冷启动算进基线。
    for (let i = 0; i < warmupRuns; i++) {
      buildRenderItems(messages);
    }
    for (let i = 0; i < runs; i++) {
      const t0 = performance.now();
      buildRenderItems(messages);
      times.push(performance.now() - t0);
    }
    return median(times);
  }

  it('N=100: typical short session, median < 5ms (loose: 100ms)', () => {
    const median = benchmark(100);
    console.log(`[perf] buildRenderItems N=100: median=${median.toFixed(2)}ms`);
    expect(median).toBeLessThan(DEFAULT_PERF_BUDGET_MS);
  });

  it('N=500: medium session, median < 20ms (loose: 100ms)', () => {
    const median = benchmark(500);
    console.log(`[perf] buildRenderItems N=500: median=${median.toFixed(2)}ms`);
    expect(median).toBeLessThan(DEFAULT_PERF_BUDGET_MS);
  });

  it('N=1000: large session (commit ffff3603 baseline), median < 50ms (loose: 100ms)', () => {
    const median = benchmark(1000);
    console.log(`[perf] buildRenderItems N=1000: median=${median.toFixed(2)}ms`);
    expect(median).toBeLessThan(DEFAULT_PERF_BUDGET_MS);
  });

  it('N=2000: stress session, median < 100ms', () => {
    const median = benchmark(2000);
    console.log(`[perf] buildRenderItems N=2000: median=${median.toFixed(2)}ms`);
    expect(median).toBeLessThan(DEFAULT_PERF_BUDGET_MS);
  });

  it('N=5000: default stress session, median < 100ms', () => {
    const median = benchmark(5000, 9, 5);
    console.log(`[perf] buildRenderItems N=5000: median=${median.toFixed(2)}ms`);
    expect(median).toBeLessThan(DEFAULT_PERF_BUDGET_MS);
  });

  (RUN_50K_STRESS ? it : it.skip)('50k stress: local baseline median <= baseline * 1.2', () => {
    const median = benchmark(50_000, 5);
    console.log(`[perf] buildRenderItems N=50000: median=${median.toFixed(2)}ms baseline=${LOCAL_BASELINE_50K_MS}ms`);
    expect(median).toBeLessThanOrEqual(LOCAL_BASELINE_50K_MS * BASELINE_REGRESSION_FACTOR);
  });
});

// ── Scenario 2: U1 短 session 端到端二段式 ────────────────────────────────

describe('Scenario 2 — U1 short session full two-stage trace (build → decide)', () => {
  // 触发场景:50 条全是 tool_use + tool_result(同一 segment,折叠成一张 chip)。
  // 真实渲染高度极小,contentH << viewport,scrollH===clientH 死锁条件。

  function buildShortFoldedSession(toolCallCount: number): ChatMessage[] {
    const msgs: ChatMessage[] = [mkAssistant('a0', 'starting tools')];
    for (let i = 0; i < toolCallCount; i++) {
      const tuId = `t${i}`;
      msgs.push(mkTool(tuId, 'Bash'));
      msgs.push(mkResult(`r${i}`, `tu-${tuId}`));
    }
    return msgs;
  }

  it('50 tool calls in one consecutive run fold into a SINGLE tool_segment item', () => {
    const messages = buildShortFoldedSession(50);
    const { items } = buildRenderItems(messages);
    // 1 个 assistant message item + 1 个 tool_segment item(50 个 tool_use 折叠)
    expect(items.length).toBe(2);
    expect(items[0].type).toBe('message');
    expect(items[1].type).toBe('tool_segment');
    if (items[1].type === 'tool_segment') {
      expect(items[1].toolCalls.length).toBe(50);
    }
  });

  it('full trace: build → windowAtTop math → decideAutoFillAction returns load-from-db when stuck', () => {
    const messages = buildShortFoldedSession(50);
    const { items: allRenderItems } = buildRenderItems(messages);
    const visibleRenderItems = allRenderItems.slice(
      Math.max(0, allRenderItems.length - RENDER_WINDOW_INITIAL_ITEMS),
    );
    const windowAtTop = visibleRenderItems.length === allRenderItems.length;
    expect(windowAtTop).toBe(true);

    // 短 session contentH 远小于 viewport, scrollH===clientH 死锁状态
    const action = decideAutoFillAction({
      scrollHeight: 1354,
      clientHeight: 1354,
      windowAtTop,
      hasMoreMessages: true,
      isLoadingMore: false,
      attemptCount: 0,
    });
    expect(action).toBe('load-from-db');
  });

  it('after DB load adds N more messages, allRenderItems grows → windowAtTop=false → expand-window fires', () => {
    // 模拟 DB load 返回 50 条更老消息 prepend
    const oldMessages = buildShortFoldedSession(50);
    const olderMessages = buildShortFoldedSession(50).map((m, i) => ({
      ...m,
      clientId: `older-${i}`,
      toolUseId: m.toolUseId ? `tu-older-${i}` : undefined,
    }));
    const merged = [...olderMessages, ...oldMessages];

    const { items: allRenderItems } = buildRenderItems(merged);
    // 两批共 100 个 tool_call + 2 个 assistant text = 2 个 segment + 2 个 message item
    expect(allRenderItems.length).toBe(4);

    // 锚点假设还在旧批次的首个 segment (没动 expand)
    const oldFirstSeg = allRenderItems[2]; // [a-older, seg-older, a-old, seg-old]
    expect(oldFirstSeg.type).toBe('message');
    const visibleRenderItems = allRenderItems.slice(
      allRenderItems.findIndex((it) => it.key === oldFirstSeg.key),
    );
    const windowAtTop = visibleRenderItems.length === allRenderItems.length;
    expect(windowAtTop).toBe(false); // ✓ 新 prepend 的没进 visible

    const action = decideAutoFillAction({
      scrollHeight: 1354,
      clientHeight: 1354,
      windowAtTop,
      hasMoreMessages: true,
      isLoadingMore: false,
      attemptCount: 1, // 已经 load 过一次
    });
    expect(action).toBe('expand-window'); // ✓ Stage 1 优先于 Stage 2
  });
});

// ── Scenario 2b: render-window 不从 Task/Todo 卡中间开窗 ───────────────────

describe('Scenario 2b — render-window start snaps to user turn boundary', () => {
  it('includes the preceding user message when the default 80-item window would start at a task card', () => {
    const messages: ChatMessage[] = [
      mkUser('u-before', 'before'),
      mkAssistant('a-before', 'before answer'),
      mkUser('u-task', 'fix the task card'),
      // 运行中的子 Agent 卡(无 result)—— 非 boundary item,窗口不该从它开窗。
      mkTool('task-1', 'Task', { description: 'fix the task card' }),
      mkAssistant('a-task', 'done'),
    ];
    for (let i = 0; i < 39; i++) {
      messages.push(mkUser(`u-tail-${i}`, `tail ${i}`));
      messages.push(mkAssistant(`a-tail-${i}`, `tail answer ${i}`));
    }

    const allRenderItems = groupWorkRuns(buildRenderItems(messages).items, false);
    const rawStartIdx = Math.max(0, allRenderItems.length - RENDER_WINDOW_INITIAL_ITEMS);

    expect(allRenderItems[rawStartIdx]?.type).toBe('agent_task');

    const snappedStartIdx = snapRenderWindowStartIdx(allRenderItems, rawStartIdx);
    const firstVisible = allRenderItems[snappedStartIdx];

    expect(firstVisible?.type).toBe('message');
    if (firstVisible?.type === 'message') {
      expect(firstVisible.message.role).toBe('user');
      expect(firstVisible.message.clientId).toBe('u-task');
    }
    expect(allRenderItems[snappedStartIdx + 1]?.type).toBe('agent_task');
  });
});

// ── Scenario 3: U2 末尾混合丢弃类型 + valid message ────────────────────────

describe('Scenario 3 — U2 tail integration (mixed dropped types + valid msg)', () => {
  /**
   * 现实场景:SDK resume 一次性把大量 tool_result 补到 messages 末尾;同时这段
   * 历史可能还混杂 ask_user / AskUserQuestion / ExitPlanMode 等被丢弃类型,加上
   * 最后用户发的一条 message。验证 buildRenderItems 末尾恰好落在 valid message item。
   */
  function buildResumeTailScenario(): ChatMessage[] {
    return [
      mkUser('u0', 'first user turn'),
      mkAssistant('a0'),
      mkTool('t0', 'Bash'),
      mkResult('r0', 'tu-t0'),
      mkAssistant('a1', 'closing'),
      // ── SDK resume 把这堆补到末尾 ──
      // 多条 orphan tool_result (toolUseId 指向不存在的 tu — 主路径不命中)
      mkResult('orphan1', 'tu-does-not-exist-1'),
      mkResult('orphan2', 'tu-does-not-exist-2'),
      mkResult('orphan3', 'tu-does-not-exist-3'),
      // ask_user 类型
      mkAskUser('ask-1'),
      mkAskUser('ask-2'),
      // AskUserQuestion / ExitPlanMode 工具调用(被 buildRenderItems 跳过)
      mkTool('aq1', 'AskUserQuestion'),
      mkResult('aqr1', 'tu-aq1'),
      mkTool('ep1', 'ExitPlanMode'),
      mkResult('epr1', 'tu-ep1'),
      // 最后一条有效 assistant message (真实场景:用户重新激活后的应答)
      mkAssistant('a-final', 'resumed reply'),
    ];
  }

  it('allRenderItems tail is the LAST valid message (not any dropped type)', () => {
    const messages = buildResumeTailScenario();
    const { items: allRenderItems } = buildRenderItems(messages);
    const tail = allRenderItems.at(-1);
    expect(tail).toBeDefined();
    expect(tail?.type).toBe('message');
    if (tail?.type === 'message') {
      expect(tail.message.clientId).toBe('a-final');
      expect(tail.message.role).toBe('assistant');
    }
  });

  it('all dropped types are absorbed in Pass 2 — allRenderItems.length < messages.length', () => {
    const messages = buildResumeTailScenario();
    const { items: allRenderItems } = buildRenderItems(messages);
    expect(allRenderItems.length).toBeLessThan(messages.length);
  });

  it('default window slice(-INITIAL_ITEMS) is non-empty (U2 死锁不可能复现)', () => {
    const messages = buildResumeTailScenario();
    const { items: allRenderItems } = buildRenderItems(messages);
    const visibleRenderItems = allRenderItems.slice(
      Math.max(0, allRenderItems.length - RENDER_WINDOW_INITIAL_ITEMS),
    );
    expect(visibleRenderItems.length).toBeGreaterThan(0);
    // 末尾仍是 valid item — 自愈 effect 删除安全
    expect(visibleRenderItems.at(-1)?.type).toBe('message');
  });

  it('with all-dropped tail, decideAutoFillAction never returns "none" due to empty items', () => {
    const messages = buildResumeTailScenario();
    const { items: allRenderItems } = buildRenderItems(messages);
    const visibleRenderItems = allRenderItems.slice(
      Math.max(0, allRenderItems.length - RENDER_WINDOW_INITIAL_ITEMS),
    );
    const windowAtTop = visibleRenderItems.length === allRenderItems.length;

    // 短 session 模拟 contentH 不撑满 viewport
    const action = decideAutoFillAction({
      scrollHeight: 1354,
      clientHeight: 1354,
      windowAtTop,
      hasMoreMessages: true,
      isLoadingMore: false,
      attemptCount: 0,
    });
    // 不会被"空 items"卡死,会正常进入 expand 或 load 分支
    expect(action).not.toBe('none');
  });

  // ── 拓展极端 case:整段 messages 末尾几十条全是被丢弃类型 ─────────────
  // 这是 U2 原始死锁场景的 worst case,锁住"render-item 轴下绝对不再死锁"。

  it('extreme: tail of 50 orphan + ask_user — allRenderItems tail still valid', () => {
    const valid: ChatMessage[] = [mkUser('u0'), mkAssistant('a0', 'valid content')];
    const droppedTail: ChatMessage[] = [];
    for (let i = 0; i < 25; i++) {
      droppedTail.push(mkResult(`orphan${i}`, `tu-nonexistent-${i}`));
      droppedTail.push(mkAskUser(`ask${i}`));
    }
    const messages = [...valid, ...droppedTail];

    const { items: allRenderItems } = buildRenderItems(messages);
    expect(allRenderItems.length).toBe(2); // u0 + a0,其它 50 条全丢
    const tail = allRenderItems.at(-1);
    expect(tail?.type).toBe('message');
    if (tail?.type === 'message') {
      expect(tail.message.clientId).toBe('a0');
    }

    // 关键不变量:短 session 死锁条件下,helper 决策不会因 items 为空而退化
    const visibleRenderItems = allRenderItems.slice(
      Math.max(0, allRenderItems.length - RENDER_WINDOW_INITIAL_ITEMS),
    );
    expect(visibleRenderItems.length).toBe(2);
    expect(
      shouldAutoLoadMoreHistory({
        scrollHeight: 1354,
        clientHeight: 1354,
        hasMoreMessages: true,
        isLoadingMore: false,
        attemptCount: 0,
      }),
    ).toBe(true);
    expect(
      shouldAutoExpandRenderWindow({
        scrollHeight: 1354,
        clientHeight: 1354,
        windowAtTop: visibleRenderItems.length === allRenderItems.length,
      }),
    ).toBe(false); // windowAtTop=true 时 expand 不需要触发
  });
});

// ── Scenario 4: 两段式首屏窗口(FIRST_PAINT → INITIAL boost)的包含不变量 ──────
// 切会话首帧只画末尾 FIRST_PAINT 个 item,空闲期扩回 INITIAL。这里钉住两条:
//   1. FIRST_PAINT < INITIAL(boost 方向恒为「向前扩」,不会反向收缩);
//   2. 首帧窗口是 boost 后窗口的后缀子集(boost 只在视口上方 prepend,尾部
//      item 序列不变 —— 钉底重钉无跳变的前提)。
describe('two-phase first-paint window', () => {
  it('first-paint slice is a tail subset of the boosted INITIAL slice', () => {
    const messages: ChatMessage[] = [];
    for (let i = 0; i < 120; i++) {
      messages.push(mkUser(`u-${i}`, `q${i}`));
      messages.push(mkAssistant(`a-${i}`, `ans${i}`));
    }
    const { items } = buildRenderItems(messages, new Map());
    const allRenderItems = groupWorkRuns(items, false);
    expect(allRenderItems.length).toBeGreaterThan(RENDER_WINDOW_INITIAL_ITEMS);

    expect(RENDER_WINDOW_FIRST_PAINT_ITEMS).toBeLessThan(RENDER_WINDOW_INITIAL_ITEMS);

    const firstPaintStart = snapRenderWindowStartIdx(
      allRenderItems,
      Math.max(0, allRenderItems.length - RENDER_WINDOW_FIRST_PAINT_ITEMS),
    );
    const boostedStart = snapRenderWindowStartIdx(
      allRenderItems,
      Math.max(0, allRenderItems.length - RENDER_WINDOW_INITIAL_ITEMS),
    );
    const firstPaint = allRenderItems.slice(firstPaintStart);
    const boosted = allRenderItems.slice(boostedStart);

    // 首帧至少覆盖 FIRST_PAINT 个 item(snap 只会向前多包,不会少给)
    expect(firstPaint.length).toBeGreaterThanOrEqual(RENDER_WINDOW_FIRST_PAINT_ITEMS);
    // boost 只向前扩:首帧窗口必须是 boost 窗口的后缀(尾部 key 序列完全一致)
    expect(boostedStart).toBeLessThanOrEqual(firstPaintStart);
    expect(boosted.slice(boosted.length - firstPaint.length).map((it) => it.key)).toEqual(
      firstPaint.map((it) => it.key),
    );
    // 两个窗口的最后一个 item 恒为全量末尾 item(窗口永远含最新内容)
    expect(firstPaint[firstPaint.length - 1]?.key).toBe(
      allRenderItems[allRenderItems.length - 1]?.key,
    );
  });
});

describe('anchored bounded window includes its target', () => {
  it('adds boundary lookback distance to the desired forward count', () => {
    // target 位于 turn 起点后第 24 个 item;15-item 窗口若不补 lookback 会漏掉 target。
    const startIdx = 10;
    const anchorIdx = startIdx + 24;
    expect(resolveAnchoredWindowItemCount(startIdx, anchorIdx, 15)).toBe(39);
    expect(startIdx + resolveAnchoredWindowItemCount(startIdx, anchorIdx, 15)).toBeGreaterThan(
      anchorIdx,
    );
  });

  it('does not inflate a window when snapping keeps the anchor as start', () => {
    expect(resolveAnchoredWindowItemCount(20, 20, 15)).toBe(15);
  });
});

describe('budget-clamped default window boost', () => {
  it('boosts a short session when the byte budget hid some items', () => {
    expect(
      shouldBoostDefaultWindow({
        allItemCount: 10,
        visibleItemCount: 5,
        defaultWindowItems: 15,
      }),
    ).toBe(true);
  });

  it('does not boost a genuinely complete short session', () => {
    expect(
      shouldBoostDefaultWindow({
        allItemCount: 10,
        visibleItemCount: 10,
        defaultWindowItems: 15,
      }),
    ).toBe(false);
  });

  it('does not boost after the default window already reached INITIAL', () => {
    expect(
      shouldBoostDefaultWindow({
        allItemCount: RENDER_WINDOW_INITIAL_ITEMS + 20,
        visibleItemCount: RENDER_WINDOW_INITIAL_ITEMS,
        defaultWindowItems: RENDER_WINDOW_INITIAL_ITEMS,
      }),
    ).toBe(false);
  });
});

describe('budget-clamped default window user expansion', () => {
  it('uses the actual visible start when byte budget hid early items', () => {
    expect(
      resolveDefaultWindowStartIdx({
        allItemCount: 10,
        defaultWindowItems: 15,
        visibleStartIdx: 5,
        visibleItemCount: 5,
      }),
    ).toBe(5);
  });

  it('uses the declared tail capacity when the visible window is complete', () => {
    expect(
      resolveDefaultWindowStartIdx({
        allItemCount: 100,
        defaultWindowItems: 15,
        visibleStartIdx: 85,
        visibleItemCount: 15,
      }),
    ).toBe(85);
  });
});

describe('first-paint content budget (clampTailWindowStartByBudget)', () => {
  const mkItem = (id: string, contentSize: number) => ({
    key: `message-${id}`,
    type: 'message' as const,
    message: mkAssistant(id, 'x'.repeat(contentSize)),
  });

  it('small messages never hit the budget — start index unchanged', () => {
    const items = Array.from({ length: 15 }, (_, i) => mkItem(`s-${i}`, 500));
    expect(clampTailWindowStartByBudget(items, 0)).toBe(0);
  });

  it('large messages shrink the window from the front', () => {
    // 每条 12KB:64k 预算 ≈ 5 条(200 固定开销 + 12000)。15 条起点应收窄到只渲染约 5 条。
    const items = Array.from({ length: 15 }, (_, i) => mkItem(`l-${i}`, 12_000));
    const clamped = clampTailWindowStartByBudget(items, 0);
    expect(clamped).toBeGreaterThan(0);
    const rendered = items.length - clamped;
    const cost = items.slice(clamped).reduce((acc, it) => acc + estimateRenderItemMountCost(it), 0);
    expect(cost).toBeLessThanOrEqual(RENDER_WINDOW_FIRST_PAINT_BUDGET + 12_200);
    expect(rendered).toBeGreaterThanOrEqual(5);
    expect(rendered).toBeLessThan(8);
  });

  it('always keeps at least the last item even when a single item busts the budget', () => {
    const items = [mkItem('huge', RENDER_WINDOW_FIRST_PAINT_BUDGET * 2)];
    expect(clampTailWindowStartByBudget(items, 0)).toBe(0);
  });

  it('window tail is always the latest item', () => {
    const items = Array.from({ length: 10 }, (_, i) => mkItem(`t-${i}`, 20_000));
    const clamped = clampTailWindowStartByBudget(items, 0);
    const rendered = items.slice(clamped);
    expect(rendered[rendered.length - 1]?.key).toBe(items[items.length - 1]?.key);
  });

  it('non-message items use flat estimates and stay cheap', () => {
    const seg = {
      key: 'seg-a',
      type: 'tool_segment' as const,
      toolCalls: [mkTool('a')],
      resultMap: new Map<string, string>(),
      settledIds: new Set<string>(),
      resultTsMap: new Map<string, number>(),
    };
    expect(estimateRenderItemMountCost(seg)).toBeLessThan(1000);
  });
});

describe('restored reading position', () => {
  it('grows a short restored window when overflow still cannot accommodate the saved offset', () => {
    // Regression: 98 px of overflow existed, but restoring needed 330 px.
    expect(viewportRestoreNeedsMoreContent(330, 1242, 1144, false)).toBe(true);
    expect(viewportRestoreNeedsMoreContent(330, 1600, 1144, false)).toBe(false);
    expect(viewportRestoreNeedsMoreContent(330, 1242, 1144, true)).toBe(false);
    expect(viewportRestoreNeedsMoreContent(0, 900, 1144, false)).toBe(false);
  });

  it('retains real source identifiers for synthetic cards and compound keys', () => {
    expect(restoreClientIdFromKey('genfiles-user-with-dashes')).toBe('user-with-dashes');
    expect(restoreClientIdFromKey('work-summary-tool-with-dashes')).toBe('tool-with-dashes');
    expect(restoreClientIdFromKey('subagent-media-tool-with-dashes')).toBe('tool-with-dashes');
    expect(restoreClientIdFromKey('ghostcard-tool-with-dashes')).toBe('tool-with-dashes');
    expect(restoreClientIdFromKey('fork-origin-session')).toBeUndefined();
    expect(restoreClientIdForItem({ type: 'agent_plan', key: 'plan-changing', todos: [], sourceClientIds: ['plan-source'] }))
      .toBe('plan-source');
    expect(restoreClientIdForItem({ type: 'generated_files', key: 'genfiles-user', files: [], turnStartMs: null, turnEndMs: null }))
      .toBe('user');
  });

  const items = Array.from({ length: RENDER_WINDOW_INITIAL_ITEMS + 40 }, (_, i) => ({
    key: `message-m-${i}`,
    type: 'message' as const,
    message: mkAssistant(`m-${i}`),
  }));

  it('restores an old anchor outside the tail using a bounded window', () => {
    const snapshot = { windowAnchorKey: null, viewportTopKey: items[0].key, offset: 18, isNearBottom: false };
    expect(resolveSavedViewportKey(items, snapshot)).toBe(items[0].key);
    expect(resolveAnchoredWindowItemCount(0, 0, RENDER_WINDOW_FIRST_PAINT_ITEMS))
      .toBe(RENDER_WINDOW_FIRST_PAINT_ITEMS);
    expect(resolveSavedViewportKey(items.slice(1), snapshot)).toBeNull();
  });

  it('remounts around the viewport instead of the entire previously expanded history', () => {
    const snapshot = { windowAnchorKey: items[0].key, viewportTopKey: items[70].key,
      anchoredForwardCount: 120, offset: 18, isNearBottom: false };
    const window = resolveRestoredRenderWindow(snapshot);
    const anchorIndex = items.findIndex(item => item.key === window.anchor);
    const start = snapRenderWindowStartIdx(items, anchorIndex);
    const visible = items.slice(start, start + resolveAnchoredWindowItemCount(start, anchorIndex, window.forwardItems));
    expect(window.forwardItems).toBe(RENDER_WINDOW_FIRST_PAINT_ITEMS);
    expect(visible).toContain(items[70]);
    expect(visible).not.toContain(items[0]);
    expect(visible.length).toBeLessThan(snapshot.anchoredForwardCount);
  });

  it('retains legacy window fallback and resets near-bottom snapshots to the tail', () => {
    const legacy = { windowAnchorKey: items[0].key, viewportTopKey: '',
      anchoredForwardCount: 120, offset: 18, isNearBottom: false };
    expect(resolveRestoredRenderWindow(legacy)).toEqual({ anchor: items[0].key, forwardItems: 120 });
    expect(resolveRestoredRenderWindow({ ...legacy, isNearBottom: true }))
      .toEqual({ anchor: null, forwardItems: RENDER_WINDOW_FIRST_PAINT_ITEMS });
  });

  it('prefers a saved generated-files card over its earlier source user row', () => {
    const source = { type: 'message' as const, key: 'msg-user', message: mkUser('user') };
    const card = { type: 'generated_files' as const, key: 'genfiles-user', files: [], turnStartMs: null, turnEndMs: null };
    const snapshot = { windowAnchorKey: null, viewportTopKey: card.key, restoreClientId: 'user', offset: 12, isNearBottom: false };
    expect(resolveSavedViewportKey([source, card], snapshot)).toBe(card.key);
    expect(resolveSavedViewportKey([source], snapshot)).toBe(source.key);
    expect(resolveSavedViewportKey([], snapshot)).toBeNull();
  });
});