packages/transcript/src/history/foldFacts.ts

import type { TranscriptInteraction } from '../model/interaction';
import type { TranscriptItem, TranscriptMarker, TranscriptTaskRef } from '../model/item';
import type { GoalMeta, GoalStatus, TranscriptMeta } from '../model/meta';
import type { TranscriptTask } from '../model/task';
import type { TodoItem, TranscriptTodo } from '../model/todo';
import type { TranscriptTurn } from '../model/turn';
import type { AgentTranscriptSnapshot } from '../ops/operation';

export interface HistoryWireRecord {
  readonly type: string;
  readonly time?: number;
  readonly [key: string]: unknown;
}

interface UpdateStorePayload {
  readonly key?: unknown;
  readonly value?: unknown;
}

interface GoalPayload {
  readonly objective?: unknown;
  readonly completionCriterion?: unknown;
  readonly status?: unknown;
  readonly tokensUsed?: unknown;
  readonly budgetLimits?: { readonly tokenBudget?: unknown };
}

interface TaskInfoPayload {
  readonly taskId?: unknown;
  readonly kind?: unknown;
  readonly status?: unknown;
  readonly detached?: unknown;
  readonly description?: unknown;
  readonly agentId?: unknown;
  readonly startedAt?: unknown;
  readonly endedAt?: unknown;
}

interface InteractionRequestPayload {
  readonly id?: unknown;
  readonly kind?: unknown;
  readonly toolCallId?: unknown;
  readonly request?: unknown;
}

interface InteractionResolvedPayload {
  readonly id?: unknown;
  readonly response?: unknown;
}

interface PlanRevisionPayload {
  readonly id?: unknown;
  readonly version?: unknown;
  readonly key?: unknown;
  readonly path?: unknown;
  readonly sha256?: unknown;
  readonly bytes?: unknown;
}

interface TurnEndedPayload {
  readonly turnId?: unknown;
  readonly reason?: unknown;
  readonly error?: unknown;
  readonly durationMs?: unknown;
}

interface TurnStepInterruptedPayload {
  readonly turnId?: unknown;
  readonly step?: unknown;
  readonly reason?: unknown;
  readonly message?: unknown;
}

interface TurnPromptPayload {
  readonly origin?: unknown;
  readonly promptId?: unknown;
  readonly turnId?: unknown;
}
interface ContextUndoPayload {
  readonly count?: unknown;
}
interface ContextAppendMessagePayload {
  readonly message?: {
    readonly id?: unknown;
    readonly role?: unknown;
    readonly origin?: unknown;
  };
}
interface TurnCancelPayload {
  readonly turnId?: unknown;
  readonly target?: unknown;
  readonly reason?: unknown;
}

function isVisibleTurnOrigin(origin: unknown): boolean {
  const kind = (origin as { kind?: unknown } | undefined)?.kind;
  if (kind === 'system_trigger') {
    const name = (origin as { name?: unknown } | undefined)?.name;
    return name === 'goal_continuation' || name === 'subagent';
  }
  if (kind === 'skill_activation' || kind === 'plugin_command') {
    return (origin as { trigger?: unknown } | undefined)?.trigger === 'user-slash';
  }
  if (kind === 'injection' || kind === 'retry' || kind === 'compaction_summary') return false;
  return true;
}

function isUndoAnchorTurnOrigin(origin: unknown): boolean {
  const payload = origin as { kind?: unknown; trigger?: unknown } | undefined;
  if (payload?.kind === undefined || payload.kind === 'user') return true;
  return (
    (payload.kind === 'skill_activation' || payload.kind === 'plugin_command') &&
    payload.trigger === 'user-slash'
  );
}

function turnOriginKind(origin: unknown): TranscriptTurn['origin']['kind'] {
  const payload = origin as { kind?: unknown; taskId?: unknown } | undefined;
  switch (payload?.kind) {
    case 'user':
    case 'shell_command':
      return 'user';
    case 'cron_job':
    case 'cron_missed':
      return 'cron';
    case 'task':
    case 'background_task':
      return typeof payload.taskId === 'string' ? 'task' : 'other';
    case 'hook_result':
      return 'hook';
    case 'compaction_summary':
      return 'compaction';
    default:
      return 'other';
  }
}

function mapTaskKind(kind: unknown): TranscriptTask['kind'] {
  switch (kind) {
    case 'process':
      return 'shell';
    case 'agent':
      return 'subagent';
    default:
      return 'other';
  }
}

const TASK_STATES = new Set<TranscriptTask['state']>([
  'running',
  'completed',
  'failed',
  'timed_out',
  'killed',
  'lost',
]);

const GOAL_STATUSES = new Set<GoalStatus>(['active', 'paused', 'blocked', 'complete']);

function mapInteractionEndState(
  kind: TranscriptInteraction['interactionKind'],
  response: unknown,
): TranscriptInteraction['state'] {
  if (kind === 'question') return response === null ? 'dismissed' : 'answered';
  const decision = (response as { decision?: unknown } | null | undefined)?.decision;
  if (decision === 'approved' || decision === 'rejected' || decision === 'cancelled') {
    return decision;
  }
  return 'cancelled';
}

function mapTurnEndReason(reason: unknown): TranscriptTurn['state'] | undefined {
  switch (reason) {
    case 'completed':
      return 'completed';
    case 'cancelled':
      return 'cancelled';
    case 'failed':
    case 'blocked':
      return 'failed';
    default:
      return undefined;
  }
}

function readTurnErrorMessage(error: unknown): string | undefined {
  if (error === null || typeof error !== 'object') return undefined;
  const message = (error as { message?: unknown }).message;
  return typeof message === 'string' ? message : undefined;
}

function recordTimeIso(record: HistoryWireRecord): string | undefined {
  const time: unknown = record.time;
  if (typeof time === 'number' && Number.isFinite(time)) return new Date(time).toISOString();
  if (typeof time === 'string') return time;
  return undefined;
}

function epochMsToIso(value: unknown): string | undefined {
  return typeof value === 'number' && Number.isFinite(value)
    ? new Date(value).toISOString()
    : undefined;
}

function payloadOf(record: HistoryWireRecord): Record<string, unknown> {
  const { type: _type, time: _time, ...payload } = record;
  return payload;
}

function readTodoItems(raw: unknown): TodoItem[] {
  if (!Array.isArray(raw)) return [];
  const items: TodoItem[] = [];
  for (const entry of raw) {
    const title = (entry as { title?: unknown } | undefined)?.title;
    const status = (entry as { status?: unknown } | undefined)?.status;
    if (typeof title !== 'string') continue;
    if (status !== 'pending' && status !== 'in_progress' && status !== 'done') continue;
    items.push({ title, status });
  }
  return items;
}

export function foldWireRecordFacts(
  records: Iterable<HistoryWireRecord>,
  base: AgentTranscriptSnapshot,
  options?: { readonly resolvePlanRevisionKey?: (key: string) => string },
): AgentTranscriptSnapshot {
  const tasks = new Map<string, TranscriptTask>();
  const interactions = new Map<string, TranscriptInteraction>();
  const endedTurns = new Map<number, HistoryWireRecord>();
  const interruptedSteps = new Map<number, Map<number, HistoryWireRecord>>();
  const turnPromptIds = new Map<number, string>();
  const turnOrigins = new Map<number, unknown>();
  let hasExplicitTurnId = false;
  let nextTurnId = 0;
  const cancelledTurnIds = new Set<number>();
  const hiddenTurnIds = new Set<number>();
  const undoAnchors: { firstRawTurnId: number }[] = [];
  const pendingUndoAnchorTurnIds: number[] = [];
  let undoAnchorFloor = 0;
  const skipCancelledTurnIds = (): void => {
    while (cancelledTurnIds.delete(nextTurnId)) {
      hiddenTurnIds.add(nextTurnId);
      nextTurnId += 1;
    }
  };
  let todo: TranscriptTodo | undefined;
  let goal: GoalMeta | undefined;
  let goalTouched = false;
  let planActive: boolean | undefined;
  let planRevision: { readonly reviewPath?: string; readonly version?: number } | undefined;
  let swarmActive: boolean | undefined;
  let towerActive: boolean | undefined;

  const appended: TranscriptItem[] = [];
  const activeCancelTurnIds = new Set<number>();
  let markerSeq = 0;
  const usedRefIds = new Set<string>();
  for (const item of base.items) {
    if (item.kind === 'marker') {
      const match = /^m(\d+)$/.exec(item.markerId);
      if (match !== null) markerSeq = Math.max(markerSeq, Number(match[1]));
    } else if (item.kind === 'taskref') {
      usedRefIds.add(item.refId);
    }
  }
  const pushMarker = (marker: string, record: HistoryWireRecord): void => {
    markerSeq += 1;
    const item: TranscriptMarker = {
      kind: 'marker',
      markerId: `m${markerSeq}`,
      marker,
      payload: payloadOf(record),
      at: recordTimeIso(record),
    };
    appended.push(item);
  };

  const upsertTask = (record: HistoryWireRecord): void => {
    const info = record['info'] as TaskInfoPayload | undefined;
    if (info === undefined || typeof info.taskId !== 'string') return;
    const taskId = info.taskId;
    const prev = tasks.get(taskId);
    const status = info.status;
    const task: TranscriptTask = {
      taskId,
      kind: mapTaskKind(info.kind),
      state:
        typeof status === 'string' && TASK_STATES.has(status as TranscriptTask['state'])
          ? (status as TranscriptTask['state'])
          : (prev?.state ?? 'running'),
      detached: typeof info.detached === 'boolean' ? info.detached : (prev?.detached ?? true),
      description: typeof info.description === 'string' ? info.description : prev?.description,
      agentId: typeof info.agentId === 'string' ? info.agentId : prev?.agentId,
      outputTail:
        typeof record['outputTail'] === 'string'
          ? record['outputTail']
          : (prev?.outputTail ?? ''),
      startedAt: prev?.startedAt ?? epochMsToIso(info.startedAt),
      endedAt: epochMsToIso(info.endedAt) ?? prev?.endedAt,
    };
    tasks.set(taskId, task);
    if (record.type === 'task.started') {
      const refId = `ref-${taskId}`;
      if (!usedRefIds.has(refId)) {
        usedRefIds.add(refId);
        const ref: TranscriptTaskRef = {
          kind: 'taskref',
          refId,
          taskId,
          at: recordTimeIso(record),
        };
        appended.push(ref);
      }
    }
  };

  for (const record of records) {
    switch (record.type) {
      case 'tools.update_store': {
        const payload = record as UpdateStorePayload;
        if (payload.key !== 'todo') break;
        todo = {
          todoId: 'todo',
          items: readTodoItems(payload.value),
          updatedAt: recordTimeIso(record),
        };
        break;
      }
      case 'goal.create': {
        const payload = record as GoalPayload;
        goalTouched = true;
        goal = {
          objective: typeof payload.objective === 'string' ? payload.objective : '',
          status: 'active',
          completionCriterion:
            typeof payload.completionCriterion === 'string'
              ? payload.completionCriterion
              : undefined,
          budgetUsed: 0,
        };
        pushMarker('goal', record);
        break;
      }
      case 'goal.update': {
        const payload = record as GoalPayload;
        goalTouched = true;
        if (goal !== undefined) {
          const tokenBudget = payload.budgetLimits?.tokenBudget;
          goal = {
            ...goal,
            status:
              typeof payload.status === 'string' &&
              GOAL_STATUSES.has(payload.status as GoalStatus)
                ? (payload.status as GoalStatus)
                : goal.status,
            budgetUsed:
              typeof payload.tokensUsed === 'number' ? payload.tokensUsed : goal.budgetUsed,
            budgetLimit: typeof tokenBudget === 'number' ? tokenBudget : goal.budgetLimit,
          };
        }
        pushMarker('goal', record);
        break;
      }
      case 'goal.clear': {
        goalTouched = true;
        goal = undefined;
        break;
      }
      case 'plan_mode.enter': {
        planActive = true;
        planRevision = undefined;
        pushMarker('plan.enter', record);
        break;
      }
      case 'plan_mode.exit':
      case 'plan_mode.cancel': {
        planActive = false;
        planRevision = undefined;
        pushMarker('plan.exit', record);
        break;
      }
      case 'plan.revision': {
        const payload = record as PlanRevisionPayload;
        const path =
          typeof payload.key === 'string'
            ? (options?.resolvePlanRevisionKey?.(payload.key) ?? payload.key)
            : typeof payload.path === 'string'
              ? payload.path
              : undefined;
        planActive = true;
        planRevision = {
          reviewPath: path,
          version: typeof payload.version === 'number' ? payload.version : undefined,
        };
        if (path === undefined) {
          pushMarker('plan.revision', record);
        } else {
          const { key: _key, ...rest } = record;
          pushMarker('plan.revision', { ...rest, path });
        }
        break;
      }
      case 'swarm_mode.enter': {
        swarmActive = true;
        pushMarker('swarm.enter', record);
        break;
      }
      case 'swarm_mode.exit': {
        swarmActive = false;
        pushMarker('swarm.exit', record);
        break;
      }
      case 'tower_mode.enter': {
        towerActive = true;
        break;
      }
      case 'tower_mode.exit': {
        towerActive = false;
        break;
      }
      case 'task.started':
      case 'task.terminated': {
        upsertTask(record);
        break;
      }
      case 'turn.cancel': {
        const payload = record as TurnCancelPayload;
        if (
          payload.target === 'queued' &&
          typeof payload.turnId === 'number' &&
          payload.turnId >= nextTurnId
        ) {
          cancelledTurnIds.add(payload.turnId);
          skipCancelledTurnIds();
          break;
        }
        if (
          payload.target !== 'active' ||
          typeof payload.turnId !== 'number' ||
          !Number.isInteger(payload.turnId) ||
          payload.turnId < 0 ||
          activeCancelTurnIds.has(payload.turnId)
        ) {
          break;
        }
        activeCancelTurnIds.add(payload.turnId);
        if (payload.reason !== 'user_cancelled') break;
        pushMarker('interruption', record);
        break;
      }
      case 'context.undo': {
        const count = (record as ContextUndoPayload).count;
        if (typeof count !== 'number' || !Number.isSafeInteger(count) || count <= 0) break;
        let firstUndoneTurnId: number | undefined;
        for (let i = 0; i < count && undoAnchors.length > undoAnchorFloor; i++) {
          const anchor = undoAnchors.pop();
          if (anchor !== undefined) firstUndoneTurnId = anchor.firstRawTurnId;
        }
        if (firstUndoneTurnId !== undefined) {
          for (let turnId = firstUndoneTurnId; turnId < nextTurnId; turnId++) {
            hiddenTurnIds.add(turnId);
          }
        }
        break;
      }
      case 'context.clear':
      case 'context.apply_compaction': {
        undoAnchorFloor = undoAnchors.length;
        break;
      }
      case 'context.append_message': {
        const message = (record as ContextAppendMessagePayload).message;
        if (message?.role !== 'user' || !isUndoAnchorTurnOrigin(message.origin)) break;
        const matchingIndex =
          typeof message.id === 'string'
            ? pendingUndoAnchorTurnIds.findIndex(
                (turnId) => turnPromptIds.get(turnId) === message.id,
              )
            : -1;
        const legacyIndex =
          matchingIndex < 0 && typeof message.id === 'string'
            ? pendingUndoAnchorTurnIds.findIndex((turnId) => !turnPromptIds.has(turnId))
            : -1;
        const matchedTurnId =
          matchingIndex >= 0
            ? pendingUndoAnchorTurnIds.splice(matchingIndex, 1)[0]
            : legacyIndex >= 0
              ? pendingUndoAnchorTurnIds.splice(legacyIndex, 1)[0]
              : typeof message.id !== 'string'
                ? pendingUndoAnchorTurnIds.shift()
                : undefined;
        if (
          matchedTurnId !== undefined &&
          !turnPromptIds.has(matchedTurnId) &&
          typeof message.id === 'string'
        ) {
          turnPromptIds.set(matchedTurnId, message.id);
        }
        undoAnchors.push({ firstRawTurnId: matchedTurnId ?? nextTurnId });
        break;
      }
      case 'interaction.request': {
        const payload = record as InteractionRequestPayload;
        if (payload.kind !== 'approval' && payload.kind !== 'question') break;
        if (typeof payload.id !== 'string') break;
        const requestToolCallId = (payload.request as { toolCallId?: unknown } | undefined)
          ?.toolCallId;
        const toolCallId =
          typeof payload.toolCallId === 'string'
            ? payload.toolCallId
            : typeof requestToolCallId === 'string'
              ? requestToolCallId
              : undefined;
        interactions.set(payload.id, {
          interactionId: payload.id,
          interactionKind: payload.kind,
          toolCallId,
          state: 'pending',
          request: payload.request,
        });
        break;
      }
      case 'interaction.resolved': {
        const payload = record as InteractionResolvedPayload;
        if (typeof payload.id !== 'string') break;
        const entity = interactions.get(payload.id);
        if (entity === undefined) break;
        interactions.set(payload.id, {
          ...entity,
          state: mapInteractionEndState(entity.interactionKind, payload.response),
          response: payload.response,
        });
        break;
      }
      case 'turn.ended': {
        const payload = record as TurnEndedPayload;
        if (typeof payload.turnId === 'number') {
          endedTurns.set(payload.turnId, record);
          const pendingIndex = pendingUndoAnchorTurnIds.indexOf(payload.turnId);
          if (pendingIndex >= 0) pendingUndoAnchorTurnIds.splice(pendingIndex, 1);
        }
        break;
      }
      case 'turn.step.interrupted': {
        const payload = record as TurnStepInterruptedPayload;
        if (
          typeof payload.turnId !== 'number' ||
          typeof payload.step !== 'number' ||
          typeof payload.reason !== 'string'
        ) {
          break;
        }
        let steps = interruptedSteps.get(payload.turnId);
        if (steps === undefined) {
          steps = new Map();
          interruptedSteps.set(payload.turnId, steps);
        }
        steps.set(payload.step, record);
        break;
      }
      case 'turn.prompt': {
        skipCancelledTurnIds();
        const payload = record as TurnPromptPayload;
        const turnId = typeof payload.turnId === 'number' ? payload.turnId : nextTurnId;
        hasExplicitTurnId ||= typeof payload.turnId === 'number';
        nextTurnId = Math.max(nextTurnId, turnId + 1);
        turnOrigins.set(turnId, payload.origin);
        if (typeof payload.promptId === 'string') turnPromptIds.set(turnId, payload.promptId);
        if (isUndoAnchorTurnOrigin(payload.origin)) pendingUndoAnchorTurnIds.push(turnId);
        if (!isVisibleTurnOrigin(payload.origin)) hiddenTurnIds.add(turnId);
        break;
      }
      default:
        break;
    }
  }

  for (const [id, entity] of interactions) {
    if (entity.state === 'pending') {
      interactions.set(id, { ...entity, state: 'cancelled' });
    }
  }

  const baseTurns = base.items.filter((item): item is TranscriptTurn => item.kind === 'turn');
  const ordinalByPromptId = new Map(
    baseTurns.flatMap((turn) =>
      turn.triggerPromptId === undefined ? [] : [[turn.triggerPromptId, turn.ordinal] as const],
    ),
  );
  const claimedOrdinals = new Set<number>();
  const ordinalByRawTurnId = new Map<number, number>();
  const claimBaseOrdinal = (
    predicate: (turn: TranscriptTurn) => boolean = () => true,
  ): number | undefined => {
    const turn = baseTurns.find(
      (candidate) =>
        !claimedOrdinals.has(candidate.ordinal) &&
        predicate(candidate),
    );
    if (turn === undefined) return undefined;
    claimedOrdinals.add(turn.ordinal);
    return turn.ordinal;
  };
  const lastRawTurnId = Math.max(nextTurnId - 1, ...endedTurns.keys(), ...interruptedSteps.keys());
  const rawTurnIds = Array.from(
    { length: lastRawTurnId + 1 },
    (_, turnId) => turnId,
  ).filter(
    (turnId) =>
      !hiddenTurnIds.has(turnId) &&
      (!hasExplicitTurnId ||
        turnOrigins.has(turnId) ||
        endedTurns.has(turnId) ||
        interruptedSteps.has(turnId)),
  );
  for (const turnId of rawTurnIds) {
    const promptId = turnPromptIds.get(turnId);
    const matchedOrdinal = promptId === undefined ? undefined : ordinalByPromptId.get(promptId);
    if (matchedOrdinal !== undefined && !claimedOrdinals.has(matchedOrdinal)) {
      claimedOrdinals.add(matchedOrdinal);
      ordinalByRawTurnId.set(turnId, matchedOrdinal);
    }
  }
  for (const turnId of rawTurnIds) {
    if (ordinalByRawTurnId.has(turnId)) continue;
    const origin = turnOrigins.get(turnId);
    const strictOrigin = turnOrigins.has(turnId) && !isUndoAnchorTurnOrigin(origin);
    if (!strictOrigin) continue;
    const fallbackOrdinal = claimBaseOrdinal(
      (candidate) =>
        candidate.triggerPromptId === undefined &&
        candidate.origin.kind === turnOriginKind(origin),
    );
    if (fallbackOrdinal !== undefined) ordinalByRawTurnId.set(turnId, fallbackOrdinal);
  }
  for (const turnId of rawTurnIds) {
    if (ordinalByRawTurnId.has(turnId)) continue;
    const promptId = turnPromptIds.get(turnId);
    const origin = turnOrigins.get(turnId);
    const strictOrigin = turnOrigins.has(turnId) && !isUndoAnchorTurnOrigin(origin);
    if (promptId === undefined || strictOrigin) continue;
    const emptyPromptOrdinal = claimBaseOrdinal(
      (candidate) =>
        candidate.triggerPromptId === undefined && candidate.origin.kind === 'other',
    );
    if (emptyPromptOrdinal !== undefined) {
      ordinalByRawTurnId.set(turnId, emptyPromptOrdinal);
    }
  }
  for (const turnId of rawTurnIds) {
    if (ordinalByRawTurnId.has(turnId)) continue;
    const promptId = turnPromptIds.get(turnId);
    const origin = turnOrigins.get(turnId);
    const strictOrigin = turnOrigins.has(turnId) && !isUndoAnchorTurnOrigin(origin);
    if (promptId !== undefined || strictOrigin) continue;
    const fallbackOrdinal = claimBaseOrdinal();
    if (fallbackOrdinal !== undefined) ordinalByRawTurnId.set(turnId, fallbackOrdinal);
  }

  const endedByOrdinal = new Map<number, HistoryWireRecord>();
  for (const [turnId, record] of endedTurns) {
    const ordinal = ordinalByRawTurnId.get(turnId);
    if (ordinal !== undefined) endedByOrdinal.set(ordinal, record);
  }

  const interruptedByOrdinal = new Map<number, Map<number, HistoryWireRecord>>();
  for (const [turnId, steps] of interruptedSteps) {
    const ordinal = ordinalByRawTurnId.get(turnId);
    if (ordinal !== undefined) interruptedByOrdinal.set(ordinal, steps);
  }

  const items =
    endedByOrdinal.size > 0 || interruptedByOrdinal.size > 0
      ? base.items.map((item) => {
          if (item.kind !== 'turn') return item;
          const record = endedByOrdinal.get(item.ordinal);
          const interrupted = interruptedByOrdinal.get(item.ordinal);
          if (record === undefined && interrupted === undefined) return item;
          const steps = ((): TranscriptTurn['steps'] => {
            if (interrupted === undefined) return item.steps;
            const hitOrdinals = new Set<number>();
            const patched = item.steps.map((step) => {
              const hit = interrupted.get(step.ordinal);
              if (hit === undefined) return step;
              const stepPayload = hit as TurnStepInterruptedPayload;
              if (typeof stepPayload.reason !== 'string') return step;
              hitOrdinals.add(step.ordinal);
              return {
                ...step,
                state: 'interrupted' as const,
                endedAt: recordTimeIso(hit) ?? step.endedAt,
                endReason: stepPayload.reason,
                endMessage:
                  typeof stepPayload.message === 'string' ? stepPayload.message : undefined,
              };
            });
            for (const [stepOrdinal, hit] of interrupted) {
              if (hitOrdinals.has(stepOrdinal)) continue;
              const stepPayload = hit as TurnStepInterruptedPayload;
              if (typeof stepPayload.reason !== 'string') continue;
              patched.push({
                kind: 'step',
                stepId: `${item.turnId}.${stepOrdinal}`,
                turnId: item.turnId,
                ordinal: stepOrdinal,
                state: 'interrupted',
                frames: [],
                endedAt: recordTimeIso(hit),
                endReason: stepPayload.reason,
                endMessage:
                  typeof stepPayload.message === 'string' ? stepPayload.message : undefined,
              });
            }
            return patched.toSorted((a, b) => a.ordinal - b.ordinal);
          })();
          if (record === undefined) return { ...item, steps };
          const payload = record as TurnEndedPayload;
          return {
            ...item,
            steps,
            state: mapTurnEndReason(payload.reason) ?? item.state,
            endedAt: recordTimeIso(record) ?? item.endedAt,
            durationMs:
              typeof payload.durationMs === 'number' ? payload.durationMs : item.durationMs,
            error: readTurnErrorMessage(payload.error) ?? item.error,
          };
        })
      : base.items;

  const modesTouched = planActive !== undefined || swarmActive !== undefined || towerActive !== undefined;
  const meta: TranscriptMeta = {
    ...base.meta,
    goal: goalTouched ? goal : base.meta.goal,
    modes: modesTouched
      ? {
          ...base.meta.modes,
          plan:
            planActive === undefined
              ? base.meta.modes?.plan
              : planActive
                ? (planRevision ?? {})
                : undefined,
          swarm: swarmActive === undefined ? base.meta.modes?.swarm : swarmActive ? {} : undefined,
          tower: towerActive === undefined ? base.meta.modes?.tower : towerActive ? {} : undefined,
        }
      : base.meta.modes,
  };

  return {
    ...base,
    items: appended.length > 0 ? [...items, ...appended] : items,
    tasks: [...tasks.values()],
    interactions: [...interactions.values()],
    todos: todo !== undefined ? [todo] : base.todos,
    meta,
  };
}