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。

25.5 KB
Raw Blame
/** Desktop item projection for the shared work-run grouping algorithm. No UI side effects. */
import { isContinuationMessage } from '@cindy/maker-shared/synthetic-trigger';
import {
  deriveAgentTaskStatus,
  subagentSpawnReceiptName,
  subagentSpawnResultIndicatesRunning,
  type AgentTaskStatus,
  type AgentTaskTerminalStatus,
} from '@cindy/maker-shared/agent-task';
import {
  groupWorkRuns as groupSharedWorkRuns,
  isDeliveryProseText,
  isSteerUserRow,
} from '@cindy/maker-shared/message-render';
import type { AgentTaskUpdate, ChatMessage } from '@/hooks/useCCAgentChat';
import type { GeneratedFileRef } from '@/lib/generatedFiles';
import type { TurnChangeSetSummary } from '../../../shared/turnChangeSet';
import type { TodoItem } from './TodoListCard';
import type { ToolMediaItem } from './AgentActionRow';

export type MessageRenderItem = { type: 'message'; key: string; message: ChatMessage };
type AgentPlanRenderItem = {
  type: 'agent_plan';
  key: string;
  todos: TodoItem[];
  /** 同一 session 的计划工具行;历史 prepend 改变首行 key 后仍可恢复旧锚点。 */
  sourceClientIds: string[];
  /** 计划调用在流里的位置与时间锚点;原 tool_use 行由本卡取代。 */
  createdAt?: string;
};
export type ToolSegmentRenderItem = {
  /** A run of consecutive tool_use messages between text segments,
   *  rendered as a single AgentActionsBlock. v2 — no isStreaming
   *  field; default-collapsed + persistent memory removes the need
   *  to thread streaming state down. */
  type: 'tool_segment';
  key: string;
  toolCalls: ChatMessage[];
  resultMap: Map<string, string>;
  /** tool_use clientId 集合:tool_result 已到达(含被 shouldHideToolResult
   *  隐藏、没进 resultMap 的空结果)。行级 running/done 状态判定用 —
   *  只看 resultMap 会让 orca 通信工具永久显示 running。 */
  settledIds: Set<string>;
  /** tool_use clientId → 对应 tool_result 的 createdAt(ms)。
   *  段的结束时间必须算进 result:单次工具跑了半小时以上时,只看最后一个 tool_use 的
   *  createdAt 会把段的结束时间大幅低估,让紧随其后的最终答复被空洞守卫误判(#676
   *  review)。resultMap 只留正文,时间戳单独存这里。 */
  resultTsMap: Map<string, number>;
};
export type AgentTaskRenderItem = {
  type: 'agent_task';
  key: string;
  toolCall?: ChatMessage;
  update?: AgentTaskUpdate;
  result?: string;
  persistedStatus?: AgentTaskTerminalStatus;
  /** Host `subagent_runs` status for this call (local tasks); see deriveAgentTaskStatus. */
  durableStatus?: AgentTaskStatus;
  /** 对应 tool_result 的 createdAt(ms)。历史会话没有 live taskUpdates 时,item 的结束
   *  时间只能靠它 —— 否则跑了半小时以上的 Agent/Task 会让紧随其后的最终答复被空洞守卫
   *  误判(#676 review)。与 tool_segment 的 resultTsMap 同源。 */
  resultTsMs?: number;
};
export type ForkOriginRenderItem = {
  type: 'fork_origin';
  key: string;
  parentSessionId: string;
  forkedAtMessageId: string;
};
type TurnChangesRenderItem = {
  /** Exact provider patches attached to one visible user turn. */
  type: 'turn_changes';
  key: string;
  changeSet: TurnChangeSetSummary;
};
type GeneratedFilesRenderItem = {
  type: 'generated_files';
  key: string;
  files: GeneratedFileRef[];
  turnStartMs: number | null;
  turnEndMs: number | null;
  /** 最新一轮没有后续 user 边界时 turnEndMs 仍为空,用封口信号触发完成后复核。 */
  turnSealed?: boolean;
};

/** 原子工作子项:tool / agent task / thinking / assistant 工作文字。 */
export type WorkChildItem = ToolSegmentRenderItem | AgentTaskRenderItem | MessageRenderItem;

/** work_group 可以嵌套一层:完成态外组装 assistant 文字时间线,其中每段
 *  连续动作仍是独立的内层「已工作 Xs」。内层继续只收原子工作子项。 */
export type WorkGroupChildItem = WorkChildItem | WorkGroupRenderItem;

interface WorkGroupRenderItem {
  /** work-group:运行中的连续动作段,或完成态收拢整段工作文字的外层时间线。
   *  动作段展开后直接显示思考 / 工具行;外层展开后显示 assistant 文字和
   *  仍保持折叠的内层动作段。tool_media 不参与合并,继续留在组外可见。 */
  type: 'work_group';
  key: string;
  children: WorkGroupChildItem[];
  deferred?: import('@cindy/maker-shared/message-window').DeferredHistoryWork;
  durationMs?: number;
  /** 当前是否是仍在执行的尾部动作段。完成态时间线始终 false。 */
  isStreaming: boolean;
  /** 工作段起点 epoch ms,供 live elapsed ticker 使用。优先是上一个边界
   *  (用户消息/上一句正文,可能早于段内首个活动),边界缺失时退回首个活动
   *  时间戳 —— 与 durationMs 的段起点同源(见 createWorkGroup)。 */
  startedAtMs?: number;
}

export type RenderItem =
  | MessageRenderItem
  | AgentPlanRenderItem
  | ToolSegmentRenderItem
  | AgentTaskRenderItem
  | ForkOriginRenderItem
  | TurnChangesRenderItem
  | GeneratedFilesRenderItem
  | {
      /** tool-result-media: 把 tool_result 里的 xdt_image_url(s) / xdt_video_urls
       *  提取出来作为独立视觉消息渲染,跳出 tool_segment 折叠卡片。统一容器,
       *  按 kind 分发到 ChatImageView / ChatVideoView。
       *
       *  生成期间不展示占位卡 — 与 image_generate 保持同款体验:tool_use 卡
       *  自身就标识"正在做",result 一到再渲染媒体。失败由 tool_result 文本
       *  里的 error 字段承载,不需要单独的 placeholder。 */
      type: 'tool_media';
      key: string;
      items: ToolMediaItem[];
    }
  | {
      /** ghost-card(卡槽③海报模式):意识为自己的一次 ghost_call 供片的
       *  聊天卡片,是该次调用的**唯一呈现**——配上卡后对应工具行不进
       *  tool_segment(行与卡信息重复,合并进卡),原始调用参数由卡片头带
       *  展开区承担(toolCall 透传)。key 锚定 ghost_call tool_use 的
       *  clientId(`ghostcard-${clientId}`,窗口锚定稳定);卡体 html/height
       *  渲染时从 ghostCardStore 现取(限速 ≥1s/卡,重建频率可控)。
       *  settled=false 为进行中(turn 内活卡,claude 精确 toolUseId 锚 /
       *  codex 同 ghost 启发式锚),tool_result 到达后经 xdt_card_id 配对
       *  转 settled。未供卡的调用不产生本 item —— 逐像素回退今日渲染。 */
      type: 'ghost_card';
      key: string;
      callId: string;
      ghostId: string;
      /** 该次调用的意识侧工具名(toolInput.tool;身份头徽章展示)。 */
      tool: string;
      /** 原始 tool_use 消息(头带展开区显示调用参数;审计层不因行隐身而丢)。 */
      toolCall: ChatMessage;
      settled: boolean;
      /** 配对到的 tool_result 时间戳(ms)。与 AgentTaskRenderItem.resultTsMs 同口径:
       *  toolCall.createdAt 只是"开始调用",一次跑很久的供卡调用(出图 / 出视频)拿它
       *  当结束会把结束时间低估整个执行时长,紧随其后的正文被误判成历史空洞。
       *  未配对(活卡)时缺省。 */
      resultTsMs?: number;
      /** 回锚媒体:后续调用(如 poll_result)的 tool_result 带 xdt_anchor_card_id
       *  指回本卡时,其媒体挂在卡正下方渲染(替换"生成中"的视觉位置),而非
       *  留在轮询调用处。仅同 ghostId 的结果可锚入;无回锚时字段缺省。 */
      media?: ToolMediaItem[];
    }
  | WorkGroupRenderItem;

export function isCompletedAssistantMessage(message: ChatMessage): boolean {
  if (message.failedSamplingAttempt) return false;
  return (
    message.turnCompleted === true ||
    (message.turnMoney?.amount ?? 0) > 0 ||
    (typeof message.turnCostUsd === 'number' && message.turnCostUsd > 0) ||
    // turnUsageDetails 也只在 turn 结束时 patch(算不出报价的轮次只落它),
    // 与费用字段一样是等价的收尾信号 —— 少这一条,无金额轮就挂不出 action bar。
    message.turnUsageDetails !== undefined
  );
}

/** 完成态 work_group 可合并的子项:tool_segment / agent_task / thinking /
 *  assistant 工作文字。正常流式正文不会提前折叠;已证实失败的采样输出
 *  复用活动折叠,无需等待成功答复出现。 */
function isWorkChild(it: RenderItem): it is WorkChildItem {
  return (
    it.type === 'tool_segment' ||
    it.type === 'agent_task' ||
    (it.type === 'message' &&
      (it.message.role === 'thinking' ||
        (it.message.role === 'assistant' && !it.message.systemCardType)))
  );
}

/** 运行中(未到终态)的子 Agent 卡片 —— 折叠时视为"可见锚点",绝不折进
 *  「已工作 Xs」工作组:任务没完成就归档会谎报终态时长(典型:后台 workflow
 *  子 Agent 仍在跑,父 turn 却已产出最终正文)。status 派生口径与 AgentTaskCard
 *  完全一致:配对的最终 result 会把 stale running 收敛为 completed,但不覆盖
 *  failed/stopped 等明确终态,
 *  保证"卡片显示运行中"与"是否折叠"永远同步。 */
// A paired final result closes a stale running update; this must match AgentTaskCard.
function isRunningAgentTask(it: RenderItem): boolean {
  if (it.type !== 'agent_task') return false;
  const status = deriveAgentTaskStatus(it.update?.status, it.result, {
    persistedStatus: it.persistedStatus,
    durableStatus: it.durableStatus,
    resultIsLaunchReceipt:
      subagentSpawnReceiptName(it.toolCall?.toolName, it.toolCall?.toolInput, it.result) !==
        undefined || subagentSpawnResultIndicatesRunning(it.toolCall?.toolName, it.result),
  });
  return status === 'running';
}

/** workflow 卡永远平铺,完成后也不折进工作组:它是后台任务面板的常驻入口,
 *  折叠掉等于把入口藏起来(产品拍板 2026-07-27:完成后保留痕迹、可点击进
 *  面板详情;对齐官方——原版完成的 workflow 行留在对话里)。 */
function isWorkflowTaskItem(it: RenderItem): boolean {
  return (
    it.type === 'agent_task' &&
    (it.update?.taskType === 'local_workflow' || it.toolCall?.toolName === 'Workflow')
  );
}

/** Normal assistant progress stays in the main stream. SDK-proven failed
 * sampling output uses the existing work fold even before a retry succeeds. */
function isWorkActivityItem(it: RenderItem): it is WorkChildItem {
  return (
    !isRunningAgentTask(it) &&
    // workflow 卡三条分组路径(answered/legacy/active)统一平铺,见 isWorkflowTaskItem。
    !isWorkflowTaskItem(it) &&
    (it.type === 'tool_segment' ||
      it.type === 'agent_task' ||
      (it.type === 'message' && (it.message.role === 'thinking' ||
        (it.message.role === 'assistant' && it.message.failedSamplingAttempt === true))))
  );
}

/**
 * 交付正文 item —— 无论落在 turn 的哪个位置都不折进「已工作 Xs」。
 *
 * 为什么只靠 seal 位置不够:「最终答复」只认最后一次动作之后的正文,而 agent
 * 常见「先输出正文 → 再执行一个收尾副作用(发通知 / 落库 / 提交) → 再说一句
 * 已完成」。这时真正的交付内容排在收尾动作之前,会被整段折起来,只剩收尾那句
 * 元数据留在消息流里(实例:2026-07-31 定时巡检的产品决策简报 3250 字被折,
 * 外面只剩 110 字的「已触发通知」)。
 *
 * 正文判据(长度 / 块级 markdown 结构 / 内嵌图片)由 maker-shared 的 isDeliveryProseText
 * 单一提供,两端不各写一份;桌面消息另带 images / files 附件,附件本身就是交付成果。
 */
function isDeliveryProseItem(it: RenderItem): boolean {
  return (
    it.type === 'message' &&
    it.message.role === 'assistant' &&
    !it.message.failedSamplingAttempt &&
    !it.message.systemCardType &&
    (Boolean(it.message.images?.length || it.message.files?.length) ||
      isDeliveryProseText(it.message.content))
  );
}

/** 最终可见正文候选:同一用户 turn 内最后一条普通 assistant 文本。 */
function isAssistantAnswerCandidate(it: RenderItem): it is MessageRenderItem {
  return (
    it.type === 'message' &&
    it.message.role === 'assistant' &&
    !it.message.failedSamplingAttempt &&
    !it.message.systemCardType &&
    it.message.content.trim().length > 0
  );
}

/** 自动压缩会开始新的 live 工作片段,因此也必须结束压缩前的动作组。 */
function isCompactBoundaryItem(it: RenderItem): it is MessageRenderItem {
  return (
    it.type === 'message' &&
    it.message.role === 'assistant' &&
    it.message.systemCardType === 'compact'
  );
}

/** 子项的稳定 clientId(group key 派生用)。 */
function workChildClientId(it: WorkChildItem): string {
  if (it.type === 'tool_segment') return it.toolCalls[0].clientId;
  if (it.type === 'agent_task') {
    return (
      it.toolCall?.clientId ??
      it.update?.parentToolUseId ??
      it.update?.taskId ??
      (it.key.startsWith('task-update-') ? it.key.slice('task-update-'.length) : it.key)
    );
  }
  return it.message.clientId;
}

/** group 的身份锚在首个真实活动(tool / thinking / agent task)。
 *  完成后的合并组沿用第一段的锚点,保持该段的手动展开态。 */
function workGroupClientId(run: WorkChildItem[]): string {
  const firstActivity = run.find((it) => it.type !== 'message' || it.message.role === 'thinking');
  return workChildClientId(firstActivity ?? run[0]);
}

export function renderItemStartMs(item: RenderItem): number | null {
  if (item.type === 'message') {
    const ms = Date.parse(item.message.createdAt ?? '');
    return Number.isFinite(ms) ? ms : null;
  }
  if (item.type === 'tool_segment') {
    const ms = Date.parse(item.toolCalls[0]?.createdAt ?? '');
    return Number.isFinite(ms) ? ms : null;
  }
  if (item.type === 'agent_task') {
    const ms = Date.parse(item.toolCall?.createdAt ?? item.update?.createdAt ?? '');
    return Number.isFinite(ms) ? ms : null;
  }
  if (item.type === 'agent_plan') {
    const ms = Date.parse(item.createdAt ?? '');
    return Number.isFinite(ms) ? ms : null;
  }
  // ghost_card 是那次调用在流里的**唯一**呈现(工具行被卡片取代),所以它必须
  // 报出调用时间。漏掉的后果是间隔判定把它当"无时间戳"跳过:空洞后的第一个
  // 动作恰好是卡片时切不开,卡片还会被归到空洞前那一组里(#676 review)。
  if (item.type === 'ghost_card') {
    const ms = Date.parse(item.toolCall.createdAt ?? '');
    return Number.isFinite(ms) ? ms : null;
  }
  if (item.type === 'work_group') {
    for (const child of item.children) {
      const childMs = renderItemStartMs(child);
      if (childMs !== null) return childMs;
    }
  }
  // 剩下两类**故意**不报时间,不是漏:
  //  - tool_media:段产物,永远紧跟在派生它的 tool_segment 之后(见 flushSegment),
  //    锚点留在段末正是它自己的时间区间,单独给它一个时间戳没有意义。
  //  - fork_origin:分叉标记,不是动作,不该参与间隔判定。
  return null;
}

/**
 * item 的结束时间戳 —— 空洞判定必须用它,不能用 start。
 *
 * 一个合法连续 turn 里的 tool_segment 本身可能跨半小时以上(段内每次相邻调用都在
 * 阈值内,所以不会被切段)。若拿下一条 item 的 start 去跟这个段的 **start** 比,
 * 差值就等于整段耗时,会把正常长任务误判成历史空洞:该切的没切,不该切的切了,
 * 前面的 assistant 进度文字被留在工作组外,时长也退化成段兜底而非最终答复。
 *
 * 段的结束必须算进 tool_result:单次工具跑半小时以上时(典型:一次长构建 / CI),
 * 段里只有一个 tool_use,它的 createdAt 是"开始执行"的时刻,拿它当段末会把结束
 * 时间低估整个执行时长,紧随其后的最终答复照样被误判成空洞。
 */
export function renderItemEndMs(item: RenderItem): number | null {
  if (item.type === 'tool_segment') {
    let latest = Number.NEGATIVE_INFINITY;
    for (const call of item.toolCalls) {
      const callMs = Date.parse(call.createdAt ?? '');
      if (Number.isFinite(callMs)) latest = Math.max(latest, callMs);
      const resultMs = item.resultTsMap.get(call.clientId);
      if (resultMs !== undefined) latest = Math.max(latest, resultMs);
    }
    return Number.isFinite(latest) ? latest : renderItemStartMs(item);
  }
  if (item.type === 'agent_task') {
    // fallback 顺序:updatedAt → update.createdAt → toolCall.createdAt。
    // AgentTaskUpdate 可以只有 createdAt 而没有 updatedAt(见 normalizeAgentTaskUpdate),
    // 那时 update.createdAt 比调用发起时刻更接近任务结束 —— 先取 toolCall.createdAt 会
    // 低估结束时间,进而误判空洞、低报工作组时长(#676 review)。
    const ms = Date.parse(
      item.update?.updatedAt ?? item.update?.createdAt ?? item.toolCall?.createdAt ?? '',
    );
    const liveEnd = Number.isFinite(ms) ? ms : renderItemStartMs(item);
    // 历史会话没有 live update 时,liveEnd 退化成调用的开始时间;result 时间戳才是
    // 这张卡真正的结束(与 tool_segment 同口径)。两者取更晚的。
    if (item.resultTsMs === undefined) return liveEnd;
    return liveEnd === null ? item.resultTsMs : Math.max(liveEnd, item.resultTsMs);
  }
  if (item.type === 'ghost_card') {
    const startMs = renderItemStartMs(item);
    if (item.resultTsMs === undefined) return startMs;
    return startMs === null ? item.resultTsMs : Math.max(startMs, item.resultTsMs);
  }
  if (item.type === 'work_group') {
    // 全量取 max,不是"最后一个 child":children 按**发起**时刻排列,并行的 Agent/Task 乱序完成时
    // 真正的结束时刻可能落在更靠前的 child 上(先发起、更晚 settle)。取最后一个会低估组的结束
    // 时间,于是空洞判定的锚点变小、把本来连续的 turn 误判成空洞切开 —— 与本函数 tool_segment
    // 分支、以及 groupWorkRuns 里 prevEndMs 的 Math.max 是同一条理由(#676 review codex P1)。
    // 手机端同款函数(maker-shared 的 itemEndTimestamp)已按此收敛,#1210 review 指出这里镜像存在。
    let latest: number | null = null;
    for (const child of item.children) {
      const childMs = renderItemEndMs(child);
      if (childMs === null) continue;
      latest = latest === null ? childMs : Math.max(latest, childMs);
    }
    return latest;
  }
  // thinking 的 createdAt 是块**开始**的时刻,真正结束要加 thinkingDurationMs
  // (与 workRunEndTs 同口径)。一个想了半小时以上的 thinking 块后面紧跟工具或正文时,
  // 只看 createdAt 会把它误判成历史空洞、切开一个本来连续的 turn。
  const startMs = renderItemStartMs(item);
  if (startMs !== null && item.type === 'message' && item.message.role === 'thinking') {
    // duration 与 mapServerCreatedAt 同口径夹断:该字段可能是负数 / 非有限值(那边就做了
    // Math.max(0, …) 的防御)。不夹断会得出 end < start,空洞判定与工作组时长都跟着错
    // (#676 review copilot)。
    const durationMs = item.message.thinkingDurationMs;
    const safeDurationMs =
      typeof durationMs === 'number' && Number.isFinite(durationMs) ? Math.max(0, durationMs) : 0;
    return startMs + safeDurationMs;
  }
  return startMs;
}

/** 消息 createdAt → epoch ms,缺失 / 非法返回 null。 */
export function messageTs(msg: ChatMessage): number | null {
  if (!msg.createdAt) return null;
  const t = new Date(msg.createdAt).getTime();
  return Number.isFinite(t) ? t : null;
}

/** 边界项(用户消息 / assistant 正文)的时间戳;非 message 项(卡片等)返回 null,
 *  让下一段退回段内锚点,避免把已折叠段的时长重复计入。 */
function boundaryTs(item: RenderItem | undefined): number | null {
  return item && item.type === 'message' ? messageTs(item.message) : null;
}

/** run 首子项的起始时间戳。 */
function workRunStartTs(it: WorkChildItem): number | null {
  if (it.type === 'tool_segment') return messageTs(it.toolCalls[0]);
  if (it.type === 'agent_task') return renderItemStartMs(it);
  return messageTs(it.message);
}

/**
 * run 末子项的结束时间戳 —— 直接复用 renderItemEndMs,不再自己算一份。
 *
 * 原来这里另算一份:tool_segment 取**最后一次调用的发起时刻**、agent_task 取
 * `updatedAt ?? toolCall.createdAt`,两者都不看 tool_result 时间。于是"一个跑了 40 分钟的
 * 工具 / Task 之后紧跟一段历史空洞、后面没有 assistant 正文"时,createWorkGroup 拿不到
 * nextItem、回落到这里,时长显示成约 0s —— 而 renderItemEndMs 明明已经算得出真正的结束
 * 时间(#676 review codex P1)。两处口径合一,顺带修掉 agent_task 那个把
 * `toolCall.createdAt` 排在 `update.createdAt` 前面的旧 fallback 顺序。
 */
function workRunEndTs(it: WorkChildItem): number | null {
  return renderItemEndMs(it);
}

/**
 * 没有终结正文可用时,run 的结束时间 = **所有子项结束时间的最大值**。
 *
 * 不能"从后往前找第一个有时间的子项就返回":并行的 Agent/Task 会乱序完成(A 跑到 40 分钟,
 * B 紧随其后 2 分钟就结束),末尾那张卡的结束时间可能远早于整段真正的结束。被空洞收尾的组
 * 正好走这条 fallback(没有 nextItem),于是 40 分钟的工作显示成约 2 分钟 —— 而空洞判定那边
 * 用的已经是正确的最大值(#676 review codex P1)。
 */
function workRunFallbackEndTs(run: WorkChildItem[]): number | null {
  let latest: number | null = null;
  for (const item of run) {
    const ts = workRunEndTs(item);
    if (ts === null) continue;
    latest = latest === null ? ts : Math.max(latest, ts);
  }
  return latest;
}

function createWorkGroup(
  run: WorkChildItem[],
  nextItem: RenderItem | undefined,
  isStreaming = false,
  prevBoundaryTs: number | null = null,
): Extract<RenderItem, { type: 'work_group' }> {
  const firstActivity = run.find((it) => it.type !== 'message' || it.message.role === 'thinking');
  const anchorTs = workRunStartTs(firstActivity ?? run[0]);
  // 段起点优先锚上一个边界(用户消息 / 上一句正文),与「正在工作…」活表的墙钟
  // 口径一致:一次性到达的 thinking 块 createdAt≈结束时刻,只用段内锚点会把
  // 模型思考整段丢掉(实际 6s 显示 1s,内层相加也对不上外层总表)。边界缺失
  // (窗口截断)或时序异常(rewind 改序)时退回段内锚点。
  const startTs =
    prevBoundaryTs !== null && (anchorTs === null || prevBoundaryTs <= anchorTs)
      ? prevBoundaryTs
      : anchorTs;
  const endTs =
    nextItem && nextItem.type === 'message'
      ? messageTs(nextItem.message)
      : workRunFallbackEndTs(run);
  const durationMs =
    startTs !== null && endTs !== null && endTs >= startTs ? endTs - startTs : undefined;
  return {
    type: 'work_group',
    key: `work-${workGroupClientId(run)}`,
    children: run,
    durationMs,
    isStreaming,
    ...(startTs !== null ? { startedAtMs: startTs } : {}),
  };
}

/** 完成态时间线:assistant 工作文字直接成为外组子项,文字之间的连续动作
 *  继续复用 createWorkGroup 生成内层「已工作 Xs」。外组使用独立 key,
 *  避免与第一段动作共享展开记忆;内组 key 保持不变,从运行中到完成后连续。 */
function createCompletedWorkGroup(
  run: WorkChildItem[],
  nextItem: RenderItem | undefined,
  prevBoundaryTs: number | null = null,
): WorkGroupRenderItem {
  const hasAssistantText = run.some(
    (item) => item.type === 'message' && item.message.role === 'assistant' && !item.message.failedSamplingAttempt,
  );
  if (!hasAssistantText) return createWorkGroup(run, nextItem, false, prevBoundaryTs);

  const children: WorkGroupChildItem[] = [];
  let activityRun: WorkChildItem[] = [];
  let innerPrevBoundaryTs = prevBoundaryTs;
  const flushActivityRun = (activityNextItem: RenderItem | undefined) => {
    if (activityRun.length === 0) return;
    children.push(createWorkGroup(activityRun, activityNextItem, false, innerPrevBoundaryTs));
    activityRun = [];
  };

  for (const item of run) {
    if (isWorkActivityItem(item)) {
      activityRun.push(item);
      continue;
    }
    flushActivityRun(item);
    children.push(item);
    innerPrevBoundaryTs = boundaryTs(item);
  }
  flushActivityRun(nextItem);

  const outer = createWorkGroup(run, nextItem, false, prevBoundaryTs);
  return {
    ...outer,
    key: `work-summary-${workGroupClientId(run)}`,
    children,
    isStreaming: false,
  };
}

/** Keep desktop card shapes and stable keys while sharing turn, gap and answer boundaries. */
export function groupWorkRuns(items: RenderItem[], isSessionStreaming: boolean): RenderItem[] {
  return groupSharedWorkRuns<RenderItem, WorkChildItem>(items, isSessionStreaming, {
    isUserBoundary: (item) => item.type === 'message' && item.message.role === 'user' && !isSteerUserRow(item.message),
    isContinuationBoundary: (item) => item.type === 'message' && isContinuationMessage(item.message),
    isAnswer: isAssistantAnswerCandidate,
    canPrependToAnswer: (item) => item.type !== 'message' || item.message.assistantPhase !== 'commentary',
    isSealedAnswer: (item) => item.type === 'message' && isCompletedAssistantMessage(item.message),
    isCompactBoundary: isCompactBoundaryItem,
    isActivity: isWorkActivityItem,
    isArchivable: (item): item is WorkChildItem =>
      !isRunningAgentTask(item) &&
      !isWorkflowTaskItem(item) &&
      !isDeliveryProseItem(item) &&
      isWorkChild(item),
    startTimestamp: renderItemStartMs,
    endTimestamp: renderItemEndMs,
    boundaryTimestamp: boundaryTs,
    userBoundaryEnd: (item, previousEnd) => renderItemEndMs(item) ?? previousEnd,
    createGroup: createWorkGroup,
    createCompletedGroup: createCompletedWorkGroup,
  });
}