Skip to content

armgit / cindy

Public Imported from GitHub
0

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

30.4 KB
Raw Blame
import type { TFunction } from 'i18next';
import { formatSessionDuration } from '@/lib/sessionDurationFormat';
import { Fragment, useEffect, useMemo, useCallback, useState } from 'react';
import {
  AlertCircle,
  Bot,
  CheckCircle2,
  ChevronRight,
  CircleStop,
  LoaderCircle,
  PanelRight,
  Square,
  SquareTerminal,
  Workflow,
} from 'lucide-react';
import { useTranslation } from 'react-i18next';
import {
  deriveAgentTaskStatus,

  type AgentTaskStatus,

  type AgentTaskTerminalStatus,
} from '@cindy/maker-shared/agent-task';

import { useExpandedBlockMemory } from '@/hooks/useExpandedBlockMemory';
import {
  BackgroundCommandDetails,
  RunningElapsed,
  parseTaskTimestamp,
} from './AgentTaskLiveDetails';
import { Collapse } from '@/components/ui/collapse';
import { Spinner } from '@/components/ui/spinner';
import type { AgentTaskUpdate, ChatMessage } from '@/hooks/useCCAgentChat';
import { canManageBackgroundTasks, stopBackgroundTask } from '@/lib/backgroundTaskStop';
import { reportBackgroundTaskStopFailure } from '@/lib/backgroundTaskStopFailure';
import { getWorkflowProgressFor, isRemoteSessionSticky } from '@/lib/makerTransport';
import { openBackgroundTasksTab } from '@/features/right-sidebar/lib/openBackgroundTasksTab';
import { openSubagentsTab } from '@/features/right-sidebar/lib/openSubagentsTab';
import { extractWorkflowTaskId } from '@/features/right-sidebar/plugins/background-tasks/listSessionTasks';
import { WorkflowAgentStrip } from '@/features/right-sidebar/plugins/background-tasks/WorkflowAgentStrip';
import {
  fileStatusToTaskStatus,
  workflowAgentVisualState,
} from '@/features/right-sidebar/plugins/background-tasks/workflowProgressModel';
import { useSidebarPanelReachable } from '@/features/cc-agent/embeddedSessionNavigation';
import { cn } from '@/lib/utils';
import { formatModelShortLabel } from '@/lib/modelShortLabel';
import { formatCompactTokens } from '@/lib/usageFormat';
import { CODEX_SUBAGENT_EFFORTS } from '../../../shared/subagentModelSettings';
import {
  PI_SUBAGENT_TOOL_NAME,
  formatAgentTaskTitle,
  isClaudeSubagentToolName,
  isSubagentResultError,
  subagentSpawnReceiptName,
  subagentSpawnResultIndicatesRunning,
} from '@cindy/maker-shared/agent-task';

// 徽标可显示的思考强度档:协议全部合法档(效果词表 effortLevels 四语齐)。
const EFFORT_BADGE_LEVELS = new Set<string>(['minimal', ...CODEX_SUBAGENT_EFFORTS]);

interface AgentTaskCardProps {
  renderItemKey?: string;
  toolCall?: ChatMessage;
  update?: AgentTaskUpdate;
  result?: string;
  persistedStatus?: AgentTaskTerminalStatus;
  /** Host `subagent_runs` status for this call; see deriveAgentTaskStatus. */
  durableStatus?: AgentTaskStatus;
  /**
   * subagent-model-chip: 子代理实际跑的模型 raw id,由 MessageStream 用
   * parentToolUseId→model 映射(从子消息 agentMeta 反查)解析后传入,作为
   * 历史重载(此时 update 为空)时的兜底来源。实时态优先用 update.model。
   */
  subagentModel?: string;
  /**
   * 当前会话 id。workflow 卡用于打开右栏后台任务面板并定位详情;stop 按钮
   * 定位任务也依赖它。
   */
  sessionId?: string;
  /** Current owning harness. Pi's durable-detail sidebar must never surface
   * after the session has switched to Claude Code or Codex. */
  sessionAgentKind?: 'cc' | 'codex' | 'pi';
}

function readInputString(input: unknown, keys: string[]): string | undefined {
  if (!input || typeof input !== 'object') return undefined;
  const obj = input as Record<string, unknown>;
  for (const key of keys) {
    const value = obj[key];
    if (typeof value === 'string' && value.trim()) return value.trim();
  }
  return undefined;
}

function readInputStringArray(input: unknown, key: string): string[] {
  if (!input || typeof input !== 'object') return [];
  const value = (input as Record<string, unknown>)[key];
  if (!Array.isArray(value)) return [];
  return value.filter((item): item is string => typeof item === 'string' && item.length > 0);
}

function compactText(text: string | undefined, max = 260): string | undefined {
  if (!text) return undefined;
  const oneLine = text.replace(/\s+/g, ' ').trim();
  if (oneLine.length <= max) return oneLine;
  return `${oneLine.slice(0, max - 1)}…`;
}

function detailText(...values: Array<string | undefined>): string | undefined {
  for (const value of values) {
    const trimmed = value?.trim();
    if (trimmed) return trimmed;
  }
  return undefined;
}

function formatDuration(ms: number | undefined, t?: TFunction): string | undefined {
  if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0) return undefined;
  if (ms < 1000) return `${ms}ms`;
  return formatSessionDuration(ms, t);
}

function statusIcon(status: AgentTaskUpdate['status']) {
  if (status === 'completed') return CheckCircle2;
  if (status === 'failed') return AlertCircle;
  if (status === 'stopped') return CircleStop;
  return LoaderCircle;
}

/**
 * workflow 历史卡文件终态读取的模块级共享(key = sessionId+taskId):历史会话
 * 可能同屏多张卡,各读一遍会把 main 侧跨目录扫描放大 N 倍。终态文件不可变,
 * 正结果永久有效;负结果(读不到)同样缓存 —— 历史卡的文件早已定型,与面板
 * 补读的 per-task 记忆同口径,不轮询不重试。
 */
const historyFileStatusCache = new Map<
  string,
  Promise<'completed' | 'failed' | 'stopped' | null>
>();

function readHistoryFileStatus(
  sessionId: string,
  taskId: string,
): Promise<'completed' | 'failed' | 'stopped' | null> {
  const key = `${sessionId} ${taskId}`;
  let pending = historyFileStatusCache.get(key);
  if (!pending) {
    pending = getWorkflowProgressFor(sessionId, taskId)
      .then((progress) => {
        const mapped = fileStatusToTaskStatus(progress?.status);
        // 只缓存终态:null(文件缺失/未收口)可能是终态通知先于落盘的窄窗口,
        // 永久缓存会把这张卡钉死在推导状态 —— 让下次挂载重读。
        if (mapped === null) historyFileStatusCache.delete(key);
        return mapped;
      })
      .catch(() => {
        historyFileStatusCache.delete(key);
        return null;
      });
    historyFileStatusCache.set(key, pending);
  }
  return pending;
}

export function AgentTaskCard({
  renderItemKey,
  toolCall,
  update,
  result,
  persistedStatus,
  durableStatus,
  subagentModel,
  sessionId,
  sessionAgentKind,
}: AgentTaskCardProps) {
  const { t } = useTranslation();
  const blockId = `task:${toolCall?.clientId ?? update?.taskId ?? 'unknown'}`;
  // subagent-model-chip: 子代理模型 —— 实时态优先 update.model(progress 事件
  // 带),历史重载(update 缺省)回退到从子消息反查的 subagentModel。Claude
  // Agent/Task 的 input.model 只是请求值,可能被运行时个性化配置覆盖,不能冒充
  // 实际模型;Codex collab spawn 沿用既有显式模型展示。`model: null` 是实时聚合卡
  // 的显式清除指令,不能再落到历史/输入兜底,
  // 否则多 receiver 模型冲突时旧徽标会被重新显示。V1 多 receiver 的实时聚合结论
  // 不落库;重载后既无法证明所有 receiver 都已上报、也无法证明模型一致,所以历史态
  // 同样不从首条子消息或 spawn 参数猜回单一徽标。默认继承主模型时 Codex live tracker
  // 会按 spawn 当刻的运行时模型冻结到 update.model;历史态若没有这条事实仍不猜。
  const receiverThreadIds = readInputStringArray(toolCall?.toolInput, 'receiverThreadIds');
  const isPiDurableSubagent = update?.provider === 'pi' && update.taskType === 'pi_subagent';
  const codexSpawnModel = toolCall?.toolName?.startsWith('collab:') === true
    ? readInputString(toolCall.toolInput, ['model'])
    : undefined;
  const ambiguousMultiReceiverHistory =
    !update && toolCall?.toolName?.startsWith('collab:') === true && receiverThreadIds.length > 1;
  const modelLabel = formatModelShortLabel(
    update?.model === null
      ? undefined
      : update?.model ?? (ambiguousMultiReceiverHistory
        ? undefined
        : subagentModel ?? codexSpawnModel),
  );
  // codex spawn 可为子代理显式指定思考强度(translator 透传 reasoningEffort);
  // 已知档位才走 effortLevels 词表,未知值不显示。CC 无此参数,行为不变。
  // 显示集合含 minimal:设置页白名单(CODEX_SUBAGENT_EFFORTS)刻意不含它,但
  // seed/glm 系模型的 spawn 参数可显式给 minimal(协议合法档),徽标不静默降级。
  const effortRaw = isPiDurableSubagent
    ? update?.reasoningEffort ?? readInputString(toolCall?.toolInput, ['reasoningEffort', 'thinking'])
    : readInputString(toolCall?.toolInput, ['reasoningEffort']);
  const effortLabel =
    effortRaw && EFFORT_BADGE_LEVELS.has(effortRaw) ? t(`effortLevels.${effortRaw}`) : undefined;
  const chipLabel = [modelLabel, effortLabel].filter(Boolean).join(' · ');
  const { expanded, setExpanded } = useExpandedBlockMemory(blockId);
  const toggle = useCallback(() => setExpanded((v) => !v), [setExpanded]);
  const [piResultExpanded, setPiResultExpanded] = useState(false);

  // workflow-card: Workflow 工具在父会话事件流里是单个 local_workflow 任务(内部子 agent
  // 不发独立 task 事件,只有 workflow 级聚合进度)。按 taskType / toolName 识别:标题优先取
  // workflowName、头像换 Workflow 图标、provider 标签显示 "Workflow"。workflow 卡不展开 ——
  // 主视图在右栏「后台任务」面板,整卡是打开面板并定位详情的入口。
  const isWorkflow = update?.taskType === 'local_workflow' || toolCall?.toolName === 'Workflow';
  // 历史重载(update 清空)从 tool_result 文本恢复任务 id —— 与面板
  // listSessionTasks 同一提取实现,保证 focusTaskId 两边配得上。
  const workflowTaskId = update?.taskId ?? (isWorkflow ? extractWorkflowTaskId(result) : undefined);

  // workflow 历史卡的状态真相:tool_result 只是启动回执(失败也存在),拿它断言
  // completed 会给 failed/stopped 涂绿,与面板列表行(已做文件修正)同屏矛盾。
  // 读一次 wf 文件终态覆盖(与面板同源);读不到(SSH 等声明过的降级边界)保持推导。
  const [historyFileStatus, setHistoryFileStatus] = useState<
    'completed' | 'failed' | 'stopped' | null
  >(null);
  useEffect(() => {
    if (!isWorkflow || update?.status || !sessionId || !workflowTaskId) return;
    let disposed = false;
    try {
      // 经模块级缓存共享:同屏多张历史卡同 taskId 只读一次(见 readHistoryFileStatus)。
      void readHistoryFileStatus(sessionId, workflowTaskId).then((mapped) => {
        if (disposed) return;
        if (mapped) setHistoryFileStatus(mapped);
      });
    } catch {
      // 静默:transport 不可用(极端环境)同样保持推导状态。
    }
    return () => {
      disposed = true;
    };
  }, [isWorkflow, update?.status, sessionId, workflowTaskId]);



  // bash-task-card: 后台 Bash(run_in_background)与子 Agent 共用本卡,但视觉上
  // 是「后台命令」—— 终端图标 + shell provider 标签,避免用户把跑测试的 bash
  // 误读成一个子 Agent。
  const isBash = update?.taskType === 'local_bash';
  const isSubagent = !isWorkflow && !isBash;
  const provider = update?.provider
    ?? (toolCall?.toolName?.startsWith('collab:')
      ? 'codex'
      : toolCall?.toolName === PI_SUBAGENT_TOOL_NAME ? 'pi' : 'claude-code');
  // `<tool_use_error>` 是 Claude SDK 协议级标记,只对 Claude 子任务(Agent/Task)的
  // 结果有意义。后台 Bash、PI subagent 与 Codex `collab:*` 的成功产物可能合法地以
  // 该前缀开头,无条件判定会把成功任务误标成 failed。工具名已知时按工具名收窄,
  // 只有历史回放(update 卡无 toolCall)才退回 provider 判定。
  const claudeProtocolResult =
    isSubagent
    && (toolCall?.toolName !== undefined
      ? isClaudeSubagentToolName(toolCall.toolName)
      : provider === 'claude-code');

  const status = isWorkflow
    ? (update?.status ?? historyFileStatus ?? (result ? 'completed' : 'running'))
    : deriveAgentTaskStatus(update?.status, result, {
        persistedStatus,
        durableStatus,
        resultIsLaunchReceipt:
          subagentSpawnReceiptName(toolCall?.toolName, toolCall?.toolInput, result) !== undefined
          || subagentSpawnResultIndicatesRunning(toolCall?.toolName, result),
        resultIsError: claudeProtocolResult && isSubagentResultError(result),
      });
  const StatusIcon = statusIcon(status);
  const statusIconClassName = cn(
    'text-[var(--text-secondary)]',
    status === 'failed' && 'text-[var(--error-fg)]',
  );
  const AvatarIcon = isWorkflow ? Workflow : isBash ? SquareTerminal : Bot;
  const title = compactText(
    formatAgentTaskTitle(provider, (isWorkflow ? update?.workflowName : undefined) ??
      update?.title ??
      readInputString(toolCall?.toolInput, ['description', 'task', 'name']) ??
      readInputString(toolCall?.toolInput, ['prompt'])),
    96,
  ) ?? t(isWorkflow ? 'chat.agentTask.provider.workflow' : 'chat.agentTask.emptyTitle');
  const description = compactText(
    update?.description ??
      readInputString(toolCall?.toolInput, ['prompt', 'description', 'task']),
  );
  // codex spawn 启动卡:translator 的 tool_result_full 只放结构化数据(agentPath
  // 原文),用户可见句子在这里按 locale 组装。判据与 mobile 卡模型共用
  // maker-shared 的 subagentSpawnReceiptName,不在端上内联复制。
  const spawnReceiptName = subagentSpawnReceiptName(toolCall?.toolName, toolCall?.toolInput, result);
  const resultIsPiLaunchReceipt = isPiDurableSubagent
    && subagentSpawnResultIndicatesRunning(toolCall?.toolName, result);
  // Claude's async receipt is internal metadata addressed to the model (agentId,
  // output file); it is never the task's summary.
  const resultIsClaudeLaunchReceipt = !isPiDurableSubagent
    && provider === 'claude-code'
    && subagentSpawnResultIndicatesRunning(toolCall?.toolName, result);
  // 判据与抑制规则同 maker-shared 的 buildAgentTaskCardModel:有 live update 时不显示
  // 「已启动」句子(title + 状态已表达),否则 codex 卡会比 Claude 卡多一行冗余文案。
  // PI/Claude detached tool_result 也是启动回执;终态卡必须优先显示后续 durable
  // update.summary,不能把「已启动」错当最终答案。
  const summary = spawnReceiptName
    ? (update
        ? detailText(update.summary)
        : t('chat.agentTask.subagentStarted', { name: formatAgentTaskTitle(provider, spawnReceiptName) }))
    : resultIsPiLaunchReceipt
      ? detailText(update?.summary, result)
      : resultIsClaudeLaunchReceipt
        ? detailText(update?.summary)
        : detailText(result, update?.summary);
  const piResultNeedsCollapse = Boolean(
    isPiDurableSubagent
      && summary
      && (summary.length > 320 || summary.split(/\r?\n/).length > 4),
  );
  // 任务开始时间:本机会话优先取发起它的工具调用消息时间(重载后仍是真实启动时刻),
  // 孤儿 update(workflow / 子 agent 内部启动)回退到 renderer 首次收到事件的时间。
  // 远程会话的消息时间来自被控端时钟,与本机 Date.now() 相减会被两台电脑的时钟差放大,
  // 改为优先用本机收到任务事件的时间(update.createdAt 由本机 store 盖章)。
  const toolCallStartedAtMs = parseTaskTimestamp(toolCall?.createdAt);
  const updateStartedAtMs = parseTaskTimestamp(update?.createdAt);
  const startedAtMs = sessionId && isRemoteSessionSticky(sessionId)
    ? updateStartedAtMs ?? toolCallStartedAtMs
    : toolCallStartedAtMs ?? updateStartedAtMs;
  // 终态用时:provider 给了 durationMs 就用它;后台命令没有 usage,用首末事件时间差兜底。
  // 运行中有开始时间时改为每秒刷新的「已运行」,不再显示 provider 上一帧的静态时长。
  const showLiveElapsed = status === 'running' && startedAtMs !== undefined;
  const endedAtMs = status === 'running' ? undefined : parseTaskTimestamp(update?.updatedAt);
  const duration = showLiveElapsed
    ? undefined
    : formatDuration(
        update?.usage?.durationMs
          ?? (startedAtMs !== undefined && endedAtMs !== undefined && endedAtMs >= startedAtMs
            ? endedAtMs - startedAtMs
            : undefined),
        t,
      );
  const bashCommand = isBash ? readInputString(toolCall?.toolInput, ['command']) : undefined;
  const providerLabel = isWorkflow
    ? t('chat.agentTask.provider.workflow')
    : isBash
      ? t('chat.agentTask.provider.shell')
      : provider === 'codex'
        ? t('chat.agentTask.provider.codex')
        : provider === 'pi'
          ? t('chat.agentTask.provider.pi')
          : t('chat.agentTask.provider.claude');

  // 停止按钮:Claude 后台任务沿用 SDK stopTask;PI 只开放 Cindy durable runner
  // 明确标成 taskType=pi_subagent 的异步任务。普通 PI 前台委派没有 durable 控制面,
  // 不能仅凭 provider 猜测可停止。Codex 仍无 stopTask 通道。
  // 点击后交给会话归属端的 stopAgentTask(device-link 远程会话隧道到被控端);成功与否
  // 都由 task_notification / durable status 事件流收口(状态翻 stopped → 按钮自然消失),
  // 这里只管在飞态防连点。
  const [stopping, setStopping] = useState(false);
  const providerCanStop = update?.provider === 'claude-code'
    || (update?.provider === 'pi' && update.taskType === 'pi_subagent');
  const canStop =
    status === 'running' &&
    Boolean(sessionId) &&
    Boolean(update?.taskId) &&
    providerCanStop &&
    Boolean(sessionId && canManageBackgroundTasks(sessionId));
  const handleStop = useCallback(() => {
    if (!sessionId || !update?.taskId) return;
    setStopping(true);
    void stopBackgroundTask(sessionId, update.taskId)
      .catch((error: unknown) => {
        // 失败时卡片仍显示 running,用户可重试;只有远程电脑版本过旧时提示升级。
        reportBackgroundTaskStopFailure(error, t);
      })
      .finally(() => setStopping(false));
  }, [sessionId, update?.taskId, t]);

  // workflow 卡整卡点击 → 打开右栏后台任务面板并定位本任务(workflowTaskId 在
  // 组件顶部与状态修正共用同一次推导)。三者缺一就退回传统展开交互,让
  // description/summary 就地可读,不做「点了没反应」的假入口。
  //
  // panelReachable:内嵌宿主(协同 worker 面板 / workdir-browse 窄 rail / Orca
  // split)里右栏显示的是别的会话(或压根没在场),往本会话 bucket 写 tab 用户看
  // 不到 —— 那里必须退回展开区,否则卡片既点不动、又因面板入口化丢掉了展开区。
  const panelReachable = useSidebarPanelReachable(sessionId);
  const canOpenInPanel = Boolean(sessionId) && Boolean(workflowTaskId) && panelReachable;
  const subagentFocusId = update?.taskId ?? toolCall?.toolUseId;
  const canOpenSubagentInPanel =
    isPiDurableSubagent &&
    sessionAgentKind === 'pi' &&
    Boolean(sessionId) &&
    Boolean(subagentFocusId) &&
    panelReachable;
  const openInPanel = useCallback(() => {
    if (!sessionId || !workflowTaskId) return;
    void openBackgroundTasksTab(sessionId, { focusTaskId: workflowTaskId });
  }, [sessionId, workflowTaskId]);
  const openSubagentInPanel = useCallback(() => {
    if (!sessionId || !subagentFocusId) return;
    void openSubagentsTab(sessionId, {
      focusRunId: subagentFocusId,
      focusProvider: provider,
    });
  }, [provider, sessionId, subagentFocusId]);

  // workflow 摘要行:当前运行中 agent 的 phaseTitle + 已收口/总数。收口判定走
  // workflowAgentVisualState 归一(与方块条 / 面板同一词表源,done 与 failed 都算收口)。
  const workflowSummary = useMemo(() => {
    if (!isWorkflow) return null;
    const entries = update?.workflowProgress;
    if (!entries || entries.length === 0) return null;
    let total = 0;
    let done = 0;
    let phase: string | undefined;
    for (const entry of entries) {
      if (entry.type !== 'workflow_agent') continue;
      total += 1;
      const visual = workflowAgentVisualState(entry.state);
      if (visual === 'done' || visual === 'failed') {
        done += 1;
      } else if (visual === 'running' && entry.phaseTitle) {
        phase = entry.phaseTitle;
      }
    }
    return total > 0 ? { phase, done, total } : null;
  }, [isWorkflow, update?.workflowProgress]);

  // 方块条数据:workflow_agent 条目按 spawn 顺序透传(state/label)。
  const workflowAgentCells = useMemo(() => {
    if (!isWorkflow) return [];
    return (update?.workflowProgress ?? [])
      .filter((entry) => entry.type === 'workflow_agent')
      .map((entry) => ({
        ...(entry.state !== undefined ? { state: entry.state } : {}),
        ...(entry.label !== undefined ? { label: entry.label } : {}),
      }));
  }, [isWorkflow, update?.workflowProgress]);

  const meta = useMemo(() => {
    const parts: Array<{ key: string; text: string }> = [
      { key: 'provider', text: providerLabel },
    ];
    if (typeof update?.usage?.totalTokens === 'number') {
      parts.push({
        key: 'tokens',
        text: t('chat.agentTask.tokens', { count: formatCompactTokens(update.usage.totalTokens) }),
      });
    }
    if (typeof update?.usage?.toolUses === 'number') {
      parts.push({ key: 'toolUses', text: t('chat.agentTask.toolUses', { count: update.usage.toolUses }) });
    }
    if (duration) parts.push({ key: 'duration', text: duration });
    return parts;
  }, [duration, providerLabel, t, update?.usage?.totalTokens, update?.usage?.toolUses]);

  return (
    // data-message-client-id:MessageStream 的消息级 focus(后台任务面板行点击 /
    // 搜索跳转)靠该锚点滚动定位 —— 普通消息行有,任务卡也必须有,否则面板点
    // Agent/Bash 行会静默无反应。
    <div
      data-render-item-key={renderItemKey}
      className="flex w-full justify-start"
      {...(toolCall?.clientId ? { 'data-message-client-id': toolCall.clientId } : {})}
    >
      <div className="w-full rounded-xl border border-[var(--border-default)] bg-[var(--surface-elevated)] px-3 py-2">
        {/* 头部按钮:普通卡 = 展开 toggle;workflow 卡 = 打开后台任务面板入口。
            button 不能嵌套,停止按钮以兄弟节点挂在右侧(仅 running 时出现)。 */}
        <div className="flex w-full items-start gap-2">
        <button
          type="button"
          onClick={isWorkflow && canOpenInPanel ? openInPanel : toggle}
          className="flex min-w-0 flex-1 items-start gap-2 rounded-lg text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--focus-ring)]"
          {...(isWorkflow && canOpenInPanel
            ? { 'aria-label': t('chat.agentTask.openInPanel') }
            : {
                'aria-expanded': expanded,
                'aria-label': expanded
                  ? t('chat.agentTask.hideDetails')
                  : t('chat.agentTask.showDetails'),
              })}
        >
          <span className="mt-0.5 inline-flex h-5 w-5 shrink-0 items-center justify-center rounded-full bg-[var(--surface-chip)] text-[var(--text-secondary)]">
            <AvatarIcon size={14} aria-hidden="true" />
          </span>
          <span className="min-w-0 flex-1">
            <span className="flex min-w-0 items-center gap-2">
              {isSubagent && <span className="shrink-0 text-11 text-[var(--text-secondary)]">{t('rightSidebar.tabs.kinds.subagents')}</span>}
              <span className="min-w-0 flex-1 truncate text-14 font-medium leading-[1.428571] text-[var(--text-primary)]">
                {title}
              </span>
              <span className={cn('inline-flex shrink-0 items-center gap-1.5 whitespace-nowrap text-12 leading-[1.333333]', statusIconClassName)}>
                <Spinner icon={StatusIcon} size={12} spinning={status === 'running'} />
                {t(`chat.agentTask.status.${status}`)}
              </span>
            </span>
            <span className="mt-0.5 flex flex-wrap items-center gap-x-2 gap-y-0.5 text-12 leading-[1.333333] text-[var(--text-tertiary)]">
              {meta.map((part) => (
                <Fragment key={part.key}>
                  <span>{part.text}</span>
                  {/* subagent-model-chip: 模型(codex 卡可另含思考强度)chip 紧跟在
                      provider 之后,与 meta 文本同处第二行。 */}
                  {part.key === 'provider' && chipLabel && (
                    <span
                      data-agent-task-model-chip="true"
                      // 字体不特殊处理:size / weight / color 全部继承 meta 行
                      // (text-12 / normal / --text-tertiary),只保留 chip 的底色与圆角。
                      className="inline-flex items-center rounded-full bg-[var(--surface-chip)] px-1.5 py-0.5"
                    >
                      {chipLabel}
                    </span>
                  )}
                </Fragment>
              ))}
              {showLiveElapsed && startedAtMs !== undefined && <RunningElapsed startedAtMs={startedAtMs} />}
            </span>
            {workflowSummary && (
              <span
                data-workflow-progress-line="true"
                className="mt-0.5 block truncate text-12 leading-4 text-[var(--text-tertiary)]"
              >
                {workflowSummary.phase
                  ? t('chat.agentTask.workflowProgressLine', {
                      phase: workflowSummary.phase,
                      done: workflowSummary.done,
                      total: workflowSummary.total,
                    })
                  : t('chat.agentTask.workflowProgressCount', {
                      done: workflowSummary.done,
                      total: workflowSummary.total,
                    })}
              </span>
            )}
            {workflowAgentCells.length > 0 && (
              // 逐 agent 状态方块条:卡片紧凑场景截断到 40 格,总览细节进面板。
              <span className="mt-1 block">
                <WorkflowAgentStrip cells={workflowAgentCells} maxVisible={40} />
              </span>
            )}
          </span>
          {isWorkflow && canOpenInPanel ? (
            <PanelRight
              size={14}
              className="mt-1 shrink-0 text-[var(--text-tertiary)]"
              aria-hidden="true"
            />
          ) : (
            <ChevronRight
              size={14}
              className={cn(
                'mt-1 shrink-0 text-[var(--text-tertiary)]',
                'transition-transform duration-[var(--motion-fast,150ms)] motion-reduce:transition-none',
                expanded && 'rotate-90',
              )}
              aria-hidden="true"
            />
          )}
        </button>
        {canOpenSubagentInPanel && (
          <button
            type="button"
            onClick={openSubagentInPanel}
            title={t('chat.agentTask.openInPanel')}
            aria-label={t('chat.agentTask.openInPanel')}
            data-agent-task-open-subagents="true"
            className={cn(
              'inline-flex h-8 w-8 shrink-0 items-center justify-center rounded-full',
              'text-[var(--text-secondary)] hover:bg-[var(--surface-chip)] hover:text-[var(--text-primary)]',
              'transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--focus-ring)]',
            )}
          >
            <PanelRight size={12} aria-hidden="true" />
          </button>
        )}
        {canStop && (
          <button
            type="button"
            onClick={handleStop}
            disabled={stopping}
            title={t('chat.agentTask.stop')}
            aria-label={t('chat.agentTask.stop')}
            data-agent-task-stop="true"
            className={cn(
              'inline-flex h-8 w-8 shrink-0 items-center justify-center rounded-full',
              'text-[var(--text-secondary)] hover:bg-[var(--surface-chip)] hover:text-[var(--text-primary)]',
              'transition-colors disabled:cursor-not-allowed disabled:opacity-50',
              'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--focus-ring)]',
            )}
          >
            <Square size={11} aria-hidden="true" />
          </button>
        )}
        </div>

        {/* live workflow 卡不渲染展开区(详情在后台任务面板);历史 workflow 卡
            (无 live taskId,面板无数据)保留展开区兜底展示 description/summary。 */}
        {!(isWorkflow && canOpenInPanel) && (
          <Collapse open={expanded}>
            <div className="mt-2 border-l-2 border-[var(--agent-actions-rail)] pl-3 text-13 leading-5 text-[var(--text-secondary)]">
              {isBash && (
                <BackgroundCommandDetails
                  sessionId={sessionId}
                  command={bashCommand}
                  startedAtMs={startedAtMs}
                  taskId={update?.taskId}
                  running={status === 'running'}
                  expanded={expanded}
                />
              )}
              {description && <p className="mb-1">{description}</p>}
              {summary && (
                <>
                  <p
                    data-agent-task-result-preview={isPiDurableSubagent ? 'true' : undefined}
                    className={cn(
                      'mb-1 whitespace-pre-wrap',
                      piResultNeedsCollapse && !piResultExpanded && 'line-clamp-4',
                    )}
                  >
                    {summary}
                  </p>
                  {piResultNeedsCollapse && (
                    <button
                      type="button"
                      aria-expanded={piResultExpanded}
                      onClick={() => setPiResultExpanded((current) => !current)}
                      className="mb-1 rounded-full text-12 text-[var(--accent-emphasis)] hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--focus-ring)]"
                    >
                      {t(piResultExpanded
                        ? 'chat.agentTask.hideFullResult'
                        : 'chat.agentTask.showFullResult')}
                    </button>
                  )}
                </>
              )}
              {update?.lastToolName && (
                <p className="text-12 leading-4 text-[var(--text-tertiary)]">
                  {t('chat.agentTask.lastTool', { tool: update.lastToolName })}
                </p>
              )}
              {update?.outputFile && (
                <p className="text-12 leading-4 text-[var(--text-tertiary)]">
                  {t('chat.agentTask.outputFile', { path: update.outputFile })}
                </p>
              )}
            </div>
          </Collapse>
        )}
      </div>
    </div>
  );
}