@pasko70/pibo 1.12.0 → 1.12.1

package/dist/sessions/pibo-data-store.js

@@ -1,3 +1,4 @@
+import { ChatDataIngestService } from "../data/ingest-service.js";
 import { PiboDataStore } from "../data/pibo-store.js";
 import { createPiboSession, matchesFindInput, } from "./store.js";
 export class PiboDataSessionStore {
@@ -119,6 +120,70 @@ export class PiboDataSessionStore {
     getTelemetryStore() {
         return this.dataStore.telemetry;
     }
+    recoverInterruptedRuntimeState(input = {}) {
+        const at = input.at ?? new Date().toISOString();
+        const runsBySession = groupRunsByController(input.recoveredRuns ?? []);
+        return this.dataStore.transaction(() => {
+            const recoveredTurns = this.dataStore.telemetry.recoverInterruptedTurns({
+                at,
+                resolveOutcome: (turn) => recoveryOutcomeForTurn(turn, runsBySession.get(turn.piboSessionId) ?? []),
+            });
+            if (recoveredTurns.length === 0)
+                return [];
+            const ingest = new ChatDataIngestService(this.dataStore);
+            const results = [];
+            for (const recovered of recoveredTurns) {
+                const session = this.get(recovered.turn.piboSessionId);
+                if (!session)
+                    continue;
+                const row = this.db.prepare("SELECT room_id FROM sessions WHERE id = ?").get(session.id);
+                const event = {
+                    type: "session_error",
+                    piboSessionId: session.id,
+                    eventId: recoveryEventId(recovered.turn),
+                    error: recovered.outcome.summary,
+                    errorDetails: {
+                        category: "runtime_restart",
+                        errorClass: recovered.outcome.status === "aborted" ? "runtime_abort" : "runtime_error",
+                        code: recovered.outcome.status === "timeout" ? "timeout" : "runtime_interrupted",
+                        origin: "runtime",
+                        severity: "error",
+                        retryable: false,
+                        userMessage: "The previous gateway runtime ended before this turn completed.",
+                    },
+                };
+                this.db.prepare(`
+					UPDATE sessions SET
+						status = 'error',
+						updated_at = ?,
+						last_activity_at = MAX(last_activity_at, ?)
+					WHERE id = ? AND deleted_at IS NULL
+				`).run(at, at, session.id);
+                this.db.prepare(`
+					UPDATE session_navigation SET
+						status = 'error',
+						last_activity_at = MAX(last_activity_at, ?),
+						sort_key = MAX(sort_key, ?),
+						updated_at = ?
+					WHERE session_id = ?
+				`).run(at, at, at, session.id);
+                ingest.ingestOutputEvent({
+                    session,
+                    roomId: row?.room_id ?? undefined,
+                    actorId: session.id,
+                    event,
+                    createdAt: at,
+                });
+                results.push({
+                    turnId: recovered.turn.turnId,
+                    piboSessionId: session.id,
+                    event,
+                    outcome: recovered.outcome,
+                });
+            }
+            return results;
+        });
+    }
     close() {
         if (this.ownsDataStore)
             this.dataStore.close();
@@ -137,6 +202,55 @@ export class PiboDataSessionStore {
 export function createDefaultPiboDataSessionStore() {
     return new PiboDataSessionStore(new PiboDataStore());
 }
+function groupRunsByController(runs) {
+    const grouped = new Map();
+    for (const run of runs) {
+        const items = grouped.get(run.controllerPiboSessionId) ?? [];
+        items.push(run);
+        grouped.set(run.controllerPiboSessionId, items);
+    }
+    return grouped;
+}
+function recoveryOutcomeForTurn(turn, runs) {
+    if (turn.status === "queued") {
+        return {
+            status: "aborted",
+            summary: "Queued turn was interrupted by gateway restart before it could start.",
+        };
+    }
+    const timedOut = runs.find((run) => run.status === "timed_out");
+    if (timedOut) {
+        return {
+            status: "timeout",
+            summary: `Gateway restart recovery timed out yielded run ${timedOut.runId} before this turn completed.`,
+        };
+    }
+    const failed = runs.find((run) => run.status === "failed");
+    if (failed) {
+        return {
+            status: "error",
+            summary: `Gateway restart recovery failed yielded run ${failed.runId} before this turn completed.`,
+        };
+    }
+    const queued = runs.find((run) => run.status === "queued");
+    if (queued) {
+        return {
+            status: "aborted",
+            summary: `Gateway restart interrupted this turn; yielded run ${queued.runId} was queued for retry.`,
+        };
+    }
+    return {
+        status: "aborted",
+        summary: "Turn was interrupted by gateway restart.",
+    };
+}
+function recoveryEventId(turn) {
+    if (turn.eventId)
+        return turn.eventId;
+    if (turn.inputEventId)
+        return turn.inputEventId;
+    return turn.turnId.startsWith("turn_") ? turn.turnId.slice("turn_".length) : turn.turnId;
+}
 function sessionFromRow(row) {
     return {
         id: row.id,

package/dist/shared/trace-engine.js

@@ -1,5 +1,5 @@
 import { reconcileAsyncAgentRunStatuses } from "./trace-async-agent-runs.js";
-import { applySingleEventToNodes, contentDeltaPatchNodeId, dedupeTraceEvents, eventsCanAffectAsyncAgentRunStatus, findOpenTranscriptEventIds, isConfirmedUserMessageEcho, latestTraceStreamId, mergeMessageTurnTimings, messageTurnTimingsFromEvents, reconcileTranscriptUserMessageTimestamps, traceEventDedupeKey, } from "./trace-event-projection.js";
+import { applySingleEventToNodes, contentDeltaPatchNodeId, dedupeTraceEvents, eventsCanAffectAsyncAgentRunStatus, findOpenTranscriptEventIds, isConfirmedUserMessageEcho, latestTraceStreamId, mergeMessageTurnTimings, messageTurnTimingsFromEvents, reconcileTranscriptUserMessages, traceEventDedupeKey, } from "./trace-event-projection.js";
 import { flattenTraceNodes, mapTraceNodesById, nestTraceNodes } from "./trace-nodes.js";
 import { nestMutableCopiedTraceNodes, shareUnchangedTraceNodes } from "./trace-patch-nodes.js";
 import { mapTraceChildSessionsByParent, mapTraceSubagentSessionLinks, } from "./trace-subagent-links.js";
@@ -13,10 +13,10 @@ export function buildTraceViewFromEvents(input) {
     const events = dedupeTraceEvents(input.events);
     const allEntries = input.transcriptEntries ?? [];
     const openTranscriptEventIds = findOpenTranscriptEventIds(events, sessionStatus);
-    const entries = projectTranscriptEntries(allEntries, sessionStatus, openTranscriptEventIds);
     const turnTimings = mergeMessageTurnTimings(input.turnTimings ?? [], messageTurnTimingsFromEvents(events));
+    const entries = projectTranscriptEntries(allEntries, sessionStatus, openTranscriptEventIds, turnTimings);
     const nodes = traceNodesFromEntries(input.session.id, entries, turnTimings);
-    reconcileTranscriptUserMessageTimestamps(nodes, events);
+    reconcileTranscriptUserMessages(nodes, events, turnTimings);
     const byId = mapTraceNodesById(nodes);
     const childByParent = mapTraceChildSessionsByParent(input.sessions ?? []);
     const linkedChildByToolCallId = mapTraceSubagentSessionLinks(events);

package/dist/shared/trace-event-projection.js

@@ -30,7 +30,7 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
     }
     if (payload.type === "assistant_message") {
         const node = assistantMessageNodeFromEvent(piboSessionId, payload, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex);
-        const existing = byId.get(node.id);
+        const existing = byId.get(node.id) ?? findMatchingContentNode(byId, node);
         if (existing) {
             mergeAssistantMessageEvent(existing, node);
             return;
@@ -59,7 +59,7 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
         }
     }
     if (node.type === "assistant.message") {
-        const existing = byId.get(node.id);
+        const existing = byId.get(node.id) ?? findMatchingContentNode(byId, node);
         if (existing) {
             mergeAssistantMessageEvent(existing, node);
             return;
@@ -73,7 +73,7 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
         }
     }
     if (node.type === "model.reasoning") {
-        const existing = byId.get(node.id);
+        const existing = byId.get(node.id) ?? findMatchingContentNode(byId, node);
         if (existing) {
             mergeReasoningEvent(existing, node);
             return;
@@ -194,26 +194,77 @@ export function contentDeltaPatchNodeId(event) {
     }
     return undefined;
 }
-export function reconcileTranscriptUserMessageTimestamps(nodes, events) {
+export function reconcileTranscriptUserMessages(nodes, events, turnTimings = []) {
     const transcriptUsers = nodes.filter((node) => node.type === "user.message" && node.source === "transcript");
+    const timingByEventId = new Map(turnTimings.map((timing) => [timing.eventId, timing]));
+    let latestTranscriptUser;
+    for (const node of nodes) {
+        if (node.type === "user.message" && node.source === "transcript") {
+            latestTranscriptUser = node;
+            continue;
+        }
+        if (node.type !== "assistant.message" ||
+            node.source !== "transcript" ||
+            !node.eventId ||
+            !latestTranscriptUser ||
+            transcriptUserMessageHasCanonicalIdentity(latestTranscriptUser))
+            continue;
+        const timing = timingByEventId.get(node.eventId);
+        if (timing?.userText &&
+            normalizedUserMessageText(traceNodeText(latestTranscriptUser)) !== normalizedUserMessageText(timing.userText))
+            continue;
+        assignTranscriptUserMessageIdentity(latestTranscriptUser, timing);
+    }
+    let timingCursor = transcriptUsers.length - 1;
+    for (let timingIndex = turnTimings.length - 1; timingIndex >= 0; timingIndex -= 1) {
+        const timing = turnTimings[timingIndex];
+        const prompt = normalizedUserMessageText(timing.userText);
+        if (!prompt)
+            continue;
+        const exactMatchIndex = transcriptUsers.findIndex((node, index) => index <= timingCursor &&
+            !transcriptUserMessageHasCanonicalIdentity(node) &&
+            node.entryId === timing.eventId);
+        let matchIndex = exactMatchIndex;
+        if (matchIndex === -1 && (timing.userMessageType === "message_steered" || timing.completedAt)) {
+            for (let userIndex = timingCursor; userIndex >= 0; userIndex -= 1) {
+                const node = transcriptUsers[userIndex];
+                if (transcriptUserMessageHasCanonicalIdentity(node))
+                    continue;
+                if (normalizedUserMessageText(traceNodeText(node)) !== prompt)
+                    continue;
+                matchIndex = userIndex;
+                break;
+            }
+        }
+        if (matchIndex === -1)
+            continue;
+        const matchedNode = transcriptUsers[matchIndex];
+        assignTranscriptUserMessageIdentity(matchedNode, timing);
+        timingCursor = matchIndex - 1;
+    }
     let userCursor = 0;
     for (const storedEvent of events) {
         const event = storedEvent.payload;
         if ((event.type !== "message_queued" && event.type !== "message_steered") || event.source !== "user")
             continue;
-        const eventId = typeof event.eventId === "string" ? event.eventId : storedEvent.eventId;
+        const payloadEventId = typeof event.eventId === "string" ? event.eventId : undefined;
+        const eventId = payloadEventId ?? storedEvent.eventId;
+        const canonicalId = `event:${event.type}:${payloadEventId ?? cryptoSafeId(event)}`;
+        const stableKey = eventStableKey(event);
         const text = typeof event.text === "string" ? event.text : undefined;
-        const matchIndex = transcriptUsers.findIndex((node, index) => {
-            if (index < userCursor)
-                return false;
-            if (eventId && (node.entryId === eventId || node.stableKey === `entry:${eventId}`))
-                return true;
-            return Boolean(text && traceNodeText(node) === text);
-        });
+        const identityMatchIndex = transcriptUsers.findIndex((node) => transcriptUserMessageMatchesIdentity(node, canonicalId, stableKey, eventId));
+        const matchIndex = identityMatchIndex !== -1
+            ? identityMatchIndex
+            : transcriptUsers.findIndex((node, index) => index >= userCursor &&
+                !transcriptUserMessageHasCanonicalIdentity(node) &&
+                Boolean(text && traceNodeText(node) === text));
         if (matchIndex === -1)
             continue;
-        transcriptUsers[matchIndex].startedAt = storedEvent.createdAt;
-        userCursor = matchIndex + 1;
+        const matchedNode = transcriptUsers[matchIndex];
+        matchedNode.id = canonicalId;
+        matchedNode.stableKey = stableKey;
+        matchedNode.startedAt = storedEvent.createdAt;
+        userCursor = Math.max(userCursor, matchIndex + 1);
     }
 }
 export function isConfirmedUserMessageEcho(nodes, event) {
@@ -223,15 +274,46 @@ function confirmedUserMessageEchoNode(nodes, event) {
     const payload = event.payload;
     if ((payload.type !== "message_queued" && payload.type !== "message_steered") || payload.source !== "user")
         return undefined;
-    const eventId = typeof payload.eventId === "string" ? payload.eventId : event.eventId;
+    const payloadEventId = typeof payload.eventId === "string" ? payload.eventId : undefined;
+    const eventId = payloadEventId ?? event.eventId;
+    const canonicalId = `event:${payload.type}:${payloadEventId ?? cryptoSafeId(payload)}`;
+    const stableKey = eventStableKey(payload);
     const text = typeof payload.text === "string" ? payload.text : undefined;
-    return flattenTraceNodes([...nodes]).find((node) => {
-        if (node.type !== "user.message" || node.source !== "transcript")
-            return false;
-        if (eventId && (node.entryId === eventId || node.stableKey === `entry:${eventId}`))
-            return true;
-        return Boolean(text && traceNodeText(node) === text);
-    });
+    const transcriptUsers = flattenTraceNodes([...nodes]).filter((node) => node.type === "user.message" && node.source === "transcript");
+    const identityMatch = transcriptUsers.find((node) => transcriptUserMessageMatchesIdentity(node, canonicalId, stableKey, eventId));
+    if (identityMatch)
+        return identityMatch;
+    return transcriptUsers.find((node) => !transcriptUserMessageHasCanonicalIdentity(node) && Boolean(text && traceNodeText(node) === text));
+}
+function transcriptUserMessageMatchesIdentity(node, canonicalId, stableKey, eventId) {
+    if (node.id === canonicalId || node.stableKey === stableKey)
+        return true;
+    if (!eventId)
+        return false;
+    if (node.entryId === eventId || node.stableKey === `entry:${eventId}`)
+        return true;
+    return [node.id, node.stableKey].some((value) => canonicalUserMessageEventId(value) === eventId);
+}
+function transcriptUserMessageHasCanonicalIdentity(node) {
+    return [node.id, node.stableKey].some((value) => canonicalUserMessageEventId(value) !== undefined);
+}
+function canonicalUserMessageEventId(value) {
+    for (const prefix of ["event:message_queued:", "event:message_steered:"]) {
+        if (value?.startsWith(prefix))
+            return value.slice(prefix.length);
+    }
+    return undefined;
+}
+function assignTranscriptUserMessageIdentity(node, timing) {
+    if (!timing)
+        return;
+    const userMessageType = timing.userMessageType ?? "message_queued";
+    node.id = `event:${userMessageType}:${timing.eventId}`;
+    node.stableKey = `event:${userMessageType}:${timing.eventId}`;
+}
+function normalizedUserMessageText(value) {
+    const normalized = value?.replace(/\s+/g, " ").trim();
+    return normalized || undefined;
 }
 function traceNodeText(node) {
     if (typeof node.output === "string")
@@ -505,6 +587,11 @@ function mergeAssistantDeltaEvent(nodes, byId, event, sessionStatus, createdAt,
     nodes.push(node);
     byId.set(node.id, node);
 }
+function findMatchingContentNode(byId, update) {
+    if (!update.stableKey)
+        return undefined;
+    return [...byId.values()].find((candidate) => candidate.type === update.type && candidate.stableKey === update.stableKey);
+}
 function mergeAssistantMessageEvent(target, update) {
     target.status = update.status;
     target.summary = update.summary ?? target.summary;
@@ -517,7 +604,8 @@ function mergeThinkingDeltaEvent(nodes, byId, event, sessionStatus, createdAt, e
         return;
     const thinkingId = thinkingEventNodeId(event);
     const id = thinkingId ? thinkingNodeId(thinkingId) : `event:thinking_delta:${cryptoSafeId(event)}`;
-    const existing = byId.get(id);
+    const stableKey = thinkingId ? `reasoning:${thinkingId}` : id;
+    const existing = byId.get(id) ?? [...byId.values()].find((candidate) => candidate.type === "model.reasoning" && candidate.stableKey === stableKey);
     if (existing) {
         const text = `${typeof existing.output === "string" ? existing.output : ""}${event.text}`;
         existing.status = sessionStatus === "running" ? "running" : "done";
@@ -537,7 +625,7 @@ function mergeThinkingDeltaEvent(nodes, byId, event, sessionStatus, createdAt, e
         summary: event.text,
         output: event.text,
         source: "event-log",
-        stableKey: thinkingId ? `reasoning:${thinkingId}` : id,
+        stableKey,
         orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex),
         children: [],
     };
@@ -583,12 +671,17 @@ export function mergeMessageTurnTimings(...groups) {
             byEventId.set(timing.eventId, timing);
             continue;
         }
+        const reasoningIndices = mergeUniqueIndices(existing.reasoningIndices, timing.reasoningIndices);
+        const assistantIndices = mergeUniqueIndices(existing.assistantIndices, timing.assistantIndices);
         const merged = {
             eventId: timing.eventId,
             userText: timing.userText ?? existing.userText,
+            userMessageType: timing.userMessageType ?? existing.userMessageType,
             startedAt: timing.startedAt ?? existing.startedAt,
             completedAt: timing.completedAt ?? existing.completedAt,
             durationMs: timing.durationMs ?? existing.durationMs,
+            ...(reasoningIndices ? { reasoningIndices } : {}),
+            ...(assistantIndices ? { assistantIndices } : {}),
         };
         if (merged.durationMs === undefined) {
             const startedAtMs = parseTimestamp(merged.startedAt);
@@ -601,41 +694,74 @@ export function mergeMessageTurnTimings(...groups) {
     }
     return [...byEventId.values()];
 }
+function mergeUniqueIndices(first, second) {
+    if (!first?.length && !second?.length)
+        return undefined;
+    return [...new Set([...(first ?? []), ...(second ?? [])])];
+}
+function appendUniqueIndex(indices, partIndex) {
+    if (indices?.includes(partIndex))
+        return indices;
+    return [...(indices ?? []), partIndex];
+}
 export function messageTurnTimingsFromEvents(events) {
     const timings = new Map();
-    const completedEventIds = [];
-    const completedEventIdSet = new Set();
+    const eventIds = [];
+    const seenEventIds = new Set();
     const ignoredEventIds = new Set();
     for (const storedEvent of events) {
         const event = storedEvent.payload;
-        if (event.type !== "message_started" && event.type !== "message_finished")
+        if (event.type !== "message_queued" &&
+            event.type !== "message_steered" &&
+            event.type !== "message_started" &&
+            event.type !== "message_finished" &&
+            event.type !== "session_error" &&
+            event.type !== "thinking_finished" &&
+            event.type !== "assistant_message")
             continue;
         const eventId = typeof event.eventId === "string" ? event.eventId : undefined;
         if (!eventId)
             continue;
-        if (event.type === "message_started" && event.source === "service") {
+        if ((event.type === "message_queued" || event.type === "message_started") && event.source === "service") {
             ignoredEventIds.add(eventId);
             continue;
         }
         if (ignoredEventIds.has(eventId))
             continue;
+        if (!seenEventIds.has(eventId)) {
+            eventIds.push(eventId);
+            seenEventIds.add(eventId);
+        }
         const timing = timings.get(eventId) ?? {};
-        if (event.type === "message_started") {
+        if (event.type === "message_queued") {
+            timing.userText ??= event.text;
+        }
+        else if (event.type === "message_steered") {
+            timing.userText ??= event.text;
+            timing.userMessageType = "message_steered";
+        }
+        else if (event.type === "message_started") {
             timing.userText ??= event.text;
             timing.startedAt ??= storedEvent.createdAt;
         }
-        else {
+        else if (event.type === "message_finished" || event.type === "session_error") {
             timing.completedAt = storedEvent.createdAt;
-            if (!completedEventIdSet.has(eventId)) {
-                completedEventIds.push(eventId);
-                completedEventIdSet.add(eventId);
-            }
+        }
+        else if (event.type === "thinking_finished" && hasVisibleText(event.text)) {
+            const partIndex = typeof event.thinkingIndex === "number" ? event.thinkingIndex : event.contentIndex;
+            if (typeof partIndex === "number")
+                timing.reasoningIndices = appendUniqueIndex(timing.reasoningIndices, partIndex);
+        }
+        else if (event.type === "assistant_message" && hasVisibleText(event.text)) {
+            const partIndex = typeof event.assistantIndex === "number" ? event.assistantIndex : event.contentIndex;
+            if (typeof partIndex === "number")
+                timing.assistantIndices = appendUniqueIndex(timing.assistantIndices, partIndex);
         }
         timings.set(eventId, timing);
     }
-    return completedEventIds.flatMap((eventId) => {
+    return eventIds.flatMap((eventId) => {
         const timing = timings.get(eventId);
-        if (!timing?.completedAt)
+        if (!timing)
             return [];
         const startedAtMs = parseTimestamp(timing.startedAt);
         const completedAtMs = parseTimestamp(timing.completedAt);
@@ -643,10 +769,13 @@ export function messageTurnTimingsFromEvents(events) {
                 eventId,
                 userText: timing.userText,
                 startedAt: timing.startedAt,
+                ...(timing.userMessageType ? { userMessageType: timing.userMessageType } : {}),
                 completedAt: timing.completedAt,
                 durationMs: startedAtMs === undefined || completedAtMs === undefined
                     ? undefined
                     : Math.max(0, completedAtMs - startedAtMs),
+                ...(timing.reasoningIndices ? { reasoningIndices: timing.reasoningIndices } : {}),
+                ...(timing.assistantIndices ? { assistantIndices: timing.assistantIndices } : {}),
             }];
     });
 }

package/dist/shared/trace-nodes.js

@@ -19,14 +19,16 @@ function areTraceNodesSorted(nodes) {
     return true;
 }
 export function compareTraceNodes(left, right) {
-    const bySameTurnPhase = compareSameTurnPhase(left, right);
-    if (bySameTurnPhase !== 0)
-        return bySameTurnPhase;
-    if (left.orderKey?.sourceRank === right.orderKey?.sourceRank) {
+    if (left.orderKey && right.orderKey && left.orderKey.sourceRank === right.orderKey.sourceRank) {
         const bySameSourceOrder = compareTraceOrder(left.orderKey, right.orderKey);
         if (bySameSourceOrder !== 0)
             return bySameSourceOrder;
     }
+    else {
+        const bySameTurnPhase = compareSameTurnPhase(left, right);
+        if (bySameTurnPhase !== 0)
+            return bySameTurnPhase;
+    }
     const byStartTime = compareOptionalIsoTime(left.startedAt, right.startedAt);
     if (byStartTime !== 0)
         return byStartTime;

package/dist/shared/trace-page-merge.js

@@ -1,4 +1,5 @@
 import { flattenTraceNodes, nestTraceNodes } from "./trace-nodes.js";
+import { compareTraceOrder } from "./trace-order.js";
 export function mergeOlderTracePage(current, older) {
     if (current.piboSessionId !== older.piboSessionId)
         return current;
@@ -28,8 +29,8 @@ export function mergeRefreshedTracePage(current, refreshed) {
         return refreshed;
     return {
         ...refreshed,
-        nodes: mergeTraceNodes(current.nodes, refreshed.nodes),
-        rawEvents: current.rawEvents.length ? current.rawEvents : refreshed.rawEvents,
+        nodes: mergeRefreshedTraceNodes(current.nodes, refreshed),
+        rawEvents: mergeTraceRawEvents(current.rawEvents, refreshed.rawEvents),
         beforeCursor: current.beforeCursor,
         firstEventSequence: current.firstEventSequence ?? refreshed.firstEventSequence,
         nextBeforeSequence: current.nextBeforeSequence,
@@ -38,6 +39,109 @@ export function mergeRefreshedTracePage(current, refreshed) {
         eventLimit: current.eventLimit ?? refreshed.eventLimit,
     };
 }
+function mergeRefreshedTraceNodes(currentNodes, refreshed) {
+    const flattenedCurrentNodes = flattenTraceNodes([...currentNodes]);
+    const refreshedNodes = flattenTraceNodes([...refreshed.nodes]);
+    const refreshedIds = new Set(refreshedNodes.map((node) => node.id));
+    const canonicalTranscriptEventIds = transcriptEventIds([...flattenedCurrentNodes, ...refreshedNodes]);
+    const refreshedOrderBoundaries = earliestTraceNodeOrdersBySource(refreshedNodes);
+    const refreshedStartedAt = earliestTraceNodeTimestamp(refreshedNodes);
+    const retainedOlderNodes = flattenedCurrentNodes.filter((node) => {
+        if (refreshedIds.has(node.id))
+            return true;
+        if (node.type === "agent.turn" &&
+            node.source === "event-log" &&
+            node.eventId &&
+            canonicalTranscriptEventIds.has(node.eventId))
+            return false;
+        if (isTransientTailNode(node))
+            return false;
+        const eventSequence = node.orderKey?.eventSequence;
+        if (eventSequence !== undefined && refreshed.firstEventSequence !== undefined) {
+            return eventSequence < refreshed.firstEventSequence;
+        }
+        const refreshedOrderBoundary = node.orderKey
+            ? refreshedOrderBoundaries.get(node.orderKey.sourceRank)
+            : undefined;
+        if (node.orderKey && refreshedOrderBoundary) {
+            return compareTraceOrder(node.orderKey, refreshedOrderBoundary) < 0;
+        }
+        if (node.source === "live" || node.orderKey?.streamId !== undefined)
+            return false;
+        const startedAt = parseTimestamp(node.startedAt);
+        return startedAt !== undefined && refreshedStartedAt !== undefined && startedAt < refreshedStartedAt;
+    });
+    const mergedIds = new Set([...retainedOlderNodes, ...refreshedNodes].map((node) => node.id));
+    const removedCurrentIds = new Set(flattenedCurrentNodes
+        .filter((node) => !mergedIds.has(node.id))
+        .map((node) => node.id));
+    return mergeTraceNodes(clearRemovedParentIds(retainedOlderNodes, removedCurrentIds), clearRemovedParentIds(refreshedNodes, removedCurrentIds));
+}
+function clearRemovedParentIds(nodes, removedIds) {
+    return nodes.map((node) => node.parentId && removedIds.has(node.parentId)
+        ? { ...node, parentId: undefined }
+        : node);
+}
+function transcriptEventIds(nodes) {
+    const eventIds = new Set();
+    for (const node of nodes) {
+        if (node.source === "transcript" && node.eventId)
+            eventIds.add(node.eventId);
+    }
+    return eventIds;
+}
+function isTransientTailNode(node) {
+    return node.source === "live" || node.orderKey?.streamId !== undefined;
+}
+function earliestTraceNodeOrdersBySource(nodes) {
+    const earliestBySource = new Map();
+    for (const node of nodes) {
+        if (!node.orderKey)
+            continue;
+        const earliest = earliestBySource.get(node.orderKey.sourceRank);
+        if (!earliest || compareTraceOrder(node.orderKey, earliest) < 0) {
+            earliestBySource.set(node.orderKey.sourceRank, node.orderKey);
+        }
+    }
+    return earliestBySource;
+}
+function earliestTraceNodeTimestamp(nodes) {
+    let earliest;
+    for (const node of nodes) {
+        const startedAt = parseTimestamp(node.startedAt);
+        if (startedAt === undefined)
+            continue;
+        earliest = earliest === undefined ? startedAt : Math.min(earliest, startedAt);
+    }
+    return earliest;
+}
+function parseTimestamp(value) {
+    if (!value)
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function mergeTraceRawEvents(currentEvents, refreshedEvents) {
+    if (!refreshedEvents.length)
+        return currentEvents;
+    const firstRefreshedSequence = refreshedEvents.reduce((first, event) => {
+        if (event.eventSequence === undefined)
+            return first;
+        return first === undefined ? event.eventSequence : Math.min(first, event.eventSequence);
+    }, undefined);
+    const byKey = new Map();
+    for (const event of currentEvents) {
+        if (firstRefreshedSequence !== undefined && event.eventSequence !== undefined && event.eventSequence >= firstRefreshedSequence)
+            continue;
+        byKey.set(traceRawEventKey(event), event);
+    }
+    for (const event of refreshedEvents)
+        byKey.set(traceRawEventKey(event), event);
+    return [...byKey.values()];
+}
+function traceRawEventKey(event) {
+    return event.id || `${event.eventSequence ?? ""}:${event.type}:${event.createdAt}`;
+}
 function mergeTraceNodes(olderNodes, currentNodes) {
     const byId = new Map();
     for (const node of flattenTraceNodes([...olderNodes])) {