@cats-inc/cats-platform 0.1.0

package/build/server/shared/liveIndicator.js

@@ -0,0 +1,1640 @@
+import { normalizeRuntimeContentBlock, } from './runtimeContentBlocks.js';
+import { normalizeRuntimeMessageSegmentEntry } from '../runtime/messageSegments.js';
+import { buildChatConversationId } from './chatCoreIds.js';
+import { isBrowserLiveTraceEnabled, pushBrowserLiveTrace } from './liveTrace.js';
+const MAX_LIVE_INDICATOR_BLOCKS = 12;
+const MAX_LIVE_INDICATOR_EVENTS = 8;
+const MAX_EVENT_TEXT = 220;
+// UI-side heuristic for when a streaming text bubble has gone visually stale
+// enough that we should hand off to a dedicated waiting placeholder. This is
+// intentionally local to the product projection layer for now; if runtimes
+// later expose explicit "text completed, tool still running" timing/status,
+// move this threshold behind that richer signal instead of widening renderer
+// heuristics again.
+const STALLED_STREAMING_TEXT_WAITING_DELAY_MS = 1200;
+export const EMPTY_LIVE_INDICATOR = {
+    active: false,
+    phase: 'idle',
+    sourceMessageId: null,
+    laneId: null,
+    targetStateId: null,
+    segmentIndex: 0,
+    sessionId: null,
+    identityParticipantId: null,
+    participantId: null,
+    catId: null,
+    activeCatIds: [],
+    catName: null,
+    speakerLabel: null,
+    sessionStartedAt: null,
+    requiresSessionStartConfirmation: false,
+    progressText: '',
+    progressKind: null,
+    tools: [],
+    contentBlocks: [],
+    events: [],
+    segments: [],
+    lastActivityAtMs: null,
+    lastVisibleContentAtMs: null,
+};
+function buildLiveIndicatorSegmentId(input) {
+    const sourceMessageId = readString(input.sourceMessageId) ?? 'no-source';
+    const identity = readString(input.laneId)
+        ?? input.targetStateId
+        ?? readString(input.sessionId)
+        ?? input.identityParticipantId
+        ?? input.participantId
+        ?? input.catId
+        ?? readString(input.speakerLabel)
+        ?? 'anonymous';
+    return `${sourceMessageId}:${identity}:segment:${input.segmentIndex}`;
+}
+export function createLiveIndicatorSegmentState(input) {
+    const catId = input.catId ?? null;
+    const segmentIndex = input.segmentIndex ?? 0;
+    const activeCatIds = input.activeCatIds?.filter((id) => id.trim().length > 0)
+        ?? (catId ? [catId] : []);
+    return {
+        id: input.id?.trim() || buildLiveIndicatorSegmentId({
+            sourceMessageId: input.sourceMessageId ?? null,
+            laneId: input.laneId ?? null,
+            targetStateId: input.targetStateId ?? null,
+            sessionId: input.sessionId ?? null,
+            identityParticipantId: input.identityParticipantId ?? input.participantId ?? null,
+            participantId: input.participantId ?? null,
+            catId,
+            speakerLabel: input.speakerLabel ?? null,
+            segmentIndex,
+        }),
+        phase: input.phase,
+        sourceMessageId: input.sourceMessageId ?? null,
+        laneId: input.laneId ?? null,
+        targetStateId: input.targetStateId ?? null,
+        segmentIndex,
+        sessionId: input.sessionId ?? null,
+        identityParticipantId: input.identityParticipantId ?? input.participantId ?? null,
+        participantId: input.participantId ?? null,
+        catId,
+        activeCatIds,
+        catName: input.catName ?? null,
+        speakerLabel: input.speakerLabel ?? null,
+        sessionStartedAt: input.sessionStartedAt ?? null,
+        requiresSessionStartConfirmation: input.requiresSessionStartConfirmation === true,
+        progressText: input.progressText ?? '',
+        progressKind: input.progressKind ?? null,
+        tools: input.tools ?? [],
+        contentBlocks: input.contentBlocks ?? [],
+        events: input.events ?? [],
+        lastActivityAtMs: typeof input.lastActivityAtMs === 'number' ? input.lastActivityAtMs : null,
+        lastVisibleContentAtMs: typeof input.lastVisibleContentAtMs === 'number'
+            ? input.lastVisibleContentAtMs
+            : null,
+    };
+}
+function dedupeLiveIndicatorSegmentsById(segments) {
+    if (segments.length <= 1) {
+        return [...segments];
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (let index = segments.length - 1; index >= 0; index -= 1) {
+        const segment = segments[index];
+        if (seen.has(segment.id)) {
+            continue;
+        }
+        seen.add(segment.id);
+        deduped.push(segment);
+    }
+    return deduped.reverse();
+}
+export function resolvePrimaryLiveIndicatorSegment(liveIndicator) {
+    const segments = resolveLiveIndicatorSegments(liveIndicator);
+    if (!liveIndicator?.active || segments.length === 0) {
+        return null;
+    }
+    return segments.at(-1) ?? null;
+}
+export function resolveLiveIndicatorSegments(liveIndicator) {
+    if (!liveIndicator?.active) {
+        return [];
+    }
+    if (liveIndicator.segments.length > 0) {
+        return dedupeLiveIndicatorSegmentsById(liveIndicator.segments);
+    }
+    if (liveIndicator.phase === 'idle') {
+        return [];
+    }
+    return [
+        createLiveIndicatorSegmentState({
+            phase: liveIndicator.phase,
+            targetStateId: liveIndicator.targetStateId,
+            sourceMessageId: liveIndicator.sourceMessageId,
+            laneId: liveIndicator.laneId,
+            segmentIndex: liveIndicator.segmentIndex,
+            sessionId: liveIndicator.sessionId,
+            identityParticipantId: liveIndicator.identityParticipantId,
+            participantId: liveIndicator.participantId,
+            catId: liveIndicator.catId,
+            activeCatIds: liveIndicator.activeCatIds,
+            catName: liveIndicator.catName,
+            speakerLabel: liveIndicator.speakerLabel,
+            sessionStartedAt: liveIndicator.sessionStartedAt,
+            requiresSessionStartConfirmation: liveIndicator.requiresSessionStartConfirmation,
+            progressText: liveIndicator.progressText,
+            progressKind: liveIndicator.progressKind,
+            tools: liveIndicator.tools,
+            contentBlocks: liveIndicator.contentBlocks,
+            events: liveIndicator.events,
+        }),
+    ];
+}
+export function projectLiveIndicatorStateFromSegments(segments, active = segments.length > 0) {
+    const normalizedSegments = dedupeLiveIndicatorSegmentsById(segments);
+    const primary = normalizedSegments.at(-1) ?? null;
+    if (!primary || !active) {
+        return EMPTY_LIVE_INDICATOR;
+    }
+    return {
+        active: true,
+        phase: primary.phase,
+        sourceMessageId: primary.sourceMessageId,
+        laneId: primary.laneId,
+        targetStateId: primary.targetStateId,
+        segmentIndex: primary.segmentIndex,
+        sessionId: primary.sessionId,
+        identityParticipantId: primary.identityParticipantId,
+        participantId: primary.participantId,
+        catId: primary.catId,
+        activeCatIds: primary.activeCatIds,
+        catName: primary.catName,
+        speakerLabel: primary.speakerLabel,
+        sessionStartedAt: primary.sessionStartedAt,
+        requiresSessionStartConfirmation: primary.requiresSessionStartConfirmation,
+        progressText: primary.progressText,
+        progressKind: primary.progressKind,
+        tools: primary.tools,
+        contentBlocks: primary.contentBlocks,
+        events: primary.events,
+        segments: normalizedSegments,
+        lastActivityAtMs: primary.lastActivityAtMs,
+        lastVisibleContentAtMs: primary.lastVisibleContentAtMs,
+    };
+}
+function replacePrimaryLiveIndicatorSegment(previous, nextSegment) {
+    if (!previous.active || previous.segments.length === 0) {
+        return projectLiveIndicatorStateFromSegments([nextSegment]);
+    }
+    return projectLiveIndicatorStateFromSegments([
+        ...previous.segments.slice(0, -1),
+        nextSegment,
+    ]);
+}
+function appendLiveIndicatorSegment(previous, nextSegment) {
+    const previousPrimary = resolvePrimaryLiveIndicatorSegment(previous);
+    if (!previousPrimary) {
+        return projectLiveIndicatorStateFromSegments([nextSegment]);
+    }
+    const sealedPrimary = previousPrimary.phase === 'sealed'
+        ? previousPrimary
+        : {
+            ...previousPrimary,
+            phase: 'sealed',
+        };
+    return projectLiveIndicatorStateFromSegments([
+        ...previous.segments.slice(0, -1),
+        sealedPrimary,
+        nextSegment,
+    ]);
+}
+function resolveLogicalParticipantId(input) {
+    return input.identityParticipantId ?? input.participantId ?? null;
+}
+function isSameLiveIndicatorTimelineIdentity(previousSegment, nextSpeakerState) {
+    if (!previousSegment) {
+        return false;
+    }
+    return doesLiveIndicatorLogicalIdentityMatch(previousSegment, nextSpeakerState);
+}
+function doesLiveIndicatorLogicalIdentityMatch(left, right) {
+    const leftSourceMessageId = left.sourceMessageId ?? null;
+    const rightSourceMessageId = right.sourceMessageId ?? null;
+    const leftLaneId = left.laneId ?? null;
+    const rightLaneId = right.laneId ?? null;
+    const leftTargetStateId = left.targetStateId ?? null;
+    const rightTargetStateId = right.targetStateId ?? null;
+    const leftParticipantId = resolveLogicalParticipantId(left);
+    const rightParticipantId = resolveLogicalParticipantId(right);
+    const leftCatId = left.catId ?? null;
+    const rightCatId = right.catId ?? null;
+    const leftSpeakerLabel = left.speakerLabel ?? null;
+    const rightSpeakerLabel = right.speakerLabel ?? null;
+    if (leftLaneId !== null && rightLaneId !== null) {
+        return leftLaneId === rightLaneId;
+    }
+    if (leftTargetStateId !== null && rightTargetStateId !== null) {
+        return leftTargetStateId === rightTargetStateId;
+    }
+    return leftSourceMessageId === rightSourceMessageId
+        && leftParticipantId === rightParticipantId
+        && leftCatId === rightCatId
+        && leftSpeakerLabel === rightSpeakerLabel;
+}
+function projectLogicalLiveIndicatorSegments(segments) {
+    const projected = [];
+    for (const segment of segments) {
+        const sortedBlocks = [...segment.contentBlocks].sort((left, right) => left.index - right.index);
+        if (sortedBlocks.length === 0) {
+            projected.push(segment);
+            continue;
+        }
+        let currentBlocks = [];
+        let logicalOffset = 0;
+        const flushCurrentBlocks = (phase) => {
+            if (currentBlocks.length === 0) {
+                return;
+            }
+            projected.push(createLiveIndicatorSegmentState({
+                ...segment,
+                id: buildLiveIndicatorSegmentId({
+                    sourceMessageId: segment.sourceMessageId,
+                    laneId: segment.laneId,
+                    targetStateId: segment.targetStateId,
+                    sessionId: segment.sessionId,
+                    participantId: segment.participantId,
+                    catId: segment.catId,
+                    speakerLabel: segment.speakerLabel,
+                    segmentIndex: segment.segmentIndex + logicalOffset,
+                }),
+                phase,
+                segmentIndex: segment.segmentIndex + logicalOffset,
+                contentBlocks: currentBlocks,
+            }));
+            logicalOffset += 1;
+            currentBlocks = [];
+        };
+        for (let blockIndex = 0; blockIndex < sortedBlocks.length; blockIndex += 1) {
+            const block = sortedBlocks[blockIndex];
+            const currentHasText = currentBlocks.some((candidate) => candidate.kind === 'text');
+            if (block.kind === 'text') {
+                if (currentBlocks.length === 0 || !currentHasText) {
+                    currentBlocks.push(block);
+                    continue;
+                }
+                flushCurrentBlocks('sealed');
+                currentBlocks.push(block);
+                continue;
+            }
+            if (currentBlocks.length === 0 || !currentHasText) {
+                currentBlocks.push(block);
+                continue;
+            }
+            flushCurrentBlocks('sealed');
+            currentBlocks.push(block);
+        }
+        flushCurrentBlocks(segment.phase);
+    }
+    return projected;
+}
+function updatePrimaryLiveIndicatorSegment(previous, updater) {
+    const primary = resolvePrimaryLiveIndicatorSegment(previous);
+    if (!primary) {
+        return previous;
+    }
+    return replacePrimaryLiveIndicatorSegment(previous, updater(primary));
+}
+function updateLiveIndicatorSegmentAt(previous, segmentIndex, updater) {
+    const segments = resolveLiveIndicatorSegments(previous);
+    const targetSegment = segments[segmentIndex];
+    if (!targetSegment) {
+        return previous;
+    }
+    return projectLiveIndicatorStateFromSegments(segments.map((segment, index) => index === segmentIndex ? updater(segment) : segment));
+}
+function updateMatchingLiveIndicatorSegment(previous, matcher, updater) {
+    const segments = resolveLiveIndicatorSegments(previous);
+    const matchIndex = segments.findIndex(matcher);
+    if (matchIndex < 0) {
+        return previous;
+    }
+    const nextSegments = segments.map((segment, index) => index === matchIndex ? updater(segment) : segment);
+    return projectLiveIndicatorStateFromSegments(nextSegments);
+}
+function findMatchingLiveIndicatorSegmentIndex(previous, nextSpeakerState) {
+    const segments = resolveLiveIndicatorSegments(previous);
+    for (let index = segments.length - 1; index >= 0; index -= 1) {
+        if (doesLiveIndicatorLogicalIdentityMatch(segments[index], nextSpeakerState)) {
+            return index;
+        }
+    }
+    return -1;
+}
+function resolveLiveIndicatorEventTargetSegment(previous, data) {
+    const nextSpeakerState = resolveLiveIndicatorSpeakerState(previous, data);
+    const segmentIndex = findMatchingLiveIndicatorSegmentIndex(previous, nextSpeakerState);
+    if (segmentIndex >= 0) {
+        const segments = resolveLiveIndicatorSegments(previous);
+        return {
+            segmentIndex,
+            segment: segments[segmentIndex] ?? null,
+        };
+    }
+    const primary = resolvePrimaryLiveIndicatorSegment(previous);
+    return {
+        segmentIndex: primary ? resolveLiveIndicatorSegments(previous).length - 1 : -1,
+        segment: primary,
+    };
+}
+function updateLiveIndicatorEventSegment(previous, data, updater) {
+    const target = resolveLiveIndicatorEventTargetSegment(previous, data);
+    if (target.segmentIndex < 0 || !target.segment) {
+        return previous;
+    }
+    return updateLiveIndicatorSegmentAt(previous, target.segmentIndex, updater);
+}
+function appendLiveIndicatorSegmentAfterIndex(previous, segmentIndex, nextSegment) {
+    const segments = resolveLiveIndicatorSegments(previous);
+    const targetSegment = segments[segmentIndex];
+    if (!targetSegment) {
+        return appendLiveIndicatorSegment(previous, nextSegment);
+    }
+    const sealedTarget = targetSegment.phase === 'sealed'
+        ? targetSegment
+        : {
+            ...targetSegment,
+            phase: 'sealed',
+        };
+    return projectLiveIndicatorStateFromSegments([
+        ...segments.slice(0, segmentIndex),
+        sealedTarget,
+        nextSegment,
+        ...segments.slice(segmentIndex + 1),
+    ]);
+}
+function segmentHasTextContent(segment) {
+    return segment.contentBlocks.some((block) => block.kind === 'text' && block.text.trim().length > 0);
+}
+function segmentHasStreamingTextContent(segment) {
+    return segment.contentBlocks.some((block) => block.kind === 'text'
+        && block.status === 'streaming'
+        && block.text.trim().length > 0);
+}
+function shouldProjectStalledStreamingTextAsWaiting(segment, nowMs) {
+    return segment.phase === 'streaming'
+        && segmentHasStreamingTextContent(segment)
+        && segment.lastVisibleContentAtMs != null
+        && nowMs - segment.lastVisibleContentAtMs >= STALLED_STREAMING_TEXT_WAITING_DELAY_MS;
+}
+export function estimateNextLiveIndicatorProjectionAtMs(liveIndicator, nowMs = Date.now()) {
+    if (!liveIndicator?.active) {
+        return null;
+    }
+    const streamingDueTimes = resolveLiveIndicatorSegments(liveIndicator)
+        .filter((segment) => segment.phase === 'streaming' && segmentHasStreamingTextContent(segment))
+        .map((segment) => segment.lastVisibleContentAtMs)
+        .filter((timestamp) => typeof timestamp === 'number')
+        .map((timestamp) => timestamp + STALLED_STREAMING_TEXT_WAITING_DELAY_MS)
+        .filter((dueAt) => dueAt > nowMs);
+    if (streamingDueTimes.length === 0) {
+        return null;
+    }
+    return Math.min(...streamingDueTimes);
+}
+function resolveProjectedTextSegmentOrdinal(segments, segmentIndex) {
+    const targetSegment = segments[segmentIndex];
+    if (!targetSegment || !segmentHasTextContent(targetSegment)) {
+        return null;
+    }
+    let ordinal = 0;
+    for (let index = 0; index < segments.length; index += 1) {
+        const candidate = segments[index];
+        if (!segmentHasTextContent(candidate)
+            || !isSameLiveIndicatorTimelineIdentity(candidate, targetSegment)) {
+            continue;
+        }
+        if (index === segmentIndex) {
+            return ordinal;
+        }
+        ordinal += 1;
+    }
+    return null;
+}
+function segmentHasOnlySyntheticTextFallback(segment) {
+    return segment.contentBlocks.length > 0
+        && segment.contentBlocks.every((block) => isSyntheticFallbackTextBlock(block));
+}
+function isSameLogicalContentBlock(left, right) {
+    return left.id === right.id || (left.index === right.index && left.kind === right.kind);
+}
+function segmentHasMaterializedContent(segment) {
+    return segment.contentBlocks.length > 0
+        || segment.progressText.trim().length > 0
+        || segment.events.length > 0
+        || segment.tools.length > 0;
+}
+function segmentHasRenderableTranscriptContent(segment) {
+    if (segment.progressText.trim().length > 0 || segment.events.length > 0 || segment.tools.length > 0) {
+        return true;
+    }
+    return segment.contentBlocks.some((block) => {
+        if (block.kind === 'text') {
+            return block.text.trim().length > 0;
+        }
+        if (block.kind === 'tool') {
+            return true;
+        }
+        if (block.kind === 'status') {
+            return block.text.trim().length > 0;
+        }
+        return false;
+    });
+}
+export function hasVisibleLiveIndicatorSegmentActivity(segment) {
+    return segment.phase === 'waiting'
+        || segment.contentBlocks.length > 0
+        || segment.progressText.trim().length > 0
+        || segment.progressKind !== null
+        || segment.events.length > 0
+        || segment.tools.length > 0;
+}
+export function createWaitingLiveIndicatorState(input) {
+    const revealIdentity = input.revealIdentity === true;
+    return projectLiveIndicatorStateFromSegments([
+        createLiveIndicatorSegmentState({
+            phase: 'waiting',
+            // Target-state identity is internal routing state, not user-facing identity.
+            // Keep it even for anonymous waiting bubbles so persisted segments can retire
+            // the correct live segment once the reply lands.
+            sourceMessageId: input.sourceMessageId ?? null,
+            laneId: input.laneId ?? null,
+            targetStateId: input.targetStateId ?? null,
+            segmentIndex: input.segmentIndex ?? 0,
+            sessionId: input.sessionId ?? null,
+            identityParticipantId: input.participantId ?? null,
+            participantId: revealIdentity ? input.participantId ?? null : null,
+            catId: revealIdentity ? input.catId : null,
+            speakerLabel: revealIdentity ? input.speakerLabel : null,
+            sessionStartedAt: input.sessionStartedAt ?? null,
+            requiresSessionStartConfirmation: input.requiresSessionStartConfirmation === true,
+        }),
+    ]);
+}
+export function resolveLiveIndicatorSpeakerState(previous, data) {
+    const previousSegment = resolvePrimaryLiveIndicatorSegment(previous);
+    const previousSourceMessageId = previousSegment?.sourceMessageId ?? previous.sourceMessageId;
+    const previousLaneId = previousSegment?.laneId ?? previous.laneId;
+    const previousTargetStateId = previousSegment?.targetStateId ?? previous.targetStateId;
+    const hasSourceMessageId = Object.prototype.hasOwnProperty.call(data, 'sourceMessageId');
+    const hasLaneId = Object.prototype.hasOwnProperty.call(data, 'laneId');
+    const hasIdentityParticipantId = Object.prototype.hasOwnProperty.call(data, 'identityParticipantId');
+    const hasParticipantId = Object.prototype.hasOwnProperty.call(data, 'participantId');
+    const hasCatId = Object.prototype.hasOwnProperty.call(data, 'catId');
+    const hasSpeakerLabel = Object.prototype.hasOwnProperty.call(data, 'speakerLabel');
+    const hasTargetStateId = Object.prototype.hasOwnProperty.call(data, 'targetStateId');
+    const previousIdentityParticipantId = previousSegment?.identityParticipantId
+        ?? previous.identityParticipantId;
+    const nextParticipantId = hasParticipantId
+        ? readNullableString(data.participantId)
+        : previousSegment?.participantId ?? previous.participantId;
+    const nextIdentityParticipantId = hasIdentityParticipantId
+        ? readNullableString(data.identityParticipantId)
+        : hasParticipantId
+            ? readNullableString(data.participantId)
+            : previousIdentityParticipantId;
+    const nextCatId = hasCatId
+        ? readNullableString(data.catId)
+        : previousSegment?.catId ?? previous.catId;
+    const nextSpeakerLabel = hasSpeakerLabel
+        ? readNullableString(data.speakerLabel)
+        : previousSegment?.speakerLabel ?? previous.speakerLabel;
+    return {
+        sourceMessageId: hasSourceMessageId
+            ? (readNullableString(data.sourceMessageId) ?? previousSourceMessageId)
+            : previousSourceMessageId,
+        laneId: hasLaneId
+            ? (readNullableString(data.laneId) ?? previousLaneId)
+            : previousLaneId,
+        targetStateId: hasTargetStateId
+            ? (readNullableString(data.targetStateId) ?? previousTargetStateId)
+            : previousTargetStateId,
+        identityParticipantId: nextIdentityParticipantId,
+        participantId: nextParticipantId,
+        catId: nextCatId,
+        activeCatIds: nextCatId ? [nextCatId] : [],
+        speakerLabel: nextSpeakerLabel,
+    };
+}
+function resolveLiveIndicatorSessionState(previous, data) {
+    const previousSegment = resolvePrimaryLiveIndicatorSegment(previous);
+    const hasSessionId = Object.prototype.hasOwnProperty.call(data, 'sessionId');
+    const hasSessionStartedAt = Object.prototype.hasOwnProperty.call(data, 'sessionStartedAt');
+    const hasSessionStartConfirmation = Object.prototype.hasOwnProperty.call(data, 'requiresSessionStartConfirmation');
+    return {
+        sessionId: hasSessionId
+            ? readNullableString(data.sessionId)
+            : previousSegment?.sessionId ?? previous.sessionId,
+        sessionStartedAt: hasSessionStartedAt
+            ? readNullableString(data.sessionStartedAt)
+            : previousSegment?.sessionStartedAt ?? previous.sessionStartedAt,
+        requiresSessionStartConfirmation: hasSessionStartConfirmation
+            ? data.requiresSessionStartConfirmation === true
+            : previousSegment?.requiresSessionStartConfirmation
+                ?? previous.requiresSessionStartConfirmation,
+    };
+}
+export function applyLiveIndicatorEvent(previous, eventType, data, observedAtMs = Date.now()) {
+    if (!previous.active) {
+        return previous;
+    }
+    const nextState = prepareLiveIndicatorStateForEvent(previous, eventType, data);
+    switch (eventType) {
+        case 'progress':
+            return applyProgressEvent(nextState, data, observedAtMs);
+        case 'text':
+            return applyTextEvent(nextState, data, observedAtMs);
+        case 'tool_use':
+            return applyToolUseEvent(nextState, data, observedAtMs);
+        case 'tool_result':
+            return applyToolResultEvent(nextState, data, observedAtMs);
+        case 'content_block':
+            return applyContentBlockEvent(nextState, data, observedAtMs);
+        case 'result':
+            return applyResultEvent(nextState, data, observedAtMs);
+        case 'session_closed': {
+            const currentSegment = resolveLiveIndicatorEventTargetSegment(nextState, data).segment;
+            return currentSegment?.phase === 'waiting'
+                ? nextState
+                : applyResultEvent(nextState, data, observedAtMs);
+        }
+        case 'error':
+            return applyErrorEvent(nextState, data, observedAtMs);
+        default:
+            return nextState;
+    }
+}
+function shouldStartNewSegmentForEvent(previousSegment, nextSpeakerState, eventType, data) {
+    if (!previousSegment) {
+        return false;
+    }
+    const identityChanged = !doesLiveIndicatorLogicalIdentityMatch(previousSegment, nextSpeakerState);
+    if (previousSegment.phase === 'sealed') {
+        if (eventType === 'content_block') {
+            const block = normalizeRuntimeContentBlock(data);
+            if (block
+                && previousSegment.contentBlocks.some((candidate) => isSameLogicalContentBlock(candidate, block))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (identityChanged) {
+        return segmentHasMaterializedContent(previousSegment);
+    }
+    if (previousSegment.phase === 'waiting' && !segmentHasMaterializedContent(previousSegment)) {
+        return false;
+    }
+    if (previousSegment.phase === 'streaming' && !segmentHasMaterializedContent(previousSegment)) {
+        return false;
+    }
+    switch (eventType) {
+        case 'progress':
+        case 'tool_use':
+        case 'tool_result':
+        case 'error':
+            return segmentHasTextContent(previousSegment);
+        case 'content_block': {
+            const block = normalizeRuntimeContentBlock(data);
+            if (!block) {
+                return false;
+            }
+            if (block.kind === 'text') {
+                if (segmentHasOnlySyntheticTextFallback(previousSegment)) {
+                    return false;
+                }
+                const hasSameBlock = previousSegment.contentBlocks.some((candidate) => candidate.id === block.id);
+                return segmentHasTextContent(previousSegment) && !hasSameBlock;
+            }
+            return segmentHasTextContent(previousSegment);
+        }
+        default:
+            return false;
+    }
+}
+function createNextLiveIndicatorSegment(previousSegment, nextSpeakerState, nextSessionState, phase) {
+    const sameTimeline = isSameLiveIndicatorTimelineIdentity(previousSegment, nextSpeakerState);
+    return createLiveIndicatorSegmentState({
+        phase,
+        sourceMessageId: nextSpeakerState.sourceMessageId,
+        laneId: nextSpeakerState.laneId,
+        targetStateId: nextSpeakerState.targetStateId,
+        segmentIndex: sameTimeline && previousSegment
+            ? previousSegment.segmentIndex + 1
+            : 0,
+        sessionId: nextSessionState.sessionId,
+        identityParticipantId: nextSpeakerState.identityParticipantId,
+        participantId: nextSpeakerState.participantId,
+        catId: nextSpeakerState.catId,
+        activeCatIds: nextSpeakerState.activeCatIds,
+        speakerLabel: nextSpeakerState.speakerLabel,
+        sessionStartedAt: nextSessionState.sessionStartedAt,
+        requiresSessionStartConfirmation: nextSessionState.requiresSessionStartConfirmation,
+    });
+}
+function prepareLiveIndicatorStateForEvent(previous, eventType, data) {
+    const nextSpeakerState = resolveLiveIndicatorSpeakerState(previous, data);
+    const nextSessionState = resolveLiveIndicatorSessionState(previous, data);
+    const segments = resolveLiveIndicatorSegments(previous);
+    const previousSegmentIndex = findMatchingLiveIndicatorSegmentIndex(previous, nextSpeakerState);
+    const previousSegment = previousSegmentIndex >= 0
+        ? segments[previousSegmentIndex] ?? null
+        : resolvePrimaryLiveIndicatorSegment(previous);
+    if (shouldStartNewSegmentForEvent(previousSegment, nextSpeakerState, eventType, data)) {
+        const nextSegment = createNextLiveIndicatorSegment(previousSegment, nextSpeakerState, nextSessionState, eventType === 'session_closed' ? 'waiting' : 'streaming');
+        if (previousSegmentIndex >= 0 && previousSegmentIndex < segments.length - 1) {
+            return appendLiveIndicatorSegmentAfterIndex(previous, previousSegmentIndex, nextSegment);
+        }
+        return appendLiveIndicatorSegment(previous, nextSegment);
+    }
+    if (!previousSegment) {
+        return projectLiveIndicatorStateFromSegments([
+            createNextLiveIndicatorSegment(null, nextSpeakerState, nextSessionState, 'waiting'),
+        ]);
+    }
+    const updateSegment = (segment) => ({
+        ...segment,
+        ...nextSpeakerState,
+        ...nextSessionState,
+        id: buildLiveIndicatorSegmentId({
+            sourceMessageId: nextSpeakerState.sourceMessageId,
+            laneId: nextSpeakerState.laneId,
+            targetStateId: nextSpeakerState.targetStateId,
+            sessionId: nextSessionState.sessionId,
+            identityParticipantId: nextSpeakerState.identityParticipantId,
+            participantId: nextSpeakerState.participantId,
+            catId: nextSpeakerState.catId,
+            speakerLabel: nextSpeakerState.speakerLabel,
+            segmentIndex: segment.segmentIndex,
+        }),
+    });
+    return previousSegmentIndex >= 0
+        ? updateLiveIndicatorSegmentAt(previous, previousSegmentIndex, updateSegment)
+        : updatePrimaryLiveIndicatorSegment(previous, updateSegment);
+}
+export function buildLiveIndicatorScrollKey(liveIndicator) {
+    if (!liveIndicator) {
+        return '';
+    }
+    const segments = resolveLiveIndicatorSegments(liveIndicator);
+    return [
+        liveIndicator.active ? '1' : '0',
+        segments
+            .map((segment) => [
+            segment.id,
+            segment.phase,
+            segment.sourceMessageId ?? '',
+            segment.laneId ?? '',
+            segment.targetStateId ?? '',
+            String(segment.segmentIndex),
+            segment.sessionId ?? '',
+            segment.identityParticipantId ?? '',
+            segment.participantId ?? '',
+            segment.activeCatIds.join('|'),
+            segment.catId ?? '',
+            segment.speakerLabel ?? '',
+            segment.sessionStartedAt ?? '',
+            segment.requiresSessionStartConfirmation ? '1' : '0',
+            segment.progressText ?? '',
+            segment.tools
+                .map((tool) => `${tool.toolId}:${tool.toolName}:${tool.done ? '1' : '0'}`)
+                .join('|'),
+            segment.contentBlocks
+                .map((block) => [
+                block.id,
+                String(block.index),
+                block.kind,
+                block.status,
+                block.title ?? '',
+                block.text,
+                block.toolId ?? '',
+            ].join(':'))
+                .join('|'),
+            segment.events
+                .map((event) => [
+                event.eventType,
+                event.label,
+                event.text,
+                event.tone,
+                event.kind ?? '',
+                event.toolId ?? '',
+            ].join(':'))
+                .join('|'),
+        ].join('~'))
+            .join('::'),
+    ].join('::');
+}
+function anonymizeLiveIndicatorSegmentIfSessionUnconfirmed(segment, sessionMessages) {
+    const requiresAnonymousSessionGate = (segment.phase === 'waiting' || segment.phase === 'streaming')
+        && segment.requiresSessionStartConfirmation
+        && !hasConfirmedLiveIndicatorSessionStart(sessionMessages, projectLiveIndicatorStateFromSegments([segment]), segment.sessionStartedAt);
+    if (!requiresAnonymousSessionGate) {
+        return segment;
+    }
+    return createLiveIndicatorSegmentState({
+        ...segment,
+        phase: 'waiting',
+        participantId: null,
+        catId: null,
+        activeCatIds: [],
+        catName: null,
+        speakerLabel: null,
+        progressText: '',
+        progressKind: null,
+        tools: [],
+        contentBlocks: [],
+        events: [],
+    });
+}
+export function resolveVisibleLiveIndicator(liveIndicator, messages, activeTurnUpdatedAt, sessionMessages = messages, nowMs = Date.now()) {
+    if (!liveIndicator?.active) {
+        return liveIndicator ?? null;
+    }
+    const sourceSegments = resolveLiveIndicatorSegments(liveIndicator);
+    const projectedSourceSegments = projectLogicalLiveIndicatorSegments(sourceSegments);
+    const gatedSegments = projectedSourceSegments.map((segment) => anonymizeLiveIndicatorSegmentIfSessionUnconfirmed(segment, sessionMessages));
+    const visibleSegments = gatedSegments.filter((segment, index) => {
+        const hasLaterDistinctLogicalSegment = gatedSegments
+            .slice(index + 1)
+            .some((candidate) => !doesLiveIndicatorLogicalIdentityMatch(segment, candidate));
+        const persistedSegmentIndex = resolveProjectedTextSegmentOrdinal(projectedSourceSegments, index) ?? segment.segmentIndex;
+        if (hasVisiblePersistedSegment(messages, segment, persistedSegmentIndex)) {
+            return false;
+        }
+        if (segment.phase === 'sealed'
+            && hasLaterDistinctLogicalSegment
+            && readString(segment.sourceMessageId)
+            && segmentHasTextContent(segment)
+            && hasVisibleLiveIndicatorSpeakerReplyAfterMessage(messages, segment.sourceMessageId, projectLiveIndicatorStateFromSegments([segment]))) {
+            return false;
+        }
+        if (segment.phase === 'sealed'
+            && hasLaterDistinctLogicalSegment
+            && !segmentHasRenderableTranscriptContent(segment)) {
+            return false;
+        }
+        if (index > 0 && !hasVisibleLiveIndicatorSegmentActivity(segment)) {
+            return false;
+        }
+        return true;
+    });
+    const buildTrailingWaitingPlaceholder = (lastSegment) => {
+        if (!activeTurnUpdatedAt) {
+            return null;
+        }
+        const turnTerminated = lastSegment.events.some((event) => event.eventType === 'result' || event.eventType === 'error');
+        if (turnTerminated) {
+            return null;
+        }
+        const activeTurnTimestamp = Date.parse(activeTurnUpdatedAt);
+        if (!Number.isFinite(activeTurnTimestamp)) {
+            return null;
+        }
+        // Use a speaker/lane-scoped reply timestamp so a persisted reply from a
+        // sibling lane (concurrent / compare flows) cannot suppress this lane's
+        // gap placeholder. Falls back to the global timestamp only when the
+        // segment lacks any speaker identity to scope the comparison.
+        const segmentScopedIndicator = projectLiveIndicatorStateFromSegments([lastSegment]);
+        const latestReplyTimestamp = hasLiveIndicatorIdentity(segmentScopedIndicator)
+            ? resolveLatestVisibleReplyTimestamp(messages, (message) => doesMessageMatchLiveIndicatorSpeaker(message, segmentScopedIndicator))
+            : resolveLatestVisibleReplyTimestamp(messages);
+        if (latestReplyTimestamp > activeTurnTimestamp) {
+            return null;
+        }
+        return createLiveIndicatorSegmentState({
+            phase: 'waiting',
+            sourceMessageId: lastSegment.sourceMessageId,
+            laneId: lastSegment.laneId,
+            targetStateId: lastSegment.targetStateId,
+            segmentIndex: lastSegment.segmentIndex + 1,
+            sessionId: lastSegment.sessionId,
+            identityParticipantId: lastSegment.identityParticipantId,
+            participantId: lastSegment.participantId,
+            catId: lastSegment.catId,
+            activeCatIds: lastSegment.activeCatIds,
+            catName: lastSegment.catName,
+            speakerLabel: lastSegment.speakerLabel,
+            sessionStartedAt: lastSegment.sessionStartedAt,
+            requiresSessionStartConfirmation: lastSegment.requiresSessionStartConfirmation,
+            lastActivityAtMs: lastSegment.lastActivityAtMs,
+            lastVisibleContentAtMs: lastSegment.lastVisibleContentAtMs,
+        });
+    };
+    if (visibleSegments.length === 0) {
+        // All source segments were filtered (typically because the sealed reply
+        // was persisted to the transcript). If we're still inside an active
+        // workflow turn that has not yet emitted a terminal event, surface a
+        // waiting placeholder preserving the last segment's identity so the
+        // transcript keeps showing typing dots during the gap between a sealed
+        // reply and the next runtime event. Without this, CLI-backed sessions
+        // leave an orphan avatar floating after the sealed bubble for seconds.
+        if (sourceSegments.length > 0) {
+            const placeholder = buildTrailingWaitingPlaceholder(sourceSegments.at(-1));
+            if (placeholder) {
+                return projectLiveIndicatorStateFromSegments([placeholder]);
+            }
+        }
+        return null;
+    }
+    // Sealed-primary gap: the last visible segment is sealed but the workflow
+    // turn has not yet emitted a terminal event. Append a waiting placeholder
+    // so the user keeps seeing typing dots after the sealed bubble while the
+    // runtime prepares its next segment (tool_use, next text, etc.).
+    const lastVisibleSegment = visibleSegments.at(-1);
+    if (lastVisibleSegment.phase === 'streaming'
+        && shouldProjectStalledStreamingTextAsWaiting(lastVisibleSegment, nowMs)) {
+        // The source segment is still streaming, but its last visible text update
+        // has been idle long enough that the conversation should look like
+        // "sealed text bubble + still working" instead of "static text bubble
+        // with inline dots". Keep the raw state untouched; only the visible
+        // projection splits it into a sealed transcript bubble plus a waiting
+        // placeholder.
+        const sealedVisibleSegment = createLiveIndicatorSegmentState({
+            ...lastVisibleSegment,
+            phase: 'sealed',
+        });
+        const placeholder = buildTrailingWaitingPlaceholder(sealedVisibleSegment);
+        if (placeholder) {
+            visibleSegments[visibleSegments.length - 1] = sealedVisibleSegment;
+            visibleSegments.push(placeholder);
+        }
+    }
+    else if (lastVisibleSegment.phase === 'sealed') {
+        const placeholder = buildTrailingWaitingPlaceholder(lastVisibleSegment);
+        if (placeholder) {
+            visibleSegments.push(placeholder);
+        }
+    }
+    const canReuseOriginalLiveIndicator = visibleSegments.length === projectedSourceSegments.length
+        && projectedSourceSegments.length === sourceSegments.length
+        && liveIndicator.segments.length === 0
+        && visibleSegments.every((segment, index) => segment === projectedSourceSegments[index]);
+    const normalizedVisibleIndicator = (canReuseOriginalLiveIndicator)
+        ? liveIndicator
+        : projectLiveIndicatorStateFromSegments(visibleSegments);
+    if (!activeTurnUpdatedAt) {
+        return normalizedVisibleIndicator;
+    }
+    const activeTurnTimestamp = Date.parse(activeTurnUpdatedAt);
+    if (Number.isNaN(activeTurnTimestamp)) {
+        return normalizedVisibleIndicator;
+    }
+    const primarySegment = resolvePrimaryLiveIndicatorSegment(normalizedVisibleIndicator);
+    if ((primarySegment?.laneId || primarySegment?.targetStateId) && primarySegment.phase !== 'sealed') {
+        traceLiveIndicatorVisibility({
+            liveIndicator: normalizedVisibleIndicator,
+            messages,
+            activeTurnUpdatedAt,
+            visible: true,
+            reason: 'segment_timeline_visible',
+            latestReplyTimestamp: Number.NEGATIVE_INFINITY,
+        });
+        return normalizedVisibleIndicator;
+    }
+    if (hasLiveIndicatorIdentity(normalizedVisibleIndicator)) {
+        const latestSpeakerReplyTimestamp = resolveLatestVisibleReplyTimestamp(messages, (message) => doesMessageMatchLiveIndicatorSpeaker(message, normalizedVisibleIndicator));
+        const visible = latestSpeakerReplyTimestamp < activeTurnTimestamp;
+        traceLiveIndicatorVisibility({
+            liveIndicator: normalizedVisibleIndicator,
+            messages,
+            activeTurnUpdatedAt,
+            visible,
+            reason: visible ? 'speaker_still_streaming' : 'same_speaker_reply_visible',
+            latestReplyTimestamp: latestSpeakerReplyTimestamp,
+        });
+        return visible ? normalizedVisibleIndicator : null;
+    }
+    const latestVisibleReplyTimestamp = resolveLatestVisibleReplyTimestamp(messages);
+    const visible = latestVisibleReplyTimestamp < activeTurnTimestamp;
+    traceLiveIndicatorVisibility({
+        liveIndicator: normalizedVisibleIndicator,
+        messages,
+        activeTurnUpdatedAt,
+        visible,
+        reason: visible ? 'visible_before_identity' : 'reply_after_active_turn',
+        latestReplyTimestamp: latestVisibleReplyTimestamp,
+    });
+    return visible ? normalizedVisibleIndicator : null;
+}
+export function resolveTranscriptFollowState(liveIndicator, messages, activeTurnUpdatedAt, sessionMessages = messages, nowMs = Date.now()) {
+    const visibleLiveIndicator = resolveVisibleLiveIndicator(liveIndicator, messages, activeTurnUpdatedAt, sessionMessages, nowMs);
+    const lastMessage = messages.at(-1);
+    return {
+        visibleLiveIndicator,
+        transcriptScrollKey: [
+            messages.length,
+            lastMessage?.id ?? '',
+            lastMessage?.createdAt ?? '',
+            buildLiveIndicatorScrollKey(visibleLiveIndicator),
+        ].join('::'),
+    };
+}
+function applyProgressEvent(previous, data, observedAtMs) {
+    const text = summarizeEventText(data.text);
+    const metadata = asRecord(data.metadata);
+    const kind = typeof metadata?.kind === 'string' ? metadata.kind : null;
+    if (!text) {
+        return updateLiveIndicatorEventSegment(previous, data, (segment) => ({
+            ...segment,
+            phase: 'streaming',
+            ...(kind ? { progressKind: kind } : {}),
+            lastActivityAtMs: observedAtMs,
+        }));
+    }
+    return updateLiveIndicatorEventSegment(previous, data, (segment) => ({
+        ...segment,
+        phase: 'streaming',
+        progressText: text,
+        progressKind: kind,
+        events: appendLiveIndicatorEvent(segment.events, {
+            eventType: 'progress',
+            label: progressLabel(kind),
+            text,
+            tone: kind === 'reasoning' ? 'default' : 'active',
+            kind,
+            toolName: null,
+            toolId: null,
+        }),
+        lastActivityAtMs: observedAtMs,
+        lastVisibleContentAtMs: observedAtMs,
+    }));
+}
+function applyTextEvent(previous, data, observedAtMs) {
+    const textChunk = typeof data.text === 'string' ? data.text : '';
+    const summarizedText = summarizeEventText(data.text);
+    if (!textChunk && !summarizedText) {
+        return updateLiveIndicatorEventSegment(previous, data, (segment) => ({
+            ...segment,
+            phase: 'streaming',
+            lastActivityAtMs: observedAtMs,
+        }));
+    }
+    return updateLiveIndicatorEventSegment(previous, data, (segment) => ({
+        ...segment,
+        phase: 'streaming',
+        progressText: '',
+        progressKind: null,
+        contentBlocks: synthesizeTextContentBlock(segment.contentBlocks, textChunk),
+        events: summarizedText
+            ? appendLiveIndicatorEvent(segment.events, {
+                eventType: 'text',
+                label: 'Text',
+                text: summarizedText,
+                tone: 'default',
+                kind: 'text',
+                toolName: null,
+                toolId: null,
+            })
+            : segment.events,
+        lastActivityAtMs: observedAtMs,
+        lastVisibleContentAtMs: observedAtMs,
+    }));
+}
+function synthesizeTextContentBlock(contentBlocks, textChunk) {
+    if (!textChunk) {
+        return contentBlocks;
+    }
+    if (contentBlocks.some((block) => !isSyntheticFallbackTextBlock(block))) {
+        return contentBlocks;
+    }
+    const lastBlock = contentBlocks.at(-1);
+    if (lastBlock?.kind === 'text' && lastBlock.status === 'streaming') {
+        return contentBlocks.map((block) => block.id === lastBlock.id
+            ? { ...block, text: block.text + textChunk }
+            : block);
+    }
+    const nextIndex = contentBlocks.length > 0
+        ? Math.max(...contentBlocks.map((block) => block.index)) + 1
+        : 0;
+    return [
+        ...contentBlocks,
+        {
+            id: `text:${nextIndex}`,
+            index: nextIndex,
+            kind: 'text',
+            status: 'streaming',
+            title: null,
+            text: textChunk,
+            toolName: null,
+            toolId: null,
+            metadata: {
+                syntheticTextFallback: true,
+            },
+        },
+    ].slice(-MAX_LIVE_INDICATOR_BLOCKS);
+}
+function isSyntheticFallbackTextBlock(block) {
+    return block.kind === 'text' && block.metadata?.syntheticTextFallback === true;
+}
+function applyToolUseEvent(previous, data, observedAtMs) {
+    const normalizedSegment = normalizeRuntimeMessageSegmentEntry({
+        type: 'tool_use',
+        ...data,
+    });
+    const toolName = (normalizedSegment?.kind === 'tool_use'
+        ? normalizedSegment.toolName
+        : readString(data.toolName)) || 'tool';
+    const toolId = normalizedSegment?.kind === 'tool_use'
+        ? normalizedSegment.toolId
+        : readString(data.toolId);
+    return updateLiveIndicatorEventSegment(previous, data, (segment) => {
+        const nextTools = appendPendingTool(segment.tools, {
+            toolName,
+            toolId: toolId || toolName,
+        });
+        return {
+            ...segment,
+            phase: 'streaming',
+            tools: nextTools,
+            events: appendLiveIndicatorEvent(segment.events, {
+                eventType: 'tool_use',
+                label: 'Tool',
+                text: `Started ${toolName}`,
+                tone: 'active',
+                kind: 'tool',
+                toolName,
+                toolId: toolId || toolName,
+            }),
+            lastActivityAtMs: observedAtMs,
+        };
+    });
+}
+function applyToolResultEvent(previous, data, observedAtMs) {
+    const normalizedSegment = normalizeRuntimeMessageSegmentEntry({
+        type: 'tool_result',
+        ...data,
+    });
+    const toolId = normalizedSegment?.kind === 'tool_result'
+        ? normalizedSegment.toolId
+        : readString(data.toolId);
+    const previousSegment = resolveLiveIndicatorEventTargetSegment(previous, data).segment;
+    const toolName = (normalizedSegment?.kind === 'tool_result'
+        ? normalizedSegment.toolName
+        : readString(data.toolName))
+        || findToolName(previousSegment?.tools ?? [], toolId)
+        || 'tool';
+    const resultText = summarizeEventText(normalizedSegment?.kind === 'tool_result' ? normalizedSegment.text : data.text);
+    const isError = data.isError === true;
+    const text = resultText
+        ? `${isError ? 'Failed' : 'Completed'} ${toolName}: ${resultText}`
+        : `${isError ? 'Failed' : 'Completed'} ${toolName}`;
+    return updateLiveIndicatorEventSegment(previous, data, (segment) => ({
+        ...segment,
+        phase: 'streaming',
+        tools: markToolDone(segment.tools, toolId, toolName),
+        events: appendLiveIndicatorEvent(segment.events, {
+            eventType: 'tool_result',
+            label: isError ? 'Tool Error' : 'Tool',
+            text,
+            tone: isError ? 'error' : 'success',
+            kind: 'tool',
+            toolName,
+            toolId: toolId || toolName,
+        }),
+        lastActivityAtMs: observedAtMs,
+    }));
+}
+function applyResultEvent(previous, data = {}, observedAtMs) {
+    return updateLiveIndicatorEventSegment(previous, data, (segment) => {
+        const hasTextContent = segment.contentBlocks.some((block) => block.kind === 'text' && block.text.trim().length > 0);
+        const text = hasTextContent ? '' : (segment.progressText || 'Finalizing...');
+        return {
+            ...segment,
+            phase: 'sealed',
+            progressKind: hasTextContent ? null : 'finalizing',
+            progressText: text,
+            events: appendLiveIndicatorEvent(segment.events, {
+                eventType: 'result',
+                label: 'Result',
+                text: 'Turn completed.',
+                tone: 'success',
+                kind: 'finalizing',
+                toolName: null,
+                toolId: null,
+            }),
+            lastActivityAtMs: observedAtMs,
+            lastVisibleContentAtMs: hasTextContent ? segment.lastVisibleContentAtMs : observedAtMs,
+        };
+    });
+}
+function applyContentBlockEvent(previous, data, observedAtMs) {
+    const block = normalizeRuntimeContentBlock(data);
+    if (!block) {
+        return previous;
+    }
+    const applyBlockUpdate = (segment) => {
+        const baseContentBlocks = block.kind === 'text' && segmentHasOnlySyntheticTextFallback(segment)
+            ? []
+            : segment.contentBlocks;
+        const nextContentBlocks = [
+            ...baseContentBlocks.filter((candidate) => !isSameLogicalContentBlock(candidate, block)),
+            block,
+        ]
+            .sort((left, right) => left.index - right.index)
+            .slice(-MAX_LIVE_INDICATOR_BLOCKS);
+        return {
+            ...segment,
+            phase: segment.phase === 'sealed' ? 'sealed' : 'streaming',
+            contentBlocks: nextContentBlocks,
+            lastActivityAtMs: observedAtMs,
+            lastVisibleContentAtMs: observedAtMs,
+        };
+    };
+    const nextState = updateMatchingLiveIndicatorSegment(previous, (segment) => segment.contentBlocks.some((candidate) => isSameLogicalContentBlock(candidate, block)), applyBlockUpdate);
+    if (nextState !== previous) {
+        return nextState;
+    }
+    return updateLiveIndicatorEventSegment(previous, data, applyBlockUpdate);
+}
+function applyErrorEvent(previous, data, observedAtMs) {
+    const text = summarizeEventText(data.text) || 'Finishing...';
+    return updateLiveIndicatorEventSegment(previous, data, (segment) => ({
+        ...segment,
+        phase: 'sealed',
+        progressKind: 'error',
+        progressText: text,
+        events: appendLiveIndicatorEvent(segment.events, {
+            eventType: 'error',
+            label: 'Error',
+            text,
+            tone: 'error',
+            kind: 'error',
+            toolName: null,
+            toolId: null,
+        }),
+        lastActivityAtMs: observedAtMs,
+        lastVisibleContentAtMs: observedAtMs,
+    }));
+}
+function appendPendingTool(tools, next) {
+    if (tools.some((tool) => tool.toolId === next.toolId && !tool.done)) {
+        return tools;
+    }
+    return [...tools, { ...next, done: false }];
+}
+function markToolDone(tools, toolId, toolName) {
+    let matched = false;
+    const next = tools.map((tool) => {
+        if ((toolId && tool.toolId === toolId)
+            || (!toolId && !matched && tool.toolName === toolName && !tool.done)) {
+            matched = true;
+            return { ...tool, done: true };
+        }
+        return tool;
+    });
+    if (!matched) {
+        return [...next, { toolName, toolId: toolId || toolName, done: true }];
+    }
+    return next;
+}
+function findToolName(tools, toolId) {
+    if (!toolId) {
+        return null;
+    }
+    return tools.find((tool) => tool.toolId === toolId)?.toolName ?? null;
+}
+function appendLiveIndicatorEvent(events, next) {
+    if (!next.text) {
+        return events;
+    }
+    const previous = events.at(-1);
+    if (previous
+        && previous.eventType === next.eventType
+        && previous.text === next.text
+        && previous.toolId === next.toolId) {
+        return events;
+    }
+    if (previous && previous.eventType === 'text' && next.eventType === 'text') {
+        const mergedText = summarizeEventText(`${previous.text} ${next.text}`);
+        const merged = {
+            ...previous,
+            text: mergedText,
+        };
+        return trimLiveIndicatorEvents([...events.slice(0, -1), merged]);
+    }
+    return trimLiveIndicatorEvents([...events, next]);
+}
+function trimLiveIndicatorEvents(events) {
+    if (events.length <= MAX_LIVE_INDICATOR_EVENTS) {
+        return events;
+    }
+    return events.slice(events.length - MAX_LIVE_INDICATOR_EVENTS);
+}
+function progressLabel(kind) {
+    switch (kind) {
+        case 'tool':
+            return 'Tool';
+        case 'reasoning':
+            return 'Reasoning';
+        case 'plan':
+            return 'Plan';
+        case 'command':
+            return 'Command';
+        case 'files':
+            return 'Files';
+        case 'model_state':
+            return 'Model';
+        case 'session':
+            return 'Session';
+        default:
+            return 'Progress';
+    }
+}
+function summarizeEventText(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    const singleLine = value.replace(/\s+/g, ' ').trim();
+    if (!singleLine) {
+        return '';
+    }
+    return singleLine.length > MAX_EVENT_TEXT
+        ? `${singleLine.slice(0, MAX_EVENT_TEXT - 1)}…`
+        : singleLine;
+}
+export function hasVisibleAssistantReplyAfterMessage(messages, messageId) {
+    const sourceIndex = messages.findIndex((message) => message.id === messageId);
+    if (sourceIndex === -1) {
+        return false;
+    }
+    return messages.slice(sourceIndex + 1).some((message) => message.senderKind === 'agent' || message.senderKind === 'orchestrator');
+}
+export function hasVisibleLiveIndicatorSpeakerReplyAfterMessage(messages, messageId, liveIndicator) {
+    const sourceIndex = messages.findIndex((message) => message.id === messageId);
+    if (sourceIndex === -1) {
+        return false;
+    }
+    return messages.slice(sourceIndex + 1).some((message) => isVisibleAssistantReply(message) && doesMessageMatchLiveIndicatorSpeaker(message, liveIndicator));
+}
+export function hasVisibleSessionStartAfterMessage(messages, messageId, options = {}) {
+    const sourceIndex = messages.findIndex((message) => message.id === messageId);
+    if (sourceIndex === -1) {
+        return false;
+    }
+    const targetStateIds = new Set((options.targetStateIds ?? [])
+        .map((value) => readString(value))
+        .filter((value) => value !== null));
+    const laneIds = new Set((options.laneIds ?? [])
+        .map((value) => readString(value))
+        .filter((value) => value !== null));
+    const participantIds = new Set((options.participantIds ?? [])
+        .map((value) => readString(value))
+        .filter((value) => value !== null));
+    const allowOrchestrator = participantIds.has('orchestrator');
+    return messages.slice(sourceIndex + 1).some((message) => {
+        if (message.senderKind !== 'system') {
+            return false;
+        }
+        const metadata = asRecord(message.metadata);
+        if (readString(metadata?.event) !== 'session_started') {
+            return false;
+        }
+        if (laneIds.size > 0) {
+            const laneId = readMessageLaneId(message);
+            if (laneId) {
+                return laneIds.has(laneId);
+            }
+        }
+        if (targetStateIds.size > 0) {
+            const targetStateId = readMessageTargetStateId(message);
+            if (!targetStateId) {
+                return false;
+            }
+            return targetStateIds.has(targetStateId);
+        }
+        if (participantIds.size > 0) {
+            const targetId = readMessageTargetId(message);
+            if (targetId) {
+                return participantIds.has(targetId);
+            }
+            if (allowOrchestrator && readMessageTargetKind(message) === 'orchestrator') {
+                return true;
+            }
+            return false;
+        }
+        return true;
+    });
+}
+function resolveLatestVisibleReplyTimestamp(messages, predicate) {
+    return messages.reduce((latestTimestamp, message) => {
+        if (!isVisibleAssistantReply(message) || (predicate && !predicate(message))) {
+            return latestTimestamp;
+        }
+        const messageTimestamp = Date.parse(message.createdAt);
+        if (Number.isNaN(messageTimestamp)) {
+            return latestTimestamp;
+        }
+        return Math.max(latestTimestamp, messageTimestamp);
+    }, Number.NEGATIVE_INFINITY);
+}
+function isVisibleAssistantReply(message) {
+    return message.senderKind !== 'user' && message.senderKind !== 'system';
+}
+export function hasLiveIndicatorIdentity(liveIndicator) {
+    if (!liveIndicator?.active) {
+        return false;
+    }
+    return Boolean(readString(liveIndicator.participantId)
+        || readString(liveIndicator.speakerLabel)
+        || liveIndicator.catId
+        || liveIndicator.activeCatIds.some((id) => id.trim().length > 0));
+}
+function doesMessageMatchLiveIndicatorSpeaker(message, liveIndicator) {
+    const liveLaneId = readString(liveIndicator.laneId);
+    if (liveLaneId && doesMessageMatchLaneScopedIdentity(message, {
+        laneId: liveLaneId,
+        sourceMessageId: liveIndicator.sourceMessageId,
+    })) {
+        return true;
+    }
+    const liveTargetStateId = readString(liveIndicator.targetStateId);
+    if (liveTargetStateId) {
+        return doesMessageMatchTargetStateOrSession(message, {
+            targetStateId: liveTargetStateId,
+            sessionId: liveIndicator.sessionId,
+            sourceMessageId: liveIndicator.sourceMessageId,
+        });
+    }
+    const messageTargetId = readMessageTargetId(message);
+    const liveTargetId = readString(liveIndicator.identityParticipantId)
+        ?? readString(liveIndicator.participantId)
+        ?? liveIndicator.catId
+        ?? liveIndicator.activeCatIds.find((id) => id.trim().length > 0)
+        ?? null;
+    if (messageTargetId && liveTargetId && messageTargetId === liveTargetId) {
+        return true;
+    }
+    if (liveTargetId) {
+        return false;
+    }
+    const liveSpeakerLabel = readString(liveIndicator.speakerLabel);
+    if (!liveSpeakerLabel) {
+        return false;
+    }
+    return readString(message.senderName) === liveSpeakerLabel
+        || readMessageExecutionLabelSnapshot(message) === liveSpeakerLabel;
+}
+function hasConfirmedLiveIndicatorSessionStart(messages, liveIndicator, sessionStartedAt) {
+    const liveLaneId = readString(liveIndicator.laneId);
+    const liveTargetStateId = readString(liveIndicator.targetStateId);
+    const liveSessionId = readString(liveIndicator.sessionId);
+    const requiresTargetScopedConfirmation = Boolean(liveLaneId || liveTargetStateId);
+    const sessionStartFloorTimestamp = (() => {
+        if (!sessionStartedAt) {
+            return null;
+        }
+        const timestamp = Date.parse(sessionStartedAt);
+        return Number.isNaN(timestamp) ? null : timestamp;
+    })();
+    return messages.some((message) => {
+        if (readMessageEvent(message) !== 'session_started') {
+            return false;
+        }
+        const messageTimestamp = Date.parse(message.createdAt);
+        if (Number.isNaN(messageTimestamp)
+            || (sessionStartFloorTimestamp != null
+                && messageTimestamp < sessionStartFloorTimestamp)) {
+            return false;
+        }
+        let matchesIdentity = false;
+        if (liveLaneId) {
+            matchesIdentity = doesMessageMatchLaneScopedIdentity(message, {
+                laneId: liveLaneId,
+                sourceMessageId: liveIndicator.sourceMessageId,
+            });
+        }
+        if (!matchesIdentity && liveTargetStateId) {
+            matchesIdentity = doesMessageMatchTargetStateOrSession(message, {
+                targetStateId: liveTargetStateId,
+                sessionId: liveSessionId,
+            });
+        }
+        if (!matchesIdentity && liveSessionId) {
+            const messageSessionId = readMessageSessionId(message);
+            matchesIdentity = Boolean(messageSessionId && messageSessionId === liveSessionId);
+        }
+        const liveParticipantId = readString(liveIndicator.identityParticipantId)
+            ?? readString(liveIndicator.participantId);
+        if (liveParticipantId) {
+            if (liveParticipantId === 'orchestrator') {
+                if (readMessageTargetKind(message) !== 'orchestrator') {
+                    return false;
+                }
+                return true;
+            }
+            const messageTargetId = readMessageTargetId(message);
+            if (messageTargetId) {
+                if (messageTargetId !== liveParticipantId) {
+                    return false;
+                }
+                return requiresTargetScopedConfirmation ? matchesIdentity : true;
+            }
+            return matchesIdentity;
+        }
+        if (matchesIdentity) {
+            return true;
+        }
+        return readMessageTargetKind(message) === 'orchestrator';
+    });
+}
+export function hasConfirmedLiveIndicatorSegmentSessionStart(segment, messages) {
+    return hasConfirmedLiveIndicatorSessionStart(messages, projectLiveIndicatorStateFromSegments([segment]), segment.sessionStartedAt);
+}
+function traceLiveIndicatorVisibility(input) {
+    if (!isBrowserLiveTraceEnabled()) {
+        return;
+    }
+    const lastMessage = input.messages.at(-1);
+    const channelId = lastMessage?.channelId ?? null;
+    pushBrowserLiveTrace({
+        event: 'visibility_decision',
+        channelId,
+        conversationId: channelId ? buildChatConversationId(channelId) : null,
+        turnId: readMessageTurnId(lastMessage ?? null),
+        laneId: input.liveIndicator.laneId,
+        sourceMessageId: input.liveIndicator.sourceMessageId,
+        targetStateId: input.liveIndicator.targetStateId,
+        sessionId: input.liveIndicator.sessionId,
+        speakerLabel: input.liveIndicator.speakerLabel,
+        participantId: input.liveIndicator.participantId,
+        catId: input.liveIndicator.catId,
+        activeTurnUpdatedAt: input.activeTurnUpdatedAt,
+        visible: input.visible,
+        reason: input.reason,
+        details: {
+            phase: input.liveIndicator.phase,
+            lastMessageId: lastMessage?.id ?? null,
+            latestReplyAt: Number.isFinite(input.latestReplyTimestamp) && input.latestReplyTimestamp > Number.NEGATIVE_INFINITY
+                ? new Date(input.latestReplyTimestamp).toISOString()
+                : null,
+        },
+        signature: [
+            input.liveIndicator.phase,
+            input.liveIndicator.laneId ?? '',
+            input.liveIndicator.targetStateId ?? '',
+            input.liveIndicator.sourceMessageId ?? '',
+            input.liveIndicator.sessionId ?? '',
+            input.liveIndicator.identityParticipantId ?? '',
+            input.liveIndicator.participantId ?? '',
+            input.liveIndicator.speakerLabel ?? '',
+            input.liveIndicator.catId ?? '',
+            input.activeTurnUpdatedAt,
+            input.visible ? '1' : '0',
+            input.reason,
+            lastMessage?.id ?? '',
+        ].join('::'),
+    });
+}
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function readMessageTargetId(message) {
+    const metadata = asRecord(message.metadata);
+    return readString(metadata?.targetId)
+        || readString(metadata?.sourceRefId)
+        || readString(metadata?.participantId);
+}
+function readMessageSessionId(message) {
+    const metadata = asRecord(message.metadata);
+    return readString(metadata?.sessionId);
+}
+function readMessageLaneId(message) {
+    const metadata = asRecord(message.metadata);
+    return readString(metadata?.laneId);
+}
+function readMessageTargetStateId(message) {
+    const metadata = asRecord(message.metadata);
+    return readString(metadata?.targetStateId);
+}
+function readMessageTargetKind(message) {
+    const metadata = asRecord(message.metadata);
+    return readString(metadata?.targetKind);
+}
+function readMessageEvent(message) {
+    const metadata = asRecord(message.metadata);
+    return readString(metadata?.event);
+}
+function readMessageSourceMessageId(message) {
+    const metadata = asRecord(message.metadata);
+    return readString(metadata?.sourceMessageId);
+}
+function readMessageTurnId(message) {
+    if (!message) {
+        return null;
+    }
+    const metadata = asRecord(message.metadata);
+    return readString(metadata?.turnId);
+}
+function readMessageSegmentIndex(message) {
+    const metadata = asRecord(message.metadata);
+    return typeof metadata?.segmentIndex === 'number' && Number.isFinite(metadata.segmentIndex)
+        ? metadata.segmentIndex
+        : null;
+}
+function readMessageExecutionLabelSnapshot(message) {
+    const metadata = asRecord(message.metadata);
+    return readString(metadata?.executionLabelSnapshot);
+}
+function doesMessageMatchTargetStateOrSession(message, options) {
+    const targetStateId = readString(options.targetStateId);
+    const sourceMessageId = readString(options.sourceMessageId);
+    if (targetStateId) {
+        const messageTargetStateId = readMessageTargetStateId(message);
+        if (messageTargetStateId && messageTargetStateId === targetStateId) {
+            if (!sourceMessageId) {
+                return true;
+            }
+            const messageSourceMessageId = readMessageSourceMessageId(message);
+            return !messageSourceMessageId || messageSourceMessageId === sourceMessageId;
+        }
+    }
+    return doesMessageMatchSessionScopedIdentity(message, {
+        sessionId: options.sessionId,
+        sourceMessageId,
+    });
+}
+function doesMessageMatchLaneScopedIdentity(message, options) {
+    const laneId = readString(options.laneId);
+    if (!laneId) {
+        return false;
+    }
+    const messageLaneId = readMessageLaneId(message);
+    if (!messageLaneId || messageLaneId !== laneId) {
+        return false;
+    }
+    return true;
+}
+function doesMessageMatchSessionScopedIdentity(message, options) {
+    const sessionId = readString(options.sessionId);
+    if (!sessionId) {
+        return false;
+    }
+    const messageSessionId = readMessageSessionId(message);
+    if (!messageSessionId || messageSessionId !== sessionId) {
+        return false;
+    }
+    const sourceMessageId = readString(options.sourceMessageId);
+    if (!sourceMessageId) {
+        return true;
+    }
+    const messageSourceMessageId = readMessageSourceMessageId(message);
+    return !messageSourceMessageId || messageSourceMessageId === sourceMessageId;
+}
+function hasVisiblePersistedSegment(messages, segment, persistedSegmentIndex) {
+    const sourceMessageId = readString(segment.sourceMessageId);
+    if (segment.laneId || segment.targetStateId) {
+        return messages.some((message) => isVisibleAssistantReply(message)
+            && readMessageEvent(message) === 'assistant_turn_segment'
+            && (doesMessageMatchLaneScopedIdentity(message, {
+                laneId: segment.laneId,
+                sourceMessageId,
+            })
+                || (segment.targetStateId
+                    && ((!sourceMessageId || readMessageSourceMessageId(message) === sourceMessageId)
+                        && readMessageTargetStateId(message) === segment.targetStateId)))
+            && readMessageSegmentIndex(message) === persistedSegmentIndex);
+    }
+    const segmentParticipantId = resolveLogicalParticipantId(segment);
+    if (segment.phase === 'sealed' && segmentParticipantId && sourceMessageId) {
+        return messages.some((message) => isVisibleAssistantReply(message)
+            && readMessageEvent(message) === 'assistant_turn_segment'
+            && readMessageSourceMessageId(message) === sourceMessageId
+            && readMessageSegmentIndex(message) === persistedSegmentIndex
+            && readMessageTargetId(message) === segmentParticipantId);
+    }
+    let lastUserIndex = -1;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        if (messages[i].senderKind === 'user') {
+            lastUserIndex = i;
+            break;
+        }
+    }
+    return messages.some((message, index) => index > lastUserIndex
+        && isVisibleAssistantReply(message)
+        && readMessageEvent(message) === 'assistant_turn_segment'
+        && readMessageSegmentIndex(message) === persistedSegmentIndex);
+}
+function readString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+function readNullableString(value) {
+    if (value == null) {
+        return null;
+    }
+    return readString(value);
+}
+//# sourceMappingURL=liveIndicator.js.map