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。

27.2 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest';
import { readFileSync } from 'node:fs';
import {
  HistoryViewController, HistoryViewHandoff, projectHistoryView, renderHistoryView, historyViewLeaves, nextHistoryCacheReceipt,
} from '@cindy/maker-shared/message-window';
import { buildMessageStreamRenderProjection, buildCachedRenderItems, buildRenderItems, groupWorkRuns, selectVisibleMessages, collectTurnFinalAssistantClientIds,
  findLastUserMessageClientId, planSessionBelongsToLatestUserTurn } from '../components/chat/MessageStream';
import { deriveNavRailEntries } from '../components/chat/messageNavRailModel';
import { collectAssistantTurnUsageDetails } from '../lib/userTurnUsage';
import { buildTurnUsageDetails } from '../../shared/turnUsageDetails';
import type { HistoryChatMessage } from '../lib/makerChatStore';
import type { VoiceCallRecord } from '@cindy/maker-core';
import { BOT_MESSAGE_TIME_GROUP_MS, collectBotMessageTimeGroups } from '../features/bots/botConversationTimeline';
import { confirmRemoteUsers, projectRemoteUsers, reserveRemoteUser } from '../lib/remoteUserHandoff';

const row = (clientId: string, isStreaming = false): HistoryChatMessage => ({
  id: clientId, clientId, role: clientId === 'user' ? 'user' : 'assistant',
  content: clientId === 'user' ? 'question' : 'visible answer', isStreaming,
  createdAt: clientId === 'user' ? '2026-09-08T00:00:01Z' : '2026-09-08T00:00:00Z',
});

// Regression: filtering the raw list in CCAgentSessionView did not cover the
// independently loaded history snapshot, so a saved seven-second empty call
// reappeared after reopening the task. Exercise the production render boundary.
it.each(['raw', 'render-cache', 'history', 'cache', 'older-page'] as const)(
  'omits empty/live call cards from %s without removing saved content or handoffs',
  async (source) => {
    const call = (
      id: string,
      turns: VoiceCallRecord['turns'] = [],
      handoffs: VoiceCallRecord['handoffs'] = [],
    ): HistoryChatMessage => ({
      ...row(id),
      content: '',
      systemCardType: 'voice-call',
      systemCardData: { record: {
        version: 1, callId: id, startedAt: 1000, endedAt: 8241, turns, handoffs,
      } satisfies VoiceCallRecord },
    });
    const turn = (text: string, failed = false): VoiceCallRecord['turns'] => [
      { id: 'turn', role: 'user', text, complete: true, failed, createdAt: 1100 },
    ];
    const rows = [
      call('empty'), call('whitespace', turn(' \n\t')),
      call('spoken', turn('你好')),
      call('failed', turn('请保留原句', true)),
      call('interrupted', [{ id: 'reply', role: 'assistant', text: '还没说完', complete: false, createdAt: 1200 }]),
      call('handoff', [], [{ id: 'task', inputId: 'request', text: '后台继续', state: 'accepted' }]),
      call('live', turn('这通电话还在继续')),
    ].map((message, index) => ({
      ...message,
      createdAt: new Date(Date.UTC(2026, 9, 20) + index * BOT_MESSAGE_TIME_GROUP_MS * 2).toISOString(),
    }));
    const saved = structuredClone(rows);
    const view = new HistoryViewController<HistoryChatMessage>({
      page: async (before) => ({
        version: 1,
        items: [{ type: 'messages', key: before ? 'older' : 'latest',
          messages: source === 'older-page' ? (before ? rows.slice(0, -1) : rows.slice(-1)) : rows }],
        hasMore: source === 'older-page' && !before,
        nextCursor: source === 'older-page' && !before ? 'older' : null,
      }),
      details: async () => ({ version: 1, messages: [], hasMore: false, nextCursor: null }),
      expanded: async () => undefined,
    });
    try {
      if (source === 'cache') {
        view.setActive(false);
        await view.restoreCachedView(async () => ({ ...view.getSnapshot(), ready: true,
          items: [{ type: 'messages', key: 'cached', messages: rows }] }));
      } else if (source !== 'raw' && source !== 'render-cache') {
        await view.refresh();
        if (source === 'older-page') await view.refresh(true);
      }
      const render = (activeVoiceCallId: string | null) => {
        const renderOptions = { botSessionId: 'voice-owner', activeVoiceCallId };
        return buildMessageStreamRenderProjection({
          historyView: view, historySnapshot: view.getSnapshot(), historyLiveMessages: [],
          isSessionStreaming: false, generatedFilesItemCache: new Map(), renderOptions,
          buildRaw: () => (source === 'render-cache' ? buildCachedRenderItems : buildRenderItems)(
            rows, undefined, undefined, renderOptions,
          ),
        }).items.flatMap(item => item.type === 'message' ? [item.message] : []);
      };
      const visible = render('live');
      expect(visible.map(message => message.clientId)).toEqual(['spoken', 'failed', 'interrupted', 'handoff']);
      expect([...collectBotMessageTimeGroups(visible).keys()]).toEqual(['spoken', 'failed', 'interrupted', 'handoff']);
      // Ending a nonempty call reveals its existing card, without a new row.
      expect(render(null).map(message => message.clientId)).toEqual(['spoken', 'failed', 'interrupted', 'handoff', 'live']);
      expect(rows).toEqual(saved);
    } finally {
      view.setActive(false);
    }
  },
);

function fixture() {
  let source = [row('user')];
  const view = new HistoryViewController<HistoryChatMessage>({
    page: async () => ({ version: 1, items: projectHistoryView(source, false), hasMore: false, nextCursor: null }),
    details: async () => ({ version: 1, messages: [], hasMore: false, nextCursor: null }),
    expanded: async () => undefined,
  });
  const handoff = new HistoryViewHandoff<HistoryChatMessage>((message) => message.isStreaming === true);
  const render = (raw: HistoryChatMessage[]) => {
    const snapshot = view.getSnapshot();
    const historyIds = new Set(historyViewLeaves(snapshot.items).flatMap((item) =>
      item.type === 'messages' ? item.messages.map((row) => row.clientId) : []));
    for (const detail of snapshot.details.values()) for (const row of detail.messages) historyIds.add(row.clientId);
    raw = projectRemoteUsers(raw, historyIds);
    const state = handoff.reconcile(snapshot, raw);
    const build = (rows: readonly HistoryChatMessage[]) => groupWorkRuns(buildRenderItems([...rows]).items, false);
    const items = snapshot.ready ? renderHistoryView({
      view, snapshot, liveMessages: raw, streaming: false,
      isLive: (message) => message.isStreaming === true,
      pendingHandoff: state.pending,
      staleTail: state.tail,
      isLocalUser: (message) => message.role === 'user' && (message.isPendingPersist === true || !!message.blockedByGhost || !!message.localSendPrecedingClientIds),
      build,
      structure: {
        placeholder: () => { throw new Error('This fixture contains prose only'); },
        children: () => undefined,
        sourceIds: () => [],
        rebuild: (item) => item,
      },
    }) : build(raw);
    return { state, text: JSON.stringify(items), items };
  };
  return { view, handoff, render, setSource: (rows: HistoryChatMessage[]) => { source = rows; } };
}

describe('desktop remote history uses the shared live-to-history handoff', () => {
  it.each([false, true])('lets a newer empty page retire a receipt before the raw deletion push arrives (streamed=%s)', async (streamed) => {
    const { view, render, setSource } = fixture();
    const readReceipt = nextHistoryCacheReceipt();
    let received = { ...row('reply', streamed), cacheReceipt: nextHistoryCacheReceipt() };
    view.setActive(false);
    await view.restoreCachedView(async () => ({ ...view.getSnapshot(), ready: true, readReceipt }));
    expect(render([received]).text).toContain('visible answer');
    received = { ...received, isStreaming: false };
    setSource([]);
    view.setActive(true);
    await view.refresh();
    expect(render([received]).items).toEqual([]);
    view.setActive(false);
    expect(render([received]).items).toEqual([]);
    expect(render([received]).state.tail.size).toBe(0);
    expect(render([received]).state.pending.size).toBe(0);
  });

  // Unit: reproduce the list-receipt/history timestamp disagreement through the
  // Desktop renderer; the already received answer must never disappear on entry.
  it('keeps a received answer whose timestamp is earlier than the cached page tail', async () => {
    const { view, render, setSource } = fixture();
    const later = row('user');
    const readReceipt = nextHistoryCacheReceipt();
    const received = { ...row('reply'), cacheReceipt: nextHistoryCacheReceipt() };
    view.setActive(false);
    await view.restoreCachedView(async () => ({ items: projectHistoryView([later], false), details: new Map(),
      expanded: new Set(), nextCursor: null, hasMore: false, loading: false, ready: true, error: null, readReceipt }));
    expect(render([received]).text).toContain('visible answer');
    setSource([received, later]);
    view.setActive(true);
    await view.refresh();
    const result = render([received]);
    expect(result.items.filter(item => item.type === 'message').map(item => item.message.clientId))
      .toEqual(['reply', 'user']);
    expect(result.state.tail.size).toBe(0);
    view.setActive(false);
  });

  // Same-ID body updates must survive cache restore and yield to a later Host read.
  it('renders a later list receipt instead of the old cached body', async () => {
    const { view, render, setSource } = fixture();
    const old = { ...row('reply'), content: 'old cached body' };
    const readReceipt = nextHistoryCacheReceipt();
    const received = { ...old, content: 'updated received body', cacheReceipt: nextHistoryCacheReceipt() };
    view.setActive(false);
    await view.restoreCachedView(async () => ({ items: projectHistoryView([old], false), details: new Map(),
      expanded: new Set(), nextCursor: null, hasMore: false, loading: false, ready: true, error: null,
      readReceipt }));
    expect(render([received]).text).toContain('updated received body');
    expect(render([received]).text).not.toContain('old cached body');
    setSource([{ ...old, content: 'authoritative body' }]);
    view.setActive(true);
    await view.refresh();
    expect(render([received]).text).toContain('authoritative body');
    expect(render([received]).text).not.toContain('updated received body');
    view.setActive(false);
  });

  it.each([false, true])('places a late harness boundary before the reserved send (history ready=%s)', async (ready) => {
    const { view, render, setSource } = fixture();
    if (ready) await view.refresh();
    const previous = row('user');
    const sent = reserveRemoteUser({ ...row('sent'), role: 'user' as const, isPendingPersist: true }, [previous]);
    const boundary: HistoryChatMessage = { ...row('switch'), systemCardType: 'agent-switch',
      createdAt: '2026-09-08T00:00:02Z' };
    const raw = [previous, sent, boundary];
    const ids = () => render(raw).items.filter((item) => item.type === 'message').map((item) => item.message.clientId);
    // Local Desktop sends have no explicit reservation until their DB echo.
    const { localSendPrecedingClientIds: _reservation, ...localPending } = sent;
    expect(projectRemoteUsers([previous, localPending, boundary]).map((message) => message.clientId))
      .toEqual(['user', 'switch', 'sent']);
    expect(projectRemoteUsers(raw).map((message) => message.clientId)).toEqual(['user', 'switch', 'sent']);
    if (!ready) expect(ids()).toEqual(['user', 'switch', 'sent']);
    setSource([previous, boundary]);
    await view.refresh();
    expect(ids()).toEqual(['user', 'switch', 'sent']);
    raw[1] = { ...sent, id: 'db-sent', isPendingPersist: undefined };
    expect(ids()).toEqual(['user', 'switch', 'sent']);
    setSource([previous, boundary, raw[1]]);
    await view.refresh();
    expect(ids()).toEqual(['user', 'switch', 'sent']);
    view.setActive(false);
  });

  it('does not pull a later harness switch across a reply into an earlier send', () => {
    const previous = row('user');
    const sent = reserveRemoteUser({ ...row('sent'), role: 'user' as const }, [previous]);
    const reply = row('reply');
    const boundary = { ...row('switch'), systemCardType: 'agent-switch' as const };
    const next = reserveRemoteUser({ ...row('next'), role: 'user' as const }, [previous, sent, reply]);
    expect(projectRemoteUsers([previous, sent, reply, next, boundary]).map((message) => message.clientId))
      .toEqual(['user', 'sent', 'reply', 'switch', 'next']);
  });

  it.each([false, true])('keeps consecutive switches with their sends without a reply (next echoed=%s)', (echoed) => {
    const previous = row('user');
    const firstSwitch = { ...row('switch-first'), systemCardType: 'agent-switch' as const };
    const secondSwitch = { ...row('switch-next'), systemCardType: 'agent-switch' as const };
    // The first DB echo has arrived, but history has not retired its reservation.
    const first = reserveRemoteUser({ ...row('first'), role: 'user' as const }, [previous]);
    const next = reserveRemoteUser({ ...row('next'), role: 'user' as const,
      isPendingPersist: !echoed }, [previous, firstSwitch, first]);
    const raw = [previous, firstSwitch, first, secondSwitch, next];
    const expected = ['user', 'switch-first', 'first', 'switch-next', 'next'];
    expect(projectRemoteUsers(raw).map((message) => message.clientId)).toEqual(expected);
    expect(projectRemoteUsers(raw, new Set(['user', 'switch-first'])).map((message) => message.clientId)).toEqual(expected);
    const confirmedIds = new Set(expected);
    expect(projectRemoteUsers(confirmRemoteUsers(raw, confirmedIds), confirmedIds).map((message) => message.clientId)).toEqual(expected);
  });

  it('shows a list-pushed reply after a restored snapshot until the page read covers it', async () => {
    const { view, render, setSource } = fixture();
    const reply = { ...row('reply'), content: 'prefetched reply', createdAt: '2026-09-08T00:00:09Z' };
    const pendingUser = { ...row('typing'), role: 'user' as const, content: 'local draft send',
      isPendingPersist: true, createdAt: '2026-09-08T00:00:10Z' };
    view.setActive(false);
    await view.restoreCachedView(async () => ({ items: projectHistoryView([row('user')], false), details: new Map(),
      expanded: new Set(), nextCursor: null, hasMore: false, loading: false, ready: true, error: null }));
    const restored = render([row('user'), reply, pendingUser]);
    expect(restored.state.tail).toEqual(new Set(['reply', 'typing']));
    expect(restored.text).toContain('prefetched reply');
    expect(restored.text.split('local draft send')).toHaveLength(2);
    setSource([row('user'), reply]);
    view.setActive(true);
    await view.refresh();
    const fresh = render([row('user'), reply]);
    expect(fresh.state.tail.size).toBe(0);
    expect(fresh.text.split('prefetched reply')).toHaveLength(2);
    view.setActive(false);
  });

  it('keeps the live tail after history when the last send reservation retires', async () => {
    const { view, render, setSource } = fixture();
    await view.refresh();
    const sent = reserveRemoteUser({ ...row('sent'), role: 'user' as const }, [row('user')]);
    const reply = { ...row('reply', true), content: 'current answer',
      turnUsageDetails: buildTurnUsageDetails({ inputTokens: 3, outputTokens: 1 })! };
    const raw = [row('user'), reply, sent];
    render(raw); // Observe the live reply before the Host owns either row.
    const { localSendPrecedingClientIds: _reservation, ...hostUser } = sent;
    setSource([row('user'), hostUser]);
    await view.refresh();
    const historyIds = new Set(['user', 'sent']);
    const confirmed = confirmRemoteUsers(raw, historyIds);
    expect(confirmed.every((message) => !message.localSendPrecedingClientIds)).toBe(true);
    const display = projectRemoteUsers(confirmed, historyIds);
    expect(display.map((message) => message.clientId)).toEqual(['user', 'sent', 'reply']);
    expect(render(confirmed).items.filter((item) => item.type === 'message')
      .map((item) => item.message.clientId)).toEqual(['user', 'sent', 'reply']);
    const visible = selectVisibleMessages(display);
    const finals = collectTurnFinalAssistantClientIds(visible);
    expect(finals).toEqual(new Set(['reply']));
    expect(findLastUserMessageClientId(visible)).toBe('sent');
    expect(planSessionBelongsToLatestUserTurn(display, ['reply'])).toBe(true);
    expect(deriveNavRailEntries(visible).at(-1)?.answerExcerpt).toBe('current answer');
    expect(collectAssistantTurnUsageDetails(display, finals).get('reply')?.totalTokens).toBe(4);
    const second = reserveRemoteUser({ ...row('second'), role: 'user' as const }, display);
    const secondReply = row('second-reply', true);
    expect(projectRemoteUsers([...confirmed, secondReply, second], historyIds)
      .map((message) => message.clientId)).toEqual(['user', 'sent', 'reply', 'second', 'second-reply']);
    // Empty history (including the legacy path) provides no ordering evidence.
    expect(projectRemoteUsers(confirmed)).toEqual(confirmed);
    setSource([]);
    await view.refresh();
    expect(render(confirmed).items.filter((item) => item.type === 'message' && item.message.clientId === 'sent')).toEqual([]);
    view.setActive(false);
  });

  it('keeps turn actions, navigation, plans and usage aligned through skewed consecutive sends', () => {
    const oldAnswer = { ...row('old-answer'), content: 'old answer',
      turnUsageDetails: buildTurnUsageDetails({ inputTokens: 100, outputTokens: 1 })! };
    const history = [row('user'), oldAnswer];
    const sent = reserveRemoteUser({ ...row('sent'), role: 'user' as const }, history);
    const internal = { ...row('internal'), parentToolUseId: 'toolu_subagent',
      turnUsageDetails: buildTurnUsageDetails({ inputTokens: 5, outputTokens: 2 })! };
    const reply = { ...row('reply'), content: 'current answer',
      turnUsageDetails: buildTurnUsageDetails({ inputTokens: 3, outputTokens: 1 })! };
    const second = reserveRemoteUser({ ...row('second'), role: 'user' as const }, [...history, sent, internal, reply]);
    const secondReply = { ...row('second-reply'), content: 'second answer' };
    const display = projectRemoteUsers([...history, internal, reply, secondReply, second, sent]);
    const visible = selectVisibleMessages(display);
    expect(visible.map((message) => message.clientId)).toEqual(['user', 'old-answer', 'sent', 'reply', 'second', 'second-reply']);
    const finals = collectTurnFinalAssistantClientIds(visible);
    expect(finals).toEqual(new Set(['old-answer', 'reply', 'second-reply']));
    expect(findLastUserMessageClientId(visible)).toBe('second');
    expect(planSessionBelongsToLatestUserTurn(display, ['second-reply'])).toBe(true);
    expect(planSessionBelongsToLatestUserTurn(display, ['reply'])).toBe(false);
    expect(deriveNavRailEntries(visible).map((entry) => entry.answerExcerpt)).toEqual(['old answer', 'current answer', 'second answer']);
    expect(collectAssistantTurnUsageDetails(display, finals).get('reply')?.totalTokens).toBe(11);
    // Pin the component's inputs too: pure helpers alone cannot catch a raw-order caller.
    const source = readFileSync(new URL('../components/chat/MessageStream.tsx', import.meta.url), 'utf8');
    expect(source).toContain('selectVisibleMessages(displayMessages)');
    expect(source).toContain('planSessionBelongsToLatestUserTurn(displayMessages,');
    expect(source).toContain('const metadataMessages = metadataProjection(displayMessages)');
    expect(source).toContain('findFirstUserMessageClientId(metadataMessages,');
    expect(source).toContain('collectAssistantTurnUsageDetails(metadataMessages,');
  });

  it.each([{ predecessors: [] as string[] }, { predecessors: ['removed'] }, { predecessors: ['user'] }])('anchors a send after late history with $predecessors', async ({ predecessors }) => {
    const { view, render, setSource } = fixture();
    const sent = reserveRemoteUser({ ...row('sent'), role: 'user' as const }, predecessors.map((id) => row(id)));
    const reply = { ...row('reply', true), content: 'first reply' };
    expect(render([reply, sent]).items.filter((item) => item.type === 'message').map((item) => item.message.clientId)).toEqual(['sent', 'reply']);
    const late = { ...row('late'), role: 'user' as const, content: 'newer historical question' };
    setSource([row('user'), late]);
    await view.refresh();
    expect(render([reply, row('user'), late, sent]).items.filter((item) => item.type === 'message').map((item) => item.message.clientId)).toEqual(['user', 'late', 'sent', 'reply']);
    const second = reserveRemoteUser({ ...row('second'), role: 'user' as const }, [sent, reply]);
    const secondReply = { ...row('second-reply', true), content: 'second reply' };
    expect(render([reply, secondReply, row('user'), late, second, sent]).items.filter((item) => item.type === 'message').map((item) => item.message.clientId)).toEqual(['user', 'late', 'sent', 'reply', 'second', 'second-reply']);
    view.setActive(false);
  });

  it.each([false, true])('keeps a sent user through DB echo and stale history, ready=%s', async (ready) => {
    const { view, render, setSource } = fixture();
    if (ready) await view.refresh();
    const pending = reserveRemoteUser({ ...row('sent'), role: 'user' as const, content: 'sent text', isPendingPersist: true }, [row('user')]);
    expect(render([row('user'), pending]).text).toContain('sent text');
    const echo = { ...pending, isPendingPersist: undefined, id: 'db-sent' };
    await view.refresh();
    expect(render([row('user'), echo]).items.filter((item) => item.type === 'message' && item.message.clientId === 'sent')).toHaveLength(1);
    const authoritative = { ...row('sent'), role: 'user' as const, content: 'authoritative sent' };
    setSource([row('user'), authoritative]);
    await view.refresh();
    const confirmed = confirmRemoteUsers([echo], new Set(['sent']));
    expect(confirmed[0].localSendPrecedingClientIds).toBeUndefined();
    expect(render(confirmed).text).toContain('authoritative sent');
    setSource([]);
    await view.refresh();
    expect(render(confirmed).text).not.toContain('sent text');
    expect(render([]).items).toEqual([]);
    view.setActive(false);
  });

  it.each(['2000-01-01', '2040-01-01'])('keeps user before its reply regardless of controller clock %s', async (createdAt) => {
    const { view, render } = fixture();
    await view.refresh();
    const pending = reserveRemoteUser({ ...row('sent'), role: 'user' as const, createdAt }, [row('user')]);
    const answer = row('answer', true);
    // Raw store may have sorted the host reply ahead of the controller's user row.
    const result = render([row('user'), answer, pending]);
    expect(result.items.filter((item) => item.type === 'message').map((item) => item.message.clientId)).toEqual(['user', 'sent', 'answer']);
    const second = reserveRemoteUser({ ...row('second'), role: 'user' as const }, [row('user'), pending, answer]);
    expect(projectRemoteUsers([row('user'), second, answer, pending]).map((item) => item.clientId)).toEqual(['user', 'sent', 'answer', 'second']);
    view.setActive(false);
  });

  it('keeps finalized prose through the first stale page and takes over once by clientId', async () => {
    const { view, render, setSource } = fixture();
    expect(render([row('answer', true)]).text).toContain('visible answer');
    expect(render([row('answer')]).text).toContain('visible answer');
    await view.refresh();
    // The provisional timestamp is older than the history tail; it still belongs
    // to this displayed stream, unlike an arbitrary durable cache row.
    expect(render([row('answer')]).text).toContain('visible answer');
    expect(render([{ ...row('answer'), id: 'persisted-id', rowid: 42 }]).text).toContain('visible answer');
    await view.refresh();
    expect(render([row('answer')]).text).toContain('visible answer');
    setSource([row('user'), { ...row('answer'), id: 'persisted-id', content: 'authoritative answer' }]);
    await view.refresh();
    const final = render([row('answer')]);
    expect(final.state.pending.size).toBe(0);
    expect(final.text).not.toContain('visible answer');
    expect(final.items.filter((item) => item.type === 'message' && item.message.clientId === 'answer')).toHaveLength(1);
    expect(final.text).toContain('authoritative answer');
    view.setActive(false);
  });

  it('retains local pending user bubbles while the assistant awaits history', async () => {
    const { view, render } = fixture();
    await view.refresh();
    render([row('answer', true)]);
    const pending: HistoryChatMessage = { ...row('pending'), role: 'user', content: 'queued follow-up', isPendingPersist: true };
    const final = render([row('answer'), pending]);
    expect(final.text).toContain('visible answer');
    expect(final.text).toContain('queued follow-up');
    expect(final.items.filter((item) => item.type === 'message').map((item) => item.message.clientId)).toEqual(['user', 'answer', 'pending']);
    view.setActive(false);
  });

  it('does not resurrect finalized raw rows after removal, reset or a source switch', async () => {
    const { view, render } = fixture();
    await view.refresh();
    expect(render([row('old')]).text).not.toContain('visible answer');
    render([row('answer', true)]);
    render([]);
    expect(render([row('answer')]).text).not.toContain('visible answer');
    render([row('answer', true)]);
    view.reset();
    render([row('answer')]);
    await view.refresh();
    expect(render([row('answer')]).text).not.toContain('visible answer');
    const replacement = fixture();
    await replacement.view.refresh();
    expect(replacement.render([row('answer')]).text).not.toContain('visible answer');
    replacement.view.setActive(false);
    view.setActive(false);
  });
});

// Unit: exercise the projection used by MessageStream, including the lazy raw
// fallback. Existing handoff cases call renderHistoryView below that boundary.
it.each([false, true])('builds the displayed source and retains tool results (ready=%s)', async ready => {
  const historyRows: HistoryChatMessage[] = [row('user'),
    { ...row('call'), role: 'tool_use', toolName: 'Read', toolUseId: 'tool', toolInput: {} },
    { ...row('result'), role: 'tool_result', toolUseId: 'tool', content: 'Tool output' },
    { ...row('cached'), content: 'Cached answer' }];
  const view = new HistoryViewController<HistoryChatMessage>({
    page: async () => ({ version: 1, items: [{ type: 'messages', key: 'page', messages: historyRows }], hasMore: false, nextCursor: null }),
    details: async () => ({ version: 1, messages: [], hasMore: false, nextCursor: null }),
    expanded: async () => undefined,
  });
  if (ready) await view.refresh();
  const buildRaw = vi.fn(() => buildRenderItems([{ ...row('raw'), content: 'Raw answer' }]));
  const result = buildMessageStreamRenderProjection({
    historyView: view, historySnapshot: view.getSnapshot(), historyLiveMessages: [],
    isSessionStreaming: false, generatedFilesItemCache: new Map(), buildRaw,
  });
  expect(result.items.filter(item => item.type === 'message').map(item => item.message.content))
    .toContain(ready ? 'Cached answer' : 'Raw answer');
  expect(JSON.stringify(result.items)).not.toContain(ready ? 'Raw answer' : 'Cached answer');
  expect(buildRaw).toHaveBeenCalledTimes(ready ? 0 : 1);
  if (ready) {
    const work = result.items.find(item => item.type === 'work_group');
    const tool = work?.type === 'work_group' ? work.children.find(item => item.type === 'tool_segment') : undefined;
    expect(tool?.type === 'tool_segment' && tool.resultMap.get('call')).toBe('Tool output');
  } else {
    expect(result.singleResultMap).toBe(buildRaw.mock.results[0].value.singleResultMap);
  }
  view.setActive(false);
});