@qwen-code/qwen-code 0.19.12 → 0.20.0-nightly.20260721.cda0e0348

package/chunks/{chunk-GXFYV7MP.js → chunk-PFKNXN67.js}

@@ -1,16 +1,15 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  formatHistoryGapNotice,
-  indexGapsByChild
-} from "./chunk-HZ4M2UQD.js";
+  formatHistoryGapNotice
+} from "./chunk-6RVJRVQR.js";
 import {
   sanitizeTerminalText
-} from "./chunk-J6NT5YTN.js";
+} from "./chunk-RS7MT2QG.js";
 import {
   isGoalStatusKind,
   isTerminalGoalStatusKind
-} from "./chunk-76BFY7AF.js";
+} from "./chunk-QTERJVPZ.js";
 import {
   require_undici
 } from "./chunk-L573Z2QZ.js";
@@ -24,18 +23,18 @@ import {
   setGoalTerminalObserver,
   setLastGoalTerminal,
   unregisterGoalHook
-} from "./chunk-GCY7QTCE.js";
+} from "./chunk-NO6XTCYT.js";
 import {
   apiActivityTracker,
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-CPU6I5YV.js";
+} from "./chunk-P64HXIC5.js";
 import {
   ToolNames
-} from "./chunk-ANRANWVE.js";
+} from "./chunk-OP4MOGXF.js";
 import {
   createDebugLogger
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -683,6 +682,856 @@ __name(realpathOrResolve, "realpathOrResolve");
 // packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
 init_esbuild_shims();
 
+// packages/acp-bridge/src/transcript-replay.ts
+init_esbuild_shims();
+var MISSING_TRANSCRIPT_TOOL_RESULT_MESSAGE = "Tool result missing from saved history; the previous run likely ended before this tool completed.";
+var TRANSCRIPT_GOAL_STATUS_KINDS = /* @__PURE__ */ new Set([
+  "set",
+  "achieved",
+  "cleared",
+  "failed",
+  "aborted",
+  "checking"
+]);
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObjectRecord, "isObjectRecord");
+function toTranscriptEpochMs(timestamp) {
+  if (typeof timestamp === "number") {
+    return Number.isFinite(timestamp) ? timestamp : void 0;
+  }
+  if (typeof timestamp !== "string") return void 0;
+  const epochMs = new Date(timestamp).getTime();
+  return Number.isFinite(epochMs) ? epochMs : void 0;
+}
+__name(toTranscriptEpochMs, "toTranscriptEpochMs");
+function buildUpdateMeta(options) {
+  const timestamp = toTranscriptEpochMs(options.timestamp);
+  const sourceRecordIds = dedupeStrings(options.sourceRecordIds ?? []);
+  const qwenTranscript = {
+    ...sourceRecordIds.length > 0 ? { sourceRecordIds } : {},
+    ...options.planToolCallId ? { planToolCallId: options.planToolCallId } : {}
+  };
+  const meta = {
+    ...options.extra ?? {},
+    ...timestamp !== void 0 ? { timestamp } : {},
+    ...Object.keys(qwenTranscript).length > 0 ? { qwenTranscript } : {}
+  };
+  return Object.keys(meta).length > 0 ? meta : void 0;
+}
+__name(buildUpdateMeta, "buildUpdateMeta");
+function createTranscriptMessageUpdate(options) {
+  const meta = buildUpdateMeta(options);
+  return {
+    sessionUpdate: options.role === "user" ? "user_message_chunk" : options.thought ? "agent_thought_chunk" : "agent_message_chunk",
+    content: { type: "text", text: options.text },
+    ...meta ? { _meta: meta } : {}
+  };
+}
+__name(createTranscriptMessageUpdate, "createTranscriptMessageUpdate");
+function createTranscriptImageUpdate(options) {
+  const meta = buildUpdateMeta(options);
+  return {
+    sessionUpdate: "user_message_chunk",
+    content: { type: "image", data: options.data, mimeType: options.mimeType },
+    ...meta ? { _meta: meta } : {}
+  };
+}
+__name(createTranscriptImageUpdate, "createTranscriptImageUpdate");
+function createTranscriptUsageUpdate(usageMetadata, options = {}) {
+  const usage = {
+    inputTokens: finiteNumber2(usageMetadata.promptTokenCount) ?? 0,
+    outputTokens: finiteNumber2(usageMetadata.candidatesTokenCount) ?? 0,
+    totalTokens: finiteNumber2(usageMetadata.totalTokenCount) ?? 0,
+    ...finiteNumber2(usageMetadata.thoughtsTokenCount) !== void 0 ? { thoughtTokens: finiteNumber2(usageMetadata.thoughtsTokenCount) } : {},
+    ...finiteNumber2(usageMetadata.cachedContentTokenCount) !== void 0 ? {
+      cachedReadTokens: finiteNumber2(usageMetadata.cachedContentTokenCount)
+    } : {}
+  };
+  const meta = buildUpdateMeta({
+    ...options,
+    extra: { usage, ...options.extra ?? {} }
+  });
+  return {
+    sessionUpdate: "agent_message_chunk",
+    content: { type: "text", text: options.text ?? "" },
+    _meta: meta
+  };
+}
+__name(createTranscriptUsageUpdate, "createTranscriptUsageUpdate");
+function createTranscriptToolCallStartUpdate(options) {
+  const provenance = resolveToolProvenance(options.toolName);
+  return {
+    sessionUpdate: options.asUpdate ? "tool_call_update" : "tool_call",
+    toolCallId: options.callId,
+    status: options.status ?? "pending",
+    title: options.metadata.title,
+    content: [],
+    locations: [...options.metadata.locations],
+    kind: options.metadata.kind,
+    rawInput: options.args ?? {},
+    _meta: buildUpdateMeta({
+      ...options,
+      extra: {
+        toolName: options.toolName,
+        provenance: provenance.provenance,
+        ...provenance.serverId ? { serverId: provenance.serverId } : {},
+        ...options.extra ?? {}
+      }
+    })
+  };
+}
+__name(createTranscriptToolCallStartUpdate, "createTranscriptToolCallStartUpdate");
+function createTranscriptToolCallResultUpdate(options) {
+  const provenance = resolveToolProvenance(options.toolName);
+  const content = buildToolResultContent(options);
+  const update = {
+    sessionUpdate: "tool_call_update",
+    toolCallId: options.callId,
+    status: options.success ? "completed" : "failed",
+    content,
+    _meta: buildUpdateMeta({
+      ...options,
+      extra: {
+        toolName: options.toolName,
+        provenance: provenance.provenance,
+        ...provenance.serverId ? { serverId: provenance.serverId } : {},
+        ...options.artifacts && options.artifacts.length > 0 ? { artifacts: options.artifacts } : {},
+        ...options.extra ?? {}
+      }
+    })
+  };
+  if (options.resultDisplay !== void 0 && !isTruncatedSessionDiffDisplay(options.resultDisplay)) {
+    update["rawOutput"] = options.resultDisplay;
+  }
+  return update;
+}
+__name(createTranscriptToolCallResultUpdate, "createTranscriptToolCallResultUpdate");
+function createTranscriptPlanUpdate(todos, cumulativeUsage, options = {}) {
+  const meta = buildUpdateMeta({
+    ...options,
+    extra: {
+      ...cumulativeUsage ? { stats: { ...cumulativeUsage } } : {},
+      ...options.extra ?? {}
+    }
+  });
+  return {
+    sessionUpdate: "plan",
+    entries: todos.map((todo) => ({
+      content: todo.content,
+      priority: "medium",
+      status: todo.status
+    })),
+    ...meta ? { _meta: meta } : {}
+  };
+}
+__name(createTranscriptPlanUpdate, "createTranscriptPlanUpdate");
+function extractTranscriptTodos(resultDisplay, args) {
+  const fromDisplay = extractTodosFromDisplay(resultDisplay);
+  if (fromDisplay) return fromDisplay;
+  return args && Array.isArray(args["todos"]) ? normalizeTodos(args["todos"]) : null;
+}
+__name(extractTranscriptTodos, "extractTranscriptTodos");
+function createTranscriptReplayMachine(options = {}) {
+  return new DefaultTranscriptReplayMachine(options);
+}
+__name(createTranscriptReplayMachine, "createTranscriptReplayMachine");
+var DefaultTranscriptReplayMachine = class {
+  constructor(options) {
+    this.options = options;
+    const initialState = parseInitialState(
+      options.initialState,
+      options.onDiagnostic
+    );
+    this.usage = { ...initialState.cumulativeUsage };
+    for (const pending of initialState.pendingToolCalls) {
+      this.pendingToolCalls.set(pending.callId, pending);
+      this.usedToolCallIds.add(pending.callId);
+    }
+    for (const gap of options.gaps ?? []) {
+      if (!this.gapByChild.has(gap.childUuid)) {
+        this.gapByChild.set(gap.childUuid, gap);
+      }
+    }
+  }
+  static {
+    __name(this, "DefaultTranscriptReplayMachine");
+  }
+  pendingToolCalls = /* @__PURE__ */ new Map();
+  usedToolCallIds = /* @__PURE__ */ new Set();
+  gapByChild = /* @__PURE__ */ new Map();
+  usage;
+  finalized = false;
+  *project(record) {
+    if (this.finalized) {
+      throw new Error(
+        "Cannot project records after transcript replay finalize."
+      );
+    }
+    let ordinal = 0;
+    const emit = /* @__PURE__ */ __name((update) => ({
+      sourceRecordId: record.uuid,
+      ...record.timestamp ? { sourceTimestamp: record.timestamp } : {},
+      emissionOrdinal: ordinal++,
+      update
+    }), "emit");
+    const meta = {
+      timestamp: record.timestamp,
+      sourceRecordIds: [record.uuid]
+    };
+    const gap = this.gapByChild.get(record.uuid);
+    if (gap) {
+      yield emit(
+        createTranscriptMessageUpdate({
+          role: "assistant",
+          text: this.formatGap(gap),
+          ...meta,
+          extra: { qwenDiscreteMessage: true }
+        })
+      );
+    }
+    switch (record.type) {
+      case "user":
+        yield* this.projectUserRecord(record, emit, meta);
+        break;
+      case "assistant":
+        yield* this.projectAssistantRecord(record, emit, meta);
+        break;
+      case "tool_result":
+        yield* this.projectToolResult(record, emit, meta);
+        break;
+      case "system":
+        yield* this.projectSystemRecord(record, emit, meta);
+        break;
+      default:
+        this.report(
+          "unknown_record_or_part",
+          "Skipped an unknown transcript record type.",
+          record.uuid
+        );
+    }
+  }
+  *finalize() {
+    if (this.finalized) return;
+    this.finalized = true;
+    let ordinal = 0;
+    for (const pending of [...this.pendingToolCalls.values()]) {
+      this.pendingToolCalls.delete(pending.callId);
+      yield {
+        sourceRecordId: pending.sourceRecordId,
+        ...pending.sourceTimestamp ? { sourceTimestamp: pending.sourceTimestamp } : {},
+        emissionOrdinal: ordinal++,
+        update: createTranscriptToolCallResultUpdate({
+          toolName: pending.toolName,
+          callId: pending.callId,
+          success: false,
+          errorMessage: MISSING_TRANSCRIPT_TOOL_RESULT_MESSAGE,
+          timestamp: pending.sourceTimestamp,
+          sourceRecordIds: [pending.sourceRecordId]
+        })
+      };
+    }
+  }
+  snapshot() {
+    return {
+      v: 1,
+      pendingToolCalls: [...this.pendingToolCalls.values()].map((pending) => ({
+        ...pending
+      })),
+      cumulativeUsage: { ...this.usage }
+    };
+  }
+  *projectUserRecord(record, emit, meta) {
+    if (record.subtype === "notification" || record.subtype === "cron" || record.subtype === "mid_turn_user_message") {
+      const payload = isObjectRecord(record.systemPayload) ? record.systemPayload : void 0;
+      const displayText = payload && typeof payload["displayText"] === "string" ? payload["displayText"] : void 0;
+      if (displayText) {
+        yield emit(
+          createTranscriptMessageUpdate({
+            role: "user",
+            text: displayText,
+            ...meta,
+            ...record.subtype === "cron" ? { extra: { source: "cron" } } : {}
+          })
+        );
+        return;
+      }
+      if (record.subtype !== "mid_turn_user_message") return;
+    }
+    yield* this.projectMessageParts(record, "user", emit, meta);
+  }
+  *projectAssistantRecord(record, emit, meta) {
+    const usageMetadata = isObjectRecord(record.usageMetadata) ? record.usageMetadata : void 0;
+    let usageEmitted = false;
+    const takeUsageUpdate = /* @__PURE__ */ __name(() => {
+      if (!usageMetadata || usageEmitted) return void 0;
+      usageEmitted = true;
+      this.addUsage(usageMetadata);
+      return createTranscriptUsageUpdate(usageMetadata, meta);
+    }, "takeUsageUpdate");
+    yield* this.projectMessageParts(
+      record,
+      "assistant",
+      emit,
+      meta,
+      takeUsageUpdate
+    );
+    const trailingUsage = takeUsageUpdate();
+    if (trailingUsage) yield emit(trailingUsage);
+  }
+  *projectMessageParts(record, role, emit, meta, beforeToolCall) {
+    const parts = record.message?.parts;
+    if (!parts) return;
+    for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+      const part = parts[partIndex];
+      if (!isObjectRecord(part)) {
+        this.report(
+          "malformed_part",
+          "Skipped a malformed transcript message part.",
+          record.uuid,
+          `message.parts[${partIndex}]`
+        );
+        continue;
+      }
+      let recognized = false;
+      if (typeof part["text"] === "string" && part["text"].length > 0) {
+        recognized = true;
+        yield emit(
+          createTranscriptMessageUpdate({
+            role,
+            text: part["text"],
+            thought: role === "assistant" && part["thought"] === true,
+            ...meta
+          })
+        );
+      }
+      const inlineData = isObjectRecord(part["inlineData"]) ? part["inlineData"] : void 0;
+      if (inlineData) {
+        recognized = true;
+        const data = inlineData["data"];
+        const mimeType = inlineData["mimeType"];
+        if (role === "user" && typeof data === "string" && typeof mimeType === "string" && mimeType.startsWith("image/")) {
+          yield emit(createTranscriptImageUpdate({ data, mimeType, ...meta }));
+        } else {
+          this.report(
+            "malformed_part",
+            "Skipped an unsupported or malformed inline transcript part.",
+            record.uuid,
+            `message.parts[${partIndex}].inlineData`
+          );
+        }
+      }
+      const functionCall = isObjectRecord(part["functionCall"]) ? part["functionCall"] : void 0;
+      if (functionCall) {
+        recognized = true;
+        const toolName = typeof functionCall["name"] === "string" ? functionCall["name"] : "";
+        const args = isObjectRecord(functionCall["args"]) ? functionCall["args"] : {};
+        if (!toolName) {
+          this.report(
+            "malformed_part",
+            "Skipped a tool call without a tool name.",
+            record.uuid,
+            `message.parts[${partIndex}].functionCall`
+          );
+          continue;
+        }
+        const preToolUpdate = beforeToolCall?.();
+        if (preToolUpdate) yield emit(preToolUpdate);
+        if (toolName === "todo_write") continue;
+        const explicitId = typeof functionCall["id"] === "string" && functionCall["id"].length > 0 ? functionCall["id"] : void 0;
+        const callId = this.allocateToolCallId(
+          explicitId ?? `qwen-replay-tool:${record.uuid}:${partIndex}`
+        );
+        const update = createTranscriptToolCallStartUpdate({
+          toolName,
+          callId,
+          args,
+          status: "in_progress",
+          metadata: this.resolveToolMetadata(toolName, args, record.uuid),
+          ...meta
+        });
+        yield emit(update);
+        if (role === "assistant") {
+          this.pendingToolCalls.set(callId, {
+            callId,
+            toolName,
+            sourceRecordId: record.uuid,
+            ...record.timestamp ? { sourceTimestamp: record.timestamp } : {}
+          });
+        }
+      }
+      if (!recognized && !("functionResponse" in part)) {
+        this.report(
+          "unknown_record_or_part",
+          "Skipped an unknown transcript message part.",
+          record.uuid,
+          `message.parts[${partIndex}]`
+        );
+      }
+    }
+  }
+  *projectToolResult(record, emit, meta) {
+    const result = isObjectRecord(record.toolCallResult) ? record.toolCallResult : void 0;
+    const toolName = extractToolName(record);
+    if (!toolName) {
+      this.report(
+        "malformed_part",
+        "A transcript tool result has no tool name.",
+        record.uuid,
+        "message.parts"
+      );
+    }
+    const explicitCallId = extractToolResultCallId(record, result);
+    const callId = explicitCallId ? this.allocateToolCallId(explicitCallId, true) : this.correlateResultCallId(toolName, record.uuid);
+    this.pendingToolCalls.delete(callId);
+    const resultDisplay = result?.["resultDisplay"];
+    if (toolName === "todo_write") {
+      const todos = extractTranscriptTodos(resultDisplay);
+      if (todos) {
+        yield emit(
+          createTranscriptPlanUpdate(todos, this.usage, {
+            ...meta,
+            planToolCallId: callId
+          })
+        );
+      }
+      return;
+    }
+    yield emit(
+      createTranscriptToolCallResultUpdate({
+        toolName,
+        callId,
+        success: result?.["status"] === void 0 ? !result?.["error"] : result["status"] === "success" && !result["error"],
+        errorMessage: extractErrorMessage(result?.["error"]),
+        message: record.message?.parts,
+        resultDisplay,
+        artifacts: Array.isArray(result?.["artifacts"]) ? result["artifacts"] : void 0,
+        contentPrefix: this.buildToolResultContentPrefix(
+          resultDisplay,
+          record.uuid
+        ),
+        ...meta
+      })
+    );
+    if (isTaskExecutionDisplay(resultDisplay)) {
+      const usage = usageFromTaskExecution(resultDisplay);
+      if (Object.keys(usage).length > 0) {
+        this.addUsage(usage);
+        yield emit(createTranscriptUsageUpdate(usage, meta));
+      }
+    }
+  }
+  *projectSystemRecord(record, emit, meta) {
+    if (record.subtype !== "slash_command") return;
+    const payload = isObjectRecord(record.systemPayload) ? record.systemPayload : void 0;
+    if (payload?.["phase"] !== "result") return;
+    const items = Array.isArray(payload["outputHistoryItems"]) ? payload["outputHistoryItems"] : [];
+    for (const item of items) {
+      const goalStatus = parseTranscriptGoalStatus(item);
+      if (goalStatus) {
+        if (goalStatus.condition.length === 0) {
+          this.report(
+            "malformed_part",
+            "Skipped replay of a goal card whose condition is empty.",
+            record.uuid,
+            "systemPayload.outputHistoryItems.goalStatus.condition"
+          );
+        } else if (goalStatus.kind !== "checking") {
+          yield emit(
+            createTranscriptMessageUpdate({
+              role: "assistant",
+              text: "",
+              ...meta,
+              extra: { goalStatus }
+            })
+          );
+        }
+        continue;
+      }
+      if (!isObjectRecord(item) || typeof item["text"] !== "string") continue;
+      yield emit(
+        createTranscriptMessageUpdate({
+          role: "assistant",
+          text: item["text"].replace(/\n/g, "  \n"),
+          ...meta,
+          extra: { source: "slash_command" }
+        })
+      );
+    }
+  }
+  addUsage(metadata) {
+    this.usage.promptTokens += finiteNumber2(metadata["promptTokenCount"]) ?? 0;
+    this.usage.candidateTokens += finiteNumber2(metadata["candidatesTokenCount"]) ?? 0;
+    this.usage.cachedTokens += finiteNumber2(metadata["cachedContentTokenCount"]) ?? 0;
+  }
+  correlateResultCallId(toolName, recordId) {
+    const candidates = [...this.pendingToolCalls.values()].filter(
+      (pending) => pending.toolName === toolName
+    );
+    if (candidates.length === 1) return candidates[0].callId;
+    this.report(
+      "ambiguous_tool_call_correlation",
+      "A tool result could not be matched to exactly one pending tool call.",
+      recordId
+    );
+    return this.allocateToolCallId(`qwen-replay-tool:${recordId}:result`);
+  }
+  allocateToolCallId(candidate, reuse = false) {
+    if (reuse && this.pendingToolCalls.has(candidate)) {
+      this.usedToolCallIds.add(candidate);
+      return candidate;
+    }
+    if (!this.usedToolCallIds.has(candidate)) {
+      this.usedToolCallIds.add(candidate);
+      return candidate;
+    }
+    let occurrence = 2;
+    while (this.usedToolCallIds.has(`${candidate}:${occurrence}`)) {
+      occurrence += 1;
+    }
+    const id = `${candidate}:${occurrence}`;
+    this.usedToolCallIds.add(id);
+    return id;
+  }
+  resolveToolMetadata(toolName, args, recordId) {
+    try {
+      return this.options.presentation?.resolveToolMetadata(toolName, args) ?? fallbackToolMetadata(toolName, args);
+    } catch {
+      this.report(
+        "presentation_fallback",
+        "Tool presentation metadata fell back to deterministic defaults.",
+        recordId,
+        void 0,
+        false
+      );
+      return fallbackToolMetadata(toolName, args);
+    }
+  }
+  formatGap(gap) {
+    try {
+      return this.options.presentation?.formatHistoryGap(gap) ?? "Some earlier messages are unavailable because the saved history is incomplete.";
+    } catch {
+      this.report(
+        "presentation_fallback",
+        "History gap presentation fell back to deterministic defaults.",
+        gap.childUuid,
+        void 0,
+        false
+      );
+      return "Some earlier messages are unavailable because the saved history is incomplete.";
+    }
+  }
+  buildToolResultContentPrefix(resultDisplay, recordId) {
+    try {
+      return this.options.presentation?.buildToolResultContentPrefix?.(
+        resultDisplay
+      ) ?? defaultToolResultContentPrefix(resultDisplay);
+    } catch {
+      this.report(
+        "presentation_fallback",
+        "Tool result content presentation fell back to deterministic defaults.",
+        recordId,
+        void 0,
+        false
+      );
+      return defaultToolResultContentPrefix(resultDisplay);
+    }
+  }
+  report(code, message, recordId, path2, affectsCompleteness = true) {
+    this.options.onDiagnostic?.({
+      code,
+      severity: affectsCompleteness ? "warning" : "info",
+      message,
+      affectsCompleteness,
+      ...recordId ? { recordId } : {},
+      ...path2 ? { path: path2 } : {}
+    });
+  }
+};
+function parseTranscriptGoalStatus(value) {
+  if (!isObjectRecord(value) || value["type"] !== "goal_status") {
+    return void 0;
+  }
+  const kind = value["kind"];
+  const condition = value["condition"];
+  if (typeof kind !== "string" || !TRANSCRIPT_GOAL_STATUS_KINDS.has(kind) || typeof condition !== "string") {
+    return void 0;
+  }
+  const iterations = finiteNumber2(value["iterations"]);
+  const setAt = finiteNumber2(value["setAt"]);
+  const durationMs = finiteNumber2(value["durationMs"]);
+  const lastReason = typeof value["lastReason"] === "string" ? value["lastReason"] : void 0;
+  return {
+    kind,
+    condition,
+    ...iterations !== void 0 ? { iterations } : {},
+    ...setAt !== void 0 ? { setAt } : {},
+    ...durationMs !== void 0 ? { durationMs } : {},
+    ...lastReason !== void 0 ? { lastReason } : {}
+  };
+}
+__name(parseTranscriptGoalStatus, "parseTranscriptGoalStatus");
+function defaultToolResultContentPrefix(resultDisplay) {
+  if (!isObjectRecord(resultDisplay) || resultDisplay["type"] !== "vision_bridge_notice" || typeof resultDisplay["summary"] !== "string" || typeof resultDisplay["notice"] !== "string") {
+    return [];
+  }
+  return [
+    {
+      type: "content",
+      content: {
+        type: "text",
+        text: `${resultDisplay["summary"]}
+${resultDisplay["notice"]}`
+      }
+    }
+  ];
+}
+__name(defaultToolResultContentPrefix, "defaultToolResultContentPrefix");
+function parseInitialState(value, onDiagnostic) {
+  const empty = {
+    v: 1,
+    pendingToolCalls: [],
+    cumulativeUsage: emptyUsage()
+  };
+  if (value === void 0) return empty;
+  if (!isObjectRecord(value)) {
+    throw new TypeError("Invalid transcript replay state.");
+  }
+  if ("v" in value && value["v"] !== 1) {
+    throw new TypeError("Unsupported transcript replay state version.");
+  }
+  const rawPending = Array.isArray(value["pendingToolCalls"]) ? value["pendingToolCalls"] : [];
+  const pendingToolCalls = rawPending.flatMap(
+    (pending) => {
+      if (!isObjectRecord(pending) || typeof pending["callId"] !== "string" || typeof pending["toolName"] !== "string" || typeof pending["sourceRecordId"] !== "string") {
+        onDiagnostic?.({
+          code: "invalid_replay_state",
+          severity: "warning",
+          message: "Dropped a malformed pending tool call from replay state.",
+          affectsCompleteness: true
+        });
+        return [];
+      }
+      return [
+        {
+          callId: pending["callId"],
+          toolName: pending["toolName"],
+          sourceRecordId: pending["sourceRecordId"],
+          ...typeof pending["sourceTimestamp"] === "string" ? { sourceTimestamp: pending["sourceTimestamp"] } : {}
+        }
+      ];
+    }
+  );
+  const rawUsage = value.cumulativeUsage;
+  const usage = isObjectRecord(rawUsage) ? rawUsage : {};
+  const validUsage = finiteNumber2(usage["promptTokens"]) !== void 0 && finiteNumber2(usage["cachedTokens"]) !== void 0 && finiteNumber2(usage["candidateTokens"]) !== void 0 && finiteNumber2(usage["apiTimeMs"]) !== void 0;
+  if (!validUsage) {
+    onDiagnostic?.({
+      code: "invalid_replay_state",
+      severity: "warning",
+      message: "Reset invalid cumulative usage in transcript replay state.",
+      affectsCompleteness: true
+    });
+  }
+  return {
+    v: 1,
+    pendingToolCalls,
+    cumulativeUsage: validUsage ? {
+      promptTokens: usage["promptTokens"],
+      cachedTokens: usage["cachedTokens"],
+      candidateTokens: usage["candidateTokens"],
+      apiTimeMs: usage["apiTimeMs"]
+    } : emptyUsage()
+  };
+}
+__name(parseInitialState, "parseInitialState");
+function emptyUsage() {
+  return {
+    promptTokens: 0,
+    cachedTokens: 0,
+    candidateTokens: 0,
+    apiTimeMs: 0
+  };
+}
+__name(emptyUsage, "emptyUsage");
+function fallbackToolMetadata(toolName, args) {
+  const description = typeof args["description"] === "string" ? args["description"].trim() : "";
+  return {
+    title: description ? `${toolName}: ${description}` : toolName,
+    locations: [],
+    kind: "other"
+  };
+}
+__name(fallbackToolMetadata, "fallbackToolMetadata");
+function resolveToolProvenance(toolName) {
+  if (toolName.startsWith("mcp__")) {
+    const parts = toolName.split("__");
+    if (parts.length >= 3 && parts[1]) {
+      return { provenance: "mcp", serverId: parts[1] };
+    }
+  }
+  return { provenance: "builtin" };
+}
+__name(resolveToolProvenance, "resolveToolProvenance");
+function buildToolResultContent(options) {
+  const prefix = [...options.contentPrefix ?? []];
+  const diff = extractDiffContent(options.resultDisplay);
+  if (diff) return [...prefix, diff];
+  if (options.errorMessage) {
+    return [
+      ...prefix,
+      {
+        type: "content",
+        content: { type: "text", text: options.errorMessage }
+      }
+    ];
+  }
+  const content = [...prefix];
+  for (const part of options.message ?? []) {
+    if (!isObjectRecord(part)) continue;
+    if (typeof part["text"] === "string" && part["text"]) {
+      content.push({
+        type: "content",
+        content: { type: "text", text: part["text"] }
+      });
+    }
+    const response = isObjectRecord(part["functionResponse"]) ? part["functionResponse"] : void 0;
+    const payload = response && isObjectRecord(response["response"]) ? response["response"] : void 0;
+    if (!payload) continue;
+    try {
+      const output = payload["output"];
+      const error = payload["error"];
+      const text = typeof output === "string" ? output : typeof error === "string" ? error : JSON.stringify(payload);
+      content.push({
+        type: "content",
+        content: { type: "text", text }
+      });
+    } catch {
+    }
+  }
+  return content;
+}
+__name(buildToolResultContent, "buildToolResultContent");
+function extractDiffContent(resultDisplay) {
+  if (!isObjectRecord(resultDisplay)) return null;
+  if (!("fileName" in resultDisplay) || !("newContent" in resultDisplay)) {
+    return null;
+  }
+  if (isTruncatedSessionDiffDisplay(resultDisplay)) {
+    return {
+      type: "content",
+      content: {
+        type: "text",
+        text: buildTruncatedDiffPreviewText(resultDisplay)
+      }
+    };
+  }
+  return {
+    type: "diff",
+    path: typeof resultDisplay["fileName"] === "string" ? resultDisplay["fileName"] : "",
+    oldText: typeof resultDisplay["originalContent"] === "string" ? resultDisplay["originalContent"] : "",
+    newText: typeof resultDisplay["newContent"] === "string" ? resultDisplay["newContent"] : ""
+  };
+}
+__name(extractDiffContent, "extractDiffContent");
+function isTruncatedSessionDiffDisplay(value) {
+  return isObjectRecord(value) && value["truncatedForSession"] === true && "fileName" in value && "newContent" in value;
+}
+__name(isTruncatedSessionDiffDisplay, "isTruncatedSessionDiffDisplay");
+function buildTruncatedDiffPreviewText(display) {
+  const fileName = typeof display["fileName"] === "string" ? display["fileName"] : "the edited file";
+  const fileDiffLength = typeof display["fileDiffLength"] === "number" ? ` Original fileDiff length: ${display["fileDiffLength"]} chars.` : "";
+  return display["fileDiffTruncated"] === true ? `Full diff omitted from saved session history for ${fileName}.${fileDiffLength}` : `Saved session preview only for ${fileName}; full original and new file contents are unavailable.`;
+}
+__name(buildTruncatedDiffPreviewText, "buildTruncatedDiffPreviewText");
+function extractToolName(record) {
+  for (const part of record.message?.parts ?? []) {
+    if (!isObjectRecord(part) || !isObjectRecord(part["functionResponse"])) {
+      continue;
+    }
+    const name = part["functionResponse"]["name"];
+    if (typeof name === "string") return name;
+  }
+  return "";
+}
+__name(extractToolName, "extractToolName");
+function extractToolResultCallId(record, result) {
+  if (typeof result?.["callId"] === "string" && result["callId"].length > 0) {
+    return result["callId"];
+  }
+  for (const part of record.message?.parts ?? []) {
+    if (!isObjectRecord(part) || !isObjectRecord(part["functionResponse"])) {
+      continue;
+    }
+    const id = part["functionResponse"]["id"];
+    if (typeof id === "string" && id.length > 0) return id;
+  }
+  return void 0;
+}
+__name(extractToolResultCallId, "extractToolResultCallId");
+function extractTodosFromDisplay(value) {
+  if (isObjectRecord(value) && value["type"] === "todo_list") {
+    return Array.isArray(value["todos"]) ? normalizeTodos(value["todos"]) : null;
+  }
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value);
+    return isObjectRecord(parsed) && parsed["type"] === "todo_list" && Array.isArray(parsed["todos"]) ? normalizeTodos(parsed["todos"]) : null;
+  } catch {
+    return null;
+  }
+}
+__name(extractTodosFromDisplay, "extractTodosFromDisplay");
+function normalizeTodos(values) {
+  return values.flatMap((value) => {
+    if (!isObjectRecord(value) || typeof value["content"] !== "string")
+      return [];
+    const status = value["status"];
+    if (status !== "pending" && status !== "in_progress" && status !== "completed") {
+      return [];
+    }
+    return [
+      {
+        ...typeof value["id"] === "string" ? { id: value["id"] } : {},
+        content: value["content"],
+        status
+      }
+    ];
+  });
+}
+__name(normalizeTodos, "normalizeTodos");
+function isTaskExecutionDisplay(value) {
+  return isObjectRecord(value) && value["type"] === "task_execution";
+}
+__name(isTaskExecutionDisplay, "isTaskExecutionDisplay");
+function usageFromTaskExecution(display) {
+  const summary = isObjectRecord(display["executionSummary"]) ? display["executionSummary"] : void 0;
+  if (!summary) return {};
+  return {
+    ...finiteNumber2(summary["inputTokens"]) !== void 0 ? { promptTokenCount: summary["inputTokens"] } : {},
+    ...finiteNumber2(summary["outputTokens"]) !== void 0 ? { candidatesTokenCount: summary["outputTokens"] } : {},
+    ...finiteNumber2(summary["thoughtTokens"]) !== void 0 ? { thoughtsTokenCount: summary["thoughtTokens"] } : {},
+    ...finiteNumber2(summary["cachedTokens"]) !== void 0 ? { cachedContentTokenCount: summary["cachedTokens"] } : {},
+    ...finiteNumber2(summary["totalTokens"]) !== void 0 ? { totalTokenCount: summary["totalTokens"] } : {}
+  };
+}
+__name(usageFromTaskExecution, "usageFromTaskExecution");
+function finiteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+__name(finiteNumber2, "finiteNumber");
+function extractErrorMessage(value) {
+  if (value instanceof Error) return value.message;
+  if (!isObjectRecord(value)) return void 0;
+  return typeof value["message"] === "string" ? value["message"] : void 0;
+}
+__name(extractErrorMessage, "extractErrorMessage");
+function dedupeStrings(values) {
+  return [...new Set(values.filter((value) => value.length > 0))];
+}
+__name(dedupeStrings, "dedupeStrings");
+
 // packages/cli/src/acp-integration/session/emitters/base-emitter.ts
 init_esbuild_shims();
 var BaseEmitter = class {
@@ -785,16 +1634,14 @@ var MessageEmitter = class extends BaseEmitter {
    * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
    */
   async emitUserMessage(text, timestamp, options = {}) {
-    const epochMs = BaseEmitter.toEpochMs(timestamp);
-    const _meta = {
-      ...epochMs != null ? { timestamp: epochMs } : {},
-      ...options.source ? { source: options.source } : {}
-    };
-    await this.sendUpdate({
-      sessionUpdate: "user_message_chunk",
-      content: { type: "text", text },
-      ...Object.keys(_meta).length > 0 ? { _meta } : {}
-    });
+    await this.sendUpdate(
+      createTranscriptMessageUpdate({
+        role: "user",
+        text,
+        timestamp,
+        ...options.source ? { extra: { source: options.source } } : {}
+      })
+    );
   }
   /**
    * Emits an agent thought chunk.
@@ -803,15 +1650,15 @@ var MessageEmitter = class extends BaseEmitter {
    * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
    */
   async emitAgentThought(text, timestamp, subagentMeta) {
-    const _meta = this.buildChunkMeta(
-      BaseEmitter.toEpochMs(timestamp),
-      subagentMeta
+    await this.sendUpdate(
+      createTranscriptMessageUpdate({
+        role: "assistant",
+        thought: true,
+        text,
+        timestamp,
+        ...subagentMeta ? { extra: { ...subagentMeta } } : {}
+      })
     );
-    await this.sendUpdate({
-      sessionUpdate: "agent_thought_chunk",
-      content: { type: "text", text },
-      ..._meta ? { _meta } : {}
-    });
   }
   /**
    * Emits an agent message chunk.
@@ -820,15 +1667,14 @@ var MessageEmitter = class extends BaseEmitter {
    * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
    */
   async emitAgentMessage(text, timestamp, subagentMeta) {
-    const _meta = this.buildChunkMeta(
-      BaseEmitter.toEpochMs(timestamp),
-      subagentMeta
+    await this.sendUpdate(
+      createTranscriptMessageUpdate({
+        role: "assistant",
+        text,
+        timestamp,
+        ...subagentMeta ? { extra: { ...subagentMeta } } : {}
+      })
     );
-    await this.sendUpdate({
-      sessionUpdate: "agent_message_chunk",
-      content: { type: "text", text },
-      ..._meta ? { _meta } : {}
-    });
   }
   async emitSlashCommandOutput(text, timestamp) {
     const epochMs = BaseEmitter.toEpochMs(timestamp);
@@ -845,48 +1691,41 @@ var MessageEmitter = class extends BaseEmitter {
    * Emits usage metadata.
    */
   async emitUsageMetadata(usageMetadata, text = "", durationMs, subagentMeta) {
-    const usage = {
-      inputTokens: usageMetadata.promptTokenCount ?? 0,
-      outputTokens: usageMetadata.candidatesTokenCount ?? 0,
-      totalTokens: usageMetadata.totalTokenCount ?? 0,
-      thoughtTokens: usageMetadata.thoughtsTokenCount,
-      cachedReadTokens: usageMetadata.cachedContentTokenCount
-    };
     const cumulative = this.ctx.cumulativeUsage;
     if (cumulative) {
       const addFinite = /* @__PURE__ */ __name((total, value) => typeof value === "number" && Number.isFinite(value) ? total + value : total, "addFinite");
       cumulative.promptTokens = addFinite(
         cumulative.promptTokens,
-        usage.inputTokens
+        usageMetadata.promptTokenCount
       );
       cumulative.candidateTokens = addFinite(
         cumulative.candidateTokens,
-        usage.outputTokens
+        usageMetadata.candidatesTokenCount
       );
       cumulative.cachedTokens = addFinite(
         cumulative.cachedTokens,
-        usage.cachedReadTokens
+        usageMetadata.cachedContentTokenCount
       );
       cumulative.apiTimeMs = addFinite(cumulative.apiTimeMs, durationMs);
     }
-    let meta;
+    let activityMeta = {};
     if (typeof durationMs === "number") {
       const activity = apiActivityTracker.drain();
-      meta = {
-        usage,
-        durationMs,
+      activityMeta = {
         ...activity.errors > 0 ? { apiErrors: activity.errors } : {},
-        ...activity.retries > 0 ? { apiRetries: activity.retries } : {},
-        ...subagentMeta
+        ...activity.retries > 0 ? { apiRetries: activity.retries } : {}
       };
-    } else {
-      meta = { usage, ...subagentMeta };
     }
-    await this.sendUpdate({
-      sessionUpdate: "agent_message_chunk",
-      content: { type: "text", text },
-      _meta: meta
-    });
+    await this.sendUpdate(
+      createTranscriptUsageUpdate(usageMetadata, {
+        text,
+        extra: {
+          ...typeof durationMs === "number" ? { durationMs } : {},
+          ...activityMeta,
+          ...subagentMeta
+        }
+      })
+    );
   }
   /**
    * Emits a message chunk based on role and thought flag.
@@ -903,14 +1742,6 @@ var MessageEmitter = class extends BaseEmitter {
     }
     return isThought ? this.emitAgentThought(text, timestamp, subagentMeta) : this.emitAgentMessage(text, timestamp, subagentMeta);
   }
-  buildChunkMeta(epochMs, subagentMeta) {
-    const meta = {
-      ...subagentMeta?.parentToolCallId ? { parentToolCallId: subagentMeta.parentToolCallId } : {},
-      ...subagentMeta?.subagentType ? { subagentType: subagentMeta.subagentType } : {},
-      ...epochMs != null ? { timestamp: epochMs } : {}
-    };
-    return Object.keys(meta).length > 0 ? meta : void 0;
-  }
 };
 
 // packages/cli/src/acp-integration/session/emitters/PlanEmitter.ts
@@ -925,18 +1756,8 @@ var PlanEmitter = class extends BaseEmitter {
    * @param todos - Array of todo items to send as plan entries
    */
   async emitPlan(todos) {
-    const entries = todos.map((todo) => ({
-      content: todo.content,
-      priority: "medium",
-      // Default priority since todos don't have priority
-      status: todo.status
-    }));
     const cumulative = this.ctx.cumulativeUsage;
-    await this.sendUpdate({
-      sessionUpdate: "plan",
-      entries,
-      ...cumulative ? { _meta: { stats: { ...cumulative } } } : {}
-    });
+    await this.sendUpdate(createTranscriptPlanUpdate(todos, cumulative));
   }
   /**
    * Extracts todos from tool result display or args.
@@ -950,35 +1771,12 @@ var PlanEmitter = class extends BaseEmitter {
    * @returns Array of todos if found, null otherwise
    */
   extractTodos(resultDisplay, args) {
-    const fromDisplay = this.extractFromResultDisplay(resultDisplay);
-    if (fromDisplay) return fromDisplay;
-    if (args && Array.isArray(args["todos"])) {
-      return args["todos"];
-    }
-    return null;
-  }
-  /**
-   * Extracts todos from a result display value.
-   * Handles both object and JSON string formats.
-   */
-  extractFromResultDisplay(resultDisplay) {
-    if (!resultDisplay) return null;
-    if (typeof resultDisplay === "object") {
-      const obj = resultDisplay;
-      if (obj["type"] === "todo_list" && Array.isArray(obj["todos"])) {
-        return obj["todos"];
-      }
-    }
-    if (typeof resultDisplay === "string") {
-      try {
-        const parsed = JSON.parse(resultDisplay);
-        if (parsed?.["type"] === "todo_list" && Array.isArray(parsed["todos"])) {
-          return parsed["todos"];
-        }
-      } catch {
-      }
-    }
-    return null;
+    const todos = extractTranscriptTodos(resultDisplay, args);
+    return todos?.map((todo, index) => ({
+      id: todo.id ?? String(index),
+      content: todo.content,
+      status: todo.status
+    })) ?? null;
   }
 };
 
@@ -992,18 +1790,6 @@ function hasFullSessionContext(context) {
 }
 __name(hasFullSessionContext, "hasFullSessionContext");
 
-// packages/cli/src/utils/truncatedDiffPreview.ts
-init_esbuild_shims();
-function buildTruncatedDiffPreviewText(display) {
-  const fileName = typeof display["fileName"] === "string" ? display["fileName"] : "the edited file";
-  const fileDiffLength = typeof display["fileDiffLength"] === "number" ? ` Original fileDiff length: ${display["fileDiffLength"]} chars.` : "";
-  if (display["fileDiffTruncated"] === true) {
-    return `Full diff omitted from saved session history for ${fileName}.${fileDiffLength}`;
-  }
-  return `Saved session preview only for ${fileName}; full original and new file contents are unavailable.`;
-}
-__name(buildTruncatedDiffPreviewText, "buildTruncatedDiffPreviewText");
-
 // packages/cli/src/acp-integration/session/emitters/tool-call-emitter.ts
 var KIND_MAP = {
   ["read" /* Read */]: "read",
@@ -1056,27 +1842,22 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
       params.subagentMeta
     );
     const updatesPreparedCall = params.phase !== "preparing" && this.preparedCallIds.delete(params.callId);
-    const update = {
-      toolCallId: params.callId,
-      status: params.status || "pending",
-      title,
-      content: [],
-      locations,
-      kind,
-      rawInput: params.args ?? {},
-      _meta: {
+    await this.sendUpdate(
+      createTranscriptToolCallStartUpdate({
         toolName: params.toolName,
-        ...params.phase ? { phase: params.phase } : {},
-        ...params.subagentMeta,
-        provenance: provenance.provenance,
-        ...provenance.serverId ? { serverId: provenance.serverId } : {},
-        ...BaseEmitter.toEpochMs(params.timestamp) != null && {
-          timestamp: BaseEmitter.toEpochMs(params.timestamp)
+        callId: params.callId,
+        status: params.status || "pending",
+        args: params.args,
+        metadata: { title, locations, kind },
+        timestamp: params.timestamp,
+        asUpdate: updatesPreparedCall,
+        extra: {
+          ...params.phase ? { phase: params.phase } : {},
+          ...params.subagentMeta,
+          provenance: provenance.provenance,
+          ...provenance.serverId ? { serverId: provenance.serverId } : {}
         }
-      }
-    };
-    await this.sendUpdate(
-      updatesPreparedCall ? { sessionUpdate: "tool_call_update", ...update } : { sessionUpdate: "tool_call", ...update }
+      })
     );
     if (params.phase === "preparing") {
       this.preparedCallIds.add(params.callId);
@@ -1121,62 +1902,35 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
         params.args
       );
       if (todos && todos.length > 0) {
-        await this.planEmitter.emitPlan(todos);
-      } else if (params.args && Array.isArray(params.args["todos"])) {
-        await this.planEmitter.emitPlan([]);
-      }
-      return;
-    }
-    this.preparedCallIds.delete(params.callId);
-    let contentArray = [];
-    const diffContent = this.extractDiffContent(params.resultDisplay);
-    if (diffContent) {
-      contentArray = [diffContent];
-    } else if (params.error) {
-      contentArray = [
-        {
-          type: "content",
-          content: { type: "text", text: params.error.message }
-        }
-      ];
-    } else {
-      contentArray = this.transformPartsToToolCallContent(params.message);
-    }
-    if (isVisionBridgeNoticeDisplay(params.resultDisplay)) {
-      contentArray.unshift({
-        type: "content",
-        content: {
-          type: "text",
-          text: sanitizeTerminalText(
-            formatVisionBridgeNoticeDisplay(params.resultDisplay)
-          )
-        }
-      });
+        await this.planEmitter.emitPlan(todos);
+      } else if (params.args && Array.isArray(params.args["todos"])) {
+        await this.planEmitter.emitPlan([]);
+      }
+      return;
     }
+    this.preparedCallIds.delete(params.callId);
     const provenance = _ToolCallEmitter.resolveToolProvenance(
       params.toolName,
       params.subagentMeta
     );
-    const update = {
-      sessionUpdate: "tool_call_update",
-      toolCallId: params.callId,
-      status: params.success ? "completed" : "failed",
-      content: contentArray,
-      _meta: {
+    await this.sendUpdate(
+      createTranscriptToolCallResultUpdate({
         toolName: params.toolName,
-        ...params.subagentMeta,
-        provenance: provenance.provenance,
-        ...provenance.serverId ? { serverId: provenance.serverId } : {},
-        ...BaseEmitter.toEpochMs(params.timestamp) != null && {
-          timestamp: BaseEmitter.toEpochMs(params.timestamp)
-        },
-        ...params.artifacts && params.artifacts.length > 0 ? { artifacts: params.artifacts } : {}
-      }
-    };
-    if (params.resultDisplay !== void 0 && !this.isTruncatedSessionDiffDisplay(params.resultDisplay)) {
-      update["rawOutput"] = params.resultDisplay;
-    }
-    await this.sendUpdate(update);
+        callId: params.callId,
+        success: params.success,
+        message: params.message,
+        resultDisplay: params.resultDisplay,
+        errorMessage: params.error?.message,
+        artifacts: params.artifacts,
+        contentPrefix: buildToolResultContentPrefix(params.resultDisplay),
+        timestamp: params.timestamp,
+        extra: {
+          ...params.subagentMeta,
+          provenance: provenance.provenance,
+          ...provenance.serverId ? { serverId: provenance.serverId } : {}
+        }
+      })
+    );
   }
   /**
    * Emits a tool call error event.
@@ -1193,20 +1947,19 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
       toolName,
       subagentMeta
     );
-    await this.sendUpdate({
-      sessionUpdate: "tool_call_update",
-      toolCallId: callId,
-      status: "failed",
-      content: [
-        { type: "content", content: { type: "text", text: error.message } }
-      ],
-      _meta: {
+    await this.sendUpdate(
+      createTranscriptToolCallResultUpdate({
         toolName,
-        ...subagentMeta,
-        provenance: provenance.provenance,
-        ...provenance.serverId ? { serverId: provenance.serverId } : {}
-      }
-    });
+        callId,
+        success: false,
+        errorMessage: error.message,
+        extra: {
+          ...subagentMeta,
+          provenance: provenance.provenance,
+          ...provenance.serverId ? { serverId: provenance.serverId } : {}
+        }
+      })
+    );
   }
   /**
    * Resolve a tool's provenance for UI dispatch on tool_call events.
@@ -1315,167 +2068,88 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
     }
     return KIND_MAP[kind] ?? "other";
   }
-  // ==================== Private Helpers ====================
-  /**
-   * Extracts diff content from resultDisplay if it's a diff type (edit tool result).
-   * Returns null if not a diff.
-   */
-  extractDiffContent(resultDisplay) {
-    if (!resultDisplay || typeof resultDisplay !== "object") return null;
-    const obj = resultDisplay;
-    if ("fileName" in obj && "newContent" in obj) {
-      if (this.isTruncatedSessionDiffDisplay(resultDisplay)) {
-        return {
-          type: "content",
-          content: {
-            type: "text",
-            text: buildTruncatedDiffPreviewText(obj)
-          }
-        };
-      }
-      return {
-        type: "diff",
-        path: obj["fileName"],
-        oldText: obj["originalContent"] ?? "",
-        newText: obj["newContent"]
-      };
-    }
-    return null;
-  }
-  isTruncatedSessionDiffDisplay(resultDisplay) {
-    if (!resultDisplay || typeof resultDisplay !== "object") return false;
-    const obj = resultDisplay;
-    return obj["truncatedForSession"] === true && "fileName" in obj && "newContent" in obj;
-  }
-  /**
-   * Transforms Part[] to ToolCallContent[].
-   * Extracts text from functionResponse parts and text parts.
-   */
-  transformPartsToToolCallContent(parts) {
-    const result = [];
-    for (const part of parts) {
-      if ("text" in part && part.text) {
-        result.push({
-          type: "content",
-          content: { type: "text", text: part.text }
-        });
-      }
-      if ("functionResponse" in part && part.functionResponse) {
-        try {
-          const resp = part.functionResponse.response;
-          const outputField = resp["output"];
-          const errorField = resp["error"];
-          const responseText = typeof outputField === "string" ? outputField : typeof errorField === "string" ? errorField : JSON.stringify(resp);
-          result.push({
-            type: "content",
-            content: { type: "text", text: responseText }
-          });
-        } catch {
-        }
-      }
-    }
-    return result;
-  }
 };
-
-// packages/cli/src/acp-integration/session/history-replayer.ts
-init_esbuild_shims();
-
-// packages/cli/src/utils/chat-record-tool-call-id.ts
-init_esbuild_shims();
-function getToolResultCallId(record) {
-  return getExplicitToolResultCallId(record) ?? record.uuid;
-}
-__name(getToolResultCallId, "getToolResultCallId");
-function getExplicitToolResultCallId(record) {
-  const resultCallId = record.toolCallResult?.callId;
-  if (typeof resultCallId === "string" && resultCallId.length > 0) {
-    return resultCallId;
-  }
-  return extractFunctionResponseId(record);
-}
-__name(getExplicitToolResultCallId, "getExplicitToolResultCallId");
-function extractFunctionResponseId(record) {
-  if (!record.message?.parts) {
-    return void 0;
-  }
-  for (const part of record.message.parts) {
-    const id = "functionResponse" in part ? part.functionResponse?.id : void 0;
-    if (typeof id === "string" && id.length > 0) {
-      return id;
+function buildToolResultContentPrefix(resultDisplay) {
+  if (!isVisionBridgeNoticeDisplay(resultDisplay)) return [];
+  return [
+    {
+      type: "content",
+      content: {
+        type: "text",
+        text: sanitizeTerminalText(
+          formatVisionBridgeNoticeDisplay(resultDisplay)
+        )
+      }
     }
-  }
-  return void 0;
+  ];
 }
-__name(extractFunctionResponseId, "extractFunctionResponseId");
+__name(buildToolResultContentPrefix, "buildToolResultContentPrefix");
 
 // packages/cli/src/acp-integration/session/history-replayer.ts
+init_esbuild_shims();
 var GOAL_NOT_RESTORED_REASON = {
   "untrusted-folder": "Goal not restored: this folder is not trusted, so its Stop hook cannot run.",
   "hooks-disabled": "Goal not restored: hooks are disabled for this session.",
   "no-hook-system": "Goal not restored: the hook system is unavailable."
 };
-var MISSING_TOOL_RESULT_MESSAGE = "Tool result missing from saved history; the previous run likely ended before this tool completed.";
 var HistoryReplayer = class {
-  static {
-    __name(this, "HistoryReplayer");
-  }
-  ctx;
-  messageEmitter;
-  toolCallEmitter;
-  options;
-  pendingReplayToolCalls = /* @__PURE__ */ new Map();
   constructor(ctx, options = {}) {
     this.ctx = ctx;
     this.options = options;
     this.messageEmitter = new MessageEmitter(ctx);
     this.toolCallEmitter = new ToolCallEmitter(ctx);
+    this.machine = this.createMachine();
   }
-  /**
-   * Replays all chat records from a loaded session.
-   *
-   * @param records - Array of chat records to replay
-   * @param gaps - Optional detected history gaps; a visible notice is emitted
-   *   immediately before each gap's child record so the user sees that an
-   *   earlier segment was lost rather than assuming the halves are contiguous.
-   */
+  static {
+    __name(this, "HistoryReplayer");
+  }
+  messageEmitter;
+  toolCallEmitter;
+  options;
+  machine;
   async replay(records, gaps) {
     try {
       await this.replayPage(records, { finalizeDangling: true, gaps });
       await this.supersedeUnrestorableGoal(records);
     } finally {
-      this.pendingReplayToolCalls.clear();
       this.setActiveRecordId(null);
     }
   }
   async replayPage(records, options = {}) {
-    this.pendingReplayToolCalls.clear();
-    for (const pending of options.pendingToolCalls ?? []) {
-      this.pendingReplayToolCalls.set(pending.callId, pending);
-    }
-    const gapByChildUuid = indexGapsByChild(options.gaps);
+    this.machine = this.createMachine(options);
     let replayError;
     try {
       for (const record of records) {
-        const gap = gapByChildUuid.get(record.uuid);
-        if (gap) {
-          await this.emitHistoryGapNotice(gap, record.timestamp);
+        for (const emission of this.machine.project(record)) {
+          this.setActiveRecordId(
+            emission.sourceRecordId,
+            emission.sourceTimestamp
+          );
+          await this.sendUpdate(emission.update);
         }
-        await this.replayRecord(record);
       }
     } catch (error) {
       replayError = error;
     }
     let danglingError;
     if (options.finalizeDangling === true) {
-      try {
-        await this.failDanglingToolCalls();
-      } catch (error) {
-        danglingError = error;
+      for (const emission of this.machine.finalize()) {
+        this.setActiveRecordId(
+          emission.sourceRecordId,
+          emission.sourceTimestamp
+        );
+        try {
+          await this.sendUpdate(emission.update);
+        } catch (error) {
+          danglingError ??= error;
+        }
       }
     }
+    const replay = this.machine.snapshot();
+    this.copyCumulativeUsage(replay);
     const state = {
-      pendingToolCalls: options.finalizeDangling === true ? [] : Array.from(this.pendingReplayToolCalls.values())
+      pendingToolCalls: options.finalizeDangling === true ? [] : replay.pendingToolCalls.map(toLegacyPendingToolCall),
+      replay
     };
     this.setActiveRecordId(null);
     if (replayError && danglingError) {
@@ -1484,271 +2158,62 @@ var HistoryReplayer = class {
         "Replay and dangling-cleanup both failed"
       );
     }
-    if (replayError) {
-      throw replayError;
-    }
-    if (danglingError) {
-      throw danglingError;
-    }
+    if (replayError) throw replayError;
+    if (danglingError) throw danglingError;
     return state;
   }
   getPendingToolCalls() {
-    return Array.from(this.pendingReplayToolCalls.values());
-  }
-  /**
-   * Replays a single chat record.
-   */
-  async replayRecord(record) {
-    this.setActiveRecordId(record.uuid, record.timestamp);
-    try {
-      switch (record.type) {
-        case "user":
-          if (record.subtype === "notification" || record.subtype === "cron") {
-            const displayText = record.systemPayload?.displayText;
-            if (displayText) {
-              await this.messageEmitter.emitUserMessage(
-                displayText,
-                record.timestamp,
-                record.subtype === "cron" ? { source: "cron" } : void 0
-              );
-            }
-            break;
-          }
-          if (record.subtype === "mid_turn_user_message") {
-            const displayText = record.systemPayload?.displayText;
-            if (displayText) {
-              await this.messageEmitter.emitUserMessage(
-                displayText,
-                record.timestamp
-              );
-            } else if (record.message) {
-              await this.replayContent(
-                record.message,
-                "user",
-                record.timestamp,
-                record.uuid
-              );
-            }
-            break;
-          }
-          if (record.message) {
-            await this.replayContent(
-              record.message,
-              "user",
-              record.timestamp,
-              record.uuid
-            );
-          }
-          break;
-        case "assistant":
-          if (record.message) {
-            await this.replayContent(
-              record.message,
-              "assistant",
-              record.timestamp,
-              record.uuid
-            );
-          }
-          if (record.usageMetadata) {
-            await this.replayUsageMetadata(record.usageMetadata);
-          }
-          break;
-        case "tool_result":
-          await this.replayToolResult(record);
-          break;
-        case "system":
-          if (record.subtype === "slash_command") {
-            await this.replaySlashCommandResult(record);
-          }
-          break;
-        default:
-          break;
-      }
-    } finally {
-      this.setActiveRecordId(null);
-    }
+    return this.machine.snapshot().pendingToolCalls.map(toLegacyPendingToolCall);
   }
-  /**
-   * Emits a visible notice marking a break in the persisted history chain: an
-   * earlier segment was physically lost (storage interruption) and could not be
-   * recovered, so the surviving turns below must not be read as contiguous with
-   * whatever came before the gap. Uses the agent message channel — the same one
-   * used for other system notices (see MessageEmitter.emitStopHookLoop) — so no
-   * new session-update kind is needed.
-   */
-  async emitHistoryGapNotice(gap, timestamp) {
-    await this.messageEmitter.emitAgentMessage(
-      formatHistoryGapNotice(gap),
-      timestamp
-    );
+  getReplayState() {
+    return this.machine.snapshot();
   }
-  /**
-   * Replays content from a message (user or assistant).
-   * Handles text parts, thought parts, and function calls.
-   *
-   * @param content - The content to replay
-   * @param role - The role (user or assistant)
-   * @param timestamp - Optional server-side timestamp from the JSONL record
-   */
-  async replayContent(content, role, timestamp, recordId) {
-    for (const part of content.parts ?? []) {
-      if ("text" in part && part.text) {
-        const isThought = part.thought ?? false;
-        await this.messageEmitter.emitMessage(
-          part.text,
-          role,
-          isThought,
-          timestamp
-        );
+  createMachine(options = {}) {
+    const cumulative = this.ctx.cumulativeUsage;
+    const initialState = {
+      v: 1,
+      pendingToolCalls: (options.pendingToolCalls ?? []).map(
+        toPendingTranscriptToolCall
+      ),
+      cumulativeUsage: cumulative ? { ...cumulative } : {
+        promptTokens: 0,
+        cachedTokens: 0,
+        candidateTokens: 0,
+        apiTimeMs: 0
       }
-      if ("functionCall" in part && part.functionCall) {
-        const functionName = part.functionCall.name ?? "";
-        const sourceCallId = part.functionCall.id;
-        const callId = sourceCallId ?? `${functionName}-${Date.now()}`;
-        const emitted = await this.toolCallEmitter.emitStart({
-          toolName: functionName,
-          callId,
-          args: part.functionCall.args,
-          status: "in_progress",
-          timestamp
-        });
-        if (emitted && role === "assistant" && recordId && sourceCallId) {
-          this.pendingReplayToolCalls.set(callId, {
-            callId,
-            toolName: functionName,
-            timestamp,
-            recordId
-          });
+    };
+    return createTranscriptReplayMachine({
+      initialState,
+      gaps: options.gaps,
+      presentation: this.presentationAdapter(),
+      onDiagnostic: /* @__PURE__ */ __name((diagnostic) => {
+        if (diagnostic.code === "malformed_part" && diagnostic.path === "systemPayload.outputHistoryItems.goalStatus.condition") {
+          writeStderrLineSafe(`qwen: ${diagnostic.message}`);
         }
-      }
-    }
-  }
-  /**
-   * Replays usage metadata.
-   * @param usageMetadata - The usage metadata to replay
-   */
-  async replayUsageMetadata(usageMetadata) {
-    await this.messageEmitter.emitUsageMetadata(usageMetadata);
-  }
-  /**
-   * Replays a tool result record.
-   */
-  async replayToolResult(record) {
-    if (!record.message?.parts) {
-      return;
-    }
-    const result = record.toolCallResult;
-    const callId = getToolResultCallId(record);
-    this.pendingReplayToolCalls.delete(callId);
-    const toolName = this.extractToolNameFromRecord(record);
-    await this.toolCallEmitter.emitResult({
-      toolName,
-      callId,
-      success: result?.status === void 0 ? !result?.error : result.status === "success" && !result.error,
-      message: record.message.parts,
-      resultDisplay: result?.resultDisplay,
-      artifacts: result?.artifacts,
-      // For TodoWriteTool fallback, try to extract args from the record
-      // Note: args aren't stored in tool_result records by default
-      args: void 0,
-      timestamp: record.timestamp
+      }, "onDiagnostic")
     });
-    const { resultDisplay } = result ?? {};
-    if (!!resultDisplay && typeof resultDisplay === "object" && "type" in resultDisplay && resultDisplay.type === "task_execution") {
-      await this.emitTaskUsageFromResultDisplay(
-        resultDisplay
-      );
-    }
   }
-  async failDanglingToolCalls() {
-    let firstError;
-    for (const pending of this.pendingReplayToolCalls.values()) {
-      this.setActiveRecordId(pending.recordId, pending.timestamp);
-      try {
-        await this.toolCallEmitter.emitResult({
-          toolName: pending.toolName,
-          callId: pending.callId,
-          success: false,
-          message: [],
-          error: new Error(MISSING_TOOL_RESULT_MESSAGE),
-          timestamp: pending.timestamp
-        });
-      } catch (error) {
-        firstError ??= error;
-      } finally {
-        this.setActiveRecordId(null);
-      }
-    }
-    if (firstError) {
-      throw firstError;
-    }
+  presentationAdapter() {
+    return {
+      resolveToolMetadata: /* @__PURE__ */ __name((toolName, args) => this.toolCallEmitter.resolveToolMetadata(toolName, { ...args }), "resolveToolMetadata"),
+      formatHistoryGap: /* @__PURE__ */ __name((gap) => formatHistoryGapNotice(gap), "formatHistoryGap"),
+      buildToolResultContentPrefix
+    };
   }
-  /**
-   * Emits token usage from a AgentResultDisplay execution summary, if present.
-   */
-  async emitTaskUsageFromResultDisplay(resultDisplay) {
-    const summary = resultDisplay.executionSummary;
-    if (!summary) {
+  async sendUpdate(update) {
+    if (this.ctx.messageRewriter) {
+      await this.ctx.messageRewriter.interceptUpdate(update);
       return;
     }
-    const usageMetadata = {};
-    if (Number.isFinite(summary.inputTokens)) {
-      usageMetadata.promptTokenCount = summary.inputTokens;
-    }
-    if (Number.isFinite(summary.outputTokens)) {
-      usageMetadata.candidatesTokenCount = summary.outputTokens;
-    }
-    if (Number.isFinite(summary.thoughtTokens)) {
-      usageMetadata.thoughtsTokenCount = summary.thoughtTokens;
-    }
-    if (Number.isFinite(summary.cachedTokens)) {
-      usageMetadata.cachedContentTokenCount = summary.cachedTokens;
-    }
-    if (Number.isFinite(summary.totalTokens)) {
-      usageMetadata.totalTokenCount = summary.totalTokens;
-    }
-    if (Object.keys(usageMetadata).length > 0) {
-      await this.messageEmitter.emitUsageMetadata(usageMetadata);
-    }
+    await this.ctx.sendUpdate(update);
   }
-  /**
-   * Replays a slash_command system record by re-emitting its output as an
-   * agent message chunk. This allows Zed to reconstruct the correct turn
-   * structure (user → agent) on session resume without polluting model context.
-   *
-   * Goal cards are re-emitted as `_meta.goalStatus` rather than text: they carry
-   * no `text` field, so the plain-text path below would silently drop them and
-   * the client would lose the goal card (and its status pill) on every reload.
-   * Per-iteration `checking` cards are skipped — a TUI transcript persists one
-   * per stop-hook turn, and clients suppress them as noise. Skipping costs no
-   * fidelity: goal restore reads the records directly, not this replay.
-   */
-  async replaySlashCommandResult(record) {
-    const payload = record.systemPayload;
-    if (payload?.phase !== "result") return;
-    const items = payload.outputHistoryItems;
-    if (!Array.isArray(items) || items.length === 0) return;
-    for (const item of items) {
-      const goalStatus = parseGoalStatusItem(item);
-      if (goalStatus) {
-        if (goalConditionBlockedBy(goalStatus.condition)) {
-          writeStderrLineSafe(
-            "qwen: skipping replay of a goal card whose condition is empty."
-          );
-        } else if (goalStatus.kind !== "checking") {
-          const { type: _type, ...status } = goalStatus;
-          await this.messageEmitter.emitGoalStatus(status);
-        }
-        continue;
-      }
-      const text = isTranscriptItemRecord(item) && typeof item["text"] === "string" ? item["text"] : "";
-      if (text) {
-        await this.messageEmitter.emitSlashCommandOutput(
-          text.replace(/\n/g, "  \n"),
-          record.timestamp
-        );
-      }
-    }
+  copyCumulativeUsage(state) {
+    const cumulative = this.ctx.cumulativeUsage;
+    if (!cumulative) return;
+    cumulative.promptTokens = state.cumulativeUsage.promptTokens;
+    cumulative.cachedTokens = state.cumulativeUsage.cachedTokens;
+    cumulative.candidateTokens = state.cumulativeUsage.candidateTokens;
+    cumulative.apiTimeMs = state.cumulativeUsage.apiTimeMs;
   }
   /**
    * Emits a trailing `cleared` card when the transcript ends on an active goal
@@ -1786,27 +2251,62 @@ var HistoryReplayer = class {
       lastReason: GOAL_NOT_RESTORED_REASON[blockedBy]
     });
   }
-  /**
-   * Extracts tool name from a chat record's function response.
-   */
-  extractToolNameFromRecord(record) {
-    if (record.message?.parts) {
-      for (const part of record.message.parts) {
-        if ("functionResponse" in part && part.functionResponse?.name) {
-          return part.functionResponse.name;
-        }
-      }
-    }
-    return "";
-  }
   setActiveRecordId(recordId, timestamp) {
     this.ctx.setActiveRecordId?.(recordId, timestamp);
   }
 };
+function toPendingTranscriptToolCall(pending) {
+  return {
+    callId: pending.callId,
+    toolName: pending.toolName,
+    sourceRecordId: pending.recordId,
+    ...pending.timestamp ? { sourceTimestamp: pending.timestamp } : {}
+  };
+}
+__name(toPendingTranscriptToolCall, "toPendingTranscriptToolCall");
+function toLegacyPendingToolCall(pending) {
+  return {
+    callId: pending.callId,
+    toolName: pending.toolName,
+    recordId: pending.sourceRecordId,
+    ...pending.sourceTimestamp ? { timestamp: pending.sourceTimestamp } : {}
+  };
+}
+__name(toLegacyPendingToolCall, "toLegacyPendingToolCall");
 
 // packages/cli/src/ui/utils/export/collect.ts
 init_esbuild_shims();
 import { randomUUID } from "node:crypto";
+
+// packages/cli/src/utils/chat-record-tool-call-id.ts
+init_esbuild_shims();
+function getToolResultCallId(record) {
+  return getExplicitToolResultCallId(record) ?? record.uuid;
+}
+__name(getToolResultCallId, "getToolResultCallId");
+function getExplicitToolResultCallId(record) {
+  const resultCallId = record.toolCallResult?.callId;
+  if (typeof resultCallId === "string" && resultCallId.length > 0) {
+    return resultCallId;
+  }
+  return extractFunctionResponseId(record);
+}
+__name(getExplicitToolResultCallId, "getExplicitToolResultCallId");
+function extractFunctionResponseId(record) {
+  if (!record.message?.parts) {
+    return void 0;
+  }
+  for (const part of record.message.parts) {
+    const id = "functionResponse" in part ? part.functionResponse?.id : void 0;
+    if (typeof id === "string" && id.length > 0) {
+      return id;
+    }
+  }
+  return void 0;
+}
+__name(extractFunctionResponseId, "extractFunctionResponseId");
+
+// packages/cli/src/ui/utils/export/collect.ts
 function extractToolNameFromRecord(record) {
   if (!record.message?.parts) {
     return void 0;
@@ -1993,7 +2493,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./src-75ZPXO7B.js");
+    const { getGitRepoName } = await import("./src-Q4XB6SVD.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;
@@ -2220,6 +2720,20 @@ __name(collectSessionData, "collectSessionData");
 
 // packages/cli/src/ui/utils/export/normalize.ts
 init_esbuild_shims();
+
+// packages/cli/src/utils/truncatedDiffPreview.ts
+init_esbuild_shims();
+function buildTruncatedDiffPreviewText2(display) {
+  const fileName = typeof display["fileName"] === "string" ? display["fileName"] : "the edited file";
+  const fileDiffLength = typeof display["fileDiffLength"] === "number" ? ` Original fileDiff length: ${display["fileDiffLength"]} chars.` : "";
+  if (display["fileDiffTruncated"] === true) {
+    return `Full diff omitted from saved session history for ${fileName}.${fileDiffLength}`;
+  }
+  return `Saved session preview only for ${fileName}; full original and new file contents are unavailable.`;
+}
+__name(buildTruncatedDiffPreviewText2, "buildTruncatedDiffPreviewText");
+
+// packages/cli/src/ui/utils/export/normalize.ts
 function normalizeSessionData(sessionData, originalRecords, config) {
   const normalized = [...sessionData.messages];
   const toolCallIndexById = /* @__PURE__ */ new Map();
@@ -2308,7 +2822,7 @@ function buildToolCallMessageFromResult(record, config) {
   const rawInput = normalizeRawInput(
     functionCallArgs ?? toolCallResult?.args
   );
-  const resultContent = extractDiffContent(toolCallResult?.resultDisplay) ?? transformPartsToToolCallContent(record.message?.parts ?? []);
+  const resultContent = extractDiffContent2(toolCallResult?.resultDisplay) ?? transformPartsToToolCallContent(record.message?.parts ?? []);
   const content = isVisionBridgeNoticeDisplay(toolCallResult?.resultDisplay) ? [
     {
       type: "content",
@@ -2408,7 +2922,7 @@ function mapToolKind(kind, toolName) {
   return "other";
 }
 __name(mapToolKind, "mapToolKind");
-function extractDiffContent(resultDisplay) {
+function extractDiffContent2(resultDisplay) {
   if (!resultDisplay || typeof resultDisplay !== "object") {
     return null;
   }
@@ -2420,7 +2934,7 @@ function extractDiffContent(resultDisplay) {
           type: "content",
           content: {
             type: "text",
-            text: buildTruncatedDiffPreviewText(display)
+            text: buildTruncatedDiffPreviewText2(display)
           }
         }
       ];
@@ -2436,7 +2950,7 @@ function extractDiffContent(resultDisplay) {
   }
   return null;
 }
-__name(extractDiffContent, "extractDiffContent");
+__name(extractDiffContent2, "extractDiffContent");
 function normalizeRawInput(value) {
   if (typeof value === "string") return value;
   if (typeof value === "object" && value !== null) return value;