Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* buildRenderItemsKeyStability.test.ts
* ---------------------------------------------------------------------------
* 锁住 buildRenderItems 在以下场景下的 stable key 行为 —— render-window 把锚点从
* `firstVisibleClientId` 下移到 `firstVisibleItemKey` 后,key 的稳定性直接决定
* 滚动锚点是否会漂走 / 卡片是否会 unmount 丢折叠态。任何派生 key 的规则变更
* 都必须先 break 这些用例。
*
* 同时锁住"渲染窗口下移到 render-item 轴"的关键不变量:`allRenderItems` 末尾
* 永远是有效 item(不会是被丢弃的 ask_user / AskUserQuestion / ExitPlanMode /
* orphan tool_result),所以默认窗口 `slice(-INITIAL_ITEMS)` 必然产出非空
* `visibleRenderItems`,U2 同源死锁 bug 在 item 轴下不可能复现。
*
* 测试环境用默认 'node' —— buildRenderItems 是纯函数,MessageStream.tsx 模块
* 加载即便有 React/component 依赖也不应触发 DOM 调用(同款 pattern 见
* prevMessageJumpChip.test.ts —— 直接 import 组件里的 pure helper)。
*/
import { describe, it, expect } from 'vitest';
import { join } from 'node:path';
import {
assistantHasFollowingUserBoundary,
buildRenderItems,
collectDeleteAnchorClientIds,
collectStableLocalFileRefs,
collectTurnFinalAssistantClientIds,
isGeneratedFilesTurnSealed,
findRestorableViewportItemIdx,
renderItemContainsClientId,
groupWorkRuns,
insertForkOriginItem,
isScrollNavigationKey,
pickDeleteCompensationAnchorKey,
isPlanCardVisibleInViewport,
planSessionBelongsToLatestUserTurn,
reuseGeneratedFilesRenderItems,
simplifyBotRenderItems,
shouldBlockAssistantFork,
type RenderItem,
} from '../components/chat/MessageStream';
import { shouldHandleNavigationKey } from '../components/chat/useNavigationKeyListener';
import { handleStreamEvent, EMPTY_SESSION_STATE, type ChatMessage } from '@/lib/makerChatStore';
import type { TurnChangeSetSummary } from '../../shared/turnChangeSet';
// ── 工厂 / 用例构造工具 ────────────────────────────────────────────────────
const mkUser = (id: string, content = '...', files?: ChatMessage['files']): ChatMessage => ({
clientId: id,
role: 'user',
content,
...(files ? { files } : {}),
});
const mkAssistant = (id: string, content = 'ok'): ChatMessage => ({
clientId: id,
role: 'assistant',
content,
});
it('keeps persistent Cindy Make progress visible in the message timeline', () => {
const built = buildRenderItems([
mkUser('u1', '之前的消息'),
{
...mkAssistant('make-card'),
systemCardType: 'cindy-make',
systemCardData: { request: 'fix scrolling', report: { runId: 'run-1' } },
},
]).items;
expect(
built.some((item) => item.type === 'message' && item.message.clientId === 'make-card'),
).toBe(true);
});
it('keeps modal-only Cindy Make cards out of the message timeline', () => {
const built = buildRenderItems([
mkUser('u1', '之前的消息'),
{
...mkAssistant('make-card'),
systemCardType: 'cindy-make',
systemCardData: { modalOnly: true, report: { runId: 'run-1' } },
},
]).items;
expect(built.some((item) => item.type === 'message' && item.message.clientId === 'make-card')).toBe(
false,
);
});
it('shows completion history unless the local composer owns the testing handoff', () => {
const completion: ChatMessage = {
...mkAssistant('completion'), systemCardType: 'cindy-make-complete',
systemCardData: { reportedAt: 123, commit: 'a'.repeat(40) },
};
expect(buildRenderItems([completion]).items.some((item) => renderItemContainsClientId(item, 'completion'))).toBe(true);
expect(buildRenderItems([completion], undefined, undefined, { cindyMakeCompletionInComposer: true }).items).toEqual([]);
expect(completion.systemCardData?.commit).toBe('a'.repeat(40));
});
it.each(['running', 'failed', 'cancelled', 'completed'])(
'moves its own %s preparation out of the timeline without deleting history or hiding other cards',
(status) => {
const preparation: ChatMessage = {
...mkAssistant('make-card'),
systemCardType: 'cindy-make',
systemCardData: {
request: 'fix scrolling',
report: { runId: 'run-1', status, task: { sessionId: 'make-session' } },
},
};
const otherCard: ChatMessage = {
...preparation,
clientId: 'other-card',
systemCardData: { report: { runId: 'run-2', task: { sessionId: 'other-session' } } },
};
const messages = [preparation, otherCard, mkUser('u1', 'original request')];
const built = buildRenderItems(messages, undefined, undefined, {
cindyMakeSessionId: 'make-session',
}).items;
expect(built.some((item) => renderItemContainsClientId(item, 'make-card'))).toBe(false);
expect(built.some((item) => renderItemContainsClientId(item, 'other-card'))).toBe(true);
expect(built.some((item) => renderItemContainsClientId(item, 'u1'))).toBe(true);
expect(messages).toHaveLength(3);
expect(messages[0]).toBe(preparation);
// A source task or standalone history view still offers its existing card.
const original = buildRenderItems(messages).items;
expect(original.some((item) => renderItemContainsClientId(item, 'make-card'))).toBe(true);
},
);
describe('Bot 流式正文呈现', () => {
it('preserves Claude progress and folds it only after the turn seal', () => {
let state = { ...EMPTY_SESSION_STATE, isStreaming: true, messages: [mkUser('u1')] };
const visibleProse = () => simplifyBotRenderItems(
groupWorkRuns(buildRenderItems(state.messages).items, state.isStreaming), state.isStreaming,
).flatMap((item) => item.type === 'message' && item.message.role === 'assistant'
? [item.message.content] : []);
const emitText = (id: string, text: string) => {
state = handleStreamEvent(state, {
sessionId: 'claude-multi-block', type: 'text', persistId: id,
data: { text, isFinal: true },
});
};
emitText('progress', '我查一下:');
state = handleStreamEvent(state, {
sessionId: 'claude-multi-block', type: 'tool_use', persistId: 'tool',
data: { id: 'tool', name: 'Bash', input: { command: 'echo ok' } },
});
state = handleStreamEvent(state, {
sessionId: 'claude-multi-block', type: 'tool_result', persistId: 'result',
data: { toolUseId: 'tool', result: 'ok' },
});
emitText('first', 'first');
expect(visibleProse()).toEqual(['我查一下:', 'first']);
emitText('second', 'second');
expect(visibleProse()).toEqual(['我查一下:', 'first', 'second']);
state = handleStreamEvent(state, {
sessionId: 'claude-multi-block', type: 'text', persistId: 'second',
data: { text: 'second', isFinal: true, isFullText: true },
agentMeta: { turnCompleted: true },
});
expect(visibleProse()).toEqual(['first', 'second']);
state = { ...state, isStreaming: false };
expect(visibleProse()).toEqual(['first', 'second']);
});
it('运行中从首字显示未封口正文,工具留在普通工作组里', () => {
const messages = [
mkUser('u1'),
mkTool('t1', 'Bash'),
mkResult('r1', 'tu-t1'),
{ ...mkAssistant('a1', '正在逐字输出'), isStreaming: true },
];
const built = buildRenderItems(messages).items;
const visible = simplifyBotRenderItems(groupWorkRuns(built, true), true);
expect(
visible.flatMap((item) => (item.type === 'message' ? [item.message.clientId] : [])),
).toEqual(['u1', 'a1']);
// 与普通任务同一个工作组:正文开始后,前面的动作段不再是运行中尾段。
const groups = visible.filter((item) => item.type === 'work_group');
expect(groups).toHaveLength(1);
expect(groups[0].type === 'work_group' && groups[0].children.map((child) => child.type)).toEqual(['tool_segment']);
});
// Contracts: claude-code/translator assistant text blocks; pi/translator
// message_end authoritative full text; codex/translator phase-marked deltas.
// A closed block is not a turn seal: progress stays visible until the final seal.
it.each(['claude-code', 'pi', 'codex'] as const)(
'%s: preserves progress and provider final through the turn seal', (source) => {
let state = { ...EMPTY_SESSION_STATE, isStreaming: true, messages: [mkUser('u1')] };
const project = () => simplifyBotRenderItems(
groupWorkRuns(buildRenderItems(state.messages).items, state.isStreaming), state.isStreaming,
);
const visibleProse = () => project().flatMap((item) =>
item.type === 'message' && item.message.role === 'assistant' ? [item.message.content] : []);
const progressTexts = ['我查一下:', '已找到线索,继续核实', '这是最终答复'];
for (const [index, text] of progressTexts.entries()) {
const persistId = `answer-${index}`;
const providerFinal = source === 'codex' && index === 2;
state = handleStreamEvent(state, {
sessionId: 'bot-event-fixture', type: 'text', persistId,
data: { text: providerFinal ? '这是' : text, isFinal: false,
...(source === 'codex' ? { agentMessageId: persistId, phase: index === 2 ? 'final_answer' : 'commentary' } : {}),
},
});
expect(visibleProse()).toEqual([...progressTexts.slice(0, index), providerFinal ? '这是' : text]);
if (providerFinal) {
state = handleStreamEvent(state, {
sessionId: 'bot-event-fixture', type: 'text', persistId,
data: { text: '最终答复', isFinal: false, agentMessageId: persistId, phase: 'final_answer' },
});
expect(visibleProse()).toEqual(progressTexts);
}
state = handleStreamEvent(state, {
sessionId: 'bot-event-fixture', type: 'text', persistId,
data: { text, isFinal: true,
...(source !== 'claude-code' ? { isFullText: true } : {}),
...(source === 'codex' ? { agentMessageId: persistId, phase: index === 2 ? 'final_answer' : 'commentary' } : {}),
},
});
expect(visibleProse()).toEqual(progressTexts.slice(0, index + 1));
if (index < 2) {
state = handleStreamEvent(state, {
sessionId: 'bot-event-fixture', type: 'tool_use', persistId: `tool-${index}`,
data: { id: `tool-${index}`, name: 'Bash', input: { command: 'echo ok' } },
});
state = handleStreamEvent(state, {
sessionId: 'bot-event-fixture', type: 'tool_result', persistId: `result-${index}`,
data: { toolUseId: `tool-${index}`, result: 'ok' },
});
expect(visibleProse()).toEqual(progressTexts.slice(0, index + 1));
}
}
const streamingFinalKey = project().find(item => item.type === 'message'
&& item.message.clientId === 'answer-2')?.key;
// Main stamps the last assistant at done; the renderer projects that meta.
state = handleStreamEvent(state, {
sessionId: 'bot-event-fixture', type: 'text', persistId: 'answer-2',
data: { text: '这是最终答复', isFinal: true, isFullText: true },
agentMeta: { turnCompleted: true },
});
expect(visibleProse()).toEqual(['这是最终答复']);
if (source === 'codex') {
expect(streamingFinalKey).toBeDefined();
expect(project().find(item => item.type === 'message'
&& item.message.clientId === 'answer-2')?.key).toBe(streamingFinalKey);
}
// Intermediate prose and both tool runs fold into one normal summary group.
const groups = project().filter((item) => item.type === 'work_group');
expect(groups).toHaveLength(1);
expect(groups[0].key.startsWith('work-summary-')).toBe(true);
expect(state.messages.filter((message) => message.role === 'assistant').map((message) => message.content))
.toEqual(['我查一下:', '已找到线索,继续核实', '这是最终答复']);
state = { ...state, isStreaming: false };
expect(visibleProse()).toEqual(['这是最终答复']);
},
);
it('伙伴私聊往返期间持续保留双方消息戳', () => {
const directMessageStamp = (id: string, direction: 'sent' | 'received'): ChatMessage => ({
...mkAssistant(id, ''),
systemCardType: 'bot-direct-message',
systemCardData: {
v: 1,
threadId: 'thread-1',
viewerBotId: 'bot-a',
peerBotId: 'bot-b',
peerBotName: '开发Bot',
direction,
sequence: direction === 'sent' ? 1 : 2,
preview: 'hello',
},
});
const messages = [
mkUser('u1'),
directMessageStamp('dm-sent', 'sent'),
{ ...mkUser('dm-trigger'), isSyntheticTrigger: true },
directMessageStamp('dm-received', 'received'),
{ ...mkAssistant('a1', '正在回复'), isStreaming: true },
];
const visible = simplifyBotRenderItems(
groupWorkRuns(buildRenderItems(messages).items, true),
true,
);
expect(
visible.flatMap((item) => (item.type === 'message' ? [item.message.clientId] : [])),
).toEqual(['u1', 'dm-sent', 'dm-received', 'a1']);
});
});
const mkCompactBoundary = (id: string): ChatMessage => ({
clientId: id,
role: 'assistant',
content: '',
systemCardType: 'compact',
systemCardData: {
trigger: 'auto',
preTokens: 100,
postTokens: 20,
durationMs: 1000,
},
});
const mkTool = (id: string, toolName: string, toolInput: unknown = {}): ChatMessage => ({
clientId: id,
role: 'tool_use',
content: '',
toolUseId: `tu-${id}`,
toolName,
toolInput,
});
const mkResult = (id: string, toolUseId: string, content = 'result'): ChatMessage => ({
clientId: id,
role: 'tool_result',
content,
toolUseId,
});
const mkFileRef = (name: string): NonNullable<ChatMessage['files']>[number] => ({
name,
path: join('repo', name),
});
const mkAskUser = (id: string): ChatMessage => ({
clientId: id,
role: 'ask_user',
content: '',
});
const mkDatedMessageItem = (id: string, createdAt: string): RenderItem => ({
type: 'message',
key: `msg-${id}`,
message: {
clientId: id,
role: 'user',
content: id,
createdAt,
},
});
const mkAnsweredAskUser = (id: string): ChatMessage => ({
clientId: id,
role: 'ask_user',
content: '',
askUserStatus: 'answered',
askUserRequestId: `req-${id}`,
askUserQuestions: [{ question: 'Pick one', options: [] }],
askUserAnswers: { 'Pick one': 'Option A' },
});
const todoInput = (items: Array<{ content: string; status: 'pending' | 'in_progress' | 'completed' }>) => ({
todos: items.map((t, idx) => ({
content: t.content,
status: t.status,
activeForm: t.content,
id: `t${idx}`,
})),
});
const rect = (top: number, bottom: number, left = 0, right = 100) => ({
top,
right,
bottom,
left,
width: right - left,
height: bottom - top,
});
describe('isPlanCardVisibleInViewport', () => {
const viewport = rect(0, 600, 0, 800);
it('treats a partially visible card as visible', () => {
expect(isPlanCardVisibleInViewport(rect(-20, 40), viewport)).toBe(true);
});
it('treats a card covered by the composer overlay as invisible', () => {
expect(isPlanCardVisibleInViewport(rect(520, 580), viewport, 100)).toBe(false);
});
it('keeps the card visible when any pixels remain above the composer overlay', () => {
expect(isPlanCardVisibleInViewport(rect(480, 540), viewport, 100)).toBe(true);
});
});
describe('planSessionBelongsToLatestUserTurn', () => {
it('does not reactivate an older plan when a later user turn starts', () => {
expect(
planSessionBelongsToLatestUserTurn(
[mkUser('u1'), mkTool('plan1', 'update_plan'), mkUser('u2')],
['plan1'],
),
).toBe(false);
});
it('keeps steer rows inside the current plan turn', () => {
expect(
planSessionBelongsToLatestUserTurn(
[mkUser('u1'), mkTool('plan1', 'update_plan'), { ...mkUser('steer'), delivery: 'steer' }],
['plan1'],
),
).toBe(true);
});
it('keeps synthetic continuation rows inside the current plan turn', () => {
expect(
planSessionBelongsToLatestUserTurn(
[
mkUser('u1'),
mkTool('plan1', 'update_plan'),
{ ...mkUser('auto-resume'), isSyntheticTrigger: true },
],
['plan1'],
),
).toBe(true);
});
});
describe('assistant fork boundary detection', () => {
it('allows assistant fork only after the turn has a following user boundary', () => {
const messages = [
mkUser('u1'),
mkAssistant('a1'),
mkTool('t1', 'Bash'),
mkUser('u2'),
mkAssistant('a2'),
mkTool('t2', 'Read'),
];
expect(assistantHasFollowingUserBoundary(messages, 'a1')).toBe(true);
expect(assistantHasFollowingUserBoundary(messages, 'a2')).toBe(false);
});
it('does not treat same-turn steer messages as assistant fork boundaries', () => {
const steer: ChatMessage = { ...mkUser('steer'), delivery: 'steer' };
const messages = [
mkUser('u1'),
mkAssistant('a1'),
mkTool('t1', 'Bash'),
steer,
mkTool('t2', 'Read'),
];
expect(assistantHasFollowingUserBoundary(messages, 'a1')).toBe(false);
});
it('blocks assistant forks in active work-group children without a following user boundary', () => {
const messages = [
mkUser('u1'),
mkAssistant('a-draft'),
mkTool('t1', 'Bash'),
mkAssistant('a-final'),
];
const boundarySet = new Set(
messages
.filter((m) => m.role === 'assistant' && assistantHasFollowingUserBoundary(messages, m.clientId))
.map((m) => m.clientId),
);
expect(shouldBlockAssistantFork(true, messages[1], boundarySet)).toBe(true);
expect(shouldBlockAssistantFork(true, messages[3], boundarySet)).toBe(true);
expect(shouldBlockAssistantFork(false, messages[1], boundarySet)).toBe(false);
});
});
// ── turn 收尾正文检测(action bar 只挂每个 turn 的最后一条 assistant 正文)──
describe('collectTurnFinalAssistantClientIds', () => {
it('marks only the last assistant text of each user turn', () => {
const messages = [
mkUser('u1'),
mkAssistant('a1-draft'),
mkTool('t1', 'Bash'),
mkAssistant('a1-final'),
mkUser('u2'),
mkAssistant('a2-draft'),
mkAssistant('a2-final'),
];
const finals = collectTurnFinalAssistantClientIds(messages);
expect(finals.has('a1-final')).toBe(true);
expect(finals.has('a2-final')).toBe(true);
expect(finals.has('a1-draft')).toBe(false);
expect(finals.has('a2-draft')).toBe(false);
});
it('marks every sealed SDK turn when background work auto-continues without a user boundary', () => {
const messages = [
mkUser('u1'),
{ ...mkAssistant('main-summary'), turnCompleted: true },
mkTool('gate', 'Bash'),
{ ...mkAssistant('gate-followup'), turnCompleted: true },
];
const finals = collectTurnFinalAssistantClientIds(messages);
expect([...finals]).toEqual(expect.arrayContaining(['main-summary', 'gate-followup']));
expect(finals.size).toBe(2);
});
it('does not add an unsealed progress message once the user turn contains sealed answers', () => {
const messages = [
mkUser('u1'),
{ ...mkAssistant('main-summary'), turnCompleted: true },
mkAssistant('unsealed-progress'),
{ ...mkAssistant('gate-followup'), turnCompleted: true },
];
const finals = collectTurnFinalAssistantClientIds(messages);
expect([...finals]).toEqual(expect.arrayContaining(['main-summary', 'gate-followup']));
expect(finals.has('unsealed-progress')).toBe(false);
});
it('does not treat steer messages as turn boundaries', () => {
const steer: ChatMessage = { ...mkUser('steer'), delivery: 'steer' };
const messages = [
mkUser('u1'),
mkAssistant('a1'),
steer,
mkAssistant('a2'),
];
const finals = collectTurnFinalAssistantClientIds(messages);
// steer 不切 turn:a1/a2 同属一个 turn,只有 a2 是收尾正文。
expect(finals.has('a2')).toBe(true);
expect(finals.has('a1')).toBe(false);
});
it('skips system cards and empty texts when picking the turn final', () => {
const systemCard: ChatMessage = {
...mkAssistant('a-card'),
systemCardType: 'status',
};
const messages = [
mkUser('u1'),
mkAssistant('a-text'),
systemCard,
mkAssistant('a-empty', ' '),
];
const finals = collectTurnFinalAssistantClientIds(messages);
expect(finals.has('a-text')).toBe(true);
expect(finals.has('a-card')).toBe(false);
expect(finals.has('a-empty')).toBe(false);
});
it('returns nothing for turns without assistant text', () => {
const messages = [mkUser('u1'), mkTool('t1', 'Bash')];
expect(collectTurnFinalAssistantClientIds(messages).size).toBe(0);
});
it('combined with fork gate: tail-turn final shows bar only after streaming ends', () => {
const messages = [
mkUser('u1'),
mkAssistant('a-mid'),
mkTool('t1', 'Bash'),
mkAssistant('a-final'),
];
const finals = collectTurnFinalAssistantClientIds(messages);
const boundarySet = new Set<string>(); // 尾部 turn,无后续 user 边界
// MessageItem 的挂载条件:isTurnFinal && !shouldBlockAssistantFork(...)。
const showBar = (m: ChatMessage, streaming: boolean) =>
finals.has(m.clientId) && !shouldBlockAssistantFork(streaming, m, boundarySet);
// 任务执行中(流式):所有句子都不出现操作行。
expect(showBar(messages[1], true)).toBe(false);
expect(showBar(messages[3], true)).toBe(false);
// 任务结束:只有收尾正文出现。
expect(showBar(messages[1], false)).toBe(false);
expect(showBar(messages[3], false)).toBe(true);
});
});
describe('isGeneratedFilesTurnSealed', () => {
it('stays open on the latest turn until the tail sub-turn finishes', () => {
const open = [mkUser('u1'), mkTool('write-1', 'Write', { file_path: 'C:/work/a.md' })];
expect(isGeneratedFilesTurnSealed(open, false)).toBe(false);
const sealed = [...open, { ...mkAssistant('done'), turnCompleted: true }];
expect(isGeneratedFilesTurnSealed(sealed, false)).toBe(true);
});
it('does not inherit the previous sub-turn seal after auto-continue', () => {
const afterContinue = [
mkUser('u1'),
{ ...mkAssistant('main-summary'), turnCompleted: true },
mkTool('write-2', 'Write', { file_path: 'C:/work/b.md' }),
];
expect(isGeneratedFilesTurnSealed(afterContinue, false)).toBe(false);
const afterSynthetic = [
mkUser('u1'),
{ ...mkAssistant('main-summary'), turnCompleted: true },
{ ...mkUser('continue'), isSyntheticTrigger: true },
];
expect(isGeneratedFilesTurnSealed(afterSynthetic, false)).toBe(false);
});
it('reseals only after the current tail sub-turn finishes', () => {
const resealed = [
mkUser('u1'),
{ ...mkAssistant('main-summary'), turnCompleted: true },
mkTool('write-2', 'Write', { file_path: 'C:/work/b.md' }),
mkResult('write-2-result', 'tu-write-2'),
{ ...mkAssistant('gate-followup'), turnCompleted: true },
];
expect(isGeneratedFilesTurnSealed(resealed, false)).toBe(true);
});
it('treats an explicit failed tail sub-turn as sealed', () => {
const failedTail = [
mkUser('u1'),
{ ...mkAssistant('main-summary'), turnCompleted: true },
mkTool('write-2', 'Write', { file_path: 'C:/work/b.md' }),
{ ...mkAssistant('failed'), turnCompleted: false },
];
expect(isGeneratedFilesTurnSealed(failedTail, false)).toBe(true);
});
it('seals historical turns that already have a following user boundary', () => {
const historical = [mkUser('u1'), mkTool('write-1', 'Write', { file_path: 'C:/work/a.md' })];
expect(isGeneratedFilesTurnSealed(historical, true)).toBe(true);
});
});
// ── case 1: 流式追加 token 不改变 message item key ────────────────────────
describe('buildRenderItems — key stability', () => {
it('anchors exact change sets to the owning visible user turn', () => {
const firstUser = mkUser('u1');
const secondUser = mkUser('u2');
const firstSet: TurnChangeSetSummary = {
id: 'cs1',
sessionId: 's1',
anchorClientId: 'u1',
provider: 'codex',
providerTurnId: 'turn-1',
cwd: 'C:/work',
state: 'complete',
workspaceState: 'applied',
isReversible: true,
incompleteReasons: [],
createdAt: 1,
completedAt: 2,
files: [{
id: 'turn-1:a.ts',
path: 'a.ts',
oldPath: null,
status: 'modified',
additions: 2,
deletions: 1,
}],
fileCount: 1,
additions: 2,
deletions: 1,
};
const secondSet = {
...firstSet,
id: 'cs2',
anchorClientId: 'u2',
providerTurnId: 'turn-2',
createdAt: 3,
completedAt: 4,
};
const { items } = buildRenderItems(
[firstUser, mkAssistant('a1'), secondUser, mkAssistant('a2')],
undefined,
undefined,
{ turnChangeSets: [firstSet, secondSet] },
);
const cards = items.filter(
(item): item is Extract<RenderItem, { type: 'turn_changes' }> => item.type === 'turn_changes',
);
expect(cards.map((card) => card.key)).toEqual(['turnchanges-cs1', 'turnchanges-cs2']);
expect(cards.map((card) => card.changeSet.id)).toEqual(['cs1', 'cs2']);
expect(items.indexOf(cards[0])).toBeGreaterThan(items.findIndex((item) => item.key === 'msg-a1'));
});
it('places the preceding turn changes before an appended Cindy Make card', () => {
const firstUser = mkUser('u1');
const makeCard = {
...mkAssistant('make-card', ''),
systemCardType: 'cindy-make' as const,
};
const changeSet: TurnChangeSetSummary = {
id: 'cs-before-make',
sessionId: 's1',
anchorClientId: 'u1',
provider: 'codex',
providerTurnId: 'turn-1',
cwd: 'C:/work',
state: 'complete',
workspaceState: 'applied',
isReversible: true,
incompleteReasons: [],
createdAt: 1,
completedAt: 2,
files: [{
id: 'turn-1:a.ts',
path: 'a.ts',
oldPath: null,
status: 'modified',
additions: 1,
deletions: 0,
}],
fileCount: 1,
additions: 1,
deletions: 0,
};
const { items } = buildRenderItems([firstUser, mkAssistant('a1'), makeCard], undefined, undefined, {
turnChangeSets: [changeSet],
});
const changeIndex = items.findIndex((item) => item.type === 'turn_changes');
const cardIndex = items.findIndex((item) => item.key === 'msg-make-card');
expect(changeIndex).toBeGreaterThanOrEqual(0);
expect(cardIndex).toBeGreaterThan(changeIndex);
});
it('hides all zero-file change cards because they have no reviewable content', () => {
const base: TurnChangeSetSummary = {
id: 'cs-base',
sessionId: 's1',
anchorClientId: 'u1',
provider: 'claude-code',
providerTurnId: null,
cwd: 'C:/work',
state: 'partial',
workspaceState: 'applied',
isReversible: false,
incompleteReasons: [],
createdAt: 1,
completedAt: 2,
files: [],
fileCount: 0,
additions: 0,
deletions: 0,
};
const opaque: TurnChangeSetSummary = {
...base,
id: 'cs-noise',
incompleteReasons: ['opaque-tool', 'turn-failed', 'concurrent-workspace'],
};
const truncated: TurnChangeSetSummary = {
...base,
id: 'cs-too-large',
incompleteReasons: ['opaque-tool', 'diff-too-large'],
createdAt: 3,
completedAt: 4,
};
const escaped: TurnChangeSetSummary = {
...base,
id: 'cs-escape',
incompleteReasons: ['outside-workspace'],
createdAt: 5,
completedAt: 6,
};
const { items } = buildRenderItems(
[mkUser('u1'), mkAssistant('a1'), mkUser('u2')],
undefined,
undefined,
{ turnChangeSets: [opaque, truncated, escaped] },
);
const cards = items.filter(
(item): item is Extract<RenderItem, { type: 'turn_changes' }> => item.type === 'turn_changes',
);
expect(cards).toEqual([]);
});
it('keeps opaque command artifacts as fallback chips without duplicating exact files', () => {
const messages = [
mkUser('u1'),
mkTool('bash-1', 'Bash', { command: 'python gen.py > C:/work/out/report.xlsx' }),
mkResult('bash-result', 'tu-bash-1'),
mkUser('u2'),
];
const exact: TurnChangeSetSummary = {
id: 'cs-opaque',
sessionId: 's1',
anchorClientId: 'u1',
provider: 'codex',
providerTurnId: 'turn-1',
cwd: 'C:/work',
state: 'partial',
workspaceState: 'applied',
isReversible: false,
incompleteReasons: ['opaque-tool'],
createdAt: 1,
completedAt: 2,
files: [],
fileCount: 0,
additions: 0,
deletions: 0,
};
const fallback = buildRenderItems(messages, undefined, undefined, {
workingDir: 'C:/work',
turnChangeSets: [exact],
}).items.filter((item): item is Extract<RenderItem, { type: 'generated_files' }> => item.type === 'generated_files');
expect(fallback).toHaveLength(1);
expect(fallback[0]?.files[0]?.name).toBe('report.xlsx');
const exactFile = {
...exact,
files: [{
id: 'turn-1:out/report.xlsx',
path: 'out/report.xlsx',
oldPath: null,
status: 'added' as const,
additions: 1,
deletions: 0,
}],
fileCount: 1,
additions: 1,
};
const deduped = buildRenderItems(messages, undefined, undefined, {
workingDir: 'C:/work',
turnChangeSets: [exactFile],
}).items.filter((item): item is Extract<RenderItem, { type: 'generated_files' }> => item.type === 'generated_files');
expect(deduped).toHaveLength(0);
});
// 真机验收:伙伴对话里只看到工程 diff 卡「已更改 1 个文件 +137 −0 撤销/审查」,
// 交付物卡一次都没出现。根因就在这里 —— changeSet 把本轮文件从产出候选里排它
// 剔除,再自己渲染成 turn_changes。伙伴会话的方向是反的。
describe('bot sessions hand the turn over to deliverables', () => {
const messages = [
mkUser('u1'),
mkTool('bash-1', 'Bash', { command: 'make report' }),
mkResult('bash-result', 'tu-bash-1'),
mkUser('u2'),
];
const changeSet: TurnChangeSetSummary = {
id: 'cs-bot',
sessionId: 's1',
anchorClientId: 'u1',
provider: 'claude-code',
providerTurnId: null,
cwd: 'C:/work',
state: 'complete',
workspaceState: 'applied',
isReversible: true,
incompleteReasons: [],
createdAt: 1,
completedAt: 2,
files: [
{
id: 'turn-1:out/report.pdf',
path: 'out/report.pdf',
oldPath: null,
status: 'added',
additions: 137,
deletions: 0,
},
{
id: 'turn-1:src/main.ts',
path: 'src/main.ts',
oldPath: null,
status: 'modified',
additions: 3,
deletions: 1,
},
],
fileCount: 2,
additions: 140,
deletions: 1,
};
const build = (botSessionId?: string) =>
buildRenderItems(messages, undefined, undefined, {
workingDir: 'C:/work',
turnChangeSets: [changeSet],
...(botSessionId ? { botSessionId } : {}),
}).items;
it('drops the engineering diff card and promotes changeSet creates to deliverables', () => {
const items = build('sess-bot');
expect(items.filter((item) => item.type === 'turn_changes')).toEqual([]);
const generated = items.filter(
(item): item is Extract<RenderItem, { type: 'generated_files' }> =>
item.type === 'generated_files',
);
expect(generated).toHaveLength(1);
expect(generated[0]?.files.map((file) => file.name)).toEqual(['report.pdf']);
// checkpoint 的新建是结构化实锤,与文件工具新建同级(不降级成 command 候选)。
expect(generated[0]?.files[0]?.source).toBe('tool');
});
it('never turns an edited file into a deliverable', () => {
const generated = build('sess-bot').filter(
(item): item is Extract<RenderItem, { type: 'generated_files' }> =>
item.type === 'generated_files',
);
expect(generated[0]?.files.some((file) => file.name === 'main.ts')).toBe(false);
});
it('leaves ordinary tasks on the diff card, unchanged', () => {
const items = build();
expect(items.filter((item) => item.type === 'turn_changes')).toHaveLength(1);
expect(items.filter((item) => item.type === 'generated_files')).toEqual([]);
});
});
it('reuses the generated-files item when only unrelated messages change', () => {
const messages = [
mkUser('u1'),
mkTool('write-1', 'Write', { file_path: 'C:/work/report.md', content: 'x' }),
mkResult('write-result', 'tu-write-1'),
mkAssistant('a1', 'done'),
];
const first = buildRenderItems(messages, undefined, undefined, { workingDir: 'C:/work' });
const cache = new Map();
const reusedOnce = reuseGeneratedFilesRenderItems(first.items, cache);
const second = buildRenderItems(
[...messages.slice(0, -1), { ...messages[3], content: 'done plus more' }],
undefined,
undefined,
{ workingDir: 'C:/work' },
);
const reusedTwice = reuseGeneratedFilesRenderItems(second.items, cache);
const firstCard = reusedOnce.find(
(item): item is Extract<RenderItem, { type: 'generated_files' }> =>
item.type === 'generated_files',
);
const secondCard = reusedTwice.find(
(item): item is Extract<RenderItem, { type: 'generated_files' }> =>
item.type === 'generated_files',
);
expect(firstCard).toBeDefined();
expect(secondCard).toBe(firstCard);
});
it('unseals generated files when the same visible turn auto-continues after turnCompleted', () => {
const workingDir = 'C:/work';
const firstWrite = mkTool('write-1', 'Write', { file_path: 'C:/work/a.md', content: 'x' });
const firstResult = mkResult('write-1-result', 'tu-write-1');
const sealed = buildRenderItems(
[mkUser('u1'), firstWrite, firstResult, { ...mkAssistant('main-summary'), turnCompleted: true }],
undefined,
undefined,
{ workingDir },
).items.find(
(item): item is Extract<RenderItem, { type: 'generated_files' }> =>
item.type === 'generated_files',
);
const continued = buildRenderItems(
[
mkUser('u1'),
firstWrite,
firstResult,
{ ...mkAssistant('main-summary'), turnCompleted: true },
mkTool('write-2', 'Write', { file_path: 'C:/work/b.md', content: 'y' }),
],
undefined,
undefined,
{ workingDir },
).items.find(
(item): item is Extract<RenderItem, { type: 'generated_files' }> =>
item.type === 'generated_files',
);
const resealed = buildRenderItems(
[
mkUser('u1'),
firstWrite,
firstResult,
{ ...mkAssistant('main-summary'), turnCompleted: true },
mkTool('write-2', 'Write', { file_path: 'C:/work/b.md', content: 'y' }),
mkResult('write-2-result', 'tu-write-2'),
{ ...mkAssistant('gate-followup'), turnCompleted: true },
],
undefined,
undefined,
{ workingDir },
).items.find(
(item): item is Extract<RenderItem, { type: 'generated_files' }> =>
item.type === 'generated_files',
);
expect(sealed?.turnSealed).toBe(true);
expect(continued?.turnSealed).toBe(false);
expect(resealed?.turnSealed).toBe(true);
});
it('streaming token append to an assistant message keeps the same item key', () => {
const m1: ChatMessage = { ...mkAssistant('a1', 'partial'), isStreaming: true };
const before = buildRenderItems([mkUser('u1'), m1]);
const m1Updated: ChatMessage = { ...m1, content: 'partial token2' };
const after = buildRenderItems([mkUser('u1'), m1Updated]);
expect(before.items.at(-1)?.key).toBe('msg-a1');
expect(after.items.at(-1)?.key).toBe('msg-a1');
});
// ── case 2: 同 segment 内新 tool_use 加入不改变 segment key ─────────────
it('new tool_use appended to existing segment keeps segment key stable (toolCalls[0] unchanged)', () => {
const before = buildRenderItems([mkUser('u1'), mkTool('t1', 'Bash')]);
const after = buildRenderItems([mkUser('u1'), mkTool('t1', 'Bash'), mkTool('t2', 'Read')]);
const beforeSeg = before.items.find((it): it is Extract<RenderItem, { type: 'tool_segment' }> => it.type === 'tool_segment');
const afterSeg = after.items.find((it): it is Extract<RenderItem, { type: 'tool_segment' }> => it.type === 'tool_segment');
expect(beforeSeg?.key).toBe('seg-t1');
expect(afterSeg?.key).toBe('seg-t1');
expect(afterSeg?.toolCalls.length).toBe(2);
});
it('agent task tools render as dedicated task items instead of joining tool segments', () => {
const task = mkTool('task1', 'Agent', { description: 'Review auth flow', prompt: 'Check auth' });
const bash = mkTool('bash1', 'Bash');
const updates = new Map([
[
'tu-task1',
{
provider: 'claude-code' as const,
taskId: 'task-1',
parentToolUseId: 'tu-task1',
status: 'running' as const,
title: 'Review auth flow',
},
],
]);
const { items } = buildRenderItems([mkUser('u1'), task, mkResult('r1', 'tu-task1', 'done'), bash], updates);
expect(items.map((it) => it.type)).toEqual(['message', 'agent_task', 'tool_segment']);
const taskItem = items[1] as Extract<RenderItem, { type: 'agent_task' }>;
expect(taskItem.key).toBe('task-task1');
expect(taskItem.update?.status).toBe('running');
expect(taskItem.result).toBe('done');
const segment = items[2] as Extract<RenderItem, { type: 'tool_segment' }>;
expect(segment.toolCalls.map((m) => m.clientId)).toEqual(['bash1']);
});
it('agent task tools preserve adjacent legacy results without toolUseId', () => {
const task: ChatMessage = {
...mkTool('task1', 'Agent', { description: 'Review auth flow', prompt: 'Check auth' }),
toolUseId: undefined,
};
const legacyResult: ChatMessage = {
clientId: 'r1',
role: 'tool_result',
content: 'legacy task summary',
};
const { items } = buildRenderItems([mkUser('u1'), task, legacyResult]);
expect(items.map((it) => it.type)).toEqual(['message', 'agent_task']);
const taskItem = items[1] as Extract<RenderItem, { type: 'agent_task' }>;
expect(taskItem.result).toBe('legacy task summary');
});
it('agent task updates without a matching tool_use still render as task items', () => {
const updates = new Map([
[
'task-1',
{
provider: 'claude-code' as const,
taskId: 'task-1',
status: 'completed' as const,
title: 'Inspect files',
summary: 'Found the relevant renderer path',
createdAt: '2026-06-24T00:00:02.000Z',
},
],
]);
const { items } = buildRenderItems([
{ ...mkUser('u1'), createdAt: '2026-06-24T00:00:01.000Z' },
{ ...mkAssistant('a1', 'done'), createdAt: '2026-06-24T00:00:03.000Z' },
], updates);
expect(items.map((it) => it.type)).toEqual(['message', 'agent_task', 'message']);
const taskItem = items[1] as Extract<RenderItem, { type: 'agent_task' }>;
expect(taskItem.key).toBe('task-update-task-1');
expect(taskItem.toolCall).toBeUndefined();
expect(taskItem.update?.summary).toBe('Found the relevant renderer path');
});
// ── case 3:plan session 在流内只产一张 stable-key 卡 ─────────────────────
// session 分组 / 输入解析语义的覆盖在 @cindy/maker-shared 的 messageRender.test.ts;
// 这里只锁桌面时间线行为:多步骤计划插卡,单步骤计划继续保持紧凑。
it('inserts a multi-step plan card between surrounding tool segments', () => {
const seq: ChatMessage[] = [
mkUser('u1'),
mkTool('t1', 'Bash'),
mkTool(
'tw1',
'TodoWrite',
todoInput([
{ content: 'Inspect state', status: 'completed' },
{ content: 'Patch renderer', status: 'in_progress' },
]),
),
mkResult('r-tw1', 'tu-tw1', 'ok'),
mkTool('t2', 'Read'),
mkAssistant('a1', 'done'),
];
const { items } = buildRenderItems(seq);
expect(items.map((it) => it.type)).toEqual([
'message',
'tool_segment',
'agent_plan',
'tool_segment',
'message',
]);
const plan = items[2] as Extract<RenderItem, { type: 'agent_plan' }>;
expect(plan.key).toBe('todo-tw1');
expect(plan.sourceClientIds).toEqual(['tw1']);
expect(plan.todos.map((todo) => todo.content)).toEqual(['Inspect state', 'Patch renderer']);
});
it('updates one logical plan card at the latest row while keeping its first key', () => {
const first = mkTool('plan1', 'update_plan', {
plan: [
{ step: 'Read code', status: 'in_progress' },
{ step: 'Patch renderer', status: 'pending' },
],
});
const second = mkTool('plan2', 'update_plan', {
plan: [
{ step: 'Read code', status: 'completed' },
{ step: 'Patch renderer', status: 'in_progress' },
],
});
const { items } = buildRenderItems([
mkUser('u1'),
first,
mkTool('t1', 'Read'),
second,
mkAssistant('a1', 'On it'),
]);
const plans = items.filter(
(item): item is Extract<RenderItem, { type: 'agent_plan' }> => item.type === 'agent_plan',
);
expect(plans).toHaveLength(1);
expect(plans[0].key).toBe('todo-plan1');
expect(plans[0].sourceClientIds).toEqual(['plan1', 'plan2']);
expect(plans[0].todos).toEqual([
{ content: 'Read code', status: 'completed' },
{ content: 'Patch renderer', status: 'in_progress' },
]);
});
it('renders a reconstructed multi-step Task plan as one inline card', () => {
const first = mkTool('tc1', 'TaskCreate', { subject: 'Collect logs' });
const second = mkTool('tc2', 'TaskCreate', { subject: 'Run tests' });
const { items } = buildRenderItems([
mkUser('u1'),
first,
mkResult('r-tc1', 'tu-tc1', 'Task #1 created successfully: Collect logs'),
second,
mkResult('r-tc2', 'tu-tc2', 'Task #2 created successfully: Run tests'),
mkAssistant('a1', 'On it'),
]);
expect(items.map((it) => it.type)).toEqual(['message', 'agent_plan', 'message']);
const plan = items[1] as Extract<RenderItem, { type: 'agent_plan' }>;
expect(plan.key).toBe('todo-tc1');
expect(plan.todos.map((todo) => todo.content)).toEqual(['Collect logs', 'Run tests']);
});
it('keeps a single-step plan suppressed without splitting the surrounding tool segment', () => {
const { items } = buildRenderItems([
mkUser('u1'),
mkTool('t1', 'Bash'),
mkTool('tw1', 'TodoWrite', todoInput([{ content: 'Only step', status: 'pending' }])),
mkResult('r-tw1', 'tu-tw1', 'ok'),
mkTool('t2', 'Read'),
mkAssistant('a1', 'done'),
]);
expect(items.map((it) => it.type)).toEqual(['message', 'tool_segment', 'message']);
const segment = items[1] as Extract<RenderItem, { type: 'tool_segment' }>;
expect(segment.toolCalls.map((tool) => tool.clientId)).toEqual(['t1', 't2']);
});
it.each(['none', 'TodoWrite', 'update_plan'])(
'keeps ordinary history and %s plans unchanged in an incomplete window', (source) => {
const messages: ChatMessage[] = [mkUser('u1')];
for (let index = 0; index < 80; index += 1) {
messages.push(mkTool(`read-${index}`, 'Read'), mkResult(`result-${index}`, `tu-read-${index}`));
}
if (source === 'TodoWrite') {
messages.push(mkTool('plan', source, { todos: [
{ content: 'Inspect', status: 'completed' },
{ content: 'Verify', status: 'pending' },
] }));
} else if (source === 'update_plan') {
messages.push(mkTool('plan', source, { plan: [
{ step: 'Inspect', status: 'completed' },
{ step: 'Verify', status: 'pending' },
] }));
}
messages.push(mkAssistant('answer', 'Done'));
const complete = buildRenderItems(messages);
const partial = buildRenderItems(messages, undefined, undefined, { historyWindowIncomplete: true });
expect(partial).toEqual(complete);
expect(partial.items.filter((item) => item.type === 'agent_plan')).toHaveLength(source === 'none' ? 0 : 1);
},
);
it('keeps independent Task plans with delayed results across user turns', () => {
const messages: ChatMessage[] = [];
const lateResults: ChatMessage[] = [];
for (let turn = 0; turn < 6; turn += 1) {
messages.push(mkUser(`user-${turn}`), mkTool(`plan-${turn}`, 'TaskList'));
lateResults.push(mkResult(`result-${turn}`, `tu-plan-${turn}`, JSON.stringify({ tasks: [
{ id: `${turn}-1`, subject: `Inspect ${turn}`, status: 'in_progress' },
{ id: `${turn}-2`, subject: `Verify ${turn}`, status: 'pending' },
] })));
messages.push(mkAssistant(`answer-${turn}`, 'Progress'));
}
messages.push(...lateResults.reverse());
const plans = buildRenderItems(messages, undefined, undefined, { historyWindowIncomplete: true })
.items.filter((item) => item.type === 'agent_plan');
expect(plans.map((plan) => ({ key: plan.key, todos: plan.todos }))).toEqual(
Array.from({ length: 6 }, (_, turn) => ({
key: `todo-plan-${turn}`,
todos: [
{ content: `Inspect ${turn}`, status: 'in_progress' },
{ content: `Verify ${turn}`, status: 'pending' },
],
})),
);
});
it('waits for older Task history before showing a partial inline plan', () => {
const first = mkTool('tc2', 'TaskCreate', { subject: 'Fix renderer' });
const second = mkTool('tc3', 'TaskCreate', { subject: 'Run tests' });
const messages = [
first,
mkResult('r-tc2', 'tu-tc2', 'Task #2 created successfully: Fix renderer'),
second,
mkResult('r-tc3', 'tu-tc3', 'Task #3 created successfully: Run tests'),
];
expect(
buildRenderItems(messages, undefined, undefined, { historyWindowIncomplete: true }).items,
).toEqual([]);
expect(
buildRenderItems(messages, undefined, undefined, {
historyWindowIncomplete: false,
}).items.map((item) => item.type),
).toEqual(['agent_plan']);
});
it('filters an earlier partial Task card when a later plan session is resolved', () => {
const messages = [
mkTool('tc2', 'TaskCreate', { subject: 'Fix renderer' }),
mkResult('r-tc2', 'tu-tc2', 'Task #2 created successfully: Fix renderer'),
mkTool('tc3', 'TaskCreate', { subject: 'Run tests' }),
mkResult('r-tc3', 'tu-tc3', 'Task #3 created successfully: Run tests'),
mkUser('u2', 'Start a different plan'),
mkTool('plan2', 'update_plan', {
plan: [
{ step: 'Read code', status: 'in_progress' },
{ step: 'Patch renderer', status: 'pending' },
],
}),
];
const plans = buildRenderItems(messages, undefined, undefined, {
historyWindowIncomplete: true,
}).items.filter(
(item): item is Extract<RenderItem, { type: 'agent_plan' }> => item.type === 'agent_plan',
);
expect(plans).toHaveLength(1);
expect(plans[0].key).toBe('todo-plan2');
});
it('keeps an authoritative TaskList card when its result follows the insertion row', () => {
const messages = [
mkUser('u1', 'Show the current tasks'),
mkTool('task-list', 'TaskList'),
mkResult(
'r-task-list',
'tu-task-list',
JSON.stringify({
tasks: [
{ id: '1', subject: 'Inspect renderer', status: 'in_progress' },
{ id: '2', subject: 'Run tests', status: 'pending' },
],
}),
),
];
const plans = buildRenderItems(messages, undefined, undefined, {
historyWindowIncomplete: true,
}).items.filter(
(item): item is Extract<RenderItem, { type: 'agent_plan' }> => item.type === 'agent_plan',
);
expect(plans).toHaveLength(1);
expect(plans[0]).toMatchObject({
key: 'todo-task-list',
todos: [
{ content: 'Inspect renderer', status: 'in_progress' },
{ content: 'Run tests', status: 'pending' },
],
});
});
it('keeps late Task results attached after a long history prefix', () => {
const messages: ChatMessage[] = [
mkUser('u1', 'Show the current tasks'),
mkTool('task-list', 'TaskList'),
];
for (let index = 0; index < 200; index += 1) {
messages.push(mkAssistant(`history-${index}`, `history ${index}`));
}
messages.push(mkResult(
'r-task-list-late',
'tu-task-list',
JSON.stringify({
tasks: [
{ id: '1', subject: 'Inspect renderer', status: 'in_progress' },
{ id: '2', subject: 'Run tests', status: 'pending' },
],
}),
));
const plans = buildRenderItems(messages, undefined, undefined, {
historyWindowIncomplete: true,
}).items.filter(
(item): item is Extract<RenderItem, { type: 'agent_plan' }> => item.type === 'agent_plan',
);
expect(plans).toHaveLength(1);
expect(plans[0]?.todos).toEqual([
{ content: 'Inspect renderer', status: 'in_progress' },
{ content: 'Run tests', status: 'pending' },
]);
});
it('black-box: repeated history-window renders keep one stable plan result', () => {
const messages: ChatMessage[] = [
mkUser('u-blackbox', 'Review the task list'),
mkTool('task-list', 'TaskList'),
];
for (let index = 0; index < 200; index += 1) {
messages.push(mkAssistant(`blackbox-history-${index}`, `history ${index}`));
}
messages.push(mkResult(
'r-task-list-blackbox',
'tu-task-list',
JSON.stringify({
tasks: [
{ id: 'blackbox-task-1', subject: 'Keep the task visible', status: 'in_progress' },
{ id: 'blackbox-task-2', subject: 'Keep the second task visible', status: 'pending' },
],
}),
));
const render = () => buildRenderItems(messages, undefined, undefined, {
historyWindowIncomplete: true,
}).items;
const first = render();
const second = render();
const summarize = (items: RenderItem[]) => items.map((item) => {
if (item.type !== 'agent_plan') return item.type;
return { type: item.type, key: item.key, todos: item.todos };
});
expect(summarize(second)).toEqual(summarize(first));
expect(second.filter((item) => item.type === 'agent_plan')).toHaveLength(1);
});
it('renders a new Task plan after a real user turn despite an older orphan update', () => {
const messages = [
mkTool('old-update', 'TaskUpdate', { taskId: 'old', status: 'in_progress' }),
mkUser('u2', 'Start a new plan'),
mkTool('new-task-1', 'TaskCreate', { subject: 'Inspect renderer' }),
mkResult(
'r-new-task-1',
'tu-new-task-1',
'Task #new-1 created successfully: Inspect renderer',
),
mkTool('new-task-2', 'TaskCreate', { subject: 'Run tests' }),
mkResult(
'r-new-task-2',
'tu-new-task-2',
'Task #new-2 created successfully: Run tests',
),
];
const plans = buildRenderItems(messages, undefined, undefined, {
historyWindowIncomplete: true,
}).items.filter(
(item): item is Extract<RenderItem, { type: 'agent_plan' }> => item.type === 'agent_plan',
);
expect(plans).toHaveLength(1);
expect(plans[0]).toMatchObject({
key: 'todo-new-task-1',
todos: [
{ content: 'Inspect renderer', status: 'pending' },
{ content: 'Run tests', status: 'pending' },
],
});
});
it('recovers an old plan anchor after prepend changes the session key', () => {
const oldWindow = buildRenderItems([
mkTool('plan2', 'update_plan', {
plan: [
{ step: 'Read code', status: 'completed' },
{ step: 'Patch renderer', status: 'in_progress' },
],
}),
]).items;
const prepended = buildRenderItems([
mkTool('plan1', 'update_plan', {
plan: [
{ step: 'Read code', status: 'in_progress' },
{ step: 'Patch renderer', status: 'pending' },
],
}),
mkTool('plan2', 'update_plan', {
plan: [
{ step: 'Read code', status: 'completed' },
{ step: 'Patch renderer', status: 'in_progress' },
],
}),
]).items;
expect(oldWindow[0]?.key).toBe('todo-plan2');
expect(prepended[0]?.key).toBe('todo-plan1');
expect(findRestorableViewportItemIdx(prepended, 'todo-plan2')).toBe(0);
});
// ── case 4: orphan tool_result 补到末尾不产生新 item / 不重 key ─────────
it('orphan tool_result appended to tail does not introduce a new item or duplicate key', () => {
const tu = mkTool('t1', 'Bash');
const before = buildRenderItems([mkUser('u1'), tu]);
const orphan = mkResult('r-late', 'tu-t1', 'late result');
const after = buildRenderItems([mkUser('u1'), tu, orphan]);
// item count 不变 —— orphan tool_result 在 Pass 2 被 skip,只是把 result 灌入
// 已有 segment 的 resultMap (主路径走 resultByToolUseId)。
expect(after.items.length).toBe(before.items.length);
const afterSeg = after.items.find((it): it is Extract<RenderItem, { type: 'tool_segment' }> => it.type === 'tool_segment');
expect(afterSeg?.key).toBe('seg-t1');
expect(afterSeg?.resultMap.get('t1')).toBe('late result');
});
// ── case 5: tool_segment 关闭后再开新 segment,两个 key 不同 ────────────
it('two tool_segments separated by text get two distinct keys', () => {
const seq: ChatMessage[] = [
mkUser('u1'),
mkTool('t1', 'Bash'),
mkAssistant('a1'), // 关闭 segment 1
mkTool('t2', 'Read'), // 开 segment 2
];
const { items } = buildRenderItems(seq);
const segs = items.filter((it): it is Extract<RenderItem, { type: 'tool_segment' }> => it.type === 'tool_segment');
expect(segs.length).toBe(2);
expect(segs[0].key).toBe('seg-t1');
expect(segs[1].key).toBe('seg-t2');
expect(segs[0].key).not.toBe(segs[1].key);
});
// ── case 6: tool_media key 显式锁规则 (`media-${segment 首 toolCall id}`) ────
// 防御:tool_media 跟其派生来源 segment 共享首 toolCall id,只是 prefix 不同 —
// 任何 key 派生规则的退化(例如改成 `media-${url}`)都会让 result 流式后到时
// 强制 unmount 卡片。
// ── case 5c: DB prepend 让 tool_segment 向前合并,老 key 失效但 toolCall 仍在新段内 ──
// 模拟用户卡死场景的核心数据形态(完整恢复逻辑在 MessageStream 的 visibleRenderItems
// useMemo / expandWindow 里通过 recoverLostAnchorIdx 走;这里锁住 buildRenderItems
// 产出的真实数据满足 recover 前提:老 toolCall 仍在新段的 toolCalls 数组里)。
it('after DB prepend ends with tool_use, old segment toolCalls[0] changes BUT the old toolCall still exists in new segment', () => {
// 现有数据:已加载的最早消息恰好是 tool_use 开头(没有前置 assistant/user)
const beforePrepend: ChatMessage[] = [mkTool('t1', 'Bash'), mkTool('t2', 'Read')];
const beforeItems = buildRenderItems(beforePrepend).items;
const oldSegment = beforeItems.find(
(it): it is Extract<RenderItem, { type: 'tool_segment' }> => it.type === 'tool_segment',
);
expect(oldSegment?.key).toBe('seg-t1');
// DB prepend:返回的更老消息末尾又是 tool_use(无 boundary message 分隔)
const prepended: ChatMessage[] = [mkAssistant('a-pre', 'pre'), mkTool('t0-older', 'Edit')];
const afterPrepend = [...prepended, ...beforePrepend];
const afterItems = buildRenderItems(afterPrepend).items;
// 新段把 t0-older 一起吸进来,key 变成 seg-t0-older
const newSegment = afterItems.find(
(it): it is Extract<RenderItem, { type: 'tool_segment' }> => it.type === 'tool_segment',
);
expect(newSegment?.key).toBe('seg-t0-older');
expect(newSegment?.key).not.toBe(oldSegment?.key); // 老 key 失效 — 这是 bug 触发条件
// 关键不变量:老 toolCall t1 仍在新段的 toolCalls 数组里 — recover 函数靠这点
// 反解 lost key 后能找回 anchor。
expect(newSegment?.toolCalls.some((tc) => tc.clientId === 't1')).toBe(true);
expect(newSegment?.toolCalls.some((tc) => tc.clientId === 't2')).toBe(true);
});
it('tool_media key derives from segment first toolCall id (stable, separate prefix from segment)', () => {
// image_generate 工具产出带 xdt_image_url 的 tool_result — extractToolResultMedia
// 期待合法 JSON + `xdt-image://` 协议前缀。
const tu = mkTool('img1', 'image_generate');
const tr = mkResult(
'imgr1',
'tu-img1',
JSON.stringify({ xdt_image_url: 'xdt-image://art/abc.png' }),
);
const { items } = buildRenderItems([mkUser('u1'), tu, tr, mkAssistant('a1')]);
const seg = items.find((it): it is Extract<RenderItem, { type: 'tool_segment' }> => it.type === 'tool_segment');
const media = items.find((it): it is Extract<RenderItem, { type: 'tool_media' }> => it.type === 'tool_media');
expect(seg?.key).toBe('seg-img1');
expect(media?.key).toBe('media-img1');
// 同源不同 prefix —— 不会撞 key
expect(seg?.key).not.toBe(media?.key);
});
it('uses tool media as fallback and suppresses it only for an inline image in the same turn', () => {
const url = 'cindy-media://blobs/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.png';
const firstTool = mkTool('img1', 'image_generate');
const firstResult = mkResult(
'imgr1',
'tu-img1',
JSON.stringify({ xdt_image_url: url }),
);
const secondTool = mkTool('img2', 'image_generate');
const secondResult = mkResult(
'imgr2',
'tu-img2',
JSON.stringify({ xdt_image_url: url }),
);
const { items } = buildRenderItems([
mkUser('u1'),
firstTool,
firstResult,
mkAssistant('a1', ``),
mkUser('u2'),
secondTool,
secondResult,
// 纯文本 URI 不是图片展示,不能压掉可靠兜底;上一轮的 Markdown 也不能跨轮去重。
mkAssistant('a2', `文件地址:${url}`),
]);
const mediaKeys = items
.filter((item): item is Extract<RenderItem, { type: 'tool_media' }> => item.type === 'tool_media')
.map((item) => item.key);
expect(mediaKeys).toEqual(['media-img2']);
});
// ── case 7: 末尾混合丢弃类型 + 有效 message,末尾仍是有效 item ──────────
// 锁住"删自愈 effect 安全"的论证:渲染窗口下移到 item 轴后,allRenderItems
// 末尾永远是有效 item,U2 "末尾窗口全 orphan / 全被丢弃" 死锁不可能复现。
it('tail of allRenderItems is never a dropped type (ask_user / AskUserQuestion / orphan tool_result)', () => {
const askUserTool = mkTool('aq1', 'AskUserQuestion');
const askUserResult = mkResult('aqr1', 'tu-aq1');
const orphanResult = mkResult('orphan1', 'tu-does-not-exist');
const seq: ChatMessage[] = [
mkUser('u1'),
mkAssistant('a1'),
askUserTool, // 丢弃
askUserResult, // 跟着被吃
mkAskUser('ask-msg-1'), // 丢弃
mkAssistant('a2', 'final valid message'),
mkAskUser('ask-msg-2'), // 丢弃
orphanResult, // 丢弃(orphan)
];
const { items } = buildRenderItems(seq);
// 末尾必须是有效 message item — 不是 ask_user / orphan
const tail = items.at(-1);
if (tail?.type !== 'message') {
throw new Error('tail render item must be a message');
}
expect(tail.message.role).toBe('assistant');
expect(tail.message.clientId).toBe('a2');
});
// ── case 8: answered ask_user 进消息流(用户选择回显),pending/未答仍被丢弃 ──
// 锁住"只过滤未回答的 ask_user"这条规则:回答完的 ask_user 必须以 message item
// 进流(由 AskUserQuestionBubble 渲染成用户回复气泡),而 undefined/pending 态
// 仍然被丢弃(留在底部 overlay)。
it('answered ask_user becomes a message item; undefined-status ask_user stays dropped', () => {
const seq: ChatMessage[] = [
mkUser('u1'),
mkAskUser('pending-1'), // 未答 → 丢弃
mkAnsweredAskUser('answered-1'), // 已答 → 进流
mkAssistant('a1', 'next step'),
];
const { items } = buildRenderItems(seq);
const answered = items.find(
(it): it is Extract<RenderItem, { type: 'message' }> =>
it.type === 'message' && it.message.clientId === 'answered-1',
);
if (!answered) {
throw new Error('answered ask_user render item not found');
}
expect(answered.message.role).toBe('ask_user');
expect(answered.key).toBe('msg-answered-1');
// 未答的那条不产生任何 item
expect(
items.some((it) => it.type === 'message' && it.message.clientId === 'pending-1'),
).toBe(false);
});
});
// ── groupWorkRuns — 工作过程折叠组 ─────────────────────────────────────────
describe('groupWorkRuns — work-group collapsing', () => {
const mkThinking = (id: string, createdAt?: string): ChatMessage => ({
clientId: id,
role: 'thinking',
content: 'reasoning...',
isStreaming: false,
thinkingDurationMs: 1000,
...(createdAt ? { createdAt } : {}),
});
const withTs = (m: ChatMessage, iso: string): ChatMessage => ({ ...m, createdAt: iso });
const build = (
messages: ChatMessage[],
streaming: boolean,
taskUpdates?: Parameters<typeof buildRenderItems>[1],
) => groupWorkRuns(buildRenderItems(messages, taskUpdates).items, streaming);
it('marks a run complete as soon as assistant text follows, even while the turn streams', () => {
const items = build(
[mkUser('u1'), mkThinking('th1'), mkTool('t1', 'Bash'), mkAssistant('a1', 'done')],
true,
);
// u1 message, work_group, a1 message
expect(items.map((it) => it.type)).toEqual(['message', 'work_group', 'message']);
const group = items[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.key).toBe('work-th1'); // 首子项(thinking)的 clientId
expect(group.children.map((c) => c.type)).toEqual(['message', 'tool_segment']);
expect(group.isStreaming).toBe(false);
});
it('groups the trailing run immediately while streaming and keeps live metadata', () => {
const items = build(
[
mkUser('u1'),
mkAssistant('a1', 'working on it'),
withTs(mkTool('t1', 'Bash'), '2026-06-24T00:00:02.000Z'),
mkThinking('th1'),
],
true,
);
expect(items.map((it) => it.type)).toEqual(['message', 'message', 'work_group']);
const group = items[2] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.key).toBe('work-t1');
expect(group.isStreaming).toBe(true);
expect(group.startedAtMs).toBe(Date.parse('2026-06-24T00:00:02.000Z'));
expect(group.children.map((c) => c.type)).toEqual(['tool_segment', 'message']);
});
it('finishes the previous live work group at an auto-compaction boundary', () => {
const items = build(
[
mkUser('u1'),
mkTool('t-before', 'Read'),
mkCompactBoundary('compact-1'),
mkThinking('th-after'),
mkTool('t-after', 'Bash'),
],
true,
);
expect(items.map((it) => it.type)).toEqual([
'message',
'work_group',
'message',
'work_group',
]);
const groups = items.filter(
(it): it is Extract<RenderItem, { type: 'work_group' }> => it.type === 'work_group',
);
expect(groups.map((group) => [group.key, group.isStreaming])).toEqual([
['work-t-before', false],
['work-th-after', true],
]);
});
it('collapses the trailing run once the session stops streaming (turn end)', () => {
const items = build(
[mkUser('u1'), mkAssistant('a1', 'working on it'), mkTool('t1', 'Bash'), mkThinking('th1')],
false,
);
// 最后一段 thinking 之后没有正文 → thinking 仍折进 work_group(只折,不外显)
expect(items.map((it) => it.type)).toEqual(['message', 'message', 'work_group']);
const group = items[2] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.key).toBe('work-t1');
expect(group.isStreaming).toBe(false);
});
it('collapses a single-card run too (threshold = 1)', () => {
const items = build([mkUser('u1'), mkTool('t1', 'Bash'), mkAssistant('a1', 'ok')], true);
expect(items.map((it) => it.type)).toEqual(['message', 'work_group', 'message']);
});
it('folds agent task tool cards into the worked group before the final answer', () => {
const task = mkTool('task1', 'Agent', { description: 'Review auth flow', prompt: 'Check auth' });
const items = build([mkUser('u1'), task, mkResult('r1', 'tu-task1', 'done'), mkAssistant('a1', 'ok')], false);
expect(items.map((it) => it.type)).toEqual(['message', 'work_group', 'message']);
const group = items[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.key).toBe('work-task1');
expect(group.children.map((c) => c.type)).toEqual(['agent_task']);
});
it('folds orphan agent task updates into the worked group before the final answer', () => {
const updates = new Map([
[
'task-1',
{
provider: 'claude-code' as const,
taskId: 'task-1',
status: 'completed' as const,
title: 'Inspect files',
summary: 'Found the relevant renderer path',
createdAt: '2026-06-24T00:00:02.000Z',
updatedAt: '2026-06-24T00:00:04.000Z',
},
],
]);
const items = build([
withTs(mkUser('u1'), '2026-06-24T00:00:01.000Z'),
withTs(mkAssistant('a1', 'done'), '2026-06-24T00:00:05.000Z'),
], false, updates);
expect(items.map((it) => it.type)).toEqual(['message', 'work_group', 'message']);
const group = items[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.key).toBe('work-task-1');
expect(group.children.map((c) => c.type)).toEqual(['agent_task']);
});
it('keeps assistant progress visible and uses it to close the preceding live group', () => {
const items = build(
[
mkUser('u1'),
mkAssistant('a-draft', 'I will inspect this first.'),
mkTool('t1', 'Bash'),
mkAssistant('a-final', 'The fix is done.'),
],
true,
);
expect(items.map((it) => it.type)).toEqual(['message', 'message', 'work_group', 'message']);
const group = items[2] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.key).toBe('work-t1');
expect(group.children.map((c) => c.type)).toEqual(['tool_segment']);
expect(group.isStreaming).toBe(false);
});
it('segments live actions at assistant text, then folds progress and actions in original order', () => {
const activeMessages = [
mkUser('u1'),
mkAssistant('a-progress-1', 'I found the renderer path.'),
mkTool('t1', 'Bash'),
mkAssistant('a-progress-2', 'The first check passed.'),
mkThinking('th2'),
mkTool('t2', 'Read'),
];
const active = build(activeMessages, true);
expect(active.map((it) => it.type)).toEqual([
'message',
'message',
'work_group',
'message',
'work_group',
]);
const activeGroups = active.filter(
(it): it is Extract<RenderItem, { type: 'work_group' }> => it.type === 'work_group',
);
expect(activeGroups.map((group) => [group.key, group.isStreaming])).toEqual([
['work-t1', false],
['work-th2', true],
]);
const completed = build(
[...activeMessages, mkAssistant('a-final', 'Everything is ready.')],
false,
);
expect(completed.map((it) => it.type)).toEqual(['message', 'work_group', 'message']);
const completedGroup = completed[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(completedGroup.key).toBe('work-summary-t1');
expect(completedGroup.children.map((child) => child.key)).toEqual([
'msg-a-progress-1',
'work-t1',
'msg-a-progress-2',
'work-th2',
]);
const nestedGroups = completedGroup.children.filter(
(child): child is Extract<RenderItem, { type: 'work_group' }> => child.type === 'work_group',
);
expect(nestedGroups.map((group) => group.children.map((child) => child.key))).toEqual([
['seg-t1'],
['msg-th2', 'seg-t2'],
]);
expect(completedGroup.isStreaming).toBe(false);
});
it('folds intermediate assistant text after streaming stops', () => {
const items = build(
[
mkUser('u1'),
mkAssistant('a-draft', 'I will inspect this first.'),
mkTool('t1', 'Bash'),
mkAssistant('a-final', 'The fix is done.'),
],
false,
);
expect(items.map((it) => it.type)).toEqual(['message', 'work_group', 'message']);
const group = items[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.key).toBe('work-summary-t1');
expect(group.children.map((c) => `${c.type}:${c.key}`)).toEqual([
'message:msg-a-draft',
'work_group:work-t1',
]);
const final = items[2] as Extract<RenderItem, { type: 'message' }>;
expect(final.message.clientId).toBe('a-final');
});
it('keeps the live action-group key on the nested completed segment', () => {
const liveMessages = [
mkUser('u1'),
mkAssistant('a-draft', 'I will inspect this first.'),
mkTool('t1', 'Bash'),
];
const completedMessages = [
...liveMessages,
mkAssistant('a-final', 'The fix is done.'),
];
const live = build(liveMessages, true).find(
(item): item is Extract<RenderItem, { type: 'work_group' }> => item.type === 'work_group',
);
const completed = build(completedMessages, false).find(
(item): item is Extract<RenderItem, { type: 'work_group' }> => item.type === 'work_group',
);
expect(live?.key).toBe('work-t1');
expect(live?.isStreaming).toBe(true);
expect(completed?.key).toBe('work-summary-t1');
expect(completed?.isStreaming).toBe(false);
const nested = completed?.children.find(
(child): child is Extract<RenderItem, { type: 'work_group' }> => child.type === 'work_group',
);
expect(nested?.key).toBe(live?.key);
expect(nested?.isStreaming).toBe(false);
});
it('restores assistant and tool anchors to the completed work group', () => {
const items = build(
[
mkUser('u1'),
mkAssistant('a-draft', 'I will inspect this first.'),
mkTool('t1', 'Bash'),
mkAssistant('a-final', 'The fix is done.'),
],
false,
);
const visibleItems = items.slice(1);
expect(visibleItems.map((it) => it.type)).toEqual(['work_group', 'message']);
expect(findRestorableViewportItemIdx(visibleItems, 'msg-a-draft')).toBe(0);
expect(findRestorableViewportItemIdx(visibleItems, 'seg-t1')).toBe(0);
});
it('restores a completed group after an older activity joins the same turn', () => {
const tail = [mkAssistant('draft', 'Reading.'), mkTool('tool-later', 'Read'), mkAssistant('final', 'Done.')];
const previous = build([mkUser('user'), ...tail], false).find((item) => item.type === 'work_group')!;
const expanded = build([mkUser('user'), mkTool('tool-earlier', 'Bash'), ...tail], false);
expect(previous.key).toBe('work-summary-tool-later');
const index = findRestorableViewportItemIdx(expanded, previous.key);
expect(index).toBe(1);
expect(expanded[index].key).toBe('work-summary-tool-earlier');
});
it('restores an anchor to a nested deferred group without requiring loaded children', () => {
const group = build(
[mkUser('user'), mkTool('tool-earlier', 'Bash'), mkAssistant('final', 'Done.')], false,
).find((item): item is Extract<RenderItem, { type: 'work_group' }> => item.type === 'work_group')!;
const deferred = { ...group, key: 'work-tool-later', children: [] };
const regrouped = { ...group, children: [deferred] };
expect(findRestorableViewportItemIdx([regrouped], 'work-summary-tool-later')).toBe(0);
expect(findRestorableViewportItemIdx([regrouped], 'work-summary-missing')).toBe(-1);
});
it.each(['work-rs_old-anchor', 'work-earlier|work-rs_old-anchor', 'work-summary-rs_old-anchor'])(
'restores a remote summary through its retained deferred identity: %s',
(key) => {
const group = build(
[mkUser('user'), mkTool('new-anchor', 'Bash'), mkAssistant('final', 'Done.')],
false,
).find((item): item is Extract<RenderItem, { type: 'work_group' }> => item.type === 'work_group')!;
const child = {
...group,
children: [],
deferred: {
key, expanded: false, loading: false, failed: false,
toggle: () => { throw new Error('Recovery must not load details'); },
retry: () => { throw new Error('Recovery must not load details'); },
},
};
const items = [{ ...group, children: [child] }];
expect(findRestorableViewportItemIdx(items, 'work-summary-rs_old-anchor')).toBe(0);
expect(findRestorableViewportItemIdx(items, 'work-rs_old-anchor')).toBe(0);
expect(findRestorableViewportItemIdx(items, 'work-summary-anchor')).toBe(-1);
expect(findRestorableViewportItemIdx(items, 'work-summary-missing')).toBe(-1);
// The same identity must survive the deletion guard, even while its
// exact child is unloaded. Near-suffix matches are not identities.
expect(renderItemContainsClientId(items[0], 'rs_old-anchor')).toBe(true);
expect(renderItemContainsClientId(items[0], 'anchor')).toBe(false);
expect(renderItemContainsClientId(items[0], 'missing')).toBe(false);
const deleted = {
...items[0],
children: [{ ...child, key: 'work-rs_old-anchor', deferred: undefined }],
};
// A stale group key alone must not keep a genuinely deleted child alive.
expect(renderItemContainsClientId(deleted, 'rs_old-anchor')).toBe(false);
},
);
it('keeps completed prior turns folded while a later turn streams', () => {
const items = build(
[
mkUser('u1'),
mkAssistant('a1-draft', 'I will inspect this first.'),
mkTool('t1', 'Bash'),
mkAssistant('a1-final', 'The first fix is done.'),
mkUser('u2'),
mkTool('t2', 'Read'),
],
true,
);
expect(items.map((it) => it.type)).toEqual([
'message',
'work_group',
'message',
'message',
'work_group',
]);
const group = items[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.key).toBe('work-summary-t1');
expect(group.children.map((c) => `${c.type}:${c.key}`)).toEqual([
'message:msg-a1-draft',
'work_group:work-t1',
]);
});
it('folds assistant-only progress while keeping the last answer visible', () => {
const items = build(
[
mkUser('u1'),
mkAssistant('a-draft', 'Progress update.'),
mkAssistant('a-final', 'Final answer.'),
],
false,
);
expect(items.map((it) => it.type)).toEqual(['message', 'work_group', 'message']);
const group = items[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.children.map((c) => c.key)).toEqual(['msg-a-draft']);
});
it('keeps trailing work separate when no final answer follows it', () => {
const items = build(
[
mkUser('u1'),
mkTool('t1', 'Bash'),
mkAssistant('a-progress', 'Still working.'),
mkTool('t2', 'Read'),
],
false,
);
expect(items.map((it) => it.type)).toEqual([
'message',
'work_group',
'message',
'work_group',
]);
const groups = items.filter(
(it): it is Extract<RenderItem, { type: 'work_group' }> => it.type === 'work_group',
);
expect(groups.map((group) => group.key)).toEqual(['work-t1', 'work-t2']);
});
it('tool_media stays outside the group and does not trigger collapse by itself while streaming', () => {
const tu = mkTool('img1', 'image_generate');
const tr = mkResult('imgr1', 'tu-img1', JSON.stringify({ xdt_image_url: 'xdt-image://art/a.png' }));
// 还没有正文 → live run 已进入 work_group;media 卡仍保持组外可见
const streaming = build([mkUser('u1'), tu, tr, mkTool('t2', 'Read')], true);
expect(streaming.map((it) => it.type)).toEqual(['message', 'work_group', 'tool_media']);
expect((streaming[1] as Extract<RenderItem, { type: 'work_group' }>).isStreaming).toBe(true);
// turn 结束 → segment 折叠进 work_group,media 卡留在组外可见
const ended = build([mkUser('u1'), tu, tr, mkTool('t2', 'Read')], false);
expect(ended.map((it) => it.type)).toEqual(['message', 'work_group', 'tool_media']);
});
it('keeps tool_media visible when a later final answer folds surrounding work', () => {
const tu = mkTool('img1', 'image_generate');
const tr = mkResult('imgr1', 'tu-img1', JSON.stringify({ xdt_image_url: 'xdt-image://art/a.png' }));
const items = build(
[
mkUser('u1'),
mkAssistant('a-draft', 'Generating a reference.'),
tu,
tr,
mkAssistant('a-final', 'Here is the reference.'),
],
false,
);
expect(items.map((it) => it.type)).toEqual([
'message',
'work_group',
'tool_media',
'message',
]);
const group = items[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.children.map((c) => `${c.type}:${c.key}`)).toEqual([
'message:msg-a-draft',
'work_group:work-img1',
]);
const media = items[2] as Extract<RenderItem, { type: 'tool_media' }>;
expect(media.key).toBe('media-img1');
});
it('does not fold work across user turn boundaries', () => {
const items = build(
[
mkUser('u1'),
mkAssistant('a1-draft', 'Checking first turn.'),
mkTool('t1', 'Bash'),
mkAssistant('a1-final', 'First answer.'),
mkUser('u2'),
mkAssistant('a2-draft', 'Checking second turn.'),
mkTool('t2', 'Read'),
mkAssistant('a2-final', 'Second answer.'),
],
false,
);
expect(items.map((it) => it.type)).toEqual([
'message',
'work_group',
'message',
'message',
'work_group',
'message',
]);
const groups = items.filter((it): it is Extract<RenderItem, { type: 'work_group' }> => it.type === 'work_group');
expect(groups.map((g) => g.key)).toEqual(['work-summary-t1', 'work-summary-t2']);
expect(groups[0].children.some((c) => c.type === 'work_group' && c.key === 'work-t2')).toBe(false);
});
it('applies final-answer folding even when the visible window starts mid-turn', () => {
const items = build(
[
mkAssistant('a-visible-old', 'Visible historical answer.'),
mkTool('t1', 'Bash'),
mkAssistant('a-visible-final', 'Visible later answer.'),
],
false,
);
expect(items.map((it) => it.type)).toEqual(['work_group', 'message']);
const group = items[0] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.children.map((c) => `${c.type}:${c.key}`)).toEqual([
'message:msg-a-visible-old',
'work_group:work-t1',
]);
});
it('keeps inline plan cards outside work-group folding', () => {
const todo = mkTool(
'tw1',
'TodoWrite',
todoInput([
{ content: 'Inspect', status: 'completed' },
{ content: 'Patch', status: 'in_progress' },
]),
);
// 正文前后各放一次:两个位置都保留流内计划卡,且不折进 work_group。
const before = build([mkUser('u1'), todo, mkAssistant('a-final', 'Done.')], false);
const after = build([mkUser('u1'), mkAssistant('a-final', 'Done.'), todo], false);
expect(before.map((it) => it.type)).toEqual(['message', 'agent_plan', 'message']);
expect(after.map((it) => it.type)).toEqual(['message', 'message', 'agent_plan']);
});
it('computes durationMs from the previous boundary (user message) to the terminating text createdAt', () => {
const seq = [
withTs(mkUser('u1'), '2026-06-10T10:00:00.000Z'),
withTs(mkTool('t1', 'Bash'), '2026-06-10T10:00:05.000Z'),
mkThinking('th1', '2026-06-10T10:00:30.000Z'),
withTs(mkAssistant('a1', 'done'), '2026-06-10T10:02:25.000Z'),
];
const items = build(seq, false);
const group = items.find((it): it is Extract<RenderItem, { type: 'work_group' }> => it.type === 'work_group');
// 10:00:00 → 10:02:25 = 2m25s:段起点锚上一边界(用户消息),把首个动作到达前
// 的模型思考/延迟计入,与「正在工作…」活表口径一致(见 workGroupDurationAnchor.test)。
expect(group?.durationMs).toBe(145_000);
});
it('computes each nested action duration between assistant work updates', () => {
const items = build(
[
withTs(mkUser('u1'), '2026-06-10T10:00:00.000Z'),
withTs(mkAssistant('a-progress-1', 'First update.'), '2026-06-10T10:00:01.000Z'),
withTs(mkTool('t1', 'Bash'), '2026-06-10T10:00:02.000Z'),
withTs(mkAssistant('a-progress-2', 'Second update.'), '2026-06-10T10:00:10.000Z'),
withTs(mkTool('t2', 'Read'), '2026-06-10T10:00:12.000Z'),
withTs(mkAssistant('a-final', 'Done.'), '2026-06-10T10:00:20.000Z'),
],
false,
);
const outer = items[1] as Extract<RenderItem, { type: 'work_group' }>;
const nested = outer.children.filter(
(child): child is Extract<RenderItem, { type: 'work_group' }> => child.type === 'work_group',
);
// 外层从上一边界(用户消息 10:00:00)到最终正文 10:00:20 = 20s;
// 内层各段从上一句正文起表:t1 = 10:00:01→10:00:10 = 9s,t2 = 10:00:10→10:00:20 = 10s。
expect(outer.durationMs).toBe(20_000);
expect(nested.map((group) => [group.key, group.durationMs])).toEqual([
['work-t1', 9_000],
['work-t2', 10_000],
]);
});
it('omits durationMs when timestamps are missing (legacy history)', () => {
const items = build([mkUser('u1'), mkTool('t1', 'Bash'), mkAssistant('a1', 'ok')], false);
const group = items.find((it): it is Extract<RenderItem, { type: 'work_group' }> => it.type === 'work_group');
expect(group?.durationMs).toBeUndefined();
});
it('group key stays stable when an earlier run collapses while a later run is still live', () => {
const base = [mkUser('u1'), mkTool('t1', 'Bash'), mkAssistant('a1', 'text')];
const before = build(base, true);
const after = build([...base, mkTool('t2', 'Read')], true);
const beforeGroup = before.find((it) => it.type === 'work_group');
const afterGroup = after.find((it) => it.type === 'work_group');
expect(beforeGroup?.key).toBe('work-t1');
expect(afterGroup?.key).toBe('work-t1'); // 尾部新 run 不影响已折叠组的 key
});
// ── 关键结论保护:最后一段 thinking 之后的 assistant 正文留可见,thinking 仍折 ──
it('keeps assistant prose written after the last thinking visible (thinking stays folded)', () => {
// 复刻「等你确认第 1 点」场景:列点的正文 + 结尾句都在最后一段 thinking 之后
const items = build(
[
mkUser('u1'),
mkThinking('th-last'),
mkAssistant('a-plan', '要确认的点:1) … 2) …'),
mkAssistant('a-final', '等你确认第 1 点后我就创建 issue。'),
],
false,
);
// thinking 折进「已工作」;两段 assistant 正文都留可见
expect(items.map((it) => it.type)).toEqual(['message', 'work_group', 'message', 'message']);
const group = items[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.children.map((c) => c.type)).toEqual(['message']); // 仅 th-last
expect((group.children[0] as Extract<RenderItem, { type: 'message' }>).message.role).toBe('thinking');
expect((items[2] as Extract<RenderItem, { type: 'message' }>).message.clientId).toBe('a-plan');
expect((items[3] as Extract<RenderItem, { type: 'message' }>).message.clientId).toBe('a-final');
});
it('folds assistant prose written before the last thinking', () => {
const items = build(
[
mkUser('u1'),
mkAssistant('a-early', 'I will inspect this first.'),
mkThinking('th-last'),
mkAssistant('a-final', 'The fix is done.'),
],
false,
);
expect(items.map((it) => it.type)).toEqual(['message', 'work_group', 'message']);
const group = items[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.children.map((c) => (c.type === 'message' ? `message:${c.message.clientId}` : c.type)))
.toEqual(['message:a-early', 'work_group']);
const thinkingGroup = group.children[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(thinkingGroup.key).toBe('work-th-last');
expect(thinkingGroup.children.map((child) => child.key)).toEqual(['msg-th-last']);
expect((items[2] as Extract<RenderItem, { type: 'message' }>).message.clientId).toBe('a-final');
});
it('folds intermediate prose when the work contains no thinking', () => {
const items = build(
[
mkUser('u1'),
mkAssistant('a-draft', 'Progress update.'),
mkTool('t1', 'Bash'),
mkAssistant('a-final', 'done'),
],
false,
);
expect(items.map((it) => it.type)).toEqual(['message', 'work_group', 'message']);
const group = items[1] as Extract<RenderItem, { type: 'work_group' }>;
expect(group.children.map((c) => `${c.type}:${c.key}`)).toEqual([
'message:msg-a-draft',
'work_group:work-t1',
]);
expect((items[2] as Extract<RenderItem, { type: 'message' }>).message.clientId).toBe('a-final');
});
});
describe('insertForkOriginItem', () => {
const forkOrigin = {
parentSessionId: 'parent',
forkedAtMessageId: 'source-user',
forkedSessionCreatedAt: '2026-06-25T10:00:00.000Z',
};
const itemIds = (items: RenderItem[]): string[] => items.map((item) => (
item.type === 'fork_origin'
? 'fork_origin'
: item.type === 'message'
? item.message.clientId
: item.key
));
it('inserts the marker only when the loaded range crosses the fork boundary', () => {
const items = [
mkDatedMessageItem('inherited', '2026-06-25T09:59:59.000Z'),
mkDatedMessageItem('branch', '2026-06-25T10:00:01.000Z'),
];
expect(itemIds(insertForkOriginItem(items, forkOrigin))).toEqual([
'inherited',
'fork_origin',
'branch',
]);
});
it('does not pin the marker to the top when only post-fork history is loaded', () => {
const items = [
mkDatedMessageItem('branch-1', '2026-06-25T10:00:01.000Z'),
mkDatedMessageItem('branch-2', '2026-06-25T10:00:02.000Z'),
];
expect(insertForkOriginItem(items, forkOrigin)).toBe(items);
});
it('does not append the marker to the latest edge when only inherited history is loaded', () => {
const items = [
mkDatedMessageItem('inherited-1', '2026-06-25T09:59:58.000Z'),
mkDatedMessageItem('inherited-2', '2026-06-25T09:59:59.000Z'),
];
expect(insertForkOriginItem(items, forkOrigin)).toBe(items);
});
});
describe('collectStableLocalFileRefs — reference stability', () => {
it('reuses previous refs when only assistant streaming content changes', () => {
const files = [mkFileRef('foo.ts')];
const beforeMessages = [mkUser('u1', 'read this', files), mkAssistant('a1', 'partial')];
const afterMessages = [
mkUser('u1', 'read this', [mkFileRef('foo.ts')]),
mkAssistant('a1', 'partial token'),
];
const beforeRefs = collectStableLocalFileRefs(beforeMessages);
const afterRefs = collectStableLocalFileRefs(afterMessages, beforeRefs);
expect(afterRefs).toBe(beforeRefs);
expect(afterRefs).toEqual(files);
});
it('returns a new ref array when user file refs change', () => {
const beforeRefs = collectStableLocalFileRefs([
mkUser('u1', 'read this', [mkFileRef('foo.ts')]),
]);
const afterRefs = collectStableLocalFileRefs(
[
mkUser('u1', 'read this', [
mkFileRef('foo.ts'),
mkFileRef('bar.ts'),
]),
],
beforeRefs,
);
expect(afterRefs).not.toBe(beforeRefs);
expect(afterRefs).toEqual([
mkFileRef('foo.ts'),
mkFileRef('bar.ts'),
]);
});
});
// ── pickDeleteCompensationAnchorKey ──────────────────────────────────────────
describe('pickDeleteCompensationAnchorKey', () => {
it('picks the first surviving neighbor after the deleted range', () => {
// 旧全量: 窗口 [w1,w2,v,w3] 被整段清掉, 邻居 after 是 next, 会话尾是 tail
const prevAll = ['head', 'w1', 'w2', 'v', 'w3', 'next', 'mid', 'tail'];
const curAll = ['head', 'next', 'mid', 'tail'];
expect(pickDeleteCompensationAnchorKey(prevAll, curAll, 'v')).toBe('next');
});
it('falls back to the nearest surviving predecessor when no successor remains', () => {
const prevAll = ['head', 'keep', 'v', 'gone1', 'gone2'];
const curAll = ['head', 'keep'];
expect(pickDeleteCompensationAnchorKey(prevAll, curAll, 'v')).toBe('keep');
});
it('does not rebuild at conversation tail when prev is the full old sequence', () => {
// 回归: 窗口整段被清时旧可见窗与 cur 全量无交集, helper 会落到 cur 末项(会话尾);
// 调用方必须传旧全量序列才能保住删除区间后的邻居。
const prevVisibleOnly = ['w1', 'w2', 'v', 'w3']; // 整窗被清, 无存活邻接
const prevAll = ['head', 'w1', 'w2', 'v', 'w3', 'next', 'mid', 'tail'];
const curAll = ['head', 'next', 'mid', 'tail'];
expect(pickDeleteCompensationAnchorKey(prevVisibleOnly, curAll, 'v')).toBe('tail');
expect(pickDeleteCompensationAnchorKey(prevAll, curAll, 'v')).toBe('next');
});
it('returns null when deleted key is absent from prevKeys', () => {
expect(pickDeleteCompensationAnchorKey(['a', 'b'], ['a', 'b', 'c'], 'missing')).toBeNull();
});
it('picks the intervening tool row when a focused child is deleted from a surviving work group', () => {
const before = groupWorkRuns(
buildRenderItems([
mkUser('u1'),
mkAssistant('a-intro', 'Starting.'),
mkTool('t1', 'Read'),
mkAssistant('a-draft', 'Progress update.'),
mkTool('t2', 'Bash'),
mkAssistant('a-final', 'done'),
]).items,
false,
);
const after = groupWorkRuns(
buildRenderItems([
mkUser('u1'),
mkAssistant('a-intro', 'Starting.'),
mkTool('t1', 'Read'),
mkTool('t2', 'Bash'),
mkAssistant('a-final', 'done'),
]).items,
false,
);
const previousAnchorIds = collectDeleteAnchorClientIds(before);
const currentAnchorIds = collectDeleteAnchorClientIds(after);
const previousGroup = before.find((item) => item.type === 'work_group');
const currentGroup = after.find((item) => item.type === 'work_group');
expect(previousGroup).toBeDefined();
expect(currentGroup).toBeDefined();
expect(previousGroup?.key).toBe(currentGroup?.key);
expect(previousAnchorIds).toEqual(['u1', 'a-intro', 't1', 'a-draft', 't2', 'a-final']);
expect(currentAnchorIds).toEqual(['u1', 'a-intro', 't1', 't2', 'a-final']);
expect(pickDeleteCompensationAnchorKey(previousAnchorIds, currentAnchorIds, 'a-draft')).toBe(
't2',
);
});
it('picks the next message when an anchored task card is deleted from a surviving work group', () => {
const messagesBefore = [
mkUser('u1'),
mkTool('t1', 'Read'),
mkResult('r-t1', 'tu-t1'),
mkTool('task1', 'Agent', { description: 'Review auth flow', prompt: 'Check auth' }),
mkResult('r-task1', 'tu-task1', 'done'),
mkAssistant('a-final', 'done'),
];
const before = groupWorkRuns(buildRenderItems(messagesBefore).items, false);
const after = groupWorkRuns(
buildRenderItems(
messagesBefore.filter((message) => !['task1', 'r-task1'].includes(message.clientId)),
).items,
false,
);
const previousAnchorIds = collectDeleteAnchorClientIds(before);
const currentAnchorIds = collectDeleteAnchorClientIds(after);
const previousGroup = before.find((item) => item.type === 'work_group');
const currentGroup = after.find((item) => item.type === 'work_group');
expect(previousGroup?.key).toBe('work-t1');
expect(currentGroup?.key).toBe(previousGroup?.key);
expect(previousAnchorIds).toEqual(['u1', 't1', 'task1', 'a-final']);
expect(currentAnchorIds).toEqual(['u1', 't1', 'a-final']);
expect(
pickDeleteCompensationAnchorKey(previousAnchorIds, currentAnchorIds, 'task1'),
).toBe('a-final');
});
it('keeps an intervening non-message render item after a top-level message is deleted', () => {
const previousItemKeys = ['msg-user', 'work-tool', 'msg-assistant'];
const currentItemKeys = ['work-tool', 'msg-assistant'];
const previousMessageIds = ['user', 'assistant'];
const currentMessageIds = ['assistant'];
expect(
pickDeleteCompensationAnchorKey(previousMessageIds, currentMessageIds, 'user'),
).toBe('assistant');
expect(
pickDeleteCompensationAnchorKey(previousItemKeys, currentItemKeys, 'msg-user'),
).toBe('work-tool');
});
});
describe('focus scroll takeover keys', () => {
it('treats Space as user-controlled scrolling', () => {
expect(isScrollNavigationKey(' ')).toBe(true);
expect(isScrollNavigationKey('Enter')).toBe(false);
});
it('does not treat Space in an editable target as scroll takeover', () => {
expect(shouldHandleNavigationKey(' ', null)).toBe(true);
expect(shouldHandleNavigationKey('PageUp', null)).toBe(true);
expect(shouldHandleNavigationKey('Enter', null)).toBe(false);
});
});
it('places the same Bot task card after its introduction and keeps it through streaming completion replies', () => {
const task: ChatMessage = { ...mkAssistant('task-card', ''), systemCardType: 'bot-session-task' };
const messages = [mkUser('start'), task, mkAssistant('intro', 'Started'),
{ ...mkUser('finished-trigger'), isSyntheticTrigger: true }, mkAssistant('done', 'Done')];
const project = (streaming: boolean) => simplifyBotRenderItems(
buildRenderItems(messages, undefined, undefined, { botSessionId: 'bot' }).items, streaming,
).flatMap((item) => item.type === 'message' ? [item.message.clientId] : []);
expect(project(true)).toEqual(['start', 'intro', 'task-card', 'done']);
expect(project(false).filter((id) => id !== 'finished-trigger')).toEqual(['start', 'intro', 'task-card', 'done']);
});
it.each(['steer', 'new', 'completion'])('keeps task introduction pairing within the actual turn: %s', (kind) => {
const task: ChatMessage = { ...mkAssistant('task-card', ''), systemCardType: 'bot-session-task' };
const interruption = { ...mkUser('interruption'), ...(kind === 'steer' ? { delivery: 'steer' as const } : {}),
...(kind === 'completion' ? { isSyntheticTrigger: true } : {}) };
const items = buildRenderItems([mkUser('start'), task, interruption, mkAssistant('intro', 'Started')],
undefined, undefined, { botSessionId: 'bot' }).items;
const ids = items.flatMap((item) => item.type === 'message' ? [item.message.clientId] : []);
expect(ids.indexOf('task-card') > ids.indexOf('intro')).toBe(kind === 'steer');
});