Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
// @vitest-environment jsdom
import React from 'react';
import { act, fireEvent, render } from '@testing-library/react';
import { describe, expect, it, vi } from 'vitest';
vi.mock('react-i18next', () => ({
useTranslation: () => ({
t: (key: string, vars?: Record<string, unknown>) => {
if (key === 'chat.agentTask.provider.claude') return 'Claude Code';
if (key === 'chat.agentTask.provider.codex') return 'Codex';
if (key === 'chat.agentTask.status.completed') return 'Completed';
if (key === 'chat.agentTask.status.running') return 'Running';
if (key === 'chat.agentTask.tokens') return `${vars?.count} tokens`;
if (key === 'chat.agentTask.toolUses') return `${vars?.count} tool uses`;
if (key === 'chat.agentTask.workflowProgressLine') {
return `${vars?.phase} · ${vars?.done}/${vars?.total} Agent`;
}
if (key === 'chat.agentTask.workflowProgressCount') {
return `${vars?.done}/${vars?.total} Agent`;
}
return key;
},
}),
}));
vi.mock('@/hooks/useExpandedBlockMemory', () => ({
useExpandedBlockMemory: () => ({
expanded: true,
setExpanded: vi.fn(),
}),
}));
const { openBackgroundTasksTabMock } = vi.hoisted(() => ({
openBackgroundTasksTabMock: vi.fn().mockResolvedValue(undefined),
}));
vi.mock('@/features/right-sidebar/lib/openBackgroundTasksTab', () => ({
openBackgroundTasksTab: openBackgroundTasksTabMock,
}));
const { openSubagentsTabMock } = vi.hoisted(() => ({
openSubagentsTabMock: vi.fn().mockResolvedValue(undefined),
}));
vi.mock('@/features/right-sidebar/lib/openSubagentsTab', () => ({
openSubagentsTab: openSubagentsTabMock,
}));
const { getWorkflowProgressForMock } = vi.hoisted(() => ({
getWorkflowProgressForMock: vi.fn().mockResolvedValue(null),
}));
const { stopAgentTaskForMock, reportStopFailureMock, canManageMock } = vi.hoisted(() => ({
// 共享任务访客(房主保留后台任务管理权)用 guest- 前缀模拟。
canManageMock: vi.fn((sessionId: string) => !sessionId.startsWith('guest-')),
// 默认按本机路由:落到 window.electronAPI.maker.stopAgentTask(与真实实现的本机分支一致)。
stopAgentTaskForMock: vi.fn((sessionId: string, taskId: string) =>
(
window as unknown as {
electronAPI: { maker: { stopAgentTask: (s: string, t: string) => Promise<unknown> } };
}
).electronAPI.maker.stopAgentTask(sessionId, taskId),
),
reportStopFailureMock: vi.fn(),
}));
vi.mock('@/lib/makerTransport', () => ({
isRemoteSessionSticky: () => false,
getWorkflowProgressFor: getWorkflowProgressForMock,
readBackgroundTaskOutputTailFor: vi.fn().mockResolvedValue({ ok: false, reason: 'unavailable' }),
}));
vi.mock('@/lib/backgroundTaskStop', () => ({
canManageBackgroundTasks: (sessionId: string) => canManageMock(sessionId),
stopBackgroundTask: stopAgentTaskForMock,
}));
vi.mock('@/lib/backgroundTaskStopFailure', () => ({
reportBackgroundTaskStopFailure: reportStopFailureMock,
}));
import { AgentTaskCard } from '@/components/chat/AgentTaskCard';
import { SessionNavigationModeProvider } from '@/features/cc-agent/embeddedSessionNavigation';
/**
* 面板入口的 affordance 判据是「本会话的右栏 bucket 通过当前交互可达」,由路由
* 主实例或可见 split pane 经 SessionNavigationModeProvider 声明(见
* useSidebarPanelReachable)。默认 fail closed:没声明 = 打不开 = 不给假入口。
*/
const withPanelHost = (
hostSessionId: string,
element: React.ReactElement,
mode: 'route-owner' | 'split-pane' = 'route-owner',
) =>
React.createElement(SessionNavigationModeProvider, {
mode,
sidebarPanelHostSessionId: hostSessionId,
children: element,
});
describe('AgentTaskCard', () => {
it.each([
['failed', 'chat.agentTask.status.failed'],
['stopped', 'chat.agentTask.status.stopped'],
] as const)('keeps a persisted %s status when replaying a non-empty result', (status, label) => {
const { container } = render(
React.createElement(AgentTaskCard, {
result: 'terminal task output',
persistedStatus: status,
toolCall: {
clientId: `tool-${status}`,
role: 'tool_use',
content: '',
toolName: 'Agent',
},
}),
);
expect(container.textContent).toContain(label);
expect(container.textContent).not.toContain('Completed');
});
it('renders the full expanded task result instead of truncating it', () => {
const tail = 'TAIL_MARKER_KEPT_VISIBLE';
const longResult = `Summary start\n\n${'x'.repeat(500)}\n${tail}`;
const { container } = render(
React.createElement(AgentTaskCard, {
result: longResult,
update: {
provider: 'claude-code',
taskId: 'task-1',
status: 'completed',
title: 'Inspect files',
},
}),
);
expect(container.textContent).toContain(tail);
expect(container.textContent).toContain('Summary start');
});
it('clamps only durable Pi results and lets the user expand the full result', () => {
const longResult = `line 1\nline 2\nline 3\nline 4\nline 5\n${'tail'.repeat(100)}`;
const { container, getByRole } = render(
React.createElement(AgentTaskCard, {
update: {
provider: 'pi',
taskId: 'pi-task-1',
taskType: 'pi_subagent',
status: 'completed',
title: 'Inspect files',
summary: longResult,
},
}),
);
const preview = container.querySelector('[data-agent-task-result-preview="true"]');
expect(preview?.className).toContain('line-clamp-4');
fireEvent.click(getByRole('button', { name: 'chat.agentTask.showFullResult' }));
expect(preview?.className).not.toContain('line-clamp-4');
expect(getByRole('button', { name: 'chat.agentTask.hideFullResult' })).toBeTruthy();
});
it('prefers the paired tool result over task update summaries', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
result: 'Final answer from the Agent tool_result',
update: {
provider: 'claude-code',
taskId: 'task-1',
status: 'completed',
title: 'Inspect files',
summary: 'Task notification summary only',
},
}),
);
expect(container.textContent).toContain('Final answer from the Agent tool_result');
expect(container.textContent).not.toContain('Task notification summary only');
});
it('replaces a PI background launch receipt with the durable terminal summary', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
toolCall: {
clientId: 'pi-bg-card',
role: 'tool_use',
content: '',
toolName: 'subagent',
toolUseId: 'pi-tool-bg',
},
result: 'Cindy subagent launched. The agent is working in the background.',
update: {
provider: 'pi',
taskId: 'pi-tool-bg',
status: 'completed',
taskType: 'pi_subagent',
summary: 'Durable terminal answer',
},
}),
);
expect(container.textContent).toContain('Durable terminal answer');
expect(container.textContent).not.toContain('Cindy subagent launched');
});
// subagent-model-chip --------------------------------------------------------
const modelChip = (container: HTMLElement) =>
container.querySelector('[data-agent-task-model-chip="true"]');
it('renders the subagent model chip from update.model (live)', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
toolCall: {
clientId: 'c-live',
role: 'tool_use',
content: '',
toolName: 'Agent',
toolUseId: 'toolu_LIVE',
toolInput: { model: 'sonnet' },
},
update: {
provider: 'claude-code',
taskId: 'task-1',
status: 'running',
title: 'Explore the codebase',
model: 'claude-haiku-4-5-20251001',
},
}),
);
expect(modelChip(container)?.textContent).toBe('Haiku 4.5');
});
it('falls back to subagentModel prop when update is absent (history reload)', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
toolCall: {
clientId: 'c1',
role: 'tool_use',
content: '',
toolName: 'Agent',
toolUseId: 'toolu_AGENT',
},
result: 'done',
subagentModel: 'claude-haiku-4-5-20251001',
}),
);
expect(modelChip(container)?.textContent).toBe('Haiku 4.5');
});
it('renders no chip when neither update.model nor subagentModel is present', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
update: {
provider: 'codex',
taskId: 'task-1',
status: 'running',
title: 'Worker task',
},
}),
);
expect(modelChip(container)).toBeNull();
});
it('renders PI thinking from the durable task update', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
update: {
provider: 'pi',
taskId: 'pi-1',
status: 'running',
taskType: 'pi_subagent',
reasoningEffort: 'high',
},
}),
);
expect(modelChip(container)?.textContent).toBe('effortLevels.high');
});
it('does not present a Claude Agent request model as the actual model', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
toolCall: {
clientId: 'c-requested',
role: 'tool_use',
content: '',
toolName: 'Agent',
toolUseId: 'toolu_REQUESTED',
toolInput: { model: 'sonnet' },
},
result: 'done',
}),
);
expect(modelChip(container)).toBeNull();
});
it('keeps the existing Codex collab explicit model chip fallback', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
toolCall: {
clientId: 'c-codex',
role: 'tool_use',
content: '',
toolName: 'collab:spawn',
toolUseId: 'call_CODEX',
toolInput: { model: 'gpt-5.6-terra' },
},
result: 'done',
}),
);
expect(modelChip(container)?.textContent).toBe('Gpt 5.6 Terra');
});
it('does not fall back to stale history or spawn input after an explicit model clear', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
toolCall: {
clientId: 'c-clear',
role: 'tool_use',
content: '',
toolName: 'collab:spawn',
toolUseId: 'toolu_CLEAR',
toolInput: { model: 'gpt-5.6-terra' },
},
update: {
provider: 'codex',
taskId: 'task-clear',
status: 'running',
model: null,
},
subagentModel: 'codex/gpt-5.5',
}),
);
expect(modelChip(container)).toBeNull();
});
// bash-task-card + 停止按钮 ---------------------------------------------------
const stopButton = (container: HTMLElement) =>
container.querySelector<HTMLButtonElement>('[data-agent-task-stop="true"]');
it('renders local_bash tasks as a background command with a stop button while running', async () => {
const stopAgentTask = vi.fn().mockResolvedValue({ ok: true });
(window as unknown as { electronAPI?: unknown }).electronAPI = {
maker: { stopAgentTask },
};
try {
const { container } = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: {
provider: 'claude-code',
taskId: 'bash-1',
status: 'running',
title: 'pnpm test:unit',
taskType: 'local_bash',
},
}),
);
expect(container.textContent).toContain('chat.agentTask.provider.shell');
const btn = stopButton(container);
expect(btn).not.toBeNull();
// stop 的 finally(setStopping)在微任务里落地,await 到位避免 act 泄漏警告。
await act(async () => {
btn!.click();
await Promise.resolve();
});
expect(stopAgentTask).toHaveBeenCalledWith('session-1', 'bash-1');
} finally {
delete (window as unknown as { electronAPI?: unknown }).electronAPI;
}
});
it('stops a running PI durable subagent through the common task control IPC', async () => {
const stopAgentTask = vi.fn().mockResolvedValue({ ok: true });
(window as unknown as { electronAPI?: unknown }).electronAPI = {
maker: { stopAgentTask },
};
try {
const { container } = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-pi',
sessionAgentKind: 'pi',
update: {
provider: 'pi',
taskId: 'pi-tool-1',
status: 'running',
taskType: 'pi_subagent',
},
}),
);
const btn = stopButton(container);
expect(btn).not.toBeNull();
await act(async () => {
btn!.click();
await Promise.resolve();
});
expect(stopAgentTask).toHaveBeenCalledWith('session-pi', 'pi-tool-1');
} finally {
delete (window as unknown as { electronAPI?: unknown }).electronAPI;
}
});
it('routes stop through the session-owner transport and reports failures (remote tasks included)', async () => {
const failure = new Error('[DEVICE_LINK_CHANNEL_NOT_ALLOWED] maker:agent-task:stop');
stopAgentTaskForMock.mockRejectedValueOnce(failure);
reportStopFailureMock.mockClear();
const { container } = render(
React.createElement(AgentTaskCard, {
sessionId: 'remote-session',
update: {
provider: 'claude-code',
taskId: 'bash-remote',
status: 'running',
taskType: 'local_bash',
},
}),
);
const btn = stopButton(container);
expect(btn).not.toBeNull();
await act(async () => {
btn!.click();
await Promise.resolve();
await Promise.resolve();
});
expect(stopAgentTaskForMock).toHaveBeenCalledWith('remote-session', 'bash-remote');
expect(reportStopFailureMock).toHaveBeenCalledWith(failure, expect.any(Function));
});
it.each(['cc', 'codex'] as const)(
'keeps a historical PI durable card inline after the session switches to %s',
(sessionAgentKind) => {
openSubagentsTabMock.mockClear();
const { container } = render(
withPanelHost(
`session-${sessionAgentKind}`,
React.createElement(AgentTaskCard, {
sessionId: `session-${sessionAgentKind}`,
sessionAgentKind,
update: {
provider: 'pi',
taskId: 'historical-pi-tool',
status: 'completed',
taskType: 'pi_subagent',
},
}),
),
);
expect(container.querySelector('[data-agent-task-open-subagents="true"]')).toBeNull();
expect(container.querySelector('button[aria-expanded]')).not.toBeNull();
expect(openSubagentsTabMock).not.toHaveBeenCalled();
},
);
it('hides the stop button for terminal tasks, codex tasks, foreground PI tasks, and when sessionId is missing', () => {
const terminal = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: {
provider: 'claude-code',
taskId: 'bash-1',
status: 'completed',
taskType: 'local_bash',
},
}),
);
expect(stopButton(terminal.container)).toBeNull();
const codex = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: { provider: 'codex', taskId: 'c1', status: 'running' },
}),
);
expect(stopButton(codex.container)).toBeNull();
const foregroundPi = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: { provider: 'pi', taskId: 'pi-1', status: 'running' },
}),
);
expect(stopButton(foregroundPi.container)).toBeNull();
const noSession = render(
React.createElement(AgentTaskCard, {
update: {
provider: 'claude-code',
taskId: 'bash-1',
status: 'running',
taskType: 'local_bash',
},
}),
);
expect(stopButton(noSession.container)).toBeNull();
// 共享任务访客没有后台任务管理权:不给停止入口。
const sharedGuest = render(
React.createElement(AgentTaskCard, {
sessionId: 'guest-session',
update: {
provider: 'claude-code',
taskId: 'bash-1',
status: 'running',
taskType: 'local_bash',
},
}),
);
expect(stopButton(sharedGuest.container)).toBeNull();
});
it('opens the existing Subagents panel focused on a PI durable run alias', () => {
openSubagentsTabMock.mockClear();
const { container } = render(
withPanelHost(
'session-pi',
React.createElement(AgentTaskCard, {
sessionId: 'session-pi',
sessionAgentKind: 'pi',
update: {
provider: 'pi',
taskId: 'pi-tool-1',
status: 'running',
taskType: 'pi_subagent',
},
}),
),
);
const button = container.querySelector<HTMLButtonElement>(
'[data-agent-task-open-subagents="true"]',
);
expect(button).not.toBeNull();
act(() => button!.click());
expect(openSubagentsTabMock).toHaveBeenCalledWith('session-pi', {
focusRunId: 'pi-tool-1',
focusProvider: 'pi',
});
});
it.each([
['claude-code', 'Agent'],
['codex', 'collab:spawnAgent'],
] as const)('keeps %s Subagent cards inline without a sidebar jump', (provider, toolName) => {
openSubagentsTabMock.mockClear();
const { container } = render(
withPanelHost(
`session-${provider}`,
React.createElement(AgentTaskCard, {
sessionId: `session-${provider}`,
toolCall: {
clientId: `${provider}-card`,
role: 'tool_use',
content: '',
toolName,
toolUseId: `${provider}-tool`,
},
update: {
provider,
taskId: `${provider}-task`,
status: 'running',
},
}),
),
);
expect(container.querySelector('[data-agent-task-open-subagents="true"]')).toBeNull();
const inlineToggle = container.querySelector<HTMLButtonElement>('button[aria-expanded]');
expect(inlineToggle).not.toBeNull();
act(() => inlineToggle!.click());
expect(openSubagentsTabMock).not.toHaveBeenCalled();
});
// workflow-card:整卡 = 后台任务面板入口 -------------------------------------
const headerButton = (container: HTMLElement) =>
container.querySelector<HTMLButtonElement>('button[aria-label="chat.agentTask.openInPanel"]');
it('opens the background tasks panel focused on the task when a workflow card is clicked', () => {
openBackgroundTasksTabMock.mockClear();
const { container } = render(
withPanelHost(
'session-1',
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: {
provider: 'claude-code',
taskId: 'wf-1',
status: 'running',
taskType: 'local_workflow',
workflowName: 'Release pipeline',
},
}),
),
);
const btn = headerButton(container);
expect(btn).not.toBeNull();
// workflow 卡不是展开 toggle:无 aria-expanded。
expect(btn!.hasAttribute('aria-expanded')).toBe(false);
act(() => {
btn!.click();
});
expect(openBackgroundTasksTabMock).toHaveBeenCalledWith('session-1', { focusTaskId: 'wf-1' });
});
it('opens the background tasks panel on the first click from a split pane', () => {
openBackgroundTasksTabMock.mockClear();
const { container } = render(
withPanelHost(
'session-b',
React.createElement(AgentTaskCard, {
sessionId: 'session-b',
update: {
provider: 'claude-code',
taskId: 'wf-split',
status: 'running',
taskType: 'local_workflow',
workflowName: 'Split workflow',
},
}),
'split-pane',
),
);
const btn = headerButton(container);
expect(btn).not.toBeNull();
expect(btn!.hasAttribute('aria-expanded')).toBe(false);
act(() => {
btn!.click();
});
expect(openBackgroundTasksTabMock).toHaveBeenCalledWith('session-b', {
focusTaskId: 'wf-split',
});
});
it('falls back to the expand toggle when sessionId or taskId is missing on a workflow card', () => {
// 历史重载 workflow 卡(无 live taskId / sessionId):面板侧无该任务数据,
// 入口模式退回传统展开交互,description/summary 仍就地可读,不做假入口。
openBackgroundTasksTabMock.mockClear();
const { container } = render(
React.createElement(AgentTaskCard, {
// sessionId 缺失 → 不是面板入口,而是可展开卡。
update: {
provider: 'claude-code',
taskId: 'wf-1',
status: 'completed',
taskType: 'local_workflow',
summary: 'WORKFLOW_HISTORY_SUMMARY',
},
}),
);
// 无面板入口按钮,但有展开 toggle(aria-expanded 存在)。
expect(headerButton(container)).toBeNull();
const toggleBtn = container.querySelector<HTMLButtonElement>('button[aria-expanded]');
expect(toggleBtn).not.toBeNull();
act(() => {
toggleBtn!.click();
});
expect(openBackgroundTasksTabMock).not.toHaveBeenCalled();
expect(container.textContent).toContain('WORKFLOW_HISTORY_SUMMARY');
});
it('corrects a restored workflow card to the file terminal status (failed not painted green)', async () => {
// tool_result 只是启动回执(失败也存在):历史卡不得据此断言 completed,
// 与面板列表行同源读 wf 文件终态修正。
getWorkflowProgressForMock.mockResolvedValueOnce({
runId: 'wf_hist1',
status: 'failed',
phases: [],
agents: [],
});
const { container } = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
toolCall: {
clientId: 'wf-hist-1',
role: 'tool_use',
content: '',
toolUseId: 'tu-wf-hist',
toolName: 'Workflow',
toolInput: {},
},
result: 'Workflow launched in background. Task ID: wf_hist1',
}),
);
await act(async () => {
await Promise.resolve();
});
expect(getWorkflowProgressForMock).toHaveBeenCalledWith('session-1', 'wf_hist1');
expect(container.textContent).toContain('chat.agentTask.status.failed');
});
it('recovers the panel-entry task id from the tool result on history reload', () => {
// 重载后 update 清空,但持久化 tool_result 里有 CLI 任务 id —— 卡片必须仍是
// 面板入口(与面板 listSessionTasks 的提取同源,focusTaskId 才配得上)。
openBackgroundTasksTabMock.mockClear();
const { container } = render(
withPanelHost(
'session-1',
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
toolCall: {
clientId: 'wf-call-1',
role: 'tool_use',
content: '',
toolUseId: 'tu-wf-1',
toolName: 'Workflow',
toolInput: { script: 'export const meta = {}' },
},
result: 'Workflow launched in background. Task ID: wf_restored42',
}),
),
);
const btn = headerButton(container);
expect(btn).not.toBeNull();
act(() => {
btn!.click();
});
expect(openBackgroundTasksTabMock).toHaveBeenCalledWith('session-1', {
focusTaskId: 'wf_restored42',
});
});
it('renders no inline expand region for workflow cards', () => {
const { container } = render(
withPanelHost(
'session-1',
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: {
provider: 'claude-code',
taskId: 'wf-1',
status: 'completed',
taskType: 'local_workflow',
workflowName: 'Release pipeline',
description: 'WORKFLOW_DESCRIPTION_HIDDEN',
summary: 'WORKFLOW_SUMMARY_HIDDEN',
},
}),
),
);
// useExpandedBlockMemory mock 恒为 expanded=true,仍不得渲染展开区内容。
expect(container.textContent).not.toContain('WORKFLOW_DESCRIPTION_HIDDEN');
expect(container.textContent).not.toContain('WORKFLOW_SUMMARY_HIDDEN');
expect(container.querySelector('[aria-expanded]')).toBeNull();
});
it('falls back to the expand toggle in embedded hosts where the panel bucket is invisible', () => {
// 协同 worker 面板 / workdir-browse 窄 rail:右栏显示的是别的会话(这里 lead),
// 往本会话 bucket 写 tab 用户看不到 —— 必须退回展开区,不给「点了没反应」的
// 假入口,也不能因为面板入口化就在这些宿主里彻底没有详情可读。
openBackgroundTasksTabMock.mockClear();
const { container } = render(
withPanelHost(
'lead-session',
React.createElement(AgentTaskCard, {
sessionId: 'worker-session',
update: {
provider: 'claude-code',
taskId: 'wf-1',
status: 'running',
taskType: 'local_workflow',
workflowName: 'Release pipeline',
summary: 'WORKFLOW_SUMMARY_IN_EMBEDDED_HOST',
},
}),
),
);
expect(headerButton(container)).toBeNull();
const toggleBtn = container.querySelector<HTMLButtonElement>('button[aria-expanded]');
expect(toggleBtn).not.toBeNull();
act(() => {
toggleBtn!.click();
});
expect(openBackgroundTasksTabMock).not.toHaveBeenCalled();
expect(container.textContent).toContain('WORKFLOW_SUMMARY_IN_EMBEDDED_HOST');
});
const progressLine = (container: HTMLElement) =>
container.querySelector('[data-workflow-progress-line="true"]');
it('renders the live progress line from workflowProgress entries', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: {
provider: 'claude-code',
taskId: 'wf-1',
status: 'running',
taskType: 'local_workflow',
workflowProgress: [
{ type: 'workflow_phase', index: 0, title: 'Build' },
{ type: 'workflow_agent', index: 1, label: 'a', phaseTitle: 'Build', state: 'done' },
{ type: 'workflow_agent', index: 2, label: 'b', phaseTitle: 'Test', state: 'progress' },
{ type: 'workflow_agent', index: 3, label: 'c', phaseTitle: 'Test', state: 'error' },
],
},
}),
);
expect(progressLine(container)?.textContent).toBe('Test · 2/3 Agent');
});
it("counts 'completed' agents as settled in the progress line (visual-state vocab)", () => {
const { container } = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: {
provider: 'claude-code',
taskId: 'wf-1',
status: 'running',
taskType: 'local_workflow',
workflowProgress: [
{ type: 'workflow_agent', index: 0, label: 'a', state: 'completed' },
{ type: 'workflow_agent', index: 1, label: 'b', state: 'stopped' },
{ type: 'workflow_agent', index: 2, label: 'c', state: 'start' },
],
},
}),
);
expect(progressLine(container)?.textContent).toBe('2/3 Agent');
});
it('falls back to counts only when no running agent carries a phaseTitle', () => {
const { container } = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: {
provider: 'claude-code',
taskId: 'wf-1',
status: 'completed',
taskType: 'local_workflow',
workflowProgress: [
{ type: 'workflow_agent', index: 0, label: 'a', state: 'done' },
{ type: 'workflow_agent', index: 1, label: 'b', state: 'done' },
],
},
}),
);
expect(progressLine(container)?.textContent).toBe('2/2 Agent');
});
it('renders no progress line when workflowProgress is absent, and keeps non-workflow cards off the panel entry', () => {
openBackgroundTasksTabMock.mockClear();
const workflow = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: {
provider: 'claude-code',
taskId: 'wf-1',
status: 'running',
taskType: 'local_workflow',
},
}),
);
expect(progressLine(workflow.container)).toBeNull();
const normal = render(
React.createElement(AgentTaskCard, {
sessionId: 'session-1',
update: {
provider: 'claude-code',
taskId: 'task-1',
status: 'running',
title: 'Inspect files',
},
}),
);
// 普通卡头部仍是展开 toggle,不触发面板。
const toggleBtn = normal.container.querySelector<HTMLButtonElement>('button[aria-expanded]');
expect(toggleBtn).not.toBeNull();
act(() => {
toggleBtn!.click();
});
expect(openBackgroundTasksTabMock).not.toHaveBeenCalled();
expect(progressLine(normal.container)).toBeNull();
});
});