@tutti-os/agent-gui 0.0.233 → 0.0.234

package/dist/chunk-A4KKC324.js

@@ -0,0 +1,4768 @@
+import {
+  extractAgentMcpToolTarget,
+  extractExitPlanKeepPlanningOptionId,
+  extractExitPlanModeOptions,
+  isExitPlanSwitchModeInput,
+  normalizeAgentApprovalPurpose,
+  normalizeAskUserQuestions,
+  resolveWorkspaceFilePathCandidate
+} from "./chunk-XWPHTXEM.js";
+import {
+  isWorkspaceAgentSyntheticControlMessage
+} from "./chunk-XJ34OIEQ.js";
+import {
+  extractImageGenerationPreview,
+  isImageGenerationToolCall,
+  resolveImageGenerationCanonicalToolName
+} from "./chunk-JDVP33S5.js";
+import {
+  fileChangeCountFromChanges,
+  fileChangeEntriesFromChanges,
+  fileChangeTypeValue
+} from "./chunk-F5UR6EJG.js";
+import {
+  translate
+} from "./chunk-WXLO33YP.js";
+import {
+  AGENT_PASTED_TEXT_MENTION_KIND
+} from "./chunk-FGLQZ6I4.js";
+
+// shared/agentConversation/projection/agentMessageFinalTextProjection.ts
+function projectAgentMessageFinalText(rows, detail) {
+  const finalTextTargetKeys = findLatestAssistantFinalTextTargetKeys(
+    rows,
+    buildAssistantFinalTextEligibleTurnIds(detail)
+  );
+  return rows.map((row) => {
+    if (row.kind !== "message") {
+      return row;
+    }
+    let changed = false;
+    const messages = row.messages.map((message) => {
+      const isTurnFinalText = row.speaker === "assistant" && finalTextTargetKeys.has(messagePresentationTargetKey(row, message));
+      const copyText = row.speaker === "user" ? copyTextForUserMessage(message) : isTurnFinalText ? message.body : null;
+      if ((message.copyText ?? null) === copyText && message.isTurnFinalText === (isTurnFinalText ? true : void 0)) {
+        return message;
+      }
+      changed = true;
+      const nextMessage = isTurnFinalText ? { ...message, isTurnFinalText: true } : omitTurnFinalText(message);
+      if (copyText) {
+        return { ...nextMessage, copyText };
+      }
+      const { copyText: _copyText, ...withoutCopyText } = nextMessage;
+      return withoutCopyText;
+    });
+    return changed ? { ...row, messages } : row;
+  });
+}
+function omitTurnFinalText(message) {
+  const { isTurnFinalText: _isTurnFinalText, ...withoutTurnFinalText } = message;
+  return withoutTurnFinalText;
+}
+function buildAssistantFinalTextEligibleTurnIds(detail) {
+  const ids = /* @__PURE__ */ new Set();
+  detail.turns.forEach((turn, index) => {
+    if (index < detail.turns.length - 1 || isLatestTranscriptTurnSettled(detail)) {
+      ids.add(turn.id);
+    }
+  });
+  return ids;
+}
+function isLatestTranscriptTurnSettled(detail) {
+  const latestTranscriptTurnId = detail.turns.at(-1)?.id;
+  const canonicalTurn = detail.sessionTurns?.find(
+    (turn) => turn.turnId === latestTranscriptTurnId
+  );
+  const activeTurn = detail.session.activeTurn;
+  if (activeTurn && activeTurn.turnId === latestTranscriptTurnId && activeTurn.phase !== "settled") {
+    return false;
+  }
+  if (canonicalTurn) {
+    return canonicalTurn.phase === "settled" && detail.showProcessingIndicator !== true;
+  }
+  const activePhase = activeTurn?.phase ?? "";
+  return detail.showProcessingIndicator !== true && !["submitted", "running", "waiting", "settling"].includes(activePhase);
+}
+function findLatestAssistantFinalTextTargetKeys(rows, eligibleTurnIds) {
+  const targetKeys = /* @__PURE__ */ new Set();
+  const coveredTurnIds = /* @__PURE__ */ new Set();
+  for (let rowIndex = rows.length - 1; rowIndex >= 0; rowIndex -= 1) {
+    const row = rows[rowIndex];
+    if (row?.kind !== "message" || row.speaker !== "assistant" || coveredTurnIds.has(row.turnId) || !eligibleTurnIds.has(row.turnId)) {
+      continue;
+    }
+    for (let messageIndex = row.messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+      const message = row.messages[messageIndex];
+      if (message && isSettledAssistantFinalTextCandidate(message)) {
+        targetKeys.add(messagePresentationTargetKey(row, message));
+        coveredTurnIds.add(row.turnId);
+        break;
+      }
+    }
+  }
+  return targetKeys;
+}
+function messagePresentationTargetKey(row, message) {
+  return `${row.id}\0${message.id}`;
+}
+function copyTextForUserMessage(message) {
+  return isVisibleTextMessage(message) ? message.body : null;
+}
+function isSettledAssistantFinalTextCandidate(message) {
+  return isVisibleTextMessage(message) && message.statusKind !== "working" && message.statusKind !== "waiting";
+}
+function isVisibleTextMessage(message) {
+  return message.body.trim() !== "" && message.contentKind !== "image-grid" && message.contentKind !== "collaboration" && !message.visibleError && !message.systemNotice;
+}
+
+// shared/agentConversation/projection/agentToolGroupingProjection.ts
+var AVOID_GROUPING_EDITS = false;
+function computeAgentToolGroups(sequence, {
+  avoidGroupingEdits = AVOID_GROUPING_EDITS
+}) {
+  const groups = /* @__PURE__ */ new Map();
+  const groupedIndices = /* @__PURE__ */ new Set();
+  const suppressedIndices = /* @__PURE__ */ new Set();
+  let currentCalls = [];
+  let currentEntries = [];
+  let currentIndices = [];
+  let pendingBridgeEntries = [];
+  let pendingBridgeIndices = [];
+  let startIndex = -1;
+  const finalizeGroup = () => {
+    if (currentCalls.length >= 1 && startIndex >= 0 && currentIndices.length > 0) {
+      const endIndex = currentIndices[currentIndices.length - 1] ?? startIndex;
+      groups.set(startIndex, {
+        startIndex,
+        endIndex,
+        calls: [...currentCalls],
+        entries: [...currentEntries]
+      });
+      currentIndices.forEach((index) => groupedIndices.add(index));
+    }
+    currentCalls = [];
+    currentEntries = [];
+    currentIndices = [];
+    pendingBridgeEntries = [];
+    pendingBridgeIndices = [];
+    startIndex = -1;
+  };
+  for (let index = 0; index < sequence.length; index += 1) {
+    const item = sequence[index];
+    if (!item) {
+      continue;
+    }
+    if (item.kind === "tool-call" && isGroupableToolCall(item.call)) {
+      if (avoidGroupingEdits && isEditBoundaryToolCall(item.call)) {
+        finalizeGroup();
+        continue;
+      }
+      if (startIndex < 0) {
+        startIndex = index;
+      }
+      if (pendingBridgeEntries.length > 0) {
+        currentEntries.push(...pendingBridgeEntries);
+        currentIndices.push(...pendingBridgeIndices);
+        pendingBridgeEntries = [];
+        pendingBridgeIndices = [];
+      }
+      currentCalls.push(item.call);
+      currentEntries.push({ kind: "tool-call", call: item.call });
+      currentIndices.push(index);
+      continue;
+    }
+    if (item.kind === "thinking" && startIndex >= 0 && currentCalls.length > 0) {
+      pendingBridgeEntries.push({ kind: "thinking", thinking: item.thinking });
+      pendingBridgeIndices.push(index);
+      continue;
+    }
+    finalizeGroup();
+  }
+  finalizeGroup();
+  return {
+    groups,
+    groupedIndices,
+    suppressedIndices
+  };
+}
+function projectAgentToolGroupRowFromGroup(turnId, group, agentSessionId) {
+  const firstCallId = group.calls[0]?.id ?? "unknown";
+  return {
+    kind: "tool-group",
+    id: `tool-group:${turnId}:${group.calls.map((call) => call.id).join("+")}`,
+    expansionKey: ["tool-group", agentSessionId, turnId, firstCallId].filter(Boolean).join(":"),
+    turnId,
+    grouped: true,
+    calls: group.calls,
+    summary: summarizeToolCallGroup(group.calls),
+    entries: group.entries,
+    occurredAtUnixMs: group.calls.map((call) => call.occurredAtUnixMs ?? 0).reduce((latest, value) => value > latest ? value : latest, 0) || null
+  };
+}
+function projectAgentSingleToolRow(call, turnId = call.turnId) {
+  return {
+    kind: "tool-group",
+    id: `tool-row:${call.id}`,
+    expansionKey: `tool-group:${turnId}:${call.id}`,
+    turnId,
+    grouped: false,
+    calls: [call],
+    summary: null,
+    entries: [{ kind: "tool-call", call }],
+    occurredAtUnixMs: call.occurredAtUnixMs
+  };
+}
+function isGroupableToolCall(call) {
+  switch (call.rendererKind) {
+    case "approval":
+    case "ask-user":
+    case "plan-enter":
+    case "plan-exit":
+    case "task":
+      return false;
+    default:
+      return true;
+  }
+}
+function isEditBoundaryToolCall(call) {
+  return call.rendererKind === "edit" || call.rendererKind === "write";
+}
+function summarizeToolCallGroup(calls) {
+  if (calls.length < 2) {
+    return null;
+  }
+  const changedTargets = dedupeStrings(
+    calls.filter(
+      (call) => call.rendererKind === "edit" || call.rendererKind === "write"
+    ).map((call) => summarizeCallTarget(call.compactSummary ?? call.summary)).filter((value) => value !== null)
+  );
+  if (changedTargets.length === 0) {
+    return null;
+  }
+  if (changedTargets.length === 1) {
+    return `Changed ${changedTargets[0]}`;
+  }
+  return `Changed ${changedTargets[0]} and ${changedTargets.length - 1} more files`;
+}
+function summarizeCallTarget(summary) {
+  const normalized = summary.trim();
+  if (!normalized) {
+    return null;
+  }
+  const firstLine = normalized.split("\n")[0]?.trim() ?? normalized;
+  if (!firstLine) {
+    return null;
+  }
+  const segments = firstLine.split(/[\\/]/).filter(Boolean);
+  return segments.at(-1) ?? firstLine;
+}
+function dedupeStrings(values) {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+
+// shared/agentConversation/projection/agentToolRendererKind.ts
+function resolveAgentToolRendererKind(call, approval = null, askUserQuestion = null, planMode = null, task = null) {
+  const normalizedToolName = normalizeToolName(call.toolName);
+  const normalizedCallType = normalizeCallType(call.callType);
+  if (approval) {
+    return "approval";
+  }
+  if (askUserQuestion) {
+    return "ask-user";
+  }
+  if (normalizedToolName === "askuserquestion") {
+    return "ask-user";
+  }
+  if (planMode?.kind === "enter") {
+    return "plan-enter";
+  }
+  if (normalizedToolName === "enterplanmode") {
+    return "plan-enter";
+  }
+  if (planMode?.kind === "exit") {
+    return "plan-exit";
+  }
+  if (normalizedToolName === "exitplanmode") {
+    return "plan-exit";
+  }
+  if (normalizedCallType === "approval" || normalizedToolName === "approval") {
+    return "approval";
+  }
+  if (task) {
+    return "task";
+  }
+  if (["task", "subagent", "delegatetask", "delegateagent", "agent"].includes(
+    normalizedToolName
+  )) {
+    return "task";
+  }
+  if (isImageGenerationToolCall({
+    toolName: call.toolName,
+    displayName: call.displayName,
+    content: call.content,
+    outputContent: call.output?.content,
+    outputSavedPath: call.output?.savedPath ?? call.output?.saved_path,
+    inputPrompt: call.input?.prompt
+  })) {
+    return "image-generation";
+  }
+  switch (normalizedToolName) {
+    case "read":
+    case "readfile":
+      return "read";
+    case "write":
+    case "writefile":
+      return "write";
+    case "edit":
+    case "editfile":
+    case "multiedit":
+      return "edit";
+    case "bash":
+    case "shell":
+    case "exec":
+    case "execcommand":
+      return "bash";
+    case "grep":
+    case "glob":
+    case "search":
+    case "searchfiles":
+      return "search";
+    case "websearch":
+      return "web-search";
+    case "webfetch":
+      return "web-fetch";
+    case "todowrite":
+      return "todo-write";
+    case "toolsearch":
+      return "tool-search";
+    case "skill":
+      return "skill";
+    default:
+      if (normalizedCallType === "mcp" || normalizedToolName.startsWith("mcp") || hasMcpMetadata(call.metadata)) {
+        return "mcp";
+      }
+      return "default";
+  }
+}
+function inferToolCallType(toolName) {
+  const normalizedToolName = normalizeToolName(toolName);
+  if (normalizedToolName === "approval") {
+    return "approval";
+  }
+  if (["askuserquestion", "enterplanmode", "exitplanmode"].includes(
+    normalizedToolName
+  )) {
+    return "interactive";
+  }
+  if (normalizedToolName.startsWith("mcp")) {
+    return "mcp";
+  }
+  return "tool";
+}
+function isApprovalToolCall(call) {
+  return normalizeCallType(call.callType) === "approval" || normalizeToolName(call.toolName) === "approval";
+}
+function normalizeToolName(value) {
+  return (value ?? "").replace(/[_\s-]+/g, "").trim().toLowerCase();
+}
+function hasMcpMetadata(metadata) {
+  return Boolean(
+    stringValue(metadata?.server) ?? stringValue(metadata?.serverName) ?? stringValue(metadata?.mcpServer)
+  );
+}
+function normalizeCallType(value) {
+  return (value ?? "").trim().toLowerCase();
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+// shared/agentConversation/projection/agentTranscriptPresentation.ts
+function resolveAgentTranscriptPresentationKind(notice) {
+  if (notice?.command !== "compact") {
+    return "content";
+  }
+  if (notice.commandStatus === "running") {
+    return "specific-progress";
+  }
+  if (notice.commandStatus === "completed" || notice.commandStatus === "failed" || notice.commandStatus === "canceled") {
+    return "turn-boundary";
+  }
+  return "content";
+}
+function agentTranscriptRowHasPresentationKind(row, presentationKind) {
+  return Boolean(
+    row?.kind === "message" && row.messages.some(
+      (message) => message.presentationKind === presentationKind
+    )
+  );
+}
+
+// shared/agentConversation/projection/agentApprovalProjection.ts
+function projectAgentApprovalItem(call, input, output) {
+  const callType = normalizeToken(call.callType);
+  const toolName = normalizeToken(call.toolName);
+  if (callType !== "approval" && toolName !== "approval") {
+    return null;
+  }
+  const requestId = stringValue2(input?.requestId) ?? stringValue2(call.payload?.requestId) ?? stringValue2(output?.requestId);
+  if (!requestId) {
+    return null;
+  }
+  const options = normalizeAgentApprovalOptions(
+    input?.options ?? call.payload?.options
+  );
+  if (isExitPlanSwitchModeInput(input)) {
+    return null;
+  }
+  const mcpTarget = extractAgentMcpToolTarget({
+    input,
+    payload: call.payload,
+    toolName: call.toolName,
+    name: call.name
+  });
+  const approvalPurpose = normalizeAgentApprovalPurpose(
+    call.payload?.approvalPurpose
+  );
+  return {
+    kind: "approval",
+    id: call.id,
+    turnId: call.turnId ?? "turn:unknown",
+    requestId,
+    callId: call.id.replace(/^call:/, ""),
+    ...approvalPurpose ? { approvalPurpose } : {},
+    title: mcpTarget?.displayName ?? (call.summary.trim() || call.name),
+    toolName: call.toolName,
+    status: stringValue2(call.payload?.status) ?? call.status,
+    input,
+    options,
+    output,
+    occurredAtUnixMs: call.occurredAtUnixMs ?? null
+  };
+}
+function normalizeAgentApprovalOptions(value) {
+  const values = arrayValue(value) ?? [];
+  return values.flatMap((value2) => {
+    const option = objectValue(value2);
+    const id = stringValue2(option?.optionId) ?? stringValue2(option?.id);
+    if (!id) {
+      return [];
+    }
+    const label = stringValue2(option?.name) ?? stringValue2(option?.label) ?? stringValue2(option?.title) ?? stringValue2(option?.kind) ?? id;
+    return [
+      {
+        id,
+        label,
+        kind: stringValue2(option?.kind) ?? "",
+        ...stringValue2(option?.description) ? { description: stringValue2(option?.description) } : {}
+      }
+    ];
+  });
+}
+function normalizeToken(value) {
+  return (value ?? "").trim().toLowerCase();
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function objectValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function arrayValue(value) {
+  return Array.isArray(value) ? value : null;
+}
+
+// shared/agentConversation/projection/agentInteractiveProjection.ts
+function projectAgentAskUserQuestionItem(call, input, output) {
+  if (normalizeToolName2(call.toolName) !== "askuserquestion") {
+    return null;
+  }
+  const questions = normalizeAskUserQuestions(input?.questions);
+  if (questions.length === 0) {
+    return null;
+  }
+  const answersByQuestionId = objectValue2(output?.answersByQuestionId) ?? {};
+  return {
+    kind: "ask-user",
+    id: call.id,
+    turnId: call.turnId ?? "turn:unknown",
+    requestId: stringValue3(input?.requestId) ?? stringValue3(call.payload?.requestId) ?? call.id.replace(/^call:/, ""),
+    title: call.name,
+    status: call.status,
+    questions: questions.map((question) => ({
+      ...question,
+      answer: answerForQuestion(question.id, answersByQuestionId, output)
+    })),
+    occurredAtUnixMs: call.occurredAtUnixMs ?? null
+  };
+}
+function projectAgentPlanModeItem(call, input) {
+  if (isExitPlanSwitchModeInput(input)) {
+    return {
+      itemKind: "plan-mode",
+      id: call.id,
+      turnId: call.turnId ?? "turn:unknown",
+      requestId: stringValue3(input?.requestId) ?? stringValue3(call.payload?.requestId) ?? call.id.replace(/^call:/, ""),
+      kind: "exit",
+      title: stringValue3(objectValue2(input?.toolCall)?.title) ?? call.name,
+      status: call.status,
+      plan: stringValue3(input?.plan) ?? stringValue3(call.payload?.plan) ?? (call.summary.trim() || null),
+      filePath: stringValue3(input?.filePath) ?? stringValue3(call.payload?.filePath),
+      options: extractExitPlanModeOptions(input),
+      ...keepPlanningOption(extractExitPlanKeepPlanningOptionId(input)),
+      occurredAtUnixMs: call.occurredAtUnixMs ?? null
+    };
+  }
+  const toolName = normalizeToolName2(call.toolName);
+  if (toolName === "enterplanmode") {
+    return {
+      itemKind: "plan-mode",
+      id: call.id,
+      turnId: call.turnId ?? "turn:unknown",
+      kind: "enter",
+      title: call.name,
+      status: call.status,
+      plan: stringValue3(input?.content) ?? (call.summary.trim() || null),
+      filePath: stringValue3(input?.filePath),
+      occurredAtUnixMs: call.occurredAtUnixMs ?? null
+    };
+  }
+  if (toolName !== "exitplanmode") {
+    return null;
+  }
+  return {
+    itemKind: "plan-mode",
+    id: call.id,
+    turnId: call.turnId ?? "turn:unknown",
+    requestId: stringValue3(input?.requestId) ?? stringValue3(call.payload?.requestId) ?? call.id.replace(/^call:/, ""),
+    kind: "exit",
+    title: call.name,
+    status: call.status,
+    plan: stringValue3(input?.plan) ?? stringValue3(call.payload?.plan) ?? (call.summary.trim() || null),
+    filePath: stringValue3(input?.filePath) ?? stringValue3(call.payload?.filePath),
+    occurredAtUnixMs: call.occurredAtUnixMs ?? null
+  };
+}
+function answerForQuestion(questionId, answersByQuestionId, output) {
+  const responsePayload = objectValue2(output?.payload);
+  const responseAnswersByQuestionId = objectValue2(responsePayload?.answersByQuestionId) ?? {};
+  const value = answersByQuestionId[questionId] ?? responseAnswersByQuestionId[questionId];
+  if (Array.isArray(value)) {
+    return value.flatMap(
+      (item) => typeof item === "string" && item.trim() ? [item.trim()] : []
+    );
+  }
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  const answers = arrayValue2(output?.answers) ?? arrayValue2(responsePayload?.answers);
+  return answers && answers.length > 0 ? answers.filter(
+    (item) => typeof item === "string" && item.trim().length > 0
+  ) : null;
+}
+function keepPlanningOption(optionId) {
+  return optionId ? { keepPlanningOptionId: optionId } : {};
+}
+function normalizeToolName2(value) {
+  return (value ?? "").replace(/[_\s-]+/g, "").trim().toLowerCase();
+}
+function stringValue3(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function objectValue2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function arrayValue2(value) {
+  return Array.isArray(value) ? value : null;
+}
+
+// shared/agentConversation/projection/agentTaskProjection.ts
+function projectAgentTaskItem(call, input, output, metadata) {
+  const toolName = normalizeToolName(call.toolName);
+  if (!["task", "subagent", "delegatetask", "delegateagent", "agent"].includes(
+    toolName
+  )) {
+    return null;
+  }
+  const claudeToolResponse = claudeCodeToolResponse(input) ?? claudeCodeToolResponse(output) ?? claudeCodeToolResponse(metadata);
+  const steps = normalizeTaskSteps(
+    arrayValue3(metadata?.steps) ?? arrayValue3(output?.steps) ?? arrayValue3(call.payload?.steps) ?? [],
+    call.turnId ?? "turn:unknown"
+  );
+  return {
+    kind: "task",
+    id: call.id,
+    turnId: call.turnId ?? "turn:unknown",
+    title: call.summary.trim() || call.name,
+    status: stringValue4(metadata?.taskStatus) ?? stringValue4(metadata?.subagentStatus) ?? call.status,
+    prompt: stringValue4(input?.prompt) ?? stringValue4(input?.description) ?? stringValue4(call.payload?.description) ?? stringValue4(claudeToolResponse?.prompt),
+    delegateSessionId: stringValue4(metadata?.childSessionID) ?? stringValue4(metadata?.child_session_id) ?? stringValue4(metadata?.subagentSessionID) ?? stringValue4(metadata?.subagent_session_id) ?? stringValue4(metadata?.subagentAgentId) ?? stringValue4(metadata?.agentId) ?? stringValue4(claudeToolResponse?.agentId),
+    steps,
+    result: firstNonEmptyText(output),
+    resultMarkdown: firstNonEmptyText(output),
+    durationMs: numberValue(metadata?.durationMs) ?? numberValue(output?.durationMs) ?? numberValue(claudeToolResponse?.totalDurationMs),
+    occurredAtUnixMs: call.occurredAtUnixMs ?? null
+  };
+}
+function normalizeTaskSteps(values, turnId) {
+  return values.flatMap((value, index) => {
+    const step = objectValue3(value);
+    if (!step) {
+      return [];
+    }
+    const toolName = stringValue4(step.toolName) ?? stringValue4(step.tool_name) ?? stringValue4(step.name);
+    const callType = stringValue4(step.callType) ?? stringValue4(step.call_type);
+    if (isApprovalToolCall({ toolName, callType })) {
+      return [];
+    }
+    const inputPayload = objectValue3(step.toolInput) ?? objectValue3(step.tool_input);
+    const outputPayload = objectValue3(step.toolResult) ?? objectValue3(step.tool_result);
+    const errorPayload = objectValue3(step.toolError) ?? objectValue3(step.tool_error);
+    const payload = objectValue3(step.payload);
+    const metadata = objectValue3(step.metadata);
+    const content = arrayValue3(step.content);
+    const locations = arrayValue3(step.locations);
+    return [
+      {
+        id: stringValue4(step.toolUseId) ?? stringValue4(step.id) ?? `step-${index + 1}`,
+        turnId,
+        name: toolName ? humanizeToolLabel(toolName) : `Step ${index + 1}`,
+        toolName: toolName ?? null,
+        status: stringValue4(step.status) ?? stringValue4(objectValue3(step.toolResult)?.status) ?? stringValue4(objectValue3(step.tool_result)?.status),
+        summary: firstNonEmptyText(outputPayload, inputPayload) ?? "",
+        payload: {
+          input: inputPayload,
+          output: outputPayload,
+          error: errorPayload
+        },
+        tool: projectAgentTaskStepTool({
+          id: stringValue4(step.toolUseId) ?? stringValue4(step.id) ?? `step-${index + 1}`,
+          turnId,
+          toolName,
+          name: stringValue4(step.name),
+          callType,
+          status: stringValue4(step.status) ?? stringValue4(outputPayload?.status),
+          summary: firstNonEmptyText(outputPayload, inputPayload) ?? "",
+          payload,
+          metadata,
+          input: inputPayload,
+          output: outputPayload,
+          error: errorPayload,
+          content,
+          locations,
+          occurredAtUnixMs: numberValue(step.occurredAtUnixMs)
+        }),
+        occurredAtUnixMs: numberValue(step.occurredAtUnixMs) ?? null
+      }
+    ];
+  });
+}
+function projectAgentTaskStepTool(step) {
+  const call = {
+    id: `call:${step.id}`,
+    turnId: step.turnId,
+    name: step.name ?? (step.toolName ? humanizeToolLabel(step.toolName) : "Tool"),
+    toolName: step.toolName,
+    callType: step.callType ?? inferToolCallType(step.toolName),
+    status: step.status,
+    statusKind: normalizeTaskStepStatus(step.status),
+    summary: step.summary,
+    compactSummary: step.summary || null,
+    payload: step.payload,
+    occurredAtUnixMs: step.occurredAtUnixMs
+  };
+  const approval = projectAgentApprovalItem(call, step.input, step.output);
+  const askUserQuestion = projectAgentAskUserQuestionItem(
+    call,
+    step.input,
+    step.output
+  );
+  const planMode = projectAgentPlanModeItem(call, step.input);
+  const task = projectAgentTaskItem(
+    call,
+    step.input,
+    step.output,
+    step.metadata
+  );
+  const rendererKind = resolveAgentToolRendererKind(
+    {
+      toolName: call.toolName,
+      displayName: call.name,
+      callType: call.callType,
+      input: step.input,
+      output: step.output,
+      content: step.content,
+      metadata: step.metadata
+    },
+    approval,
+    askUserQuestion,
+    planMode,
+    task
+  );
+  return {
+    kind: "tool-call",
+    ...call,
+    turnId: step.turnId,
+    compactSummary: call.compactSummary ?? null,
+    payload: step.payload,
+    toolState: null,
+    input: step.input,
+    output: step.output,
+    error: step.error,
+    metadata: step.metadata,
+    content: step.content,
+    locations: step.locations,
+    occurredAtUnixMs: call.occurredAtUnixMs ?? null,
+    rendererKind,
+    approval,
+    planMode,
+    askUserQuestion,
+    task
+  };
+}
+function humanizeToolLabel(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim().replace(/^\w/, (match) => match.toUpperCase());
+}
+function stringValue4(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function normalizeTaskStepStatus(value) {
+  switch ((value ?? "").trim().toLowerCase()) {
+    case "completed":
+    case "done":
+    case "success":
+    case "succeeded":
+      return "completed";
+    case "failed":
+    case "error":
+    case "errored":
+      return "failed";
+    case "waiting":
+    case "waiting_input":
+    case "waiting_approval":
+      return "waiting";
+    case "running":
+    case "working":
+    case "active":
+      return "working";
+    default:
+      return null;
+  }
+}
+function objectValue3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function arrayValue3(value) {
+  return Array.isArray(value) ? value : null;
+}
+function claudeCodeToolResponse(value) {
+  const meta = objectValue3(value?._meta);
+  const claudeCode = objectValue3(meta?.claudeCode);
+  return objectValue3(claudeCode?.toolResponse);
+}
+function firstNonEmptyText(...values) {
+  for (const value of values) {
+    const text = extractText(value);
+    if (text) {
+      return text;
+    }
+  }
+  return null;
+}
+function extractText(value, depth = 0) {
+  if (depth > 4) {
+    return null;
+  }
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const text = extractText(item, depth + 1);
+      if (text) {
+        return text;
+      }
+    }
+    return null;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    for (const key of [
+      "text",
+      "output",
+      "summary",
+      "message",
+      "patch",
+      "result"
+    ]) {
+      const text = extractText(record[key], depth + 1);
+      if (text) {
+        return text;
+      }
+    }
+    return extractText(record.content, depth + 1);
+  }
+  return null;
+}
+
+// shared/agentConversation/projection/agentToolProjection.ts
+function projectAgentToolCall(call) {
+  const toolState = objectValue4(call.payload?.tool_state);
+  const input = normalizeStandardACPEnvelope(
+    objectValue4(call.payload?.input) ?? objectValue4(toolState?.input)
+  );
+  const output = normalizeStandardACPEnvelope(
+    objectValue4(call.payload?.output) ?? objectValue4(toolState?.output)
+  );
+  const error = normalizeStandardACPEnvelope(
+    objectValue4(call.payload?.error) ?? objectValue4(toolState?.error)
+  );
+  const metadata = objectValue4(call.payload?.metadata);
+  const content = arrayValue4(call.payload?.content);
+  const locations = arrayValue4(call.payload?.locations);
+  const approval = projectAgentApprovalItem(call, input, output);
+  const askUserQuestion = projectAgentAskUserQuestionItem(call, input, output);
+  const planMode = projectAgentPlanModeItem(call, input);
+  const task = projectAgentTaskItem(call, input, output, metadata);
+  const mcpTarget = extractAgentMcpToolTarget({
+    input,
+    metadata,
+    payload: call.payload,
+    toolName: call.toolName,
+    name: call.name
+  });
+  const rendererKind = resolveAgentToolRendererKind(
+    {
+      toolName: call.toolName,
+      displayName: call.name,
+      callType: call.callType,
+      input,
+      output,
+      content,
+      metadata
+    },
+    approval,
+    askUserQuestion,
+    planMode,
+    task
+  );
+  const projectedCall = {
+    kind: "tool-call",
+    ...call,
+    turnId: call.turnId ?? "turn:unknown",
+    name: mcpTarget?.displayName ?? call.name,
+    compactSummary: call.compactSummary ?? call.summary,
+    payload: call.payload ?? null,
+    toolState,
+    input,
+    output,
+    error,
+    metadata,
+    content,
+    locations,
+    rendererKind,
+    approval,
+    askUserQuestion,
+    planMode,
+    task,
+    occurredAtUnixMs: call.occurredAtUnixMs ?? null
+  };
+  if (call.sourceTimelineItems) {
+    projectedCall.sourceTimelineItems = call.sourceTimelineItems;
+  }
+  return projectedCall;
+}
+function objectValue4(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function arrayValue4(value) {
+  return Array.isArray(value) ? value : null;
+}
+function normalizeStandardACPEnvelope(value) {
+  if (!value) return null;
+  const raw = objectValue4(value.rawInput) ?? objectValue4(value.rawOutput);
+  if (!raw) return value;
+  const metadata = objectValue4(raw.metadata);
+  return {
+    ...value,
+    ...raw,
+    ...metadata?.diff !== void 0 ? { diff: metadata.diff } : {},
+    ...metadata?.files !== void 0 ? { files: metadata.files } : {},
+    ...metadata?.structuredPatch !== void 0 ? { structuredPatch: metadata.structuredPatch } : {},
+    ...metadata?.detailedContent !== void 0 ? { detailedContent: metadata.detailedContent } : {},
+    ...metadata?.changes !== void 0 ? { changes: metadata.changes } : {},
+    ...metadata?.exit !== void 0 ? { exitCode: metadata.exit } : {}
+  };
+}
+
+// shared/agentConversation/projection/agentCollaborationProjection.ts
+var COLLABORATION_TIMELINE_ITEM_TYPE = "collaboration";
+function isCollaborationTimelineItem(item) {
+  return item.itemType.trim().toLowerCase() === COLLABORATION_TIMELINE_ITEM_TYPE;
+}
+function projectAgentCollaborationVM(item) {
+  const payload = normalizedPayload(item.payload);
+  if (!payload) {
+    return null;
+  }
+  const runId = stringField(payload, "runId");
+  const mode = stringField(payload, "mode");
+  if (!runId || !mode) {
+    return null;
+  }
+  const status = stringField(payload, "status") ?? item.status?.trim() ?? "running";
+  return {
+    kind: "collaboration",
+    runId,
+    workspaceId: item.workspaceId?.trim() || null,
+    agentSessionId: item.agentSessionId.trim() || null,
+    mode,
+    status,
+    triggerSource: stringField(payload, "triggerSource") ?? "user",
+    triggerReason: stringField(payload, "triggerReason"),
+    targetSessionId: stringField(payload, "targetSessionId"),
+    targetAgentTargetId: stringField(payload, "targetAgentTargetId"),
+    modelPlanId: stringField(payload, "modelPlanId"),
+    modelPlanName: stringField(payload, "modelPlanName") ?? stringField(payload, "planName"),
+    model: stringField(payload, "model"),
+    contextScope: stringField(payload, "contextScope"),
+    resultText: stringField(payload, "resultText"),
+    failureReason: stringField(payload, "failureReason"),
+    durationMs: positiveNumberField(payload, "durationMs"),
+    usage: usageField(payload),
+    adoption: stringField(payload, "adoption") ?? "not_applicable"
+  };
+}
+function usageField(payload) {
+  const usage = normalizedPayload(
+    payload.usage
+  );
+  if (!usage) {
+    return null;
+  }
+  const inputTokens = nonNegativeNumberValue(usage.inputTokens);
+  const outputTokens = nonNegativeNumberValue(usage.outputTokens);
+  if (inputTokens === null && outputTokens === null) {
+    return null;
+  }
+  return {
+    inputTokens: inputTokens ?? 0,
+    outputTokens: outputTokens ?? 0
+  };
+}
+function normalizedPayload(payload) {
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
+}
+function stringField(payload, key) {
+  const value = payload[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function positiveNumberField(payload, key) {
+  const value = nonNegativeNumberValue(payload[key]);
+  return value !== null && value > 0 ? value : null;
+}
+function nonNegativeNumberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+// shared/pastedTextReferenceProjection.ts
+import { createRichTextMentionMarkdown } from "@tutti-os/ui-rich-text/core";
+var PASTED_TEXT_ARCHIVE_PATH_RE = /(?:\/|[A-Za-z]:\\)[^\n]*?agent-prompt-assets[^\n]*?\.txt/;
+function pastedTextDraftDisplayName(index) {
+  return `pasted-text-${index + 1}.txt`;
+}
+function linkifyPastedTextReferences(text) {
+  if (!PASTED_TEXT_ARCHIVE_PATH_RE.test(text)) {
+    return text;
+  }
+  const lines = text.split("\n");
+  const out = [];
+  let refIndex = 0;
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index] ?? "";
+    const path = firstPastedTextArchivePath(line);
+    if (path) {
+      out.push(
+        pastedTextReferenceMentionMarkdown(
+          firstQuotedPreview(line),
+          path,
+          refIndex
+        )
+      );
+      refIndex += 1;
+      continue;
+    }
+    const next = lines[index + 1];
+    if (next != null && firstPastedTextArchivePath(next)) {
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n").trim();
+}
+function firstPastedTextArchivePath(line) {
+  return line.match(PASTED_TEXT_ARCHIVE_PATH_RE)?.[0].trim() ?? null;
+}
+function pastedTextReferenceMentionMarkdown(preview, path, index) {
+  return createRichTextMentionMarkdown({
+    providerId: AGENT_PASTED_TEXT_MENTION_KIND,
+    entityId: `ref-${index}`,
+    label: preview.trim() || pastedTextDraftDisplayName(index),
+    scope: { path }
+  });
+}
+function firstQuotedPreview(line) {
+  return line.match(/"([^"]*)"/)?.[1]?.trim() ?? "";
+}
+
+// shared/agentConversation/projection/agentConversationUserProjection.ts
+function projectConversationUserRow(message, fallbackTurnId, workspaceId) {
+  const turnId = message.turnId ?? fallbackTurnId;
+  return {
+    kind: "message",
+    id: `message:user:${message.id}`,
+    turnId,
+    speaker: "user",
+    messages: projectUserMessageContentParts(message, turnId, workspaceId),
+    thinking: [],
+    occurredAtUnixMs: message.occurredAtUnixMs ?? null
+  };
+}
+function projectUserMessageContentParts(message, turnId, workspaceId) {
+  const blocks = userPromptContentBlocks(message, workspaceId);
+  if (blocks.length === 0) {
+    return [textPart(message, turnId)];
+  }
+  const parts = [];
+  const imageBlocks = blocks.filter(
+    (block) => block.type === "image"
+  );
+  if (imageBlocks.length > 0) {
+    parts.push({
+      kind: "message-content",
+      id: `${message.id}:images:0`,
+      turnId,
+      body: "",
+      presentationKind: "content",
+      contentKind: "image-grid",
+      images: imageBlocks.map((image, index) => ({
+        id: `${message.id}:image:${index}`,
+        workspaceId: image.workspaceId,
+        agentSessionId: image.agentSessionId,
+        attachmentId: image.attachmentId,
+        mimeType: image.mimeType,
+        name: image.name,
+        data: image.data,
+        url: image.url,
+        path: image.path
+      })),
+      occurredAtUnixMs: message.occurredAtUnixMs ?? null,
+      sourceTimelineItems: message.sourceTimelineItems
+    });
+  }
+  blocks.forEach((block, index) => {
+    if (block.type === "image" || block.text.trim() === "") return;
+    parts.push({
+      kind: "message-content",
+      id: `${message.id}:text:${index}`,
+      turnId,
+      body: block.text,
+      presentationKind: "content",
+      contentKind: "text",
+      occurredAtUnixMs: message.occurredAtUnixMs ?? null,
+      sourceTimelineItems: message.sourceTimelineItems
+    });
+  });
+  return parts.length > 0 ? parts : [textPart(message, turnId)];
+}
+function textPart(message, turnId) {
+  return {
+    kind: "message-content",
+    id: message.id,
+    turnId,
+    body: message.body,
+    presentationKind: "content",
+    contentKind: "text",
+    occurredAtUnixMs: message.occurredAtUnixMs ?? null,
+    sourceTimelineItems: message.sourceTimelineItems
+  };
+}
+function userPromptContentBlocks(message, fallbackWorkspaceId) {
+  const item = message.sourceTimelineItems?.find(
+    (candidate) => Array.isArray(candidate.payload?.content)
+  );
+  const content = Array.isArray(item?.payload?.content) ? item.payload.content : null;
+  if (!content) return [];
+  const displayPrompt = firstString(
+    message.sourceTimelineItems?.map(
+      (candidate) => typeof candidate.payload?.displayPrompt === "string" ? candidate.payload.displayPrompt : ""
+    ) ?? []
+  );
+  const visibleDisplayPrompt = isSyntheticImageOnlyDisplayPrompt(
+    displayPrompt,
+    content
+  ) ? "" : displayPrompt;
+  const blocks = content.flatMap((raw) => {
+    const block = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
+    if (!block) return [];
+    if (block.type === "text" && typeof block.text === "string") {
+      return visibleDisplayPrompt ? [] : [{ type: "text", text: linkifyPastedTextReferences(block.text) }];
+    }
+    if (block.type !== "image") return [];
+    const mimeType = typeof block.mimeType === "string" ? block.mimeType.trim() : "";
+    if (!mimeType) return [];
+    return [
+      {
+        type: "image",
+        workspaceId: item?.workspaceId ?? fallbackWorkspaceId ?? null,
+        agentSessionId: item?.agentSessionId ?? message.id,
+        attachmentId: optionalString(block.attachmentId),
+        mimeType,
+        name: optionalString(block.name),
+        data: optionalString(block.data),
+        url: optionalString(block.url),
+        path: optionalString(block.path)
+      }
+    ];
+  });
+  return visibleDisplayPrompt ? [{ type: "text", text: visibleDisplayPrompt }, ...blocks] : blocks;
+}
+function isSyntheticImageOnlyDisplayPrompt(displayPrompt, content) {
+  if (displayPrompt !== "[Image]" && displayPrompt !== "[Images]") {
+    return false;
+  }
+  let imageCount = 0;
+  for (const raw of content) {
+    const block = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
+    if (!block) continue;
+    if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
+      return false;
+    }
+    if (block.type === "image") {
+      imageCount += 1;
+    }
+  }
+  return displayPrompt === "[Image]" ? imageCount === 1 : imageCount > 1;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function firstString(values) {
+  for (const value of values) {
+    const trimmed = value.trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
+}
+
+// shared/agentConversation/projection/agentTurnSequenceProjection.ts
+function buildAgentTurnSequenceItems(turn, workspaceId) {
+  const items = turn.rawAgentItems ?? turn.agentItems;
+  const sequence = turn.userMessages.map(
+    (message) => ({
+      kind: "user-message",
+      row: projectConversationUserRow(message, turn.id, workspaceId)
+    })
+  );
+  items.forEach((item) => {
+    if (item.kind === "message") {
+      sequence.push({
+        kind: "assistant-message",
+        message: projectMessage(item.message, turn.id)
+      });
+      return;
+    }
+    if (item.kind === "thinking") {
+      sequence.push({
+        kind: "thinking",
+        thinking: projectThinking(item.thinking, turn.id)
+      });
+      return;
+    }
+    const sourceEntries = item.groupEntries ?? item.toolCalls.map((call) => ({ kind: "tool-call", call }));
+    sourceEntries.forEach((entry) => {
+      if (entry.kind === "thinking") {
+        sequence.push({
+          kind: "thinking",
+          thinking: projectThinking(entry.thinking, turn.id)
+        });
+        return;
+      }
+      if (isApprovalToolCall(entry.call)) {
+        return;
+      }
+      sequence.push({
+        kind: "tool-call",
+        call: projectAgentToolCall(entry.call)
+      });
+    });
+  });
+  return sortTurnSequenceItems(sequence);
+}
+function sortTurnSequenceItems(sequence) {
+  const positioned = sequence.map((item, sourceIndex) => ({
+    item,
+    sourceIndex,
+    position: turnSequencePosition(item)
+  }));
+  if (positioned.every((entry) => entry.position.seq > 0)) {
+    return positioned.sort(
+      (left, right) => left.position.seq - right.position.seq || left.sourceIndex - right.sourceIndex
+    ).map((entry) => entry.item);
+  }
+  if (positioned.every((entry) => entry.position.occurredAtUnixMs > 0)) {
+    return positioned.sort(
+      (left, right) => left.position.occurredAtUnixMs - right.position.occurredAtUnixMs || left.sourceIndex - right.sourceIndex
+    ).map((entry) => entry.item);
+  }
+  return [...sequence];
+}
+function turnSequencePosition(item) {
+  const sourceItems = turnSequenceSourceItems(item);
+  const seq = minimumPositive(
+    sourceItems.map((sourceItem) => sourceItem.seq ?? 0)
+  );
+  const occurredAtUnixMs = minimumPositive(
+    sourceItems.map(
+      (sourceItem) => sourceItem.occurredAtUnixMs ?? sourceItem.createdAtUnixMs ?? 0
+    )
+  );
+  if (occurredAtUnixMs > 0) {
+    return { seq, occurredAtUnixMs };
+  }
+  switch (item.kind) {
+    case "user-message":
+      return { seq, occurredAtUnixMs: item.row.occurredAtUnixMs ?? 0 };
+    case "assistant-message":
+      return { seq, occurredAtUnixMs: item.message.occurredAtUnixMs ?? 0 };
+    case "thinking":
+      return { seq, occurredAtUnixMs: item.thinking.occurredAtUnixMs ?? 0 };
+    case "tool-call":
+      return { seq, occurredAtUnixMs: item.call.occurredAtUnixMs ?? 0 };
+  }
+}
+function turnSequenceSourceItems(item) {
+  switch (item.kind) {
+    case "user-message":
+      return item.row.messages.flatMap(
+        (message) => message.sourceTimelineItems ?? []
+      );
+    case "assistant-message":
+      return item.message.sourceTimelineItems ?? [];
+    case "thinking":
+      return item.thinking.sourceTimelineItems ?? [];
+    case "tool-call":
+      return item.call.sourceTimelineItems ?? [];
+  }
+}
+function minimumPositive(values) {
+  return values.reduce(
+    (minimum, value) => value > 0 && (minimum === 0 || value < minimum) ? value : minimum,
+    0
+  );
+}
+function projectMessage(message, turnId) {
+  const projected = {
+    kind: "message-content",
+    id: message.id,
+    turnId: message.turnId ?? turnId,
+    body: message.body,
+    presentationKind: resolveAgentTranscriptPresentationKind(
+      message.systemNotice ?? null
+    ),
+    statusKind: message.statusKind ?? null,
+    occurredAtUnixMs: message.occurredAtUnixMs ?? null,
+    visibleError: message.visibleError ?? null,
+    systemNotice: message.systemNotice ?? null
+  };
+  if (message.sourceTimelineItems) {
+    projected.sourceTimelineItems = message.sourceTimelineItems;
+    if (message.sourceTimelineItems.some(
+      (item) => item.payload?.messageKind === "plan"
+    )) {
+      projected.contentKind = "plan";
+    }
+    const collaborationItem = message.sourceTimelineItems.find(
+      isCollaborationTimelineItem
+    );
+    if (collaborationItem) {
+      const collaboration = projectAgentCollaborationVM(collaborationItem);
+      if (collaboration) {
+        projected.contentKind = "collaboration";
+        projected.collaboration = collaboration;
+      }
+    }
+  }
+  return projected;
+}
+function projectThinking(thinking, turnId) {
+  const projected = {
+    kind: "thinking-content",
+    id: thinking.id,
+    turnId: thinking.turnId ?? turnId,
+    body: thinking.body,
+    statusKind: thinking.statusKind ?? null,
+    occurredAtUnixMs: thinking.occurredAtUnixMs ?? null
+  };
+  if (thinking.sourceTimelineItems) {
+    projected.sourceTimelineItems = thinking.sourceTimelineItems;
+  }
+  return projected;
+}
+
+// shared/agentConversation/projection/chunkBy.ts
+function chunkBy(items, sameRun) {
+  const runs = [];
+  for (const item of items) {
+    const current = runs.at(-1);
+    if (current && sameRun(current.at(-1), item)) {
+      current.push(item);
+      continue;
+    }
+    runs.push([item]);
+  }
+  return runs;
+}
+
+// shared/agentConversation/projection/agentTurnRowProjection.ts
+function thinkingAbsorbedByMessage(previous, current) {
+  return previous.tag === "thinking" && current.tag === "message";
+}
+function toRenderUnits(sequence, groups, skippedIndices) {
+  const units = [];
+  for (let index = 0; index < sequence.length; index += 1) {
+    const group = groups.get(index);
+    if (group) {
+      units.push({ tag: "tool-group", group });
+      index = group.endIndex;
+      continue;
+    }
+    if (skippedIndices.has(index)) {
+      continue;
+    }
+    const item = sequence[index];
+    if (!item) {
+      continue;
+    }
+    switch (item.kind) {
+      case "user-message":
+        units.push({ tag: "user-message", row: item.row });
+        break;
+      case "assistant-message":
+        units.push({ tag: "message", message: item.message });
+        break;
+      case "thinking":
+        units.push({ tag: "thinking", thinking: item.thinking });
+        break;
+      case "tool-call":
+        units.push({ tag: "tool", call: item.call });
+        break;
+    }
+  }
+  return units;
+}
+function renderRun(run, turnId, agentSessionId) {
+  const last = run.at(-1);
+  if (!last) {
+    throw new Error("renderRun received an empty run");
+  }
+  if (last.tag === "tool-group") {
+    return projectAgentToolGroupRowFromGroup(
+      turnId,
+      last.group,
+      agentSessionId
+    );
+  }
+  if (last.tag === "tool") {
+    return projectAgentSingleToolRow(last.call, turnId);
+  }
+  if (last.tag === "user-message") {
+    return last.row;
+  }
+  const thinking = run.filter(
+    (unit) => unit.tag === "thinking"
+  ).map((unit) => unit.thinking);
+  if (last.tag === "message") {
+    return {
+      kind: "message",
+      id: `message:assistant:${last.message.id}`,
+      turnId: last.message.turnId,
+      speaker: "assistant",
+      messages: [last.message],
+      thinking,
+      occurredAtUnixMs: last.message.occurredAtUnixMs
+    };
+  }
+  return {
+    kind: "message",
+    id: `message:thinking:${turnId}:${thinking.map((entry) => entry.id).join("+")}`,
+    turnId,
+    speaker: "assistant",
+    messages: [],
+    thinking,
+    occurredAtUnixMs: thinking.at(-1)?.occurredAtUnixMs ?? thinking[0]?.occurredAtUnixMs ?? null
+  };
+}
+function projectTurnRows(sequence, groups, skippedIndices, turnId, agentSessionId) {
+  const units = toRenderUnits(sequence, groups, skippedIndices);
+  return chunkBy(units, thinkingAbsorbedByMessage).map(
+    (run) => renderRun(run, turnId, agentSessionId)
+  );
+}
+
+// shared/agentConversation/projection/agentProcessingProjection.ts
+function projectAgentProcessingRow(detail, rows) {
+  if (!detail.showProcessingIndicator) {
+    return null;
+  }
+  const activeTurnId = detail.session.activeTurnId;
+  const canonicalTurn = detail.sessionTurns?.find(
+    (turn) => turn.turnId === activeTurnId
+  );
+  if (canonicalTurn && canonicalTurn.phase !== "settled" && Number.isFinite(canonicalTurn.startedAtUnixMs)) {
+    if (activeTurnId && hasTurnTimingHostRow(rows, activeTurnId)) {
+      return null;
+    }
+    return processingRow(detail, activeTurnId);
+  }
+  const fallbackTurnId = activeTurnId ?? detail.turns.at(-1)?.id ?? null;
+  if (fallbackTurnId && hasSpecificProgressRow(rows, fallbackTurnId)) {
+    return null;
+  }
+  return processingRow(detail, fallbackTurnId);
+}
+function processingRow(detail, turnId) {
+  return {
+    kind: "processing",
+    id: `processing:${turnId ?? "session"}`,
+    turnId,
+    occurredAtUnixMs: detail.session.updatedAtUnixMs ?? detail.session.createdAtUnixMs ?? null
+  };
+}
+function hasTurnTimingHostRow(rows, activeTurnId) {
+  return rows.some((row) => row.turnId === activeTurnId);
+}
+function hasSpecificProgressRow(rows, activeTurnId) {
+  return rows.some((row) => {
+    if (row.turnId !== activeTurnId) {
+      return false;
+    }
+    return agentTranscriptRowHasPresentationKind(row, "specific-progress") || row.kind === "tool-group" && row.calls.some(
+      (call) => call.statusKind === "working" || call.statusKind === "waiting"
+    );
+  });
+}
+
+// shared/agentConversation/rules/agentPatchMetadata.ts
+function normalizeAgentPatchText(text) {
+  if (!text) {
+    return text;
+  }
+  const contentField = tryExtractContentField(text);
+  if (contentField) {
+    return normalizeAgentPatchText(contentField);
+  }
+  const expanded = !text.includes("\n") && text.includes("\\n") ? text.replace(/\\n/g, "\n") : text;
+  return expanded.replace(/\r\n/g, "\n").split("\n").map(
+    (line) => line.trimStart() === "\" ? "\" : line
+  ).join("\n");
+}
+function extractAgentPatchPath(patchText) {
+  const normalized = normalizeAgentPatchText(patchText ?? "");
+  if (!normalized.trim()) {
+    return null;
+  }
+  const applyPatchPath = extractApplyPatchPath(normalized);
+  if (applyPatchPath) {
+    return applyPatchPath;
+  }
+  const changeType = inferAgentPatchChangeType(normalized);
+  const gitHeader = normalized.match(/^diff --git a\/(.+?) b\/(.+)$/m);
+  const oldPath = gitHeader?.[1]?.trim() ?? null;
+  const newPath = gitHeader?.[2]?.trim() ?? null;
+  if (oldPath || newPath) {
+    return changeType === "deleted" ? nonNullPath(oldPath) ?? nonNullPath(newPath) : nonNullPath(newPath) ?? nonNullPath(oldPath);
+  }
+  if (changeType === "deleted") {
+    return extractOldHeaderPath(normalized);
+  }
+  return extractNewHeaderPath(normalized);
+}
+function inferAgentPatchChangeType(patchText) {
+  const normalized = normalizeAgentPatchText(patchText ?? "").trim();
+  if (!normalized) {
+    return "modified";
+  }
+  if (/^(\*\*\* Delete File:|deleted file mode\b|\+\+\+ \/dev\/null$)/m.test(
+    normalized
+  )) {
+    return "deleted";
+  }
+  if (/^(\*\*\* Add File:|new file mode\b|--- \/dev\/null$)/m.test(normalized)) {
+    return "created";
+  }
+  return "modified";
+}
+function extractApplyPatchPath(text) {
+  const match = text.match(/^\*\*\* (?:Add|Delete|Update) File:\s+(.+?)\s*$/m);
+  return match?.[1]?.trim() || null;
+}
+function extractOldHeaderPath(text) {
+  const match = text.match(/^---\s+(?:a\/)?([^\n]+)$/m);
+  return nonNullPath(match?.[1]?.trim() ?? null);
+}
+function extractNewHeaderPath(text) {
+  const match = text.match(/^\+\+\+\s+(?:b\/)?([^\n]+)$/m);
+  return nonNullPath(match?.[1]?.trim() ?? null);
+}
+function nonNullPath(path) {
+  if (!path || path === "/dev/null" || path === "dev/null") {
+    return null;
+  }
+  return path;
+}
+function tryExtractContentField(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && typeof parsed.content === "string") {
+      return parsed.content;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// shared/agentConversation/projection/agentTurnSummaryFileProjection.ts
+function normalizedFilePath(value, options = {}) {
+  const path = value?.trim() ?? "";
+  if (!path || isStructuredPayloadPath(path) || isIgnoredFilePath(path)) {
+    return null;
+  }
+  return resolveWorkspaceFilePathCandidate({
+    path,
+    workspaceRoot: options.workspaceRoot,
+    basePath: options.defaultCwd
+  }) ? path : null;
+}
+function isIgnoredFilePath(path) {
+  const normalizedPath = path.replace(/\\/g, "/").replace(/\/+$/, "");
+  return normalizedPath === "/dev/null" || normalizedPath === "NUL";
+}
+function isStructuredPayloadPath(path) {
+  if (/[\r\n]/.test(path)) {
+    return true;
+  }
+  if (!path.startsWith("{") && !path.startsWith("[")) {
+    return false;
+  }
+  try {
+    JSON.parse(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function applyShortestUniqueFileLabels(files) {
+  const suffixByPath = shortestUniquePathSuffixByPath(
+    files.map((file) => file.path)
+  );
+  return files.map((file) => ({
+    ...file,
+    label: suffixByPath.get(file.path) ?? file.label
+  }));
+}
+function shortestUniquePathSuffixByPath(paths) {
+  const partsByPath = new Map(
+    paths.map((path) => [path, splitPathSegments(path)])
+  );
+  const labels = /* @__PURE__ */ new Map();
+  const unresolved = new Set(paths);
+  for (let depth = 1; unresolved.size > 0; depth += 1) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const path of unresolved) {
+      const parts = partsByPath.get(path) ?? [];
+      const label = parts.slice(-Math.min(depth, parts.length)).join("/") || parts.at(-1) || path;
+      grouped.set(label, [...grouped.get(label) ?? [], path]);
+    }
+    let resolvedCount = 0;
+    for (const [label, group] of grouped) {
+      if (group.length !== 1 || !group[0]) {
+        continue;
+      }
+      labels.set(group[0], label);
+      unresolved.delete(group[0]);
+      resolvedCount += 1;
+    }
+    if (resolvedCount === 0) {
+      for (const path of unresolved) {
+        labels.set(path, path);
+      }
+      break;
+    }
+  }
+  return labels;
+}
+function splitFilePath(path) {
+  const normalized = path.trim();
+  const parts = splitPathSegments(normalized);
+  if (parts.length <= 1) {
+    return { fileName: parts[0] ?? normalized, directory: null };
+  }
+  return {
+    fileName: parts.at(-1) ?? normalized,
+    directory: parts.slice(0, -1).join("/")
+  };
+}
+function splitPathSegments(path) {
+  return path.trim().split(/[\\/]/).filter(Boolean);
+}
+function normalizeChangeType(value) {
+  switch ((value ?? "").trim().toLowerCase()) {
+    case "add":
+    case "added":
+    case "create":
+    case "created":
+    case "new":
+      return "created";
+    case "modify":
+    case "modified":
+    case "edit":
+    case "edited":
+    case "change":
+    case "changed":
+    case "update":
+    case "updated":
+      return "modified";
+    case "delete":
+    case "deleted":
+    case "remove":
+    case "removed":
+      return "deleted";
+    default:
+      return null;
+  }
+}
+function isFailedToolStatus(value) {
+  const normalized = (value ?? "").trim().toLowerCase();
+  return ["failed", "error", "errored", "canceled", "cancelled"].includes(
+    normalized
+  );
+}
+function objectValue5(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function firstFileChangeValue(...values) {
+  for (const value of values) {
+    if (Array.isArray(value) || objectValue5(value)) {
+      return value;
+    }
+  }
+  return null;
+}
+function arrayValue5(value) {
+  return Array.isArray(value) ? value : null;
+}
+function nestedTaskStepsFromPayload(payload, output) {
+  const candidates = [
+    arrayValue5(payload?.steps),
+    arrayValue5(output?.steps),
+    arrayValue5(objectValue5(payload?.metadata)?.steps),
+    arrayValue5(objectValue5(output?.metadata)?.steps)
+  ];
+  return candidates.find((value) => value && value.length > 0) ?? [];
+}
+function nestedTaskStepStatusKind(step, fallback) {
+  return stringValue5(step.statusKind) ?? stringValue5(step.status) ?? fallback ?? null;
+}
+function stringValue5(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function literalStringValue(value) {
+  return typeof value === "string" ? value : null;
+}
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+function firstPresentString(...values) {
+  for (const value of values) {
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return null;
+}
+
+// shared/agentConversation/projection/agentTurnSummaryProjection.ts
+function projectAgentTurnSummaryRows(detail) {
+  const transcriptTurnsById = new Map(
+    detail.turns.map((turn) => [turn.id, turn])
+  );
+  return (detail.sessionTurns ?? []).flatMap((turn) => {
+    const transcriptTurn = transcriptTurnsById.get(turn.turnId);
+    if (!isSettledTurnSummaryVisible(detail, turn.turnId, turn.phase) || !turn.fileChanges || !transcriptTurn) {
+      return [];
+    }
+    return projectAgentTurnSummaryRowForTurn(transcriptTurn, turn.fileChanges, {
+      defaultCwd: detail.cwd,
+      workspaceRoot: detail.workspaceRoot,
+      occurredAtUnixMs: turn.updatedAtUnixMs
+    });
+  });
+}
+function isSettledTurnSummaryVisible(detail, turnId, phase) {
+  if (phase !== "settled") return false;
+  const activeTurn = detail.session.activeTurn;
+  if (activeTurn?.turnId === turnId && activeTurn.phase !== "settled") {
+    return false;
+  }
+  return detail.showProcessingIndicator !== true || detail.turns.at(-1)?.id !== turnId;
+}
+function projectAgentTurnSummaryRowForTurn(turn, fileChanges, options = {}) {
+  const files = canonicalTurnFiles(turn.id, fileChanges, options);
+  if (files.length === 0) {
+    return [];
+  }
+  const visiblePaths = new Set(files.map((file) => file.path));
+  const patchBatches = patchBatchesFromCalls(
+    turnToolCallsForSummary(turn),
+    options
+  ).flatMap((batch) => {
+    const changes = batch.changes.filter(
+      (change) => visiblePaths.has(change.path)
+    );
+    return changes.length > 0 ? [{ ...batch, changes }] : [];
+  });
+  const createdCount = files.filter(
+    (file) => file.changeType === "created"
+  ).length;
+  return [
+    {
+      kind: "turn-summary",
+      id: `turn-summary:${turn.id}`,
+      turnId: turn.id,
+      files,
+      ...patchBatches.length > 0 ? { patchBatches } : {},
+      fileCount: files.length,
+      modifiedCount: files.length - createdCount,
+      createdCount,
+      occurredAtUnixMs: options.occurredAtUnixMs ?? null
+    }
+  ];
+}
+function canonicalTurnFiles(turnId, fileChanges, options) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const [index, value] of (arrayValue5(objectValue5(fileChanges)?.files) ?? []).entries()) {
+    const file = objectValue5(value);
+    const path = normalizedFilePath(
+      firstNonEmptyString(
+        stringValue5(file?.path),
+        stringValue5(file?.filePath),
+        stringValue5(file?.file_path)
+      ),
+      options
+    );
+    if (!file || !path) {
+      continue;
+    }
+    const parts = splitFilePath(path);
+    byPath.set(path, {
+      label: path,
+      path,
+      fileName: parts.fileName,
+      directory: parts.directory,
+      changeType: normalizeChangeType(
+        firstNonEmptyString(
+          stringValue5(file.change),
+          stringValue5(file.type),
+          stringValue5(file.status)
+        )
+      ) ?? "modified",
+      toolName: null,
+      messageId: `turn-summary:${turnId}:file:${index + 1}`,
+      unifiedDiff: firstNonEmptyString(
+        stringValue5(file.unifiedDiff),
+        stringValue5(file.unified_diff),
+        stringValue5(file.diff),
+        stringValue5(file.patch)
+      ) ?? null,
+      oldString: firstPresentString(
+        literalStringValue(file.oldString),
+        literalStringValue(file.old_string)
+      ),
+      newString: firstPresentString(
+        literalStringValue(file.newString),
+        literalStringValue(file.new_string)
+      ),
+      content: literalStringValue(file.content),
+      occurredAtUnixMs: options.occurredAtUnixMs ?? null
+    });
+  }
+  return applyShortestUniqueFileLabels([...byPath.values()]);
+}
+function turnToolCallsForSummary(turn) {
+  const callsById = /* @__PURE__ */ new Map();
+  for (const call of turn.toolCalls) {
+    callsById.set(call.id, call);
+  }
+  for (const item of turn.agentItems) {
+    if (item.kind !== "tool-calls") {
+      continue;
+    }
+    for (const call of item.toolCalls) {
+      callsById.set(call.id, call);
+    }
+    for (const entry of item.groupEntries ?? []) {
+      if (entry.kind === "tool-call") {
+        callsById.set(entry.call.id, entry.call);
+      }
+    }
+  }
+  return [...callsById.values()];
+}
+function patchBatchesFromCalls(calls, options) {
+  return calls.flatMap((call) => patchBatchesFromCall(call, options));
+}
+function patchBatchesFromCall(call, options) {
+  const directBatch = isFailedToolStatus(call.statusKind ?? null) ? [] : patchBatchFromPayload(call.id, call.payload ?? null, null, null, options);
+  const output = objectValue5(call.payload?.output);
+  const nestedBatches = nestedTaskStepsFromPayload(
+    call.payload,
+    output
+  ).flatMap((value, index) => {
+    const step = objectValue5(value);
+    if (!step || isFailedToolStatus(
+      nestedTaskStepStatusKind(step, call.statusKind ?? null)
+    )) {
+      return [];
+    }
+    return patchBatchFromPayload(
+      stringValue5(step.toolUseId) ?? stringValue5(step.id) ?? `${call.id}:step:${index + 1}`,
+      objectValue5(step.payload),
+      objectValue5(step.toolInput) ?? objectValue5(step.tool_input),
+      objectValue5(step.toolResult) ?? objectValue5(step.tool_result),
+      options
+    );
+  });
+  return [...directBatch, ...nestedBatches];
+}
+function patchBatchFromPayload(id, payload, toolInput, toolOutput, options) {
+  const toolState = objectValue5(payload?.tool_state);
+  const metadata = objectValue5(payload?.metadata);
+  const input = toolInput ?? objectValue5(payload?.input) ?? objectValue5(toolState?.input);
+  const output = toolOutput ?? objectValue5(payload?.output) ?? objectValue5(toolState?.output);
+  const rawInput = objectValue5(input?.rawInput);
+  const changes = firstFileChangeValue(
+    output?.changes,
+    payload?.changes,
+    input?.changes,
+    rawInput?.changes
+  );
+  const patchChanges = patchChangesFromChangeMap(changes);
+  if (patchChanges.length === 0) {
+    return [];
+  }
+  return [
+    {
+      cwd: firstNonEmptyString(
+        stringValue5(payload?.cwd),
+        stringValue5(input?.cwd),
+        stringValue5(rawInput?.cwd),
+        stringValue5(output?.cwd),
+        stringValue5(metadata?.cwd),
+        options.defaultCwd ?? null
+      ) ?? null,
+      toolCallId: id,
+      changes: patchChanges
+    }
+  ];
+}
+function patchChangesFromChangeMap(changes) {
+  return fileChangeEntriesFromChanges(changes).flatMap((entry) => {
+    const change = entry.change;
+    const path = entry.path.trim();
+    if (!path) {
+      return [];
+    }
+    const changeType = normalizeChangeType(fileChangeTypeValue(change));
+    const unifiedDiff = firstNonEmptyString(
+      stringValue5(change.unified_diff),
+      stringValue5(change.unifiedDiff),
+      stringValue5(change.diff),
+      stringValue5(change.patch)
+    ) ?? null;
+    let oldString = firstPresentString(
+      literalStringValue(change.old_string),
+      literalStringValue(change.oldString)
+    );
+    const explicitContent = literalStringValue(change.content);
+    let newString = firstPresentString(
+      literalStringValue(change.new_string),
+      literalStringValue(change.newString),
+      explicitContent
+    );
+    if (changeType === "created" && oldString === null && newString !== null) {
+      oldString = "";
+    }
+    if (changeType === "deleted" && oldString === null && newString !== null) {
+      oldString = newString;
+      newString = "";
+    }
+    if (changeType === "deleted" && newString === null && oldString !== null) {
+      newString = "";
+    }
+    const content = firstPresentString(
+      changeType === "deleted" ? null : explicitContent,
+      changeType === "created" ? newString : null
+    );
+    if (!unifiedDiff && oldString === null && newString === null && content === null) {
+      return [];
+    }
+    return [
+      {
+        path,
+        changeType: changeType ?? inferAgentPatchChangeType(unifiedDiff),
+        unifiedDiff,
+        oldString,
+        newString,
+        content
+      }
+    ];
+  });
+}
+
+// shared/agentConversation/projection/agentConversationProjection.ts
+var RENDER_IRRELEVANT_TRANSCRIPT_ROW_FIELDS = /* @__PURE__ */ new Set(["occurredAtUnixMs"]);
+var CODEX_SKILLS_CONTEXT_BUDGET_NOTICE_FRAGMENT = "skill descriptions were shortened to fit the 2% skills context budget";
+var CODEX_MODEL_METADATA_FALLBACK_NOTICE_FRAGMENT = "defaulting to fallback metadata";
+var MARKDOWN_IMAGE_PATTERN = /!\[[^\]]*]\(\s*(?:<([^>]+)>|([^)\s]+))(?:\s+["'][^"']*["'])?\s*\)/g;
+function projectAgentConversationVM(detail, options = {}) {
+  const rows = [];
+  const turns = detail.turns;
+  const summariesByTurnId = new Map(
+    projectAgentTurnSummaryRows(detail).map((summary) => [
+      summary.turnId,
+      summary
+    ])
+  );
+  turns.forEach((turn) => {
+    rows.push(
+      ...projectTurnConversationRows(turn, detail.session.workspaceId, {
+        agentSessionId: detail.session.agentSessionId,
+        avoidGroupingEdits: options.avoidGroupingEdits
+      })
+    );
+    const summary = summariesByTurnId.get(turn.id);
+    if (summary) rows.push(summary);
+  });
+  const normalizedRows = dropCodexRuntimeDiagnosticNotices(
+    dropRedundantErrorWarningNotices(
+      mergeAdjacentAssistantMessageRows(
+        dropRedundantCompactFailureEchoRows(
+          mergeAdjacentTransportRetryNoticeRows(rows)
+        )
+      )
+    )
+  );
+  const timelineRows = insertGoalControlRows(normalizedRows, detail);
+  const processing = projectAgentProcessingRow(detail, timelineRows);
+  const projectedRows = projectAgentMessageFinalText(
+    processing ? [...timelineRows, processing] : timelineRows,
+    detail
+  );
+  return {
+    activity: detail.activity,
+    workspaceRoot: detail.workspaceRoot,
+    sourceDetail: detail,
+    rows: projectedRows
+  };
+}
+function insertGoalControlRows(rows, detail) {
+  const controls = detail.goalControls ?? [];
+  if (controls.length === 0) {
+    return [...rows];
+  }
+  const merged = [...rows];
+  for (const control of controls) {
+    const row = {
+      kind: "goal-control",
+      id: `goal-control:${control.id}`,
+      turnId: null,
+      action: control.action,
+      body: control.body,
+      occurredAtUnixMs: control.occurredAtUnixMs ?? null,
+      sourceTimelineItems: control.sourceTimelineItems
+    };
+    const insertionIndex = merged.findIndex(
+      (candidate) => row.occurredAtUnixMs !== null && candidate.occurredAtUnixMs !== null && candidate.occurredAtUnixMs > row.occurredAtUnixMs
+    );
+    if (insertionIndex < 0) {
+      merged.push(row);
+    } else {
+      merged.splice(insertionIndex, 0, row);
+    }
+  }
+  return merged;
+}
+function dropRedundantCompactFailureEchoRows(rows) {
+  const filtered = [];
+  for (const row of rows) {
+    const previous = filtered.at(-1);
+    if (isSingleCompactFailureNoticeRow(previous) && isSinglePlainAssistantMessageRow(row) && previous.turnId === row.turnId && previous.messages[0]?.systemNotice?.detail?.trim() === row.messages[0]?.body.trim()) {
+      continue;
+    }
+    filtered.push(row);
+  }
+  return filtered;
+}
+function isSingleCompactFailureNoticeRow(row) {
+  if (!row || row.kind !== "message" || row.speaker !== "assistant" || row.thinking.length > 0 || row.messages.length !== 1) {
+    return false;
+  }
+  const notice = row.messages[0]?.systemNotice;
+  return notice?.command === "compact" && notice.commandStatus === "failed" && Boolean(notice.detail?.trim());
+}
+function isSinglePlainAssistantMessageRow(row) {
+  return row.kind === "message" && row.speaker === "assistant" && row.thinking.length === 0 && row.messages.length === 1 && !row.messages[0]?.visibleError && !row.messages[0]?.systemNotice;
+}
+function latestAssistantMessageText(conversation) {
+  if (!conversation) {
+    return null;
+  }
+  for (let rowIndex = conversation.rows.length - 1; rowIndex >= 0; rowIndex--) {
+    const row = conversation.rows[rowIndex];
+    if (row?.kind !== "message" || row.speaker !== "assistant") {
+      continue;
+    }
+    for (let messageIndex = row.messages.length - 1; messageIndex >= 0; messageIndex--) {
+      const message = row.messages[messageIndex];
+      if (!message || message.visibleError || message.systemNotice) {
+        continue;
+      }
+      if (message.contentKind && message.contentKind !== "text") {
+        continue;
+      }
+      const body = message.body.trim();
+      if (body) {
+        return body;
+      }
+    }
+  }
+  return null;
+}
+function reconcileProjectedAgentConversationVM(previous, next) {
+  if (!previous) {
+    return next;
+  }
+  const previousRowsById = new Map(previous.rows.map((row) => [row.id, row]));
+  let reusedRowCount = 0;
+  const rows = next.rows.map((row) => {
+    const previousRow = previousRowsById.get(row.id);
+    if (previousRow && equivalentTranscriptRowForRender(previousRow, row)) {
+      reusedRowCount += 1;
+      return previousRow;
+    }
+    return row;
+  });
+  const rowsArrayReused = reusedRowCount === next.rows.length && next.rows.length === previous.rows.length && next.rows.every((_row, index) => rows[index] === previous.rows[index]);
+  return {
+    ...next,
+    rows: rowsArrayReused ? previous.rows : rows
+  };
+}
+function equivalentTranscriptRowForRender(previous, next) {
+  return equivalentValueIgnoringKeys(
+    previous,
+    next,
+    RENDER_IRRELEVANT_TRANSCRIPT_ROW_FIELDS
+  );
+}
+function equivalentValueIgnoringKeys(left, right, ignoredKeys) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (typeof left !== typeof right || left === null || right === null) {
+    return false;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every(
+      (value, index) => equivalentValueIgnoringKeys(value, right[index], ignoredKeys)
+    );
+  }
+  if (typeof left !== "object" || typeof right !== "object") {
+    return false;
+  }
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord).filter(
+    (key) => !ignoredKeys.has(key)
+  );
+  const rightKeys = Object.keys(rightRecord).filter(
+    (key) => !ignoredKeys.has(key)
+  );
+  return leftKeys.length === rightKeys.length && leftKeys.every(
+    (key) => Object.prototype.hasOwnProperty.call(rightRecord, key) && equivalentValueIgnoringKeys(
+      leftRecord[key],
+      rightRecord[key],
+      ignoredKeys
+    )
+  );
+}
+function mergeAdjacentAssistantMessageRows(rows) {
+  const merged = [];
+  for (const row of rows) {
+    const previous = merged.at(-1);
+    if (isMergeableAssistantMessageRow(previous) && canMergeAdjacentAssistantMessageRows(previous, row)) {
+      const lastMessage = previous.messages.at(-1);
+      const nextMessage = row.messages[0];
+      if (lastMessage && nextMessage) {
+        lastMessage.body += nextMessage.body;
+        lastMessage.statusKind = nextMessage.statusKind ?? lastMessage.statusKind ?? null;
+        lastMessage.occurredAtUnixMs = nextMessage.occurredAtUnixMs ?? lastMessage.occurredAtUnixMs;
+      }
+      if (row.messages.length > 1) {
+        previous.messages.push(...row.messages.slice(1));
+      }
+      previous.occurredAtUnixMs = row.occurredAtUnixMs ?? previous.occurredAtUnixMs;
+      continue;
+    }
+    merged.push(row);
+  }
+  return merged;
+}
+function dropCodexRuntimeDiagnosticNotices(rows) {
+  const filteredRows = [];
+  for (const row of rows) {
+    if (row.kind !== "message" || row.speaker !== "assistant") {
+      filteredRows.push(row);
+      continue;
+    }
+    const messages = row.messages.filter(
+      (message) => !isCodexSkillsContextBudgetNotice(message)
+    );
+    if (messages.length === 0 && row.thinking.length === 0) {
+      continue;
+    }
+    if (messages.length === row.messages.length) {
+      filteredRows.push(row);
+      continue;
+    }
+    filteredRows.push({ ...row, messages });
+  }
+  return filteredRows;
+}
+function isCodexSkillsContextBudgetNotice(message) {
+  const notice = message.systemNotice;
+  if (!notice || notice.noticeKind !== "warning") {
+    return false;
+  }
+  if (notice.source !== "runtime") {
+    return false;
+  }
+  const text = [notice.title, notice.detail, message.body].filter(Boolean).join("\n").toLowerCase();
+  return text.includes(CODEX_SKILLS_CONTEXT_BUDGET_NOTICE_FRAGMENT) || text.includes(CODEX_MODEL_METADATA_FALLBACK_NOTICE_FRAGMENT);
+}
+function dropRedundantErrorWarningNotices(rows) {
+  const turnsWithVisibleError = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (row.kind !== "message" || row.speaker !== "assistant") {
+      continue;
+    }
+    for (const message of row.messages) {
+      if (message.visibleError) {
+        turnsWithVisibleError.add(row.turnId);
+      }
+    }
+  }
+  if (turnsWithVisibleError.size === 0) {
+    return [...rows];
+  }
+  const filteredRows = [];
+  for (const row of rows) {
+    if (row.kind !== "message" || row.speaker !== "assistant") {
+      filteredRows.push(row);
+      continue;
+    }
+    if (!turnsWithVisibleError.has(row.turnId)) {
+      filteredRows.push(row);
+      continue;
+    }
+    const messages = row.messages.filter(
+      (message) => !isRedundantErrorWarningNotice(message)
+    );
+    if (messages.length === 0) {
+      continue;
+    }
+    if (messages.length === row.messages.length) {
+      filteredRows.push(row);
+      continue;
+    }
+    filteredRows.push({ ...row, messages });
+  }
+  return filteredRows;
+}
+function isRedundantErrorWarningNotice(message) {
+  const notice = message.systemNotice;
+  if (!notice || notice.noticeKind !== "warning") {
+    return false;
+  }
+  const title = notice.title?.trim() ?? "";
+  return title === "Codex reported an error.";
+}
+function mergeAdjacentTransportRetryNoticeRows(rows) {
+  const merged = [];
+  for (const row of rows) {
+    const previous = merged.at(-1);
+    if (isSingleTransportRetryNoticeRow(previous) && isSingleTransportRetryNoticeRow(row) && previous.turnId === row.turnId) {
+      const previousMessage = previous.messages[0];
+      const nextMessage = row.messages[0];
+      if (!previousMessage || !nextMessage) {
+        merged.push(row);
+        continue;
+      }
+      const sourceTimelineItems = mergeSourceTimelineItems(
+        previousMessage.sourceTimelineItems,
+        nextMessage.sourceTimelineItems
+      );
+      previous.messages[0] = {
+        ...previousMessage,
+        body: nextMessage.body || previousMessage.body,
+        systemNotice: nextMessage.systemNotice ?? previousMessage.systemNotice,
+        statusKind: nextMessage.statusKind ?? previousMessage.statusKind ?? null,
+        occurredAtUnixMs: nextMessage.occurredAtUnixMs ?? previousMessage.occurredAtUnixMs,
+        ...sourceTimelineItems ? { sourceTimelineItems } : {}
+      };
+      previous.occurredAtUnixMs = row.occurredAtUnixMs ?? previous.occurredAtUnixMs;
+      continue;
+    }
+    merged.push(row);
+  }
+  return merged;
+}
+function isSingleTransportRetryNoticeRow(row) {
+  if (!row || row.kind !== "message" || row.speaker !== "assistant" || row.thinking.length > 0 || row.messages.length !== 1) {
+    return false;
+  }
+  return row.messages[0]?.systemNotice?.noticeKind === "transport_retry";
+}
+function mergeSourceTimelineItems(previous, next) {
+  if (!previous || previous.length === 0) {
+    return next;
+  }
+  if (!next || next.length === 0) {
+    return previous;
+  }
+  return [...previous, ...next];
+}
+function isMergeableAssistantMessageRow(row) {
+  return Boolean(
+    row && row.kind === "message" && row.speaker === "assistant" && row.thinking.length === 0 && !row.messages.some(isSpecialAssistantMessage)
+  );
+}
+function canMergeAdjacentAssistantMessageRows(previous, next) {
+  return next.kind === "message" && next.speaker === "assistant" && next.thinking.length === 0 && previous.turnId === next.turnId && !next.messages.some(isSpecialAssistantMessage);
+}
+function isSpecialAssistantMessage(message) {
+  return Boolean(
+    message.visibleError || message.systemNotice || message.contentKind === "plan" || message.contentKind === "collaboration"
+  );
+}
+function projectTurnConversationRows(turn, workspaceId, options) {
+  const sequence = buildAgentTurnSequenceItems(turn, workspaceId);
+  const { groups, groupedIndices, suppressedIndices } = computeAgentToolGroups(
+    sequence,
+    options
+  );
+  const skippedIndices = /* @__PURE__ */ new Set([...groupedIndices, ...suppressedIndices]);
+  return promoteGeneratedImageRows(
+    projectTurnRows(
+      sequence,
+      groups,
+      skippedIndices,
+      turn.id,
+      options.agentSessionId
+    )
+  );
+}
+function promoteGeneratedImageRows(rows) {
+  const promoted = [];
+  for (const row of rows) {
+    promoted.push(row);
+    if (row.kind !== "tool-group") {
+      continue;
+    }
+    for (const call of row.calls) {
+      const artifact = projectGeneratedImageRow(call, row.turnId);
+      if (artifact) {
+        promoted.push(artifact);
+      }
+    }
+  }
+  return dropDuplicateGeneratedImageMarkdown(promoted);
+}
+function dropDuplicateGeneratedImageMarkdown(rows) {
+  const generatedImagesByTurn = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.kind !== "generated-image") {
+      continue;
+    }
+    const reference = normalizeGeneratedImageReference(row.uri);
+    if (!reference) {
+      continue;
+    }
+    const references = generatedImagesByTurn.get(row.turnId) ?? /* @__PURE__ */ new Set();
+    references.add(reference);
+    generatedImagesByTurn.set(row.turnId, references);
+  }
+  if (generatedImagesByTurn.size === 0) {
+    return [...rows];
+  }
+  const filtered = [];
+  for (const row of rows) {
+    if (row.kind !== "message" || row.speaker !== "assistant") {
+      filtered.push(row);
+      continue;
+    }
+    const generatedImages = generatedImagesByTurn.get(row.turnId);
+    if (!generatedImages) {
+      filtered.push(row);
+      continue;
+    }
+    let changed = false;
+    const messages = row.messages.flatMap((message) => {
+      const body = removeGeneratedImageMarkdown(message.body, generatedImages);
+      if (body === message.body) {
+        return [message];
+      }
+      changed = true;
+      return body ? [{ ...message, body }] : [];
+    });
+    if (messages.length === 0 && row.thinking.length === 0) {
+      continue;
+    }
+    filtered.push(changed ? { ...row, messages } : row);
+  }
+  return filtered;
+}
+function removeGeneratedImageMarkdown(body, generatedImages) {
+  let removed = false;
+  const next = body.replace(
+    MARKDOWN_IMAGE_PATTERN,
+    (match, angleReference, plainReference) => {
+      const reference = normalizeGeneratedImageReference(
+        angleReference ?? plainReference ?? ""
+      );
+      if (!reference || !generatedImages.has(reference)) {
+        return match;
+      }
+      removed = true;
+      return "";
+    }
+  );
+  return removed ? next.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim() : body;
+}
+function normalizeGeneratedImageReference(reference) {
+  let normalized = reference.trim();
+  if (!normalized) {
+    return null;
+  }
+  if (/^file:\/\//i.test(normalized)) {
+    if (!URL.canParse(normalized)) {
+      return null;
+    }
+    normalized = new URL(normalized).pathname;
+  } else if (/^[a-z][a-z\d+.-]*:\/\//i.test(normalized)) {
+    return URL.canParse(normalized) ? new URL(normalized).href : normalized;
+  }
+  normalized = decodePercentEncodedReference(normalized);
+  normalized = normalized.replaceAll("\\", "/");
+  const prefix = normalized.startsWith("/") ? "/" : "";
+  const parts = [];
+  for (const part of normalized.split("/")) {
+    if (!part || part === ".") {
+      continue;
+    }
+    if (part === ".." && parts.length > 0) {
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  const collapsed = `${prefix}${parts.join("/")}`;
+  return /^[a-z]:\//i.test(collapsed) ? collapsed.toLowerCase() : collapsed;
+}
+function decodePercentEncodedReference(reference) {
+  return reference.replace(/(?:%[a-f\d]{2})+/gi, (encodedRun) => {
+    const bytes = encodedRun.slice(1).split("%").map((hex) => Number.parseInt(hex, 16));
+    return new TextDecoder().decode(Uint8Array.from(bytes));
+  });
+}
+function projectGeneratedImageRow(call, turnId) {
+  if (call.rendererKind !== "image-generation" || call.statusKind !== "completed") {
+    return null;
+  }
+  const image = extractImageGenerationPreview({
+    toolName: call.toolName,
+    displayName: call.name,
+    content: call.content,
+    outputContent: call.output?.content,
+    outputSavedPath: call.output?.savedPath ?? call.output?.saved_path,
+    inputPrompt: call.input?.prompt,
+    payloadInputPrompt: call.payload?.input && typeof call.payload.input === "object" && !Array.isArray(call.payload.input) ? call.payload.input.prompt : null
+  });
+  if (!image.imageUri) {
+    return null;
+  }
+  return {
+    kind: "generated-image",
+    id: `generated-image:${call.id}`,
+    turnId,
+    sourceCallId: call.id,
+    uri: image.imageUri,
+    mimeType: image.mimeType,
+    prompt: image.prompt,
+    occurredAtUnixMs: call.occurredAtUnixMs
+  };
+}
+
+// shared/workspaceAgentSystemNoticeSemantics.ts
+function resolveWorkspaceAgentNoticeCommandSemantics(input) {
+  const semanticCommand = noticeCommand(input.messageSemantics?.noticeCommand);
+  const semanticCommandStatus = noticeCommandStatus(
+    input.messageSemantics?.noticeCommandStatus
+  );
+  const payloadCommand = noticeCommand(
+    recordString(input.payload, "noticeCommand")
+  );
+  const payloadCommandStatus = noticeCommandStatus(
+    recordString(input.payload, "noticeCommandStatus")
+  );
+  const command = semanticCommand ?? payloadCommand;
+  const commandStatus = semanticCommandStatus ?? payloadCommandStatus;
+  if (command && commandStatus) {
+    return { command, commandStatus };
+  }
+  const source = recordString(input.payload, "source");
+  const hasCompactIdentity = source === "compact" || /^(?:claude-sdk:compact:|compaction:)/u.test(input.eventId?.trim() ?? "");
+  if (!hasCompactIdentity) {
+    return null;
+  }
+  const legacyCompactStatus = compactTitleStatus(recordString(input.payload, "title"), input.status) ?? (source === "compact" ? compactStreamStatus(input.status) : null);
+  if (!legacyCompactStatus) {
+    return null;
+  }
+  return {
+    command: "compact",
+    commandStatus: legacyCompactStatus
+  };
+}
+function noticeCommand(value) {
+  switch (value) {
+    case "compact":
+    case "review":
+    case "undo":
+    case "goal":
+      return value;
+    default:
+      return null;
+  }
+}
+function noticeCommandStatus(value) {
+  switch (value) {
+    case "running":
+    case "completed":
+    case "failed":
+    case "canceled":
+      return value;
+    default:
+      return null;
+  }
+}
+function compactTitleStatus(title, status) {
+  switch (title) {
+    case "Compacting context.":
+      return "running";
+    case "Context compacted.":
+      return "completed";
+    case "Context compaction interrupted.":
+      return compactStreamStatus(status) === "canceled" ? "canceled" : "failed";
+    default:
+      return null;
+  }
+}
+function compactStreamStatus(status) {
+  switch (status?.trim().toLowerCase()) {
+    case "completed":
+    case "complete":
+    case "done":
+    case "success":
+    case "succeeded":
+      return "completed";
+    case "failed":
+    case "error":
+      return "failed";
+    case "canceled":
+    case "cancelled":
+    case "stopped":
+      return "canceled";
+    default:
+      return "running";
+  }
+}
+function recordString(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+// shared/workspaceAgentToolCallIdentifiers.ts
+function looksLikeOpaqueToolCallIdentifier(value) {
+  return /^call[_:-](?:function[_:-])?[a-z0-9][a-z0-9_-]{11,}$/i.test(value);
+}
+function isOpaqueWorkspaceAgentToolCallIdentifier(value, item) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return false;
+  }
+  const knownCallId = firstPresentString2(
+    stringRecordValue(item.payload, "callId"),
+    stringRecordValue(item.payload, "callID"),
+    stringRecordValue(item.payload, "call_id"),
+    item.callId
+  );
+  if (knownCallId && normalizeOpaqueToolCallIdentifier(trimmed) === normalizeOpaqueToolCallIdentifier(knownCallId)) {
+    return true;
+  }
+  return looksLikeOpaqueToolCallIdentifier(trimmed);
+}
+function normalizeOpaqueToolCallIdentifier(value) {
+  return value.trim().toLowerCase().replace(/^call:/, "call").replace(/[\s_-]+/gu, "");
+}
+function firstPresentString2(...values) {
+  for (const value of values) {
+    const normalized = value?.trim();
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return "";
+}
+function stringRecordValue(record, key) {
+  if (!record || typeof record !== "object" || Array.isArray(record)) {
+    return void 0;
+  }
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+
+// shared/workspaceAgentToolCallLabels.ts
+var TOOL_ACTIVITY_KIND_TRANSLATION_KEYS = {
+  run_command: "agentHost.agentTool.labels.runCommand",
+  read_file: "agentHost.agentTool.labels.readFile",
+  write_file: "agentHost.agentTool.labels.writeFile",
+  edit_file: "agentHost.agentTool.labels.editFile",
+  list_files: "agentHost.agentTool.labels.listFiles",
+  search_files: "agentHost.agentTool.labels.searchFiles",
+  web_search: "agentHost.agentTool.labels.webSearch",
+  web_fetch: "agentHost.agentTool.labels.webFetch",
+  apply_patch: "agentHost.agentTool.labels.applyPatch",
+  use_tool: "agentHost.agentTool.labels.useTool",
+  find_files: "agentHost.agentTool.labels.findFiles",
+  read_command_output: "agentHost.agentTool.labels.readCommandOutput",
+  stop_command: "agentHost.agentTool.labels.stopCommand",
+  read_notebook: "agentHost.agentTool.labels.readNotebook",
+  edit_notebook: "agentHost.agentTool.labels.editNotebook",
+  update_todos: "agentHost.agentTool.labels.updateTodos",
+  delegate_agent: "agentHost.agentTool.labels.delegateAgent",
+  thinking: "agentHost.agentTool.labels.thinking",
+  responding: "agentHost.agentTool.labels.responding",
+  notification: "agentHost.agentTool.labels.notification"
+};
+var AGENT_ACTIVITY_KINDS = /* @__PURE__ */ new Set([
+  "thinking",
+  "responding",
+  "notification"
+]);
+var TOOL_NAME_TRANSLATION_KEYS = {
+  bash: "agentHost.agentTool.labels.runCommand",
+  read: "agentHost.agentTool.labels.readFile",
+  write: "agentHost.agentTool.labels.writeFile",
+  edit: "agentHost.agentTool.labels.editFile",
+  glob: "agentHost.agentTool.labels.findFiles",
+  grep: "agentHost.agentTool.labels.searchFiles",
+  websearch: "agentHost.agentTool.labels.webSearch",
+  webfetch: "agentHost.agentTool.labels.webFetch",
+  todowrite: "agentHost.agentTool.labels.updateTodos",
+  task: "agentHost.agentTool.labels.delegateAgent",
+  currenttask: "agentHost.agentTool.labels.currentIssue",
+  agent: "agentHost.agentTool.labels.delegateAgent",
+  closeagent: "agentHost.agentTool.labels.closeAgent",
+  wait: "agentHost.agentTool.labels.waitAgent"
+};
+function legacyKindToToolName(kind) {
+  switch (kind) {
+    case "run_command":
+    case "read_command_output":
+    case "stop_command":
+      return "Bash";
+    case "read_file":
+    case "read_notebook":
+    case "list_files":
+      return "Read";
+    case "write_file":
+      return "Write";
+    case "edit_file":
+    case "edit_notebook":
+    case "apply_patch":
+      return "Edit";
+    case "find_files":
+      return "Glob";
+    case "search_files":
+      return "Grep";
+    case "web_search":
+      return "WebSearch";
+    case "web_fetch":
+      return "WebFetch";
+    case "update_todos":
+      return "TodoWrite";
+    case "delegate_agent":
+      return "Task";
+    default:
+      return null;
+  }
+}
+
+// shared/workspaceAgentToolCallCanonical.ts
+function resolveCanonicalToolName(toolName) {
+  const normalized = normalizeToolNameToken(toolName);
+  switch (normalized) {
+    case "imagegeneration":
+    case "imagegen":
+    case "generateimage":
+    case "generatingimage":
+    case "imagegenerate":
+    case "imagegenerator":
+      return "ImageGeneration";
+    case "approval":
+      return "Approval";
+    case "askuserquestion":
+      return "AskUserQuestion";
+    case "enterplanmode":
+      return "EnterPlanMode";
+    case "exitplanmode":
+      return "ExitPlanMode";
+    case "toolsearch":
+      return "ToolSearch";
+    case "skill":
+      return "Skill";
+    case "think":
+      return "Think";
+    case "bash":
+      return "Bash";
+    case "read":
+      return "Read";
+    case "write":
+      return "Write";
+    case "edit":
+      return "Edit";
+    case "glob":
+      return "Glob";
+    case "grep":
+      return "Grep";
+    case "websearch":
+      return "WebSearch";
+    case "webfetch":
+      return "WebFetch";
+    case "todowrite":
+      return "TodoWrite";
+    case "task":
+    case "subagent":
+    case "runsubagent":
+    case "delegatetask":
+    case "delegateagent":
+      return "Agent";
+    case "agent":
+      return "Agent";
+    default:
+      return resolveLegacySnakeCaseToolName(toolName);
+  }
+}
+function resolveLegacySnakeCaseToolName(toolName) {
+  const trimmed = toolName?.trim() ?? "";
+  if (!trimmed || !(trimmed in TOOL_ACTIVITY_KIND_TRANSLATION_KEYS)) {
+    return null;
+  }
+  return legacyKindToToolName(trimmed);
+}
+function resolveLiveCanonicalToolName(item, rawPayloadToolName, legacyACPToolName) {
+  const itemName = (item.name ?? "").trim();
+  if (rawPayloadToolName && looksLikeOpaqueToolCallID(rawPayloadToolName, item)) {
+    return null;
+  }
+  if (rawPayloadToolName && isCanonicalMcpToolName(rawPayloadToolName, item.callType, item.payload)) {
+    return rawPayloadToolName.trim();
+  }
+  if (!isLiveCanonicalToolCall(item) || !hasCanonicalACPPayload(item.payload)) {
+    return void 0;
+  }
+  if (rawPayloadToolName) {
+    if (!shouldFallBackToLegacyACPToolName(
+      rawPayloadToolName,
+      itemName,
+      legacyACPToolName
+    )) {
+      return rawPayloadToolName.trim();
+    }
+    return null;
+  }
+  const normalizedCallType = (item.callType ?? stringPayloadValue(item.payload, "callType") ?? "").trim().toLowerCase();
+  if (normalizedCallType === "tool" || normalizedCallType === "mcp") {
+    return null;
+  }
+  return void 0;
+}
+function shouldFallBackToLegacyACPToolName(rawPayloadToolName, itemName, legacyACPToolName) {
+  const trimmed = rawPayloadToolName.trim();
+  if (!trimmed) {
+    return false;
+  }
+  if (looksLikeOpaqueToolCallIdentifier(trimmed)) {
+    return true;
+  }
+  if (legacyACPToolName === null) {
+    return false;
+  }
+  if (trimmed === itemName) {
+    return true;
+  }
+  return looksLikeOpaqueACPFunctionAlias(trimmed);
+}
+function looksLikeOpaqueACPFunctionAlias(value) {
+  return /^[A-Z][a-z0-9]{9,}$/.test(value);
+}
+function looksLikeOpaqueToolCallID(value, item) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return false;
+  }
+  const payloadCallID = stringPayloadValue(item.payload, "callId") ?? stringPayloadValue(item.payload, "callID") ?? stringPayloadValue(item.payload, "call_id");
+  if (trimmed === item.callId?.trim() || trimmed === payloadCallID?.trim()) {
+    return true;
+  }
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("call_")) {
+    return isOpaqueIdentifierTail(trimmed.slice("call_".length));
+  }
+  if (lower.startsWith("ws_")) {
+    return isOpaqueIdentifierTail(trimmed.slice("ws_".length));
+  }
+  return false;
+}
+function isOpaqueIdentifierTail(value) {
+  return value.length >= 12 && /^[a-z0-9]+$/i.test(value);
+}
+function isCanonicalMcpToolName(toolName, callType, payload) {
+  const trimmed = toolName.trim();
+  if (!trimmed) {
+    return false;
+  }
+  if (trimmed.toLowerCase().startsWith("mcp__")) {
+    return true;
+  }
+  const payloadCallType = stringPayloadValue(payload, "callType");
+  return (callType ?? "").trim().toLowerCase() === "mcp" || (payloadCallType ?? "").trim().toLowerCase() === "mcp";
+}
+function isLiveCanonicalToolCall(item) {
+  const itemType = item.itemType.trim().toLowerCase();
+  return itemType === "call.started" || itemType === "call.completed" || itemType === "call.errored";
+}
+function hasCanonicalACPPayload(payload) {
+  return Boolean(
+    recordPayloadValue(payload, "acp") || stringPayloadValue(payload, "sessionUpdate")
+  );
+}
+function normalizeToolNameToken(value) {
+  return (value ?? "").trim().toLowerCase().replace(/[_\s-]+/g, "");
+}
+function recordPayloadValue(value, key) {
+  const nested = value?.[key];
+  return nested && typeof nested === "object" && !Array.isArray(nested) ? nested : void 0;
+}
+function stringPayloadValue(value, key) {
+  const nested = value?.[key];
+  return typeof nested === "string" ? nested : void 0;
+}
+
+// shared/workspaceAgentToolCallAgentActivity.ts
+var AGENT_ACTIVITY_KINDS2 = /* @__PURE__ */ new Set([
+  "thinking",
+  "responding",
+  "notification"
+]);
+function isAgentActivityTimelineItem(item) {
+  const activityKey = activityPayloadKey(item);
+  if (activityKey.startsWith("agent.")) {
+    return true;
+  }
+  const metadata = recordValue(item.payload, "metadata");
+  const normalizedKind = normalizeToolToken(
+    firstPresentString3(
+      stringRecordValue2(item.payload, "activityKind"),
+      stringRecordValue2(item.payload, "activity_kind"),
+      stringRecordValue2(metadata, "activityKind"),
+      stringRecordValue2(metadata, "activity_kind")
+    )
+  );
+  if (AGENT_ACTIVITY_KINDS2.has(normalizedKind)) {
+    return true;
+  }
+  const normalizedName = (item.name ?? "").trim().toLowerCase().replace(/[.\-\s]+/gu, "_");
+  return normalizedName.startsWith("agent_");
+}
+function activityPayloadKey(item) {
+  const metadata = recordValue(item.payload, "metadata");
+  return firstPresentString3(
+    stringRecordValue2(item.payload, "activityKey"),
+    stringRecordValue2(item.payload, "activity_key"),
+    stringRecordValue2(metadata, "activityKey"),
+    stringRecordValue2(metadata, "activity_key")
+  ).trim().toLowerCase();
+}
+function normalizeToolToken(value) {
+  return value?.trim().toLowerCase().replace(/[-\s]+/gu, "_") ?? "";
+}
+function recordValue(value, key) {
+  const entry = value?.[key];
+  return typeof entry === "object" && entry !== null && !Array.isArray(entry) ? entry : void 0;
+}
+function stringRecordValue2(value, key) {
+  const entry = value?.[key];
+  return typeof entry === "string" ? entry : void 0;
+}
+function firstPresentString3(...values) {
+  return values.find(
+    (value) => typeof value === "string" && value.trim().length > 0
+  ) ?? "";
+}
+
+// shared/workspaceAgentToolCallSummary.ts
+function recordValue2(value, key) {
+  const nested = value?.[key];
+  return nested && typeof nested === "object" && !Array.isArray(nested) ? nested : void 0;
+}
+function stringRecordValue3(value, key) {
+  const nested = value?.[key];
+  return typeof nested === "string" ? nested : void 0;
+}
+function stringArrayRecordValue(value, key) {
+  const nested = value?.[key];
+  return Array.isArray(nested) ? nested.flatMap(
+    (item) => typeof item === "string" && item.trim() ? [item.trim()] : []
+  ) : [];
+}
+function stringArrayFirstRecordValue(value, key) {
+  return stringArrayRecordValue(value, key)[0];
+}
+function arrayRecordValue(value, key) {
+  const nested = value?.[key];
+  return Array.isArray(nested) ? nested.flatMap(
+    (item) => item && typeof item === "object" && !Array.isArray(item) ? [item] : []
+  ) : [];
+}
+function collectToolPaths(metadata, metadataInput, payloadInput) {
+  return Array.from(
+    /* @__PURE__ */ new Set([
+      ...stringArrayRecordValue(metadata, "paths"),
+      ...toolInputPaths(metadataInput),
+      ...toolInputPaths(payloadInput)
+    ])
+  );
+}
+function summarizeToolInput(value) {
+  if (!value) return "";
+  for (const key of [
+    "path",
+    "file_path",
+    "filePath",
+    "filepath",
+    "fileName",
+    "filename",
+    "target_path",
+    "targetPath",
+    "url",
+    "uri",
+    "query",
+    "pattern",
+    "prompt",
+    "instruction",
+    "task",
+    "title",
+    "message",
+    "text",
+    "cmd",
+    "command"
+  ]) {
+    const text = summarizeInputField(value, key);
+    if (text) return text;
+  }
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (isSensitiveKey(key)) continue;
+    const text = summarizeInputValue(key, fieldValue);
+    if (text) return text;
+  }
+  return "";
+}
+function summarizeFileChangeCount(...values) {
+  for (const value of values) {
+    const structuredPatch = arrayRecordValue(value, "structuredPatch");
+    if (structuredPatch.length > 1) return `${structuredPatch.length} files`;
+    const files = arrayRecordValue(recordValue2(value, "fileChanges"), "files");
+    if (files.length > 1) return `${files.length} files`;
+    const count = fileChangeCountFromChanges(value?.changes);
+    if (count > 1) return `${count} files`;
+  }
+  return null;
+}
+function summarizeTodoProgress(value) {
+  const todos = arrayRecordValue(value, "todos");
+  if (todos.length === 0) return null;
+  const completed = todos.filter(
+    (todo) => normalizeToolToken2(stringRecordValue3(todo, "status")) === "completed"
+  ).length;
+  return `${completed}/${todos.length} completed`;
+}
+function summarizeWebDomain(value) {
+  if (!value) return null;
+  try {
+    return new URL(value).hostname.replace(/^www\./, "");
+  } catch {
+    return null;
+  }
+}
+function firstPath(paths) {
+  return paths[0] ?? "";
+}
+function firstPresentString4(...values) {
+  for (const value of values) {
+    const normalized = value?.trim();
+    if (normalized) return normalized;
+  }
+  return "";
+}
+function toolInputPaths(value) {
+  if (!value) return [];
+  return [
+    ...stringValues(
+      value,
+      "path",
+      "file_path",
+      "filePath",
+      "filepath",
+      "fileName",
+      "filename",
+      "target_path",
+      "targetPath"
+    ),
+    ...stringArrayRecordValue(value, "paths"),
+    ...stringArrayRecordValue(value, "file_paths"),
+    ...stringArrayRecordValue(value, "filePaths"),
+    ...stringArrayRecordValue(value, "file_names"),
+    ...stringArrayRecordValue(value, "fileNames"),
+    ...stringArrayRecordValue(value, "filenames")
+  ];
+}
+function summarizeInputField(value, key) {
+  const fieldValue = value[key];
+  if (typeof fieldValue === "string")
+    return formatInputSummary(key, fieldValue);
+  if (Array.isArray(fieldValue)) {
+    const items = fieldValue.flatMap(
+      (item) => typeof item === "string" && item.trim() ? [item.trim()] : []
+    ).slice(0, 3);
+    if (items.length > 0) return formatInputSummary(key, items.join(", "));
+  }
+  if (fieldValue && typeof fieldValue === "object" && !Array.isArray(fieldValue)) {
+    for (const [nestedKey, nestedValue] of Object.entries(
+      fieldValue
+    )) {
+      if (isSensitiveKey(nestedKey)) continue;
+      const text = summarizeInputValue(`${key}.${nestedKey}`, nestedValue);
+      if (text) return text;
+    }
+  }
+  return "";
+}
+function summarizeInputValue(key, value) {
+  return typeof value === "string" && value.trim() ? formatInputSummary(key, value) : "";
+}
+function formatInputSummary(key, value) {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  const prefixless = new Set(
+    [
+      "path",
+      "file_path",
+      "filePath",
+      "filepath",
+      "fileName",
+      "filename",
+      "target_path",
+      "targetPath",
+      "url",
+      "uri",
+      "query",
+      "pattern",
+      "cmd",
+      "command"
+    ].map(normalizeToolToken2)
+  );
+  const text = trimmed.length > 140 ? `${trimmed.slice(0, 139)}\u2026` : trimmed;
+  return prefixless.has(normalizeToolToken2(key)) ? text : `${key}: ${text}`;
+}
+function isSensitiveKey(key) {
+  const normalized = normalizeToolToken2(key);
+  return [
+    "token",
+    "password",
+    "secret",
+    "api_key",
+    "apikey",
+    "authorization"
+  ].some((part) => normalized.includes(part));
+}
+function stringValues(value, ...keys) {
+  return keys.flatMap((key) => {
+    const text = stringRecordValue3(value, key)?.trim();
+    return text ? [text] : [];
+  });
+}
+function normalizeToolToken2(value) {
+  return value?.trim().toLowerCase().replace(/[-\s]+/gu, "_") ?? "";
+}
+
+// shared/workspaceAgentToolCallPresentation.ts
+function itemId(item) {
+  return item.eventId.trim() || `id:${item.id}`;
+}
+function isGenericToolLabel(normalizedTitle) {
+  return normalizedTitle === "tool" || normalizedTitle === "usetool";
+}
+function looksLikeOpaqueToolCallID2(value, item) {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) return false;
+  const metadata = recordValue2(item.payload, "metadata");
+  const callID = firstPresentString4(
+    item.callId,
+    stringRecordValue3(item.payload, "callId"),
+    stringRecordValue3(item.payload, "callID"),
+    stringRecordValue3(item.payload, "call_id"),
+    stringRecordValue3(metadata, "callId"),
+    stringRecordValue3(metadata, "callID"),
+    stringRecordValue3(metadata, "call_id")
+  );
+  if (callID && trimmed === callID) return true;
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("call_")) return isOpaqueTail(trimmed.slice(5));
+  if (lower.startsWith("ws_")) return isOpaqueTail(trimmed.slice(3));
+  return false;
+}
+function toolCallLabel(toolName) {
+  const normalized = normalizeToolNameToken2(toolName);
+  const translationKey = normalized ? TOOL_NAME_TRANSLATION_KEYS[normalized] : null;
+  if (translationKey) return translate(translationKey);
+  if (toolName?.trim()) return humanizeToolName(toolName);
+  return translate("agentHost.agentTool.fallbackName");
+}
+function normalizeToolNameToken2(value) {
+  return (value ?? "").trim().toLowerCase().replace(/[_\s-]+/gu, "");
+}
+function isOpaqueTail(value) {
+  return value.length >= 12 && /^[a-z0-9]+$/i.test(value);
+}
+function humanizeToolName(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+// shared/workspaceAgentToolCallDisplay.ts
+function isWorkspaceAgentToolCallItem(item) {
+  const itemType = item.itemType.trim().toLowerCase();
+  if (isAgentActivityTimelineItem(item)) {
+    return false;
+  }
+  if (itemType === "call" || itemType.startsWith("call.")) {
+    return true;
+  }
+  if (itemType.startsWith("approval.") || itemType.startsWith("interactive.")) {
+    return true;
+  }
+  const payloadCallType = stringRecordValue3(item.payload, "callType");
+  if (payloadCallType === "approval" || payloadCallType === "interactive") {
+    return true;
+  }
+  return isToolActivityTimelineItem(item);
+}
+function buildWorkspaceAgentToolCallDisplay(item) {
+  const toolName = resolveWorkspaceAgentToolName(item);
+  const detail = toolCallDetail(item, toolName);
+  return {
+    id: toolCallId(item),
+    name: toolCallLabel(toolName),
+    ...toolCallStatus(item),
+    ...detail ? { detail } : {}
+  };
+}
+function toolCallId(item) {
+  const metadata = recordValue2(item.payload, "metadata");
+  const callId = firstPresentString4(
+    stringRecordValue3(item.payload, "callId"),
+    stringRecordValue3(item.payload, "callID"),
+    stringRecordValue3(item.payload, "call_id"),
+    stringRecordValue3(metadata, "callId"),
+    stringRecordValue3(metadata, "callID"),
+    stringRecordValue3(metadata, "call_id"),
+    item.callId
+  );
+  return callId ? `call:${callId}` : itemId(item);
+}
+function resolveWorkspaceAgentToolName(item) {
+  const metadata = recordValue2(item.payload, "metadata");
+  const input = recordValue2(item.payload, "input");
+  const output = recordValue2(item.payload, "output");
+  const rawPayloadToolName = firstPresentString4(
+    stringRecordValue3(item.payload, "toolName"),
+    stringRecordValue3(metadata, "toolName"),
+    claudeCodeToolName(input),
+    claudeCodeToolName(output)
+  );
+  const imageGenerationToolName = resolveImageGenerationCanonicalToolName({
+    toolName: rawPayloadToolName,
+    displayName: item.name,
+    content: item.payload?.content,
+    outputContent: output?.content,
+    inputPrompt: input?.prompt
+  });
+  if (imageGenerationToolName) {
+    return imageGenerationToolName;
+  }
+  const canonicalToolName = resolveCanonicalToolName(rawPayloadToolName);
+  if (canonicalToolName) {
+    return canonicalToolName;
+  }
+  const liveCanonicalToolName = resolveLiveCanonicalToolName(
+    item,
+    rawPayloadToolName,
+    resolveLegacyACPToolName(item)
+  );
+  if (typeof liveCanonicalToolName === "string" && liveCanonicalToolName.trim()) {
+    return liveCanonicalToolName;
+  }
+  if (liveCanonicalToolName === null && !rawPayloadToolName) {
+    return null;
+  }
+  return resolveLegacyToolName(item) ?? resolveLegacyNamedToolName(item);
+}
+function resolveFetchToolName(payload) {
+  const input = recordValue2(payload, "input");
+  const action = recordValue2(input, "action");
+  const actionType = normalizeToolToken3(stringRecordValue3(action, "type"));
+  switch (actionType) {
+    case "search":
+    case "search_query":
+    case "web_search":
+      return "WebSearch";
+    case "open_page":
+    case "open":
+    case "fetch":
+    case "web_fetch":
+      return "WebFetch";
+    default:
+      break;
+  }
+  if (firstPresentString4(
+    stringRecordValue3(action, "url"),
+    stringRecordValue3(input, "url")
+  )) {
+    return "WebFetch";
+  }
+  if (firstPresentString4(
+    stringRecordValue3(action, "query"),
+    stringRecordValue3(input, "query"),
+    stringRecordValue3(input, "search_query"),
+    stringRecordValue3(input, "searchQuery")
+  )) {
+    return "WebSearch";
+  }
+  return null;
+}
+function resolveLegacyToolName(item) {
+  const metadata = recordValue2(item.payload, "metadata");
+  const rawKind = stringRecordValue3(item.payload, "activityKind") ?? stringRecordValue3(item.payload, "activity_kind") ?? stringRecordValue3(metadata, "activityKind") ?? stringRecordValue3(metadata, "activity_kind");
+  const normalizedKind = normalizeToolToken3(rawKind);
+  if (AGENT_ACTIVITY_KINDS.has(normalizedKind)) {
+    return null;
+  }
+  if (isToolActivityKind(normalizedKind)) {
+    return legacyKindToToolName(normalizedKind);
+  }
+  return resolveLegacyACPToolName(item);
+}
+function resolveLegacyACPToolName(item) {
+  const input = recordValue2(item.payload, "input");
+  const normalizedKind = normalizeToolToken3(
+    firstPresentString4(
+      stringRecordValue3(item.payload, "kind"),
+      stringRecordValue3(input, "kind")
+    )
+  );
+  const normalizedTitle = normalizeToolToken3(
+    firstPresentString4(
+      stringRecordValue3(item.payload, "title"),
+      stringRecordValue3(input, "title"),
+      item.name
+    )
+  );
+  const fetchToolName = resolveFetchToolName(item.payload);
+  if (fetchToolName) {
+    return fetchToolName;
+  }
+  if (normalizedKind === "fetch") {
+    return "WebFetch";
+  }
+  if (normalizedKind === "read") {
+    return stringRecordValue3(input, "pattern") ? "Glob" : "Read";
+  }
+  if (normalizedKind === "think") {
+    return normalizedTitle === "update_todo" || Array.isArray(input?.todos) ? "TodoWrite" : "Think";
+  }
+  if (normalizedKind === "search") {
+    switch (normalizedTitle) {
+      case "glob":
+      case "find":
+      case "fd":
+      case "file_search":
+        return "Glob";
+      case "grep":
+      case "rg":
+      case "ripgrep":
+      case "codebase_search":
+        return "Grep";
+      default:
+        return "Bash";
+    }
+  }
+  if (normalizedKind === "other") {
+    switch (normalizedTitle) {
+      case "todowrite":
+      case "updatetodo":
+        return "TodoWrite";
+      case "skill":
+        return "Skill";
+      case "task":
+      case "subagent":
+      case "runsubagent":
+      case "delegatetask":
+      case "delegateagent":
+      case "agent":
+        return "Agent";
+      case "rg":
+      case "ripgrep":
+        return "Grep";
+      case "find":
+      case "fd":
+        return "Glob";
+      default:
+        return null;
+    }
+  }
+  switch (normalizedKind) {
+    case "execute":
+    case "exec":
+    case "command":
+    case "shell":
+      return "Bash";
+    case "edit":
+    case "move":
+      return "Edit";
+    case "delete":
+      return "Write";
+    default:
+      return null;
+  }
+}
+function resolveLegacyNamedToolName(item) {
+  const metadata = recordValue2(item.payload, "metadata");
+  const rawTitle = firstPresentString4(
+    stringRecordValue3(item.payload, "tool"),
+    stringRecordValue3(metadata, "tool"),
+    item.name
+  );
+  if (looksLikeOpaqueToolCallID2(rawTitle, item)) {
+    return null;
+  }
+  const normalizedTitle = normalizeToolNameToken2(rawTitle);
+  switch (normalizedTitle) {
+    case "approval":
+      return "Approval";
+    case "askuserquestion":
+      return "AskUserQuestion";
+    case "enterplanmode":
+      return "EnterPlanMode";
+    case "exitplanmode":
+      return "ExitPlanMode";
+    case "toolsearch":
+      return "ToolSearch";
+    case "skill":
+      return "Skill";
+    case "bash":
+    case "shell":
+    case "exec":
+    case "execcommand":
+    case "runshellcommand":
+      return "Bash";
+    case "read":
+    case "readfile":
+      return "Read";
+    case "write":
+    case "writefile":
+      return "Write";
+    case "edit":
+    case "editfile":
+    case "multiedit":
+      return "Edit";
+    case "grep":
+      return "Grep";
+    case "glob":
+      return "Glob";
+    case "websearch":
+      return "WebSearch";
+    case "webfetch":
+      return "WebFetch";
+    case "todowrite":
+      return "TodoWrite";
+    case "task":
+    case "subagent":
+    case "runsubagent":
+    case "delegatetask":
+    case "delegateagent":
+    case "agent":
+      return "Agent";
+    default:
+      break;
+  }
+  const lowerTitle = rawTitle.trim().toLowerCase();
+  if (lowerTitle.startsWith("read ")) {
+    return "Read";
+  }
+  if (lowerTitle.startsWith("write ")) {
+    return "Write";
+  }
+  if (lowerTitle.startsWith("edit ")) {
+    return "Edit";
+  }
+  if (!normalizedTitle || isGenericToolLabel(normalizedTitle) || isOpaqueWorkspaceAgentToolCallIdentifier(rawTitle, item)) {
+    return null;
+  }
+  return rawTitle.trim();
+}
+function toolCallStatus(item) {
+  const payloadStatus = firstPresentString4(
+    item.status,
+    stringRecordValue3(item.payload, "status"),
+    stringRecordValue3(item.payload, "activityStatus"),
+    statusFromActivityEventType(activityEventType(item))
+  );
+  switch (normalizeToolToken3(payloadStatus)) {
+    case "active":
+    case "running":
+    case "working":
+      return {
+        status: translate("agentHost.agentTool.statusWorking"),
+        statusKind: "working"
+      };
+    case "completed":
+    case "done":
+    case "success":
+    case "succeeded":
+      return {
+        status: translate("agentHost.agentTool.statusCompleted"),
+        statusKind: "completed"
+      };
+    case "failed":
+    case "error":
+      return {
+        status: translate("agentHost.agentTool.statusFailed"),
+        statusKind: "failed"
+      };
+    case "canceled":
+      return {
+        status: translate("agentHost.agentTool.statusCanceled"),
+        statusKind: "canceled"
+      };
+    case "pending":
+    case "waiting":
+    case "awaiting_approval":
+    case "waiting_approval":
+    case "waiting_input":
+      return {
+        status: translate("agentHost.agentTool.statusWaiting"),
+        statusKind: "waiting"
+      };
+    default:
+      return { status: null, statusKind: null };
+  }
+}
+function toolCallDetail(item, toolName) {
+  const metadata = recordValue2(item.payload, "metadata");
+  const metadataInput = recordValue2(metadata, "input");
+  const metadataError = recordValue2(metadata, "error");
+  const payloadInput = recordValue2(item.payload, "input");
+  const payloadOutput = recordValue2(item.payload, "output");
+  const payloadError = recordValue2(item.payload, "error");
+  const paths = collectToolPaths(metadata, metadataInput, payloadInput);
+  const rawToolName = firstPresentString4(
+    stringRecordValue3(metadata, "tool"),
+    stringRecordValue3(item.payload, "tool"),
+    toolNameFromActivityKey(toolActivityKey(item)),
+    item.name
+  );
+  const visibleRawToolName = isOpaqueWorkspaceAgentToolCallIdentifier(
+    rawToolName,
+    item
+  ) ? "" : rawToolName;
+  const fallback = firstPresentString4(
+    commandDetail(
+      item.payload,
+      metadata,
+      metadataInput,
+      metadataError,
+      payloadInput,
+      payloadError
+    ),
+    toolContentDetail(
+      item.payload,
+      metadata,
+      metadataInput,
+      metadataError,
+      payloadInput,
+      payloadError
+    ),
+    item.content,
+    stringRecordValue3(item.payload, "summary"),
+    stringRecordValue3(item.payload, "content"),
+    stringRecordValue3(item.payload, "text"),
+    stringRecordValue3(metadata, "summary")
+  );
+  const query = firstPresentString4(
+    stringRecordValue3(item.payload, "query"),
+    stringArrayFirstRecordValue(item.payload, "search_query"),
+    stringArrayFirstRecordValue(item.payload, "searchQuery"),
+    stringRecordValue3(metadata, "query"),
+    stringRecordValue3(metadataInput, "query"),
+    stringArrayFirstRecordValue(metadataInput, "search_query"),
+    stringArrayFirstRecordValue(metadataInput, "searchQuery"),
+    stringRecordValue3(payloadInput, "query"),
+    stringArrayFirstRecordValue(payloadInput, "search_query"),
+    stringArrayFirstRecordValue(payloadInput, "searchQuery"),
+    stringRecordValue3(recordValue2(payloadInput, "action"), "query"),
+    stringRecordValue3(recordValue2(payloadInput, "action"), "url")
+  );
+  const webTarget = firstPresentString4(
+    query,
+    stringRecordValue3(metadataInput, "url"),
+    stringRecordValue3(payloadInput, "url")
+  );
+  const pattern = firstPresentString4(
+    stringRecordValue3(item.payload, "pattern"),
+    stringRecordValue3(metadata, "pattern"),
+    stringRecordValue3(metadataInput, "pattern"),
+    stringRecordValue3(payloadInput, "pattern")
+  );
+  const command = firstPresentString4(
+    stringRecordValue3(metadata, "command"),
+    stringRecordValue3(metadataInput, "cmd"),
+    stringRecordValue3(metadataInput, "command"),
+    stringRecordValue3(payloadInput, "cmd"),
+    stringRecordValue3(payloadInput, "command")
+  );
+  const path = firstPresentString4(
+    stringRecordValue3(metadataInput, "path"),
+    stringRecordValue3(metadataInput, "file_path"),
+    stringRecordValue3(metadataInput, "fileName"),
+    stringRecordValue3(metadataInput, "filename"),
+    stringRecordValue3(payloadInput, "path"),
+    stringRecordValue3(payloadInput, "file_path"),
+    stringRecordValue3(payloadInput, "fileName"),
+    stringRecordValue3(payloadInput, "filename")
+  );
+  const inputSummary = firstPresentString4(
+    summarizeToolInput(metadataInput),
+    summarizeToolInput(payloadInput)
+  );
+  const normalizedToolName = normalizeToolNameToken2(toolName);
+  const multiFileSummary = summarizeFileChangeCount(
+    payloadOutput,
+    payloadInput,
+    item.payload,
+    metadataInput
+  );
+  const todoSummary = summarizeTodoProgress(payloadInput);
+  const webDomainSummary = summarizeWebDomain(webTarget);
+  const imageGeneration = extractImageGenerationPreview({
+    toolName,
+    displayName: visibleRawToolName,
+    content: item.payload?.content,
+    outputContent: payloadOutput?.content,
+    outputSavedPath: payloadOutput?.savedPath ?? payloadOutput?.saved_path,
+    inputPrompt: payloadInput?.prompt,
+    payloadInputPrompt: metadataInput?.prompt
+  });
+  switch (normalizedToolName) {
+    case "imagegeneration":
+      return imageGeneration.prompt || imageGeneration.imageUri || fallback || inputSummary || null;
+    case "read":
+    case "write":
+    case "edit":
+    case "multiedit":
+      return multiFileSummary || path || firstPath(paths) || fallback || inputSummary || command || null;
+    case "glob":
+      return pattern || query || path || firstPath(paths) || fallback || inputSummary || null;
+    case "bash":
+      return command || path || firstPath(paths) || fallback || inputSummary || null;
+    case "grep":
+      return query || pattern || fallback || inputSummary || command || firstPath(paths) || null;
+    case "websearch":
+      return query || webDomainSummary || pattern || fallback || inputSummary || command || firstPath(paths) || null;
+    case "webfetch":
+      return webDomainSummary || query || pattern || fallback || inputSummary || command || firstPath(paths) || null;
+    case "todowrite":
+      return todoSummary || inputSummary || fallback || null;
+    case "toolsearch":
+    case "skill":
+    case "task":
+    case "agent":
+      return inputSummary || fallback || path || firstPath(paths) || query || pattern || command || visibleRawToolName || null;
+    default:
+      return fallback || command || path || firstPath(paths) || query || pattern || inputSummary || visibleRawToolName || null;
+  }
+}
+function commandDetail(payload, metadata, metadataInput, metadataError, payloadInput, payloadError) {
+  const payloadRawInput = recordValue2(payloadInput, "rawInput");
+  return firstPresentString4(
+    stringRecordValue3(payload, "command"),
+    stringRecordValue3(payload, "cmd"),
+    stringRecordValue3(metadata, "command"),
+    stringRecordValue3(metadata, "cmd"),
+    stringRecordValue3(metadataInput, "cmd"),
+    stringRecordValue3(metadataInput, "command"),
+    stringRecordValue3(metadataError, "cmd"),
+    stringRecordValue3(metadataError, "command"),
+    stringRecordValue3(payloadInput, "cmd"),
+    stringRecordValue3(payloadInput, "command"),
+    stringRecordValue3(payloadRawInput, "cmd"),
+    stringRecordValue3(payloadRawInput, "command"),
+    stringRecordValue3(payloadError, "cmd"),
+    stringRecordValue3(payloadError, "command")
+  );
+}
+function claudeCodeToolName(value) {
+  const meta = recordValue2(value, "_meta");
+  const claudeCode = recordValue2(meta, "claudeCode");
+  return stringRecordValue3(claudeCode, "toolName");
+}
+function toolContentDetail(payload, metadata, metadataInput, metadataError, payloadInput, payloadError) {
+  return firstPresentString4(
+    stringRecordValue3(payload, "query"),
+    stringRecordValue3(payload, "search_query"),
+    stringRecordValue3(payload, "searchQuery"),
+    stringRecordValue3(payload, "pattern"),
+    stringRecordValue3(payload, "glob"),
+    stringRecordValue3(payload, "regex"),
+    stringRecordValue3(payload, "url"),
+    stringRecordValue3(payload, "patch"),
+    stringRecordValue3(metadata, "query"),
+    stringRecordValue3(metadata, "pattern"),
+    stringRecordValue3(metadata, "glob"),
+    stringRecordValue3(metadata, "regex"),
+    stringRecordValue3(metadata, "url"),
+    stringRecordValue3(metadata, "patch"),
+    stringRecordValue3(metadataInput, "query"),
+    stringRecordValue3(metadataInput, "pattern"),
+    stringRecordValue3(metadataInput, "glob"),
+    stringRecordValue3(metadataInput, "regex"),
+    stringRecordValue3(metadataInput, "url"),
+    stringRecordValue3(metadataInput, "patch"),
+    stringRecordValue3(metadataError, "query"),
+    stringRecordValue3(metadataError, "pattern"),
+    stringRecordValue3(metadataError, "url"),
+    stringRecordValue3(payloadInput, "query"),
+    stringRecordValue3(payloadInput, "search_query"),
+    stringRecordValue3(payloadInput, "searchQuery"),
+    stringRecordValue3(payloadInput, "pattern"),
+    stringRecordValue3(payloadInput, "glob"),
+    stringRecordValue3(payloadInput, "regex"),
+    stringRecordValue3(payloadInput, "url"),
+    stringRecordValue3(payloadInput, "patch"),
+    stringRecordValue3(payloadError, "query"),
+    stringRecordValue3(payloadError, "pattern"),
+    stringRecordValue3(payloadError, "url")
+  );
+}
+function isToolActivityTimelineItem(item) {
+  const eventType = activityEventType(item);
+  if (!eventType.startsWith("activity.")) {
+    return false;
+  }
+  const activityKey = toolActivityKey(item);
+  if (activityKey.startsWith("tool.")) {
+    return true;
+  }
+  return resolveLegacyToolName(item) !== null;
+}
+function activityEventType(item) {
+  const itemType = item.itemType.trim().toLowerCase();
+  if (itemType.startsWith("activity.")) {
+    return itemType;
+  }
+  return firstPresentString4(
+    stringRecordValue3(item.payload, "eventKey"),
+    item.itemType
+  ).trim().toLowerCase();
+}
+function statusFromActivityEventType(eventType) {
+  switch (eventType) {
+    case "activity.started":
+    case "call.started":
+      return "running";
+    case "activity.completed":
+    case "call.completed":
+      return "completed";
+    case "activity.failed":
+    case "call.failed":
+    case "call.errored":
+      return "failed";
+    default:
+      return "";
+  }
+}
+function toolActivityKey(item) {
+  const metadata = recordValue2(item.payload, "metadata");
+  return firstPresentString4(
+    stringRecordValue3(item.payload, "activityKey"),
+    stringRecordValue3(item.payload, "activity_key"),
+    stringRecordValue3(metadata, "activityKey"),
+    stringRecordValue3(metadata, "activity_key")
+  ).trim().toLowerCase();
+}
+function toolNameFromActivityKey(activityKey) {
+  return activityKey.startsWith("tool.") ? activityKey.slice("tool.".length) : "";
+}
+function isToolActivityKind(value) {
+  return value in TOOL_ACTIVITY_KIND_TRANSLATION_KEYS;
+}
+function normalizeToolToken3(value) {
+  return value?.trim().toLowerCase().replace(/[-\s]+/gu, "_") ?? "";
+}
+
+// shared/workspaceAgentTimelineProjectionHelpers.ts
+function delegatedToolStepFromCall(call) {
+  const payload = normalizedPayload2(call.payload ?? void 0);
+  return {
+    id: call.id,
+    toolUseId: call.id.replace(/^call:/, ""),
+    name: call.name,
+    toolName: call.toolName,
+    callType: call.callType,
+    status: call.status,
+    toolInput: normalizedPayload2(
+      payload?.input
+    ),
+    toolResult: normalizedPayload2(
+      payload?.output
+    ),
+    toolError: normalizedPayload2(
+      payload?.error
+    ),
+    payload,
+    metadata: normalizedPayload2(
+      payload?.metadata
+    ),
+    content: Array.isArray(payload?.content) ? payload.content : null,
+    locations: Array.isArray(payload?.locations) ? payload.locations : null,
+    occurredAtUnixMs: call.occurredAtUnixMs ?? null
+  };
+}
+function compareToolCallsAscending(left, right) {
+  return (left.occurredAtUnixMs ?? 0) - (right.occurredAtUnixMs ?? 0) || left.id.localeCompare(right.id);
+}
+function parentToolUseIdFromCall(call) {
+  const metadata = normalizedPayload2(
+    call.payload?.metadata
+  );
+  const input = normalizedPayload2(
+    call.payload?.input
+  );
+  const output = normalizedPayload2(
+    call.payload?.output
+  );
+  const error = normalizedPayload2(
+    call.payload?.error
+  );
+  return firstPresentString5(
+    stringRecordValue4(metadata, "parentToolUseId"),
+    stringRecordValue4(call.payload, "parentToolUseId"),
+    claudeCodeMetaValue(input, "parentToolUseId"),
+    claudeCodeMetaValue(output, "parentToolUseId"),
+    claudeCodeMetaValue(error, "parentToolUseId")
+  );
+}
+function isTaskLikeToolCall(call) {
+  return [
+    "task",
+    "subagent",
+    "delegatetask",
+    "delegateagent",
+    "agent"
+  ].includes(normalizeToolName3(call.toolName));
+}
+function toolCallView(item) {
+  const display = buildWorkspaceAgentToolCallDisplay(item);
+  const preserveTitle = item.itemType.trim().toLowerCase().startsWith("approval.") || item.itemType.trim().toLowerCase().startsWith("interactive.") || firstPresentString5(
+    item.callType,
+    stringRecordValue4(item.payload, "callType")
+  ) === "approval";
+  const fallbackName = preserveTitle ? firstPresentString5(item.name, display.name) : display.name;
+  return withSourceTimelineItems(
+    {
+      id: display.id,
+      name: fallbackName || display.name,
+      toolName: resolveWorkspaceAgentToolName(item),
+      callType: firstPresentString5(
+        item.callType,
+        stringRecordValue4(item.payload, "callType")
+      ),
+      status: display.status,
+      statusKind: display.statusKind,
+      summary: display.detail ?? "",
+      payload: normalizedPayload2(item.payload),
+      turnId: item.turnId?.trim() || void 0,
+      compactSummary: display.detail ?? "",
+      occurredAtUnixMs: item.occurredAtUnixMs ?? item.createdAtUnixMs ?? null
+    },
+    [item]
+  );
+}
+function withSourceTimelineItems(value, sourceTimelineItems) {
+  if (!sourceTimelineItems || sourceTimelineItems.length === 0) return value;
+  Object.defineProperty(value, "sourceTimelineItems", {
+    configurable: true,
+    enumerable: false,
+    value: [...sourceTimelineItems],
+    writable: true
+  });
+  return value;
+}
+function mergeSourceTimelineItems2(previous, next) {
+  const merged = [...previous ?? [], ...next ?? []];
+  if (merged.length === 0) return void 0;
+  const byKey = /* @__PURE__ */ new Map();
+  for (const item of merged) byKey.set(sourceTimelineItemKey(item), item);
+  return [...byKey.values()].sort(compareTimelineItemsAscending);
+}
+function normalizedPayload2(payload) {
+  return payload && typeof payload === "object" ? payload : null;
+}
+function visibleErrorFromPayload(payload) {
+  if (stringRecordValue4(payload, "kind") !== "agent_visible_error") return null;
+  return {
+    code: stringRecordValue4(payload, "code"),
+    phase: stringRecordValue4(payload, "phase"),
+    provider: stringRecordValue4(payload, "provider"),
+    detail: stringRecordValue4(payload, "detail"),
+    retryable: booleanRecordValue(payload, "retryable")
+  };
+}
+function systemNoticeFromPayload(payload, context) {
+  const commandSemantics = resolveWorkspaceAgentNoticeCommandSemantics({
+    eventId: context.eventId,
+    messageSemantics: context.messageSemantics,
+    payload,
+    status: context.status
+  });
+  if (stringRecordValue4(payload, "kind") !== "agent_system_notice" && !commandSemantics) {
+    return null;
+  }
+  const source = stringRecordValue4(payload, "source");
+  return {
+    noticeKind: stringRecordValue4(payload, "noticeKind"),
+    severity: stringRecordValue4(payload, "severity"),
+    ...source ? { source } : {},
+    ...commandSemantics ? {
+      command: commandSemantics.command,
+      commandStatus: commandSemantics.commandStatus
+    } : {},
+    title: stringRecordValue4(payload, "title"),
+    detail: stringRecordValue4(payload, "detail"),
+    retryable: booleanRecordValue(payload, "retryable")
+  };
+}
+function stringRecordValue4(record, key) {
+  if (!record || typeof record !== "object" || Array.isArray(record))
+    return null;
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function claudeCodeMetaValue(record, key) {
+  const meta = normalizedPayload2(
+    record?._meta
+  );
+  const claudeCode = normalizedPayload2(
+    meta?.claudeCode
+  );
+  return stringRecordValue4(claudeCode, key);
+}
+function firstPresentString5(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+function summarizeToolCallGroup2(calls) {
+  if (calls.length < 2) return null;
+  const targets = [
+    ...new Set(
+      calls.filter(
+        (call) => ["edit", "multiedit", "write"].includes(
+          normalizeToolName3(call.toolName)
+        )
+      ).map((call) => summarizeCallTarget2(call.summary)).filter((value) => value !== null)
+    )
+  ];
+  if (targets.length === 0) return null;
+  return targets.length === 1 ? `Changed ${targets[0]}` : `Changed ${targets[0]} and ${targets.length - 1} more files`;
+}
+function shouldShowProcessingIndicator(session, turns) {
+  if (!sessionHasRunnableIndicatorState(session)) return false;
+  const lastTurn = turns.at(-1);
+  if (!lastTurn) return true;
+  const lastAgentItem = lastTurn.agentItems.at(-1);
+  if (lastAgentItem?.kind === "message" && isTerminalAgentMessageStatus(lastAgentItem.message.statusKind) && !hasActiveRunningTurn(session)) {
+    return false;
+  }
+  return !lastTurn.toolCalls.some(
+    (call) => call.statusKind === "working" || call.statusKind === "waiting"
+  );
+}
+function sourceTimelineItemKey(item) {
+  const eventId = item.eventId?.trim();
+  if (eventId) return `event:${eventId}`;
+  if (Number.isFinite(item.id) && item.id > 0) return `id:${item.id}`;
+  const seq = item.seq ?? 0;
+  return seq > 0 ? `seq:${seq}` : `local:${item.itemType}:${item.occurredAtUnixMs ?? 0}`;
+}
+function compareTimelineItemsAscending(left, right) {
+  return (left.seq ?? 0) - (right.seq ?? 0) || (left.occurredAtUnixMs ?? left.createdAtUnixMs ?? 0) - (right.occurredAtUnixMs ?? right.createdAtUnixMs ?? 0) || left.id - right.id;
+}
+function booleanRecordValue(record, key) {
+  if (!record || typeof record !== "object" || Array.isArray(record))
+    return null;
+  const value = record[key];
+  return typeof value === "boolean" ? value : null;
+}
+function normalizeToolName3(name) {
+  return (name ?? "").trim().replace(/[_\s-]+/g, "").toLowerCase();
+}
+function summarizeCallTarget2(summary) {
+  const firstLine = summary.trim().split("\n")[0]?.trim() ?? "";
+  if (!firstLine) return null;
+  return firstLine.split(/[\\/]/).filter(Boolean).at(-1) ?? firstLine;
+}
+function hasActiveRunningTurn(session) {
+  const activeTurn = session.activeTurn;
+  return Boolean(activeTurn && activeTurn.phase !== "settled");
+}
+function sessionHasRunnableIndicatorState(session) {
+  return session.activeTurn ? session.activeTurn.phase !== "settled" : false;
+}
+function isTerminalAgentMessageStatus(status) {
+  return status === "completed" || status === "failed" || status === "canceled";
+}
+
+// shared/workspaceAgentGoalControlProjection.ts
+function appendWorkspaceAgentGoalControl(target, item, id, body) {
+  if (item.itemType !== "goal.control") {
+    return false;
+  }
+  const action = normalizedPayload2(item.payload)?.action;
+  if (action !== "pause" && action !== "resume" && action !== "clear" && action !== "set") {
+    return true;
+  }
+  const normalizedBody = body.trim();
+  if (!normalizedBody) {
+    return true;
+  }
+  target.push({
+    id,
+    action,
+    body: normalizedBody,
+    occurredAtUnixMs: item.occurredAtUnixMs ?? item.createdAtUnixMs ?? null,
+    sourceTimelineItems: [item]
+  });
+  return true;
+}
+
+// shared/workspaceAgentTimelineMessageHelpers.ts
+function messageRole(item) {
+  const explicitRole = item.role?.trim().toLowerCase();
+  if (explicitRole === "user") {
+    return "user";
+  }
+  if (explicitRole === "assistant_thinking") {
+    return "thinking";
+  }
+  if (explicitRole === "assistant" || explicitRole === "agent") {
+    return "agent";
+  }
+  const itemType = item.itemType.trim().toLowerCase();
+  if (itemType === "message.user") {
+    return "user";
+  }
+  if (itemType === "message.agent" || itemType === "message.assistant") {
+    return "agent";
+  }
+  if (itemType === "message.assistant_thinking") {
+    return "thinking";
+  }
+  return null;
+}
+function messageBody(item) {
+  const payloadContent = item.payload?.content;
+  if (typeof payloadContent === "string" && payloadContent.trim()) {
+    const content2 = payloadContent.trim();
+    return isWorkspaceAgentSyntheticControlMessage(content2) ? "" : content2;
+  }
+  const content = item.content?.trim();
+  if (content) {
+    return isWorkspaceAgentSyntheticControlMessage(content) ? "" : content;
+  }
+  const payloadText = item.payload?.text;
+  if (typeof payloadText !== "string") {
+    return "";
+  }
+  const text = payloadText.trim();
+  return isWorkspaceAgentSyntheticControlMessage(text) ? "" : text;
+}
+function thinkingStatusKind(item) {
+  const status = firstPresentString6(
+    item.status,
+    stringRecordValue5(item.payload, "status"),
+    stringRecordValue5(item.payload, "streamState"),
+    stringRecordValue5(item.payload, "messageStreamState")
+  );
+  return messageStatusKind(status);
+}
+function messageStatusKind(status) {
+  switch (normalizeStatusToken(status)) {
+    case "active":
+    case "running":
+    case "streaming":
+    case "working":
+    case "inprogress":
+    case "in_progress":
+      return "working";
+    case "completed":
+    case "complete":
+    case "done":
+    case "success":
+    case "succeeded":
+      return "completed";
+    case "failed":
+    case "error":
+      return "failed";
+    case "canceled":
+      return "canceled";
+    case "pending":
+    case "waiting":
+      return "waiting";
+    default:
+      return null;
+  }
+}
+function isPlaceholderThinkingBody(body) {
+  const normalized = body.trim();
+  return normalized === "..." || normalized === "\u2026";
+}
+var reviewProcessSummaryTitlePattern = /^\*\*(.+?)\*\*(?:\r?\n\s*)?/;
+function stripReviewProcessSummaryTitle(body) {
+  const match = body.match(reviewProcessSummaryTitlePattern);
+  if (!match) {
+    return body;
+  }
+  return body.slice(match[0].length).trimStart();
+}
+function normalizedMessageBody(body) {
+  return body.trim().replace(/\s+/g, " ");
+}
+function userMessageProjectionKey(item, body) {
+  const normalizedBody = normalizedMessageBody(body);
+  if (normalizedBody) {
+    return `text:${normalizedBody}`;
+  }
+  if (!hasRenderableUserPromptContent(item.payload?.content)) {
+    return null;
+  }
+  const clientSubmitId = stringRecordValue5(item.payload, "clientSubmitId");
+  return clientSubmitId ? `client-submit:${clientSubmitId}` : `event:${item.eventId}`;
+}
+function isRecentDuplicateUserMessage(previous, current) {
+  if (!previous) {
+    return false;
+  }
+  const previousTurnId = previous.turnId?.trim();
+  const currentTurnId = current.turnId?.trim();
+  if (previousTurnId && currentTurnId && previousTurnId === currentTurnId) {
+    return true;
+  }
+  if (previousTurnId && currentTurnId) {
+    return false;
+  }
+  const previousOccurredAt = previous.occurredAtUnixMs ?? 0;
+  const currentOccurredAt = current.occurredAtUnixMs ?? 0;
+  if (previousOccurredAt > 0 && currentOccurredAt > 0) {
+    return Math.abs(currentOccurredAt - previousOccurredAt) <= 6e4;
+  }
+  const previousSeq = previous.seq ?? 0;
+  const currentSeq = current.seq ?? 0;
+  if (previousSeq > 0 && currentSeq > 0) {
+    return Math.abs(currentSeq - previousSeq) <= 5;
+  }
+  return false;
+}
+function hasRenderableUserPromptContent(content) {
+  if (!Array.isArray(content)) {
+    return false;
+  }
+  return content.some((candidate) => {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+      return false;
+    }
+    const block = candidate;
+    if (block.type === "text") {
+      return typeof block.text === "string" && block.text.trim().length > 0;
+    }
+    return block.type === "image" && typeof block.mimeType === "string" && block.mimeType.trim().length > 0;
+  });
+}
+function stringRecordValue5(record, key) {
+  if (!record || typeof record !== "object") {
+    return null;
+  }
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function firstPresentString6(...values) {
+  for (const value of values) {
+    const normalized = value?.trim();
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return null;
+}
+function normalizeStatusToken(value) {
+  return (value ?? "").trim().toLowerCase().replace(/[\s-]+/g, "_");
+}
+
+// shared/workspaceAgentTurnErrorProjection.ts
+function enrichProjectedTurnsWithCanonicalErrors({
+  turns,
+  sessionTurns,
+  provider,
+  agentSessionId
+}) {
+  for (const canonicalTurn of sessionTurns) {
+    if (canonicalTurn.outcome !== "failed" && canonicalTurn.outcome !== "interrupted") {
+      continue;
+    }
+    const detail = canonicalTurn.error?.message.trim() ?? "";
+    if (!detail) {
+      continue;
+    }
+    const turn = turns.get(canonicalTurn.turnId);
+    if (!turn) {
+      continue;
+    }
+    if (turn.agentMessages.some((message2) => message2.visibleError)) {
+      continue;
+    }
+    const matchingMessage = turn.agentMessages.find(
+      (message2) => message2.body.trim() === detail
+    );
+    if (matchingMessage) {
+      matchingMessage.status = "failed";
+      matchingMessage.statusKind = "failed";
+      matchingMessage.visibleError = visibleErrorFromCanonicalTurn(
+        canonicalTurn,
+        provider
+      );
+      continue;
+    }
+    const message = {
+      id: `turn-error:${agentSessionId}:${canonicalTurn.turnId}`,
+      body: detail,
+      status: "failed",
+      statusKind: "failed",
+      turnId: canonicalTurn.turnId,
+      occurredAtUnixMs: canonicalTurn.settledAtUnixMs ?? canonicalTurn.updatedAtUnixMs,
+      visibleError: visibleErrorFromCanonicalTurn(canonicalTurn, provider)
+    };
+    turn.agentMessages.push(message);
+    turn.agentItems.push({ kind: "message", message });
+  }
+}
+function visibleErrorFromCanonicalTurn(turn, provider) {
+  return {
+    code: turn.error?.code?.trim() || null,
+    phase: "turn",
+    provider: provider.trim() || null,
+    detail: turn.error?.message.trim() || null,
+    retryable: null
+  };
+}
+
+// shared/workspaceAgentTimelineSuppression.ts
+function toolNameFromItem(item) {
+  return resolveWorkspaceAgentToolName(item);
+}
+function normalizeToolName4(name) {
+  return (name ?? "").trim().replace(/[_\s-]+/g, "").toLowerCase();
+}
+function suppressedUnavailableAskUserQuestionCallIds(items) {
+  const suppressed = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (normalizeToolName4(toolNameFromItem(item)) !== "askuserquestion" || !isUnavailableAskUserQuestionFailure(item)) {
+      continue;
+    }
+    const callId = toolCallSuppressionId(item);
+    if (callId) {
+      suppressed.add(callId);
+    }
+  }
+  return suppressed;
+}
+function shouldSuppressToolCall(item, suppressedToolCallIds) {
+  const callId = toolCallSuppressionId(item);
+  return callId ? suppressedToolCallIds.has(callId) : false;
+}
+function toolCallSuppressionId(item) {
+  return firstPresentString5(
+    item.callId,
+    stringRecordValue4(item.payload, "callId"),
+    stringRecordValue4(item.payload, "toolCallId")
+  );
+}
+function isUnavailableAskUserQuestionFailure(item) {
+  const status = firstPresentString5(
+    item.status,
+    stringRecordValue4(item.payload, "status")
+  );
+  if (status !== "failed") {
+    return false;
+  }
+  const payload = normalizedPayload2(item.payload);
+  const output = normalizedPayload2(
+    payload?.output
+  );
+  const error = normalizedPayload2(
+    payload?.error
+  );
+  const message = firstPresentString5(
+    stringRecordValue4(output, "output"),
+    stringRecordValue4(output, "text"),
+    stringRecordValue4(output, "message"),
+    stringRecordValue4(error, "error"),
+    stringRecordValue4(error, "message"),
+    stringRecordValue4(payload, "error"),
+    stringRecordValue4(payload, "message")
+  );
+  return message?.includes("No such tool available: AskUserQuestion") ?? false;
+}
+
+// shared/workspaceAgentTimelineCanonical.ts
+function buildCanonicalWorkspaceAgentDetailView({
+  activity,
+  session,
+  sessionTurns = [],
+  timelineItems,
+  workspaceRoot = null
+}) {
+  const turns = /* @__PURE__ */ new Map();
+  const goalControls = [];
+  const recentUserMessages = /* @__PURE__ */ new Map();
+  const seenThinkingMessages = /* @__PURE__ */ new Set();
+  let activeSequenceTurnId = null;
+  const sortedTimelineItems = [...timelineItems].sort(
+    compareTimelineItemsAscending2
+  );
+  const suppressedToolCallIds = suppressedUnavailableAskUserQuestionCallIds(sortedTimelineItems);
+  for (const item of sortedTimelineItems) {
+    const role = messageRole(item);
+    const body = messageBody(item);
+    const explicitTurnId = item.turnId?.trim();
+    if (appendWorkspaceAgentGoalControl(goalControls, item, itemId2(item), body)) {
+      continue;
+    }
+    if (role === "user") {
+      const turnId2 = explicitTurnId || `seq:${item.seq || item.id}`;
+      const projectionKey = userMessageProjectionKey(item, body);
+      if (!projectionKey) {
+        continue;
+      }
+      if (isRecentDuplicateUserMessage(
+        recentUserMessages.get(projectionKey),
+        item
+      )) {
+        continue;
+      }
+      activeSequenceTurnId = turnId2;
+      const turn2 = getTurn(turns, turnId2);
+      const message = withSourceTimelineItems(
+        {
+          id: itemId2(item),
+          body,
+          turnId: turnId2,
+          occurredAtUnixMs: item.occurredAtUnixMs ?? item.createdAtUnixMs ?? null
+        },
+        [item]
+      );
+      turn2.userMessages.push(message);
+      turn2.userMessage ??= message;
+      recentUserMessages.set(projectionKey, item);
+      continue;
+    }
+    const turnId = explicitTurnId || activeSequenceTurnId || `seq:${item.seq || item.id}`;
+    const turn = getTurn(turns, turnId);
+    if (isCollaborationTimelineItem(item)) {
+      const status = firstPresentString5(
+        item.status,
+        stringRecordValue4(item.payload, "status")
+      );
+      const statusKind = messageStatusKind(status);
+      const message = withSourceTimelineItems(
+        {
+          id: itemId2(item),
+          body,
+          ...status ? { status } : {},
+          ...statusKind ? { statusKind } : {},
+          turnId,
+          occurredAtUnixMs: item.occurredAtUnixMs ?? item.createdAtUnixMs ?? null
+        },
+        [item]
+      );
+      turn.agentMessages.push(message);
+      turn.agentItems.push({ kind: "message", message });
+      continue;
+    }
+    if (isWorkspaceAgentToolCallItem(item)) {
+      if (shouldSuppressToolCall(item, suppressedToolCallIds)) {
+        continue;
+      }
+      upsertToolCall(turn, item);
+      continue;
+    }
+    if (role === "thinking" && body) {
+      const payload = normalizedPayload2(item.payload);
+      if (payload?.messageKind === "review-process") {
+        const status = firstPresentString5(
+          item.status,
+          stringRecordValue4(payload, "status")
+        );
+        const statusKind2 = messageStatusKind(status);
+        const message = withSourceTimelineItems(
+          {
+            id: itemId2(item),
+            body: stripReviewProcessSummaryTitle(body),
+            ...status ? { status } : {},
+            ...statusKind2 ? { statusKind: statusKind2 } : {},
+            turnId,
+            occurredAtUnixMs: item.occurredAtUnixMs ?? item.createdAtUnixMs ?? null
+          },
+          [item]
+        );
+        turn.agentMessages.push(message);
+        turn.agentItems.push({ kind: "message", message });
+        continue;
+      }
+      if (isPlaceholderThinkingBody(body)) {
+        continue;
+      }
+      const duplicateKey = `${turnId}\0${normalizedMessageBody(body)}`;
+      if (seenThinkingMessages.has(duplicateKey)) {
+        continue;
+      }
+      seenThinkingMessages.add(duplicateKey);
+      const statusKind = thinkingStatusKind(item);
+      const thinking = withSourceTimelineItems(
+        {
+          id: itemId2(item),
+          body,
+          ...statusKind ? { statusKind } : {},
+          turnId,
+          occurredAtUnixMs: item.occurredAtUnixMs ?? item.createdAtUnixMs ?? null
+        },
+        [item]
+      );
+      turn.agentItems.push({ kind: "thinking", thinking });
+      continue;
+    }
+    if (role === "agent" && body) {
+      const payload = normalizedPayload2(item.payload);
+      const visibleError = visibleErrorFromPayload(payload);
+      const systemNotice = systemNoticeFromPayload(payload, item);
+      const status = firstPresentString5(
+        item.status,
+        stringRecordValue4(payload, "status")
+      );
+      const statusKind = messageStatusKind(status);
+      const message = withSourceTimelineItems(
+        {
+          id: itemId2(item),
+          body,
+          ...status ? { status } : {},
+          ...statusKind ? { statusKind } : {},
+          turnId,
+          occurredAtUnixMs: item.occurredAtUnixMs ?? item.createdAtUnixMs ?? null,
+          ...visibleError ? { visibleError } : {},
+          ...systemNotice ? { systemNotice } : {}
+        },
+        [item]
+      );
+      turn.agentMessages.push(message);
+      turn.agentItems.push({ kind: "message", message });
+    }
+  }
+  enrichProjectedTurnsWithCanonicalErrors({
+    turns,
+    sessionTurns: sessionTurns.length > 0 ? sessionTurns : session.latestTurn ? [session.latestTurn] : [],
+    provider: session.provider,
+    agentSessionId: session.agentSessionId
+  });
+  const visibleTurns = [...turns.values()].filter(
+    (turn) => turn.userMessages.length > 0 || turn.agentItems.length > 0
+  );
+  nestDelegatedToolCallsAcrossTurns(visibleTurns);
+  visibleTurns.forEach(mergeBackgroundTerminalContinuations);
+  visibleTurns.forEach((turn) => {
+    turn.rawAgentItems = [...turn.agentItems];
+    turn.agentItems = regroupAgentItems(turn.agentItems);
+  });
+  return {
+    activity,
+    session,
+    sessionTurns,
+    cwd: session.cwd.trim(),
+    workspaceRoot: workspaceRoot?.trim() || null,
+    goalControls,
+    turns: visibleTurns,
+    showProcessingIndicator: shouldShowProcessingIndicator(
+      session,
+      visibleTurns
+    )
+  };
+}
+function getTurn(turns, id) {
+  const existing = turns.get(id);
+  if (existing) {
+    return existing;
+  }
+  const turn = {
+    id,
+    userMessage: null,
+    userMessages: [],
+    agentMessages: [],
+    toolCalls: [],
+    toolCallCount: 0,
+    hasFailedToolCall: false,
+    agentItems: []
+  };
+  turns.set(id, turn);
+  return turn;
+}
+function compareTimelineItemsAscending2(left, right) {
+  const leftSeq = left.seq ?? 0;
+  const rightSeq = right.seq ?? 0;
+  if (leftSeq > 0 && rightSeq > 0 && leftSeq !== rightSeq) {
+    return leftSeq - rightSeq;
+  }
+  return (left.occurredAtUnixMs ?? left.createdAtUnixMs ?? 0) - (right.occurredAtUnixMs ?? right.createdAtUnixMs ?? 0) || leftSeq - rightSeq || left.id - right.id;
+}
+function itemId2(item) {
+  const eventId = item.eventId?.trim();
+  if (eventId) {
+    return eventId;
+  }
+  const seq = item.seq ?? 0;
+  return seq > 0 ? `seq:${seq}` : `id:${item.id}`;
+}
+function upsertToolCall(turn, item) {
+  const call = toolCallView(item);
+  const existingIndex = turn.toolCalls.findIndex(
+    (existing) => existing.id === call.id
+  );
+  if (existingIndex >= 0) {
+    const existing = turn.toolCalls[existingIndex];
+    if (!existing) {
+      return;
+    }
+    turn.toolCalls[existingIndex] = mergeToolCallDetail(existing, call);
+  } else {
+    turn.toolCalls.push(call);
+  }
+  turn.toolCallCount = turn.toolCalls.length;
+  turn.hasFailedToolCall = turn.toolCalls.some(
+    (existing) => existing.statusKind === "failed"
+  );
+  upsertToolCallAgentItem(turn, call, itemId2(item));
+}
+function upsertToolCallAgentItem(turn, call, sourceId) {
+  for (const entry2 of turn.agentItems) {
+    if (entry2.kind !== "tool-calls") {
+      continue;
+    }
+    const existingIndex = entry2.toolCalls.findIndex(
+      (existing) => existing.id === call.id
+    );
+    if (existingIndex >= 0) {
+      const existing = entry2.toolCalls[existingIndex];
+      if (!existing) {
+        continue;
+      }
+      entry2.toolCalls[existingIndex] = mergeToolCallDetail(existing, call);
+      refreshToolCallAgentItem(entry2);
+      return;
+    }
+  }
+  const entry = {
+    kind: "tool-calls",
+    id: `tools:${sourceId}`,
+    toolCalls: [call],
+    toolCallCount: 1,
+    hasFailedToolCall: call.statusKind === "failed"
+  };
+  turn.agentItems.push(entry);
+}
+function refreshToolCallAgentItem(entry) {
+  entry.toolCallCount = entry.toolCalls.length;
+  entry.hasFailedToolCall = entry.toolCalls.some(
+    (existing) => existing.statusKind === "failed"
+  );
+  const summary = summarizeToolCallGroup2(entry.toolCalls);
+  if (summary) {
+    entry.summary = summary;
+  } else {
+    delete entry.summary;
+  }
+}
+function regroupAgentItems(items) {
+  const regrouped = [];
+  let pending = [];
+  const flushPending = () => {
+    if (pending.length === 0) {
+      return;
+    }
+    const groupedCalls = pending.flatMap((item) => item.toolCalls);
+    if (groupedCalls.length >= 2) {
+      regrouped.push({
+        kind: "tool-calls",
+        id: pending.map((item) => item.id).join("+"),
+        toolCalls: groupedCalls,
+        toolCallCount: groupedCalls.length,
+        hasFailedToolCall: groupedCalls.some(
+          (call) => call.statusKind === "failed"
+        ),
+        summary: summarizeToolCallGroup2(groupedCalls),
+        groupEntries: pending.flatMap(
+          (item) => item.toolCalls.map((call) => ({ kind: "tool-call", call }))
+        )
+      });
+    } else {
+      regrouped.push(...pending);
+    }
+    pending = [];
+  };
+  for (const item of items) {
+    if (item.kind === "tool-calls" && isGroupableToolCallItem(item)) {
+      pending.push(item);
+      continue;
+    }
+    flushPending();
+    regrouped.push(item);
+  }
+  flushPending();
+  return regrouped;
+}
+function isGroupableToolCallItem(item) {
+  return item.toolCalls.length === 1 && item.toolCalls.every((call) => isGroupableToolCall2(call));
+}
+function mergeToolCallDetail(previous, next) {
+  return withSourceTimelineItems(
+    {
+      ...next,
+      name: next.name || previous.name,
+      toolName: next.toolName || previous.toolName,
+      callType: next.callType || previous.callType,
+      summary: next.summary || previous.summary,
+      payload: next.payload ?? previous.payload
+    },
+    mergeSourceTimelineItems2(
+      previous.sourceTimelineItems,
+      next.sourceTimelineItems
+    )
+  );
+}
+function mergeBackgroundTerminalContinuations(turn) {
+  if (turn.agentItems.length === 0 || turn.toolCalls.length === 0) {
+    return;
+  }
+  const removedCallIDs = /* @__PURE__ */ new Set();
+  const singleCallItems = turn.agentItems.filter(
+    (item) => item.kind === "tool-calls" && item.toolCalls.length === 1
+  );
+  const turnToolIndexByID = new Map(
+    turn.toolCalls.map((call, index) => [call.id, index])
+  );
+  for (let index = 0; index < singleCallItems.length - 1; index += 1) {
+    const item = singleCallItems[index];
+    const primaryCall = item?.toolCalls[0];
+    if (!item || !primaryCall) {
+      continue;
+    }
+    const terminalSessionID = backgroundTerminalSessionID(primaryCall);
+    if (!terminalSessionID) {
+      continue;
+    }
+    const continuationCall = singleCallItems[index + 1]?.toolCalls[0];
+    if (!continuationCall || !isBackgroundTerminalContinuation(continuationCall, terminalSessionID)) {
+      continue;
+    }
+    const mergedCall = mergeBackgroundTerminalCall(
+      primaryCall,
+      continuationCall
+    );
+    item.toolCalls[0] = mergedCall;
+    const turnToolIndex = turnToolIndexByID.get(primaryCall.id);
+    if (turnToolIndex !== void 0) {
+      turn.toolCalls[turnToolIndex] = mergedCall;
+    }
+    refreshToolCallAgentItem(item);
+    removedCallIDs.add(continuationCall.id);
+    index += 1;
+  }
+  if (removedCallIDs.size === 0) {
+    return;
+  }
+  turn.agentItems = turn.agentItems.filter(
+    (item) => item.kind !== "tool-calls" || item.toolCalls.every((call) => !removedCallIDs.has(call.id))
+  );
+  turn.toolCalls = turn.toolCalls.filter(
+    (call) => !removedCallIDs.has(call.id)
+  );
+  turn.toolCallCount = turn.toolCalls.length;
+  turn.hasFailedToolCall = turn.toolCalls.some(
+    (existing) => existing.statusKind === "failed"
+  );
+}
+function mergeBackgroundTerminalCall(primary, continuation) {
+  const continuationOutput = normalizedPayload2(
+    continuation.payload?.output
+  );
+  const mergedPayload = primary.payload ? { ...primary.payload } : {};
+  if (continuationOutput) {
+    mergedPayload.output = continuationOutput;
+  }
+  return {
+    ...primary,
+    status: continuation.status || primary.status,
+    statusKind: continuation.statusKind || primary.statusKind,
+    payload: Object.keys(mergedPayload).length > 0 ? mergedPayload : primary.payload,
+    occurredAtUnixMs: continuation.occurredAtUnixMs ?? primary.occurredAtUnixMs
+  };
+}
+function nestDelegatedToolCallsAcrossTurns(turns) {
+  if (turns.length === 0) {
+    return;
+  }
+  const parentCalls = /* @__PURE__ */ new Map();
+  const callTurnByID = /* @__PURE__ */ new Map();
+  for (const turn of turns) {
+    for (const call of turn.toolCalls) {
+      parentCalls.set(call.id, call);
+      parentCalls.set(call.id.replace(/^call:/, ""), call);
+      callTurnByID.set(call.id, turn);
+      callTurnByID.set(call.id.replace(/^call:/, ""), turn);
+    }
+  }
+  const childCallsByParent = /* @__PURE__ */ new Map();
+  for (const turn of turns) {
+    for (const call of turn.toolCalls) {
+      const parentToolUseId = parentToolUseIdFromCall(call);
+      if (!parentToolUseId) {
+        continue;
+      }
+      const parentCall = parentCalls.get(parentToolUseId);
+      if (!parentCall || !isTaskLikeToolCall(parentCall)) {
+        continue;
+      }
+      const children = childCallsByParent.get(parentToolUseId) ?? [];
+      children.push(call);
+      childCallsByParent.set(parentToolUseId, children);
+    }
+  }
+  if (childCallsByParent.size === 0) {
+    return;
+  }
+  const removeIDsByTurn = /* @__PURE__ */ new Map();
+  for (const [parentID, childCalls] of childCallsByParent.entries()) {
+    const parentCall = parentCalls.get(parentID);
+    if (!parentCall) {
+      continue;
+    }
+    appendDelegatedToolSteps(parentCall, childCalls);
+    for (const childCall of childCalls) {
+      const childTurn = callTurnByID.get(childCall.id);
+      if (!childTurn) {
+        continue;
+      }
+      const removeIDs = removeIDsByTurn.get(childTurn) ?? /* @__PURE__ */ new Set();
+      removeIDs.add(childCall.id);
+      removeIDsByTurn.set(childTurn, removeIDs);
+    }
+  }
+  for (const [turn, removeIDs] of removeIDsByTurn.entries()) {
+    pruneTurnToolCalls(turn, removeIDs);
+  }
+}
+function backgroundTerminalSessionID(call) {
+  const outputText = stringRecordValue4(call.payload?.output, "output");
+  if (!outputText) {
+    return null;
+  }
+  const match = outputText.match(/Process running with session ID (\d+)/i);
+  return match?.[1] ?? null;
+}
+function isBackgroundTerminalContinuation(call, sessionID) {
+  const input = normalizedPayload2(
+    call.payload?.input
+  );
+  const inputSessionID = firstPresentString5(
+    stringRecordValue4(input, "session_id"),
+    stringRecordValue4(input, "sessionId")
+  );
+  if (inputSessionID !== sessionID) {
+    return false;
+  }
+  const chars = firstPresentString5(stringRecordValue4(input, "chars")) ?? "";
+  if (chars !== "") {
+    return false;
+  }
+  return stringRecordValue4(call.payload?.output, "output") !== null;
+}
+function isGroupableToolCall2(call) {
+  if (call.callType === "approval" || call.callType === "interactive" || call.callType === "subagent") {
+    return false;
+  }
+  switch (normalizeToolName4(call.toolName)) {
+    case "askuserquestion":
+    case "enterplanmode":
+    case "exitplanmode":
+    case "task":
+    case "subagent":
+    case "delegatetask":
+      return false;
+    default:
+      return true;
+  }
+}
+function pruneTurnToolCalls(turn, removeIDs) {
+  if (removeIDs.size === 0) {
+    return;
+  }
+  turn.toolCalls = turn.toolCalls.filter((call) => !removeIDs.has(call.id));
+  turn.toolCallCount = turn.toolCalls.length;
+  turn.hasFailedToolCall = turn.toolCalls.some(
+    (existing) => existing.statusKind === "failed"
+  );
+  turn.agentItems = turn.agentItems.flatMap((item) => {
+    if (item.kind !== "tool-calls") {
+      return [item];
+    }
+    const toolCalls = item.toolCalls.filter(
+      (call) => !removeIDs.has(call.id)
+    );
+    if (toolCalls.length === 0) {
+      return [];
+    }
+    const nextItem = {
+      ...item,
+      toolCalls
+    };
+    refreshToolCallAgentItem(nextItem);
+    return [nextItem];
+  });
+}
+function appendDelegatedToolSteps(parentCall, childCalls) {
+  const nextPayload = parentCall.payload ? { ...parentCall.payload } : {};
+  const nextMetadata = normalizedPayload2(
+    nextPayload.metadata
+  ) ?? {};
+  const existingSteps = Array.isArray(nextMetadata.steps) ? [...nextMetadata.steps] : [];
+  const existingStepIDs = new Set(
+    existingSteps.map(
+      (step) => normalizedPayload2(step)
+    ).map(
+      (step) => stringRecordValue4(step, "toolUseId") ?? stringRecordValue4(step, "id")
+    ).filter((value) => Boolean(value))
+  );
+  for (const childCall of [...childCalls].sort(compareToolCallsAscending)) {
+    const step = delegatedToolStepFromCall(childCall);
+    const stepID = stringRecordValue4(step, "toolUseId") ?? stringRecordValue4(step, "id");
+    if (stepID && existingStepIDs.has(stepID)) {
+      continue;
+    }
+    if (stepID) {
+      existingStepIDs.add(stepID);
+    }
+    existingSteps.push(step);
+  }
+  nextMetadata.steps = existingSteps;
+  nextPayload.metadata = nextMetadata;
+  parentCall.payload = nextPayload;
+}
+
+export {
+  resolveWorkspaceAgentNoticeCommandSemantics,
+  isWorkspaceAgentToolCallItem,
+  resolveWorkspaceAgentToolName,
+  buildCanonicalWorkspaceAgentDetailView,
+  agentTranscriptRowHasPresentationKind,
+  normalizeAgentApprovalOptions,
+  projectAgentTaskStepTool,
+  pastedTextDraftDisplayName,
+  normalizeAgentPatchText,
+  extractAgentPatchPath,
+  inferAgentPatchChangeType,
+  projectAgentConversationVM,
+  latestAssistantMessageText,
+  reconcileProjectedAgentConversationVM
+};
+//# sourceMappingURL=chunk-A4KKC324.js.map