@pasko70/pibo 3.0.1 → 3.1.0

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

@@ -3,10 +3,19 @@ import { compareTraceNodes, flattenTraceNodes } from "./trace-nodes.js";
 import { attachAsyncAgentRunNode, isRunStartToolNode } from "./trace-async-agent-runs.js";
 import { createRunNotificationNode, parseRunNotificationText } from "./trace-run-notifications.js";
 import { findLikelyTraceChildSession, isSubagentToolName, } from "./trace-subagent-links.js";
+import { qualifiedToolNodeId } from "./trace-tool-identity.js";
 export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent, childByParent, linkedChildByToolCallId, historyCoverage, openTranscriptEventIds, sessionStatus) {
     const payload = storedEvent.payload;
+    if (payload.type === "message_started" && payload.source === "user" && payload.eventId) {
+        const persistedUser = flattenTraceNodes([...nodes]).find((node) => node.type === "user.message"
+            && isPersistedHistorySource(node.source)
+            && node.eventId === payload.eventId);
+        if (persistedUser)
+            applyRenderSequence(persistedUser, storedEvent, payload);
+    }
     const confirmedUserMessage = historyCoverage.mode !== "none" ? confirmedUserMessageEchoNode(nodes, storedEvent) : undefined;
     if (confirmedUserMessage) {
+        applyRenderSequence(confirmedUserMessage, storedEvent, payload);
         if (payload.type === "message_steered" && payload.activeEventId) {
             confirmedUserMessage.parentId = messageTurnNodeId(payload.activeEventId);
         }
@@ -16,21 +25,23 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
         || (historyCoverage.mode === "product" && isProductHistoryEchoEvent(payload))) &&
         historyCoversEvent(payload, historyCoverage) &&
         !shouldKeepTranscriptEchoEvent(payload, openTranscriptEventIds)) {
+        applyRenderSequenceToHistoryNode(byId, storedEvent, payload);
         return;
     }
     if (isNativeHistoryToolEchoEvent(payload, historyCoverage, sessionStatus)) {
+        applyRenderSequenceToHistoryNode(byId, storedEvent, payload);
         return;
     }
     if (payload.type === "assistant_delta") {
-        mergeAssistantDeltaEvent(nodes, byId, payload, sessionStatus, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource);
+        mergeAssistantDeltaEvent(nodes, byId, payload, sessionStatus, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource, storedEvent.id);
         return;
     }
     if (payload.type === "thinking_delta") {
-        mergeThinkingDeltaEvent(nodes, byId, payload, sessionStatus, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource);
+        mergeThinkingDeltaEvent(nodes, byId, payload, sessionStatus, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource, storedEvent.id);
         return;
     }
     if (payload.type === "assistant_message") {
-        const node = assistantMessageNodeFromEvent(piboSessionId, payload, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource);
+        const node = assistantMessageNodeFromEvent(piboSessionId, payload, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource, storedEvent.id);
         const existing = byId.get(node.id) ?? findMatchingContentNode(byId, node);
         if (existing) {
             mergeAssistantMessageEvent(existing, node);
@@ -40,7 +51,7 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
         byId.set(node.id, node);
         return;
     }
-    const node = traceNodeFromEvent(piboSessionId, payload, childByParent, linkedChildByToolCallId, sessionStatus, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource);
+    const node = traceNodeFromEvent(piboSessionId, payload, childByParent, linkedChildByToolCallId, sessionStatus, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource, storedEvent.id);
     if (!node)
         return;
     applyStoredPayloadRef(node, payload, storedEvent.storedPayloadRef);
@@ -89,8 +100,7 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
         }
     }
     if (node.toolCallId) {
-        const existing = [...byId.values()].find((candidate) => candidate.toolCallId === node.toolCallId &&
-            (candidate.type === "tool.call" || candidate.type === "agent.delegation"));
+        const existing = byId.get(node.id) ?? findUniqueLegacyToolTarget(byId, node, payload);
         if (existing) {
             if (isRunStartToolNode(existing) && node.type === "agent.delegation") {
                 attachAsyncAgentRunNode(existing, piboSessionId, storedEvent.createdAt, node);
@@ -125,6 +135,36 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
     for (const indexed of flattenTraceNodes([node]))
         byId.set(indexed.id, indexed);
 }
+function findUniqueLegacyToolTarget(byId, update, event) {
+    if ("eventId" in event && event.eventId)
+        return undefined;
+    const candidates = [...byId.values()].filter((candidate) => candidate.toolCallId === update.toolCallId
+        && (candidate.type === "tool.call" || candidate.type === "tool.result" || candidate.type === "agent.delegation"));
+    return candidates.length === 1 ? candidates[0] : undefined;
+}
+function applyRenderSequenceToHistoryNode(byId, storedEvent, event) {
+    const stableKey = eventStableKey(event, traceEventInstanceKey(storedEvent.eventSequence, storedEvent.streamId, event, storedEvent.id));
+    const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
+    const target = [...byId.values()].find((node) => node.stableKey === stableKey
+        || ("toolCallId" in event
+            && typeof event.toolCallId === "string"
+            && node.toolCallId === event.toolCallId
+            && (!eventId || !node.eventId || node.eventId === eventId)));
+    if (target)
+        applyRenderSequence(target, storedEvent, event);
+}
+function applyRenderSequence(node, storedEvent, event) {
+    const renderSequence = storedEvent.renderSequence ?? event.renderSequence;
+    const eventSequence = storedEvent.eventSequence ?? storedEvent.streamId;
+    if (renderSequence === undefined && eventSequence === undefined)
+        return;
+    const orderKey = node.orderKey ?? eventTraceOrder(eventSequence, eventNodeKind(event.type));
+    node.orderKey = {
+        ...orderKey,
+        ...(eventSequence === undefined ? {} : { turnSeq: eventSequence, eventSequence }),
+        ...(renderSequence === undefined ? {} : { renderSequence }),
+    };
+}
 function applyStoredPayloadRef(node, event, storedPayloadRef) {
     if (!storedPayloadRef)
         return;
@@ -135,10 +175,11 @@ function applyStoredPayloadRef(node, event, storedPayloadRef) {
         node.payloadRefs = { ...node.payloadRefs, output: storedPayloadRef };
     }
 }
-function assistantMessageNodeFromEvent(piboSessionId, event, createdAt, eventSequence, streamId, streamFrameIndex, traceSource) {
+function assistantMessageNodeFromEvent(piboSessionId, event, createdAt, eventSequence, streamId, streamFrameIndex, traceSource, storedInstanceId) {
     const eventId = typeof event.eventId === "string" ? event.eventId : undefined;
     const assistantId = assistantEventNodeId(event);
-    const id = assistantId ? assistantMessageNodeId(assistantId) : `event:${event.type}:${cryptoSafeId(event)}`;
+    const fallbackIdentity = traceEventInstanceKey(eventSequence, streamId, event, storedInstanceId);
+    const id = assistantId ? assistantMessageNodeId(assistantId) : `event:${event.type}:${fallbackIdentity}`;
     return {
         id,
         piboSessionId,
@@ -152,8 +193,8 @@ function assistantMessageNodeFromEvent(piboSessionId, event, createdAt, eventSeq
         summary: event.text,
         output: event.text,
         source: "event-log",
-        stableKey: assistantId ? `assistant:${assistantId}` : eventStableKey(event),
-        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex, traceSource),
+        stableKey: assistantId ? `assistant:${assistantId}` : eventStableKey(event, fallbackIdentity),
+        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex, traceSource, event.renderSequence, createdAt),
         children: [],
     };
 }
@@ -267,8 +308,9 @@ export function reconcileTranscriptUserMessages(nodes, events, turnTimings = [])
             continue;
         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 fallbackIdentity = storedEvent.id ? `instance:${storedEvent.id}` : liveProjectionIdentity(event);
+        const canonicalId = `event:${event.type}:${payloadEventId ?? fallbackIdentity}`;
+        const stableKey = eventStableKey(event, fallbackIdentity);
         const text = typeof event.text === "string" ? event.text : undefined;
         const identityMatchIndex = transcriptUsers.findIndex((node) => transcriptUserMessageMatchesIdentity(node, canonicalId, stableKey, eventId));
         const matchIndex = identityMatchIndex !== -1
@@ -294,8 +336,9 @@ function confirmedUserMessageEchoNode(nodes, event) {
         return undefined;
     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 fallbackIdentity = event.id ? `instance:${event.id}` : liveProjectionIdentity(payload);
+    const canonicalId = `event:${payload.type}:${payloadEventId ?? fallbackIdentity}`;
+    const stableKey = eventStableKey(payload, fallbackIdentity);
     const text = typeof payload.text === "string" ? payload.text : undefined;
     const transcriptUsers = flattenTraceNodes([...nodes]).filter((node) => node.type === "user.message" && isPersistedHistorySource(node.source));
     const identityMatch = transcriptUsers.find((node) => transcriptUserMessageMatchesIdentity(node, canonicalId, stableKey, eventId));
@@ -377,9 +420,10 @@ export function latestTraceStreamId(events, initial) {
     return latest;
 }
 // ── event → node helpers ─────────────────────────────────────────
-function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByToolCallId, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex, traceSource) {
+function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByToolCallId, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex, traceSource, storedInstanceId) {
     const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
-    const id = `event:${event.type}:${eventId ?? cryptoSafeId(event)}`;
+    const fallbackIdentity = traceEventInstanceKey(eventSequence, streamId, event, storedInstanceId);
+    const id = `event:${event.type}:${eventId ?? fallbackIdentity}`;
     const turnParentId = eventId ? messageTurnNodeId(eventId) : undefined;
     const base = {
         id,
@@ -387,8 +431,8 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
         eventId,
         startedAt: createdAt,
         source: "event-log",
-        stableKey: eventStableKey(event),
-        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex, traceSource),
+        stableKey: eventStableKey(event, fallbackIdentity),
+        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex, traceSource, event.renderSequence, createdAt),
         children: [],
     };
     switch (event.type) {
@@ -403,7 +447,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                     startedAt: createdAt,
                     source: "event-log",
                     stableKey: eventId ? `run-notification:${eventId}` : id,
-                    orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex, traceSource),
+                    orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex, traceSource, event.renderSequence, createdAt),
                     notification,
                 });
             }
@@ -419,8 +463,6 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
         }
         case "message_started":
         case "message_finished":
-            if (event.source === "service")
-                return undefined;
             return {
                 ...base,
                 id: eventId ? messageTurnNodeId(eventId) : id,
@@ -466,16 +508,18 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
         case "tool_execution_started":
         case "tool_execution_updated":
         case "tool_execution_finished": {
+            const toolNodeId = toolInvocationNodeId(event);
             const subagentTool = isSubagentToolName(event.toolName);
-            const linkedPiboSessionId = linkedChildByToolCallId.get(event.toolCallId) ??
+            const linkedPiboSessionId = linkedChildByToolCallId.get(toolNodeId) ??
                 (subagentTool
                     ? findLikelyTraceChildSession(piboSessionId, event.toolName, event, childByParent)
                     : undefined);
             return {
                 ...base,
-                id: `tool:${event.toolCallId}`,
+                id: toolNodeId,
                 parentId: turnParentId,
                 toolCallId: event.toolCallId,
+                toolInvocationOrdinal: event.toolInvocationOrdinal ?? 0,
                 intent: event.intent,
                 type: subagentTool ? "agent.delegation" : "tool.call",
                 title: event.toolName,
@@ -498,26 +542,28 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                     ? stringifyPreview(event.result)
                     : undefined,
                 linkedPiboSessionId,
-                stableKey: `tool:${event.toolCallId}`,
+                stableKey: toolNodeId,
                 children: [],
             };
         }
         case "subagent_session": {
             const childPiboSessionId = nonEmptyString(event.childPiboSessionId);
-            const eventInstanceKey = traceEventInstanceKey(eventSequence, streamId, event);
+            const eventInstanceKey = traceEventInstanceKey(eventSequence, streamId, event, storedInstanceId);
+            const toolNodeId = event.toolCallId ? toolInvocationNodeId(event) : undefined;
             return {
                 ...base,
-                id: event.toolCallId ? `tool:${event.toolCallId}` : `event:subagent_session:${eventInstanceKey}`,
+                id: toolNodeId ?? `event:subagent_session:${eventInstanceKey}`,
                 eventId,
                 toolCallId: event.toolCallId,
+                toolInvocationOrdinal: event.toolInvocationOrdinal,
                 type: "agent.delegation",
                 title: event.toolName,
                 status: sessionStatus === "running" ? "running" : "done",
                 summary: event.subagentName,
                 input: { subagentName: event.subagentName, threadKey: event.threadKey },
                 linkedPiboSessionId: childPiboSessionId,
-                stableKey: event.toolCallId
-                    ? `tool:${event.toolCallId}`
+                stableKey: toolNodeId
+                    ? toolNodeId
                     : childPiboSessionId ? `subagent:${childPiboSessionId}` : `subagent:event:${eventInstanceKey}`,
                 children: [],
             };
@@ -534,7 +580,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 output: event.result,
             };
         case "compaction_start": {
-            const eventInstanceKey = traceEventInstanceKey(eventSequence, streamId, event);
+            const eventInstanceKey = traceEventInstanceKey(eventSequence, streamId, event, storedInstanceId);
             return {
                 ...base,
                 id: `event:compaction:${eventInstanceKey}`,
@@ -547,7 +593,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
             };
         }
         case "compaction_end": {
-            const eventInstanceKey = traceEventInstanceKey(eventSequence, streamId, event);
+            const eventInstanceKey = traceEventInstanceKey(eventSequence, streamId, event, storedInstanceId);
             return {
                 ...base,
                 id: `event:compaction:end:${eventInstanceKey}`,
@@ -577,11 +623,12 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
             return undefined;
     }
 }
-function mergeAssistantDeltaEvent(nodes, byId, event, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex, traceSource) {
+function mergeAssistantDeltaEvent(nodes, byId, event, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex, traceSource, storedInstanceId) {
     if (typeof event.text !== "string" || event.text.length === 0)
         return;
     const assistantId = assistantEventNodeId(event);
-    const id = assistantId ? assistantMessageNodeId(assistantId) : `event:assistant_delta:${cryptoSafeId(event)}`;
+    const fallbackIdentity = traceEventInstanceKey(eventSequence, streamId, event, storedInstanceId);
+    const id = assistantId ? assistantMessageNodeId(assistantId) : `event:assistant_delta:${fallbackIdentity}`;
     const existing = byId.get(id);
     if (existing) {
         const text = `${typeof existing.output === "string" ? existing.output : ""}${event.text}`;
@@ -603,7 +650,7 @@ function mergeAssistantDeltaEvent(nodes, byId, event, sessionStatus, createdAt,
         output: event.text,
         source: "event-log",
         stableKey: assistantId ? `assistant:${assistantId}` : id,
-        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex, traceSource),
+        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex, traceSource, event.renderSequence, createdAt),
         children: [],
     };
     nodes.push(node);
@@ -621,11 +668,12 @@ function mergeAssistantMessageEvent(target, update) {
     target.error = update.error ?? target.error;
     target.completedAt = update.completedAt ?? target.completedAt;
 }
-function mergeThinkingDeltaEvent(nodes, byId, event, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex, traceSource) {
+function mergeThinkingDeltaEvent(nodes, byId, event, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex, traceSource, storedInstanceId) {
     if (typeof event.text !== "string" || event.text.length === 0)
         return;
     const thinkingId = thinkingEventNodeId(event);
-    const id = thinkingId ? thinkingNodeId(thinkingId) : `event:thinking_delta:${cryptoSafeId(event)}`;
+    const fallbackIdentity = traceEventInstanceKey(eventSequence, streamId, event, storedInstanceId);
+    const id = thinkingId ? thinkingNodeId(thinkingId) : `event:thinking_delta:${fallbackIdentity}`;
     const stableKey = thinkingId ? `reasoning:${thinkingId}` : id;
     const existing = byId.get(id) ?? [...byId.values()].find((candidate) => candidate.type === "model.reasoning" && candidate.stableKey === stableKey);
     if (existing) {
@@ -648,7 +696,7 @@ function mergeThinkingDeltaEvent(nodes, byId, event, sessionStatus, createdAt, e
         output: event.text,
         source: "event-log",
         stableKey,
-        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex, traceSource),
+        orderKey: eventTraceNodeOrder(eventSequence, event.type, streamId, streamFrameIndex, traceSource, event.renderSequence, createdAt),
         children: [],
     };
     nodes.push(node);
@@ -848,11 +896,24 @@ function isOpenTranscriptEvent(event) {
         event.type === "thinking_delta" ||
         event.type === "thinking_finished");
 }
-function eventTraceNodeOrder(eventSequence, type, streamId, streamFrameIndex, traceSource) {
-    if (traceSource === "live") {
-        return liveTraceOrder(streamId, streamFrameIndex, eventNodeKind(type));
-    }
-    return eventTraceOrder(eventSequence, eventNodeKind(type));
+function eventTraceNodeOrder(eventSequence, type, streamId, streamFrameIndex, traceSource, renderSequence, createdAt) {
+    const order = traceSource === "live"
+        ? liveTraceOrder(streamId, streamFrameIndex, eventNodeKind(type))
+        : eventTraceOrder(eventSequence ?? streamId, eventNodeKind(type));
+    // Modern render sequences encode the first-visible millisecond plus a local
+    // slot. Deriving chronology from that immutable segment position keeps a
+    // live node in the same place when its persisted final receives a later
+    // database created_at timestamp.
+    const renderChronologyMs = renderSequence !== undefined && renderSequence >= 946_684_800_000_000
+        ? Math.floor(renderSequence / 1_000)
+        : undefined;
+    const chronologyMs = renderChronologyMs
+        ?? (createdAt && Number.isFinite(Date.parse(createdAt)) ? Date.parse(createdAt) : undefined);
+    return {
+        ...order,
+        ...(renderSequence === undefined ? {} : { renderSequence }),
+        ...(chronologyMs === undefined ? {} : { chronologyMs }),
+    };
 }
 function eventNodeKind(type) {
     switch (type) {
@@ -886,16 +947,16 @@ function eventNodeKind(type) {
             return "execution.command";
     }
 }
-function eventStableKey(event) {
+function eventStableKey(event, fallbackIdentity) {
     const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
     if (event.type === "tool_call" ||
         event.type === "tool_execution_started" ||
         event.type === "tool_execution_updated" ||
         event.type === "tool_execution_finished") {
-        return `tool:${event.toolCallId}`;
+        return toolInvocationNodeId(event);
     }
     if (event.type === "subagent_session" && event.toolCallId)
-        return `tool:${event.toolCallId}`;
+        return toolInvocationNodeId(event);
     if (eventId && (event.type === "message_started" || event.type === "message_finished"))
         return `turn:${eventId}`;
     if (event.type === "thinking_started" ||
@@ -910,7 +971,7 @@ function eventStableKey(event) {
         if (assistantId)
             return `assistant:${assistantId}`;
     }
-    return `event:${event.type}:${eventId ?? cryptoSafeId(event)}`;
+    return `event:${event.type}:${eventId ?? fallbackIdentity ?? liveProjectionIdentity(event)}`;
 }
 export function messageTurnNodeId(eventId) {
     return `event:message:${eventId}`;
@@ -1016,36 +1077,32 @@ function parseTimestamp(value) {
     const timestamp = new Date(value).getTime();
     return Number.isFinite(timestamp) ? timestamp : undefined;
 }
-function traceEventInstanceKey(eventSequence, streamId, event) {
+function traceEventInstanceKey(eventSequence, streamId, event, storedInstanceId) {
     if (eventSequence !== undefined)
         return `sequence:${eventSequence}`;
     if (streamId !== undefined)
         return `stream:${streamId}`;
-    return cryptoSafeId(event);
+    if (storedInstanceId)
+        return `instance:${storedInstanceId}`;
+    return liveProjectionIdentity(event);
+}
+function toolInvocationNodeId(event) {
+    const eventId = event.eventId
+        ?? (event.renderSequence !== undefined ? `render:${event.renderSequence}` : "unscoped");
+    return qualifiedToolNodeId(event.toolCallId ?? "unlinked", eventId, event.toolInvocationOrdinal ?? 0);
 }
 function nonEmptyString(value) {
     if (typeof value !== "string")
         return undefined;
     return value.trim() || undefined;
 }
-function cryptoSafeId(value) {
-    return base64UrlEncode(new TextEncoder().encode(JSON.stringify(value))).slice(0, 48);
-}
-function base64UrlEncode(bytes) {
-    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-    let output = "";
-    let index = 0;
-    for (; index + 2 < bytes.length; index += 3) {
-        const value = (bytes[index] << 16) | (bytes[index + 1] << 8) | bytes[index + 2];
-        output += alphabet[(value >> 18) & 63] + alphabet[(value >> 12) & 63] + alphabet[(value >> 6) & 63] + alphabet[value & 63];
-    }
-    if (index < bytes.length) {
-        const first = bytes[index];
-        const second = index + 1 < bytes.length ? bytes[index + 1] : 0;
-        const value = (first << 16) | (second << 8);
-        output += alphabet[(value >> 18) & 63] + alphabet[(value >> 12) & 63];
-        if (index + 1 < bytes.length)
-            output += alphabet[(value >> 6) & 63];
-    }
-    return output;
+function liveProjectionIdentity(value) {
+    const existing = liveProjectionIdentityCache.get(value);
+    if (existing)
+        return existing;
+    const identity = `live:${++liveProjectionIdentitySequence}`;
+    liveProjectionIdentityCache.set(value, identity);
+    return identity;
 }
+const liveProjectionIdentityCache = new WeakMap();
+let liveProjectionIdentitySequence = 0;

package/dist/shared/trace-history.js

@@ -1,12 +1,12 @@
 import { historyReconciliationDigest, historyReconciliationEntrySignature, } from "../agent-runtime/history.js";
 import { historyTraceOrder } from "./trace-order.js";
 import { attachAsyncAgentRunNode, reconcileAsyncAgentRunStatuses } from "./trace-async-agent-runs.js";
-import { sortTraceNodes } from "./trace-nodes.js";
+import { flattenTraceNodes, sortTraceNodes } from "./trace-nodes.js";
 import { createRunNotificationNode, parseRunNotificationText } from "./trace-run-notifications.js";
 import { isSubagentToolName } from "./trace-subagent-links.js";
 import { assistantMessageNodeId, messageTurnNodeId, thinkingNodeId } from "./trace-event-projection.js";
 import { TRACE_RECONCILIATION_ENTRY_CAP, TRACE_RECONCILIATION_TIMING_CAP } from "./trace-limits.js";
-import { qualifiedHistoryToolNodeId } from "./trace-tool-identity.js";
+import { qualifiedToolNodeId } from "./trace-tool-identity.js";
 const MAX_CONFIDENT_TIMESTAMP_DISTANCE_MS = 5 * 60 * 1_000;
 const PERSISTED_TIMESTAMP_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?(Z|([+-])(\d{2}):(\d{2}))$/;
 export function projectHistoryEntries(entries, sessionStatus, openHistoryEventIds, turnTimings = [], reconciliationProof, reconciliationAuthoritative = false) {
@@ -73,15 +73,44 @@ export function traceNodesFromHistoryEntries(piboSessionId, entries, turnTimings
                 output: { name: entry.name },
                 source,
                 stableKey: historyEntryStableKey(entry),
-                orderKey: historyTraceOrder(entryIndex, 0, "execution.command", source),
+                orderKey: historyTraceOrder(entryIndex, 0, "execution.command", source, entry.createdAt),
                 children: [],
             });
         }
     }
+    applyMonotoneHistoryChronology(nodes, entries);
     reconcileAsyncAgentRunStatuses(nodes);
     sortTraceNodes(nodes);
     return nodes;
 }
+function applyMonotoneHistoryChronology(nodes, entries) {
+    const nextValid = new Array(entries.length);
+    let next;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const parsed = parsedTimestamp(entries[index]?.createdAt);
+        if (parsed !== undefined)
+            next = parsed;
+        nextValid[index] = next;
+    }
+    const chronologyByIndex = new Map();
+    let previous;
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        const parsed = parsedTimestamp(entry.createdAt);
+        const candidate = parsed ?? nextValid[index] ?? previous;
+        if (candidate === undefined)
+            continue;
+        const monotone = previous === undefined ? candidate : Math.max(previous, candidate);
+        chronologyByIndex.set(historyIndex(entry, index), monotone);
+        previous = monotone;
+    }
+    for (const node of flattenTraceNodes(nodes)) {
+        if (!node.orderKey)
+            continue;
+        const chronologyMs = chronologyByIndex.get(node.orderKey.transcriptIndex ?? node.orderKey.turnSeq);
+        node.orderKey = { ...node.orderKey, chronologyMs };
+    }
+}
 function collectHistoryTurnTimingTargets(entries) {
     const targets = [];
     let latestUserText;
@@ -630,6 +659,8 @@ function findConfidentTimingMatch(target, turnTimings) {
 }
 function collectAssistantTurn(entries, startIndex) {
     const turnEntries = [];
+    const first = entries[startIndex];
+    const explicitTurnId = first?.type === "message" ? first.turnId : undefined;
     let index = startIndex;
     while (index < entries.length) {
         const entry = entries[index];
@@ -637,6 +668,8 @@ function collectAssistantTurn(entries, startIndex) {
             break;
         if (entry.role !== "assistant" && entry.role !== "tool")
             break;
+        if (index !== startIndex && explicitTurnId && entry.turnId && entry.turnId !== explicitTurnId)
+            break;
         turnEntries.push({ entry, index });
         index += 1;
     }
@@ -653,7 +686,7 @@ function createUserMessageNode(piboSessionId, entry, entryIndex, timing, fallbac
             entryId: entry.nativeEntryId,
             piboSessionId,
             startedAt: entry.createdAt,
-            orderKey: historyTraceOrder(orderIndex, 0, "yielded.run", source),
+            orderKey: historyTraceOrder(orderIndex, 0, "yielded.run", source, entry.createdAt),
             source,
             stableKey: historyEntryStableKey(entry),
             notification,
@@ -680,7 +713,7 @@ function createUserMessageNode(piboSessionId, entry, entryIndex, timing, fallbac
         error: entry.error,
         source,
         stableKey: eventIdentity ?? historyEntryStableKey(entry),
-        orderKey: historyTraceOrder(orderIndex, 0, "user.message", source),
+        orderKey: historyTraceOrder(orderIndex, 0, "user.message", source, entry.createdAt),
         children: [],
     };
 }
@@ -783,7 +816,7 @@ function createReasoningNode(input) {
         output: input.thinking,
         source,
         stableKey: eventIdentity ? `reasoning:${eventIdentity}` : `${historyEntryStableKey(input.entry)}:thinking:${input.contentPartIndex}`,
-        orderKey: historyTraceOrder(historyIndex(input.entry, input.entryIndex), input.contentPartIndex, "model.reasoning", source),
+        orderKey: historyTraceOrder(historyIndex(input.entry, input.entryIndex), input.contentPartIndex, "model.reasoning", source, input.entry.createdAt),
         children: [],
     };
 }
@@ -798,6 +831,7 @@ function createToolCallNode(piboSessionId, entry, entryIndex, contentPartIndex,
         eventId,
         parentId: historyTurnParentId(entry, eventId),
         toolCallId: part.toolCallId,
+        toolInvocationOrdinal,
         type: isSubagentToolName(part.toolName) ? "agent.delegation" : "tool.call",
         title: part.toolName,
         status: "done",
@@ -805,7 +839,7 @@ function createToolCallNode(piboSessionId, entry, entryIndex, contentPartIndex,
         input: part.input ?? {},
         source,
         stableKey: toolNodeId,
-        orderKey: historyTraceOrder(historyIndex(entry, entryIndex), contentPartIndex, isSubagentToolName(part.toolName) ? "agent.delegation" : "tool.call", source),
+        orderKey: historyTraceOrder(historyIndex(entry, entryIndex), contentPartIndex, isSubagentToolName(part.toolName) ? "agent.delegation" : "tool.call", source, entry.createdAt),
         children: [],
     };
 }
@@ -840,13 +874,14 @@ function createMissingToolResultNode(piboSessionId, entry, entryIndex, toolCallI
         eventId,
         parentId: historyTurnParentId(entry, eventId),
         toolCallId,
+        toolInvocationOrdinal,
         type: "tool.result",
         title: entry.toolName ?? "Tool Result",
         status: "done",
         startedAt: entry.createdAt,
         source,
         stableKey: toolNodeId,
-        orderKey: historyTraceOrder(historyIndex(entry, entryIndex), 0, "tool.result", source),
+        orderKey: historyTraceOrder(historyIndex(entry, entryIndex), 0, "tool.result", source, entry.createdAt),
         children: [],
     };
 }
@@ -870,7 +905,7 @@ function createAssistantMessageNode(input) {
         error: input.error,
         source,
         stableKey: eventIdentity ? `assistant:${eventIdentity}` : `${historyEntryStableKey(input.entry)}:response:${input.contentPartIndex}`,
-        orderKey: historyTraceOrder(historyIndex(input.entry, input.entryIndex), input.contentPartIndex, "assistant.message", source),
+        orderKey: historyTraceOrder(historyIndex(input.entry, input.entryIndex), input.contentPartIndex, "assistant.message", source, input.startedAt ?? input.entry.createdAt),
         children: input.children ?? [],
     };
 }
@@ -890,6 +925,8 @@ function historyMessageStatus(entry) {
     return "done";
 }
 function canonicalProductTurnId(entry, timing, fallbackEventId) {
+    if (entry.source === "product" && entry.turnId)
+        return entry.turnId;
     return fallbackEventId ?? timing?.eventId ?? entry.turnId;
 }
 function nativeHistoryTurnId(entry) {
@@ -904,9 +941,7 @@ function historyEntryNodeId(entry) {
     return entry.source === "native" && entry.nativeEntryId ? `entry:${entry.nativeEntryId}` : `history:${entry.id}`;
 }
 function historyToolNodeId(entry, toolCallId, eventId, toolInvocationOrdinal, qualifyProjectionIdentity) {
-    if (entry.source !== "native" || !qualifyProjectionIdentity)
-        return `tool:${toolCallId}`;
-    return qualifiedHistoryToolNodeId(toolCallId, eventId ?? `native-history-tool:${entry.historyPosition ?? entry.id}`, toolInvocationOrdinal);
+    return qualifiedToolNodeId(toolCallId, eventId ?? `native-history-tool:${entry.historyPosition ?? entry.id}`, toolInvocationOrdinal);
 }
 function nativeToolCallIdsRequiringQualification(entries, reconciliationProof) {
     const localNativeToolCallIds = nativeToolCallIds(entries);