@pasko70/pibo 1.16.5 → 2.0.0

package/dist/shared/{trace-transcript.js → trace-history.js}

@@ -1,43 +1,42 @@
-import { transcriptTraceOrder } from "./trace-order.js";
+import { historyTraceOrder } from "./trace-order.js";
 import { attachAsyncAgentRunNode, reconcileAsyncAgentRunStatuses } from "./trace-async-agent-runs.js";
 import { sortTraceNodes } from "./trace-nodes.js";
 import { createRunNotificationNode, parseRunNotificationText } from "./trace-run-notifications.js";
 import { isSubagentToolName } from "./trace-subagent-links.js";
-import { assistantMessageNodeId, thinkingNodeId } from "./trace-event-projection.js";
-export function projectTranscriptEntries(entries, sessionStatus, openTranscriptEventIds, turnTimings = []) {
-    if (sessionStatus !== "running" || openTranscriptEventIds.size === 0)
-        return entries;
-    const userTimingAssignments = assignTranscriptUserTimings(entries, turnTimings);
+import { assistantMessageNodeId, messageTurnNodeId, thinkingNodeId } from "./trace-event-projection.js";
+export function projectHistoryEntries(entries, sessionStatus, openHistoryEventIds, turnTimings = []) {
+    if (sessionStatus !== "running" || openHistoryEventIds.size === 0)
+        return [...entries];
+    const userTimingAssignments = assignHistoryUserTimings(entries, turnTimings);
     let lastUserMessageIndex = -1;
     let lastUserEventId;
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
-        if (entry.type !== "message" || messageRole(entry) !== "user")
+        if (entry.type !== "message" || entry.role !== "user")
             continue;
         lastUserMessageIndex = index;
-        lastUserEventId = openTranscriptEventIds.has(entry.id)
-            ? entry.id
+        lastUserEventId = entry.turnId && openHistoryEventIds.has(entry.turnId)
+            ? entry.turnId
             : userTimingAssignments.get(index)?.eventId;
     }
-    return lastUserMessageIndex !== -1 && lastUserEventId && openTranscriptEventIds.has(lastUserEventId)
+    return lastUserMessageIndex !== -1 && lastUserEventId && openHistoryEventIds.has(lastUserEventId)
         ? entries.slice(0, lastUserMessageIndex)
-        : entries;
+        : [...entries];
 }
-export function traceNodesFromEntries(piboSessionId, entries, turnTimings = []) {
+export function traceNodesFromHistoryEntries(piboSessionId, entries, turnTimings = []) {
     const nodes = [];
-    const turnTimingAssignments = assignTranscriptTurnTimings(entries, turnTimings);
-    const userTimingAssignments = assignTranscriptUserTimings(entries, turnTimings);
+    const turnTimingAssignments = assignHistoryTurnTimings(entries, turnTimings);
+    const userTimingAssignments = assignHistoryUserTimings(entries, turnTimings);
     let assistantTurnIndex = 0;
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
         if (entry.type === "message") {
-            const role = messageRole(entry);
-            if (role === "user") {
-                nodes.push(createUserMessageNode(piboSessionId, entry, messageContent(entry), index, userTimingAssignments.get(index)));
+            if (entry.role === "user") {
+                nodes.push(createUserMessageNode(piboSessionId, entry, index, userTimingAssignments.get(index)));
             }
-            else if (role === "assistant" || role === "toolResult") {
+            else if (entry.role === "assistant" || entry.role === "tool") {
                 const turn = collectAssistantTurn(entries, index);
-                const hasAssistant = turn.entries.some(({ entry: turnEntry }) => messageRole(turnEntry) === "assistant");
+                const hasAssistant = turn.entries.some(({ entry: turnEntry }) => turnEntry.role === "assistant");
                 const timing = hasAssistant ? turnTimingAssignments[assistantTurnIndex] : undefined;
                 nodes.push(...createAssistantTurnNodes(piboSessionId, turn.entries, timing));
                 if (hasAssistant)
@@ -46,18 +45,20 @@ export function traceNodesFromEntries(piboSessionId, entries, turnTimings = [])
             }
         }
         else if (entry.type === "session_info" && entry.name) {
+            const source = traceSource(entry.source);
+            const entryIndex = historyIndex(entry, index);
             nodes.push({
-                id: `entry:${entry.id}`,
-                entryId: entry.id,
+                id: historyEntryNodeId(entry),
+                entryId: entry.nativeEntryId,
                 piboSessionId,
                 type: "execution.command",
                 title: "Session Info",
                 status: "done",
-                startedAt: entry.timestamp,
+                startedAt: entry.createdAt,
                 output: { name: entry.name },
-                source: "transcript",
-                stableKey: `entry:${entry.id}`,
-                orderKey: transcriptTraceOrder(index, 0, "execution.command"),
+                source,
+                stableKey: historyEntryStableKey(entry),
+                orderKey: historyTraceOrder(entryIndex, 0, "execution.command", source),
                 children: [],
             });
         }
@@ -66,67 +67,64 @@ export function traceNodesFromEntries(piboSessionId, entries, turnTimings = [])
     sortTraceNodes(nodes);
     return nodes;
 }
-function messageRole(entry) {
-    return entry.message.role;
-}
-function messageContent(entry) {
-    return entry.message.content;
-}
-function messageParts(entry) {
-    const content = messageContent(entry);
-    if (typeof content === "string")
-        return [{ type: "text", text: content }];
-    return Array.isArray(content) ? content : [];
-}
-function collectTranscriptTurnTimingTargets(entries) {
+function collectHistoryTurnTimingTargets(entries) {
     const targets = [];
     let latestUserText;
     let latestUserEntryIndex;
+    let latestTurnId;
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
         if (entry.type !== "message")
             continue;
-        const role = messageRole(entry);
-        if (role === "user") {
-            latestUserText = normalizedPrompt(extractText(messageContent(entry)));
+        if (entry.role === "user") {
+            latestUserText = normalizedPrompt(historyMessageText(entry));
             latestUserEntryIndex = index;
+            latestTurnId = entry.turnId;
             continue;
         }
-        if (role !== "assistant" && role !== "toolResult")
+        if (entry.role !== "assistant" && entry.role !== "tool")
             continue;
         const turn = collectAssistantTurn(entries, index);
-        const lastAssistant = [...turn.entries].reverse().find(({ entry: turnEntry }) => messageRole(turnEntry) === "assistant");
+        const lastAssistant = [...turn.entries].reverse().find(({ entry: turnEntry }) => turnEntry.role === "assistant");
         if (lastAssistant) {
             targets.push({
                 prompt: latestUserText,
                 userEntryIndex: latestUserEntryIndex,
-                assistantAt: parsedTimestamp(lastAssistant.entry.timestamp),
+                assistantAt: parsedTimestamp(lastAssistant.entry.createdAt),
                 settled: isSettledAssistantEntry(lastAssistant.entry),
+                turnId: lastAssistant.entry.turnId ?? latestTurnId,
             });
         }
         index = turn.nextIndex - 1;
     }
     return targets;
 }
-function assignTranscriptTurnTimings(entries, turnTimings) {
+function assignHistoryTurnTimings(entries, turnTimings) {
     const messageTurnTimings = turnTimings.filter((timing) => timing.userMessageType !== "message_steered");
-    const transcriptTurns = collectTranscriptTurnTimingTargets(entries);
-    const assignments = Array(transcriptTurns.length).fill(undefined);
+    const timingByEventId = new Map(messageTurnTimings.map((timing) => [timing.eventId, timing]));
+    const historyTurns = collectHistoryTurnTimingTargets(entries);
+    const assignments = historyTurns.map((turn) => turn.turnId ? timingByEventId.get(turn.turnId) : undefined);
     let timingCursor = messageTurnTimings.length - 1;
-    for (let turnIndex = transcriptTurns.length - 1; turnIndex >= 0; turnIndex -= 1) {
-        const transcriptTurn = transcriptTurns[turnIndex];
-        if (!transcriptTurn?.prompt)
+    for (let turnIndex = historyTurns.length - 1; turnIndex >= 0; turnIndex -= 1) {
+        if (assignments[turnIndex]) {
+            const assignedIndex = messageTurnTimings.indexOf(assignments[turnIndex]);
+            if (assignedIndex >= 0)
+                timingCursor = Math.min(timingCursor, assignedIndex - 1);
+            continue;
+        }
+        const historyTurn = historyTurns[turnIndex];
+        if (!historyTurn?.prompt)
             continue;
         let matchedIndex;
         let matchedDistance = Number.POSITIVE_INFINITY;
         for (let timingIndex = timingCursor; timingIndex >= 0; timingIndex -= 1) {
             const timing = messageTurnTimings[timingIndex];
-            if (normalizedPrompt(timing?.userText) !== transcriptTurn.prompt)
+            if (normalizedPrompt(timing?.userText) !== historyTurn.prompt)
                 continue;
             const completedAt = parsedTimestamp(timing?.completedAt);
-            const distance = completedAt === undefined || transcriptTurn.assistantAt === undefined
+            const distance = completedAt === undefined || historyTurn.assistantAt === undefined
                 ? Number.POSITIVE_INFINITY
-                : Math.abs(completedAt - transcriptTurn.assistantAt);
+                : Math.abs(completedAt - historyTurn.assistantAt);
             if (matchedIndex === undefined || distance < matchedDistance) {
                 matchedIndex = timingIndex;
                 matchedDistance = distance;
@@ -139,18 +137,19 @@ function assignTranscriptTurnTimings(entries, turnTimings) {
     }
     return assignments;
 }
-function assignTranscriptUserTimings(entries, turnTimings) {
+function assignHistoryUserTimings(entries, turnTimings) {
     const users = [];
     const userPositionByEntryIndex = new Map();
     for (let entryIndex = 0; entryIndex < entries.length; entryIndex += 1) {
         const entry = entries[entryIndex];
-        if (entry.type !== "message" || messageRole(entry) !== "user")
+        if (entry.type !== "message" || entry.role !== "user")
             continue;
         userPositionByEntryIndex.set(entryIndex, users.length);
         users.push({
             entryIndex,
-            entryId: entry.id,
-            prompt: normalizedPrompt(extractText(messageContent(entry))),
+            entryId: entry.nativeEntryId,
+            turnId: entry.turnId,
+            prompt: normalizedPrompt(historyMessageText(entry)),
         });
     }
     if (!users.length || !turnTimings.length)
@@ -159,20 +158,21 @@ function assignTranscriptUserTimings(entries, turnTimings) {
     const anchorByUserPosition = new Map();
     const assignedTimingIndexes = new Set();
     for (let userPosition = 0; userPosition < users.length; userPosition += 1) {
-        const timingIndex = timingIndexByEventId.get(users[userPosition].entryId);
+        const user = users[userPosition];
+        const timingIndex = timingIndexByEventId.get(user.turnId ?? user.entryId ?? "");
         if (timingIndex === undefined || assignedTimingIndexes.has(timingIndex))
             continue;
         anchorByUserPosition.set(userPosition, timingIndex);
         assignedTimingIndexes.add(timingIndex);
     }
-    const transcriptTurns = collectTranscriptTurnTimingTargets(entries);
+    const historyTurns = collectHistoryTurnTimingTargets(entries);
     let timingUpperBound = turnTimings.length - 1;
-    for (let turnIndex = transcriptTurns.length - 1; turnIndex >= 0; turnIndex -= 1) {
-        const transcriptTurn = transcriptTurns[turnIndex];
-        const userPosition = transcriptTurn?.userEntryIndex === undefined
+    for (let turnIndex = historyTurns.length - 1; turnIndex >= 0; turnIndex -= 1) {
+        const historyTurn = historyTurns[turnIndex];
+        const userPosition = historyTurn?.userEntryIndex === undefined
             ? undefined
-            : userPositionByEntryIndex.get(transcriptTurn.userEntryIndex);
-        if (!transcriptTurn?.prompt || userPosition === undefined)
+            : userPositionByEntryIndex.get(historyTurn.userEntryIndex);
+        if (!historyTurn?.prompt || userPosition === undefined)
             continue;
         const exactAnchor = anchorByUserPosition.get(userPosition);
         if (exactAnchor !== undefined) {
@@ -184,7 +184,7 @@ function assignTranscriptUserTimings(entries, turnTimings) {
             const timing = turnTimings[timingIndex];
             if (assignedTimingIndexes.has(timingIndex) || timing.userMessageType !== "message_steered")
                 continue;
-            if (normalizedPrompt(timing.userText) !== transcriptTurn.prompt)
+            if (normalizedPrompt(timing.userText) !== historyTurn.prompt)
                 continue;
             steeringTimingIndex = timingIndex;
             break;
@@ -195,7 +195,7 @@ function assignTranscriptUserTimings(entries, turnTimings) {
             timingUpperBound = steeringTimingIndex - 1;
             continue;
         }
-        if (!transcriptTurn.settled)
+        if (!historyTurn.settled)
             continue;
         let matchedTimingIndex;
         let matchedDistance = Number.POSITIVE_INFINITY;
@@ -203,12 +203,12 @@ function assignTranscriptUserTimings(entries, turnTimings) {
             const timing = turnTimings[timingIndex];
             if (assignedTimingIndexes.has(timingIndex) || timing.userMessageType === "message_steered" || !timing.completedAt)
                 continue;
-            if (normalizedPrompt(timing.userText) !== transcriptTurn.prompt)
+            if (normalizedPrompt(timing.userText) !== historyTurn.prompt)
                 continue;
             const completedAt = parsedTimestamp(timing.completedAt);
-            const distance = completedAt === undefined || transcriptTurn.assistantAt === undefined
+            const distance = completedAt === undefined || historyTurn.assistantAt === undefined
                 ? Number.POSITIVE_INFINITY
-                : Math.abs(completedAt - transcriptTurn.assistantAt);
+                : Math.abs(completedAt - historyTurn.assistantAt);
             if (matchedTimingIndex === undefined || distance < matchedDistance) {
                 matchedTimingIndex = timingIndex;
                 matchedDistance = distance;
@@ -224,9 +224,8 @@ function assignTranscriptUserTimings(entries, turnTimings) {
     const anchors = [...anchorByUserPosition.entries()]
         .map(([userPosition, timingIndex]) => ({ userPosition, timingIndex }))
         .sort((left, right) => left.userPosition - right.userPosition);
-    for (const anchor of anchors) {
+    for (const anchor of anchors)
         assignments.set(users[anchor.userPosition].entryIndex, turnTimings[anchor.timingIndex]);
-    }
     const boundaries = [
         { userPosition: -1, timingIndex: -1 },
         ...anchors,
@@ -255,22 +254,6 @@ function assignTranscriptUserTimings(entries, turnTimings) {
     }
     return assignments;
 }
-function isSettledAssistantEntry(entry) {
-    const message = entry.message;
-    if (message.stopReason === "toolUse" || message.stopReason === "tool_use")
-        return false;
-    return message.status !== "streaming" && message.status !== "in_progress";
-}
-function normalizedPrompt(value) {
-    const normalized = value?.replace(/\s+/g, " ").trim();
-    return normalized || undefined;
-}
-function parsedTimestamp(value) {
-    if (!value)
-        return undefined;
-    const timestamp = new Date(value).getTime();
-    return Number.isFinite(timestamp) ? timestamp : undefined;
-}
 function collectAssistantTurn(entries, startIndex) {
     const turnEntries = [];
     let index = startIndex;
@@ -278,49 +261,53 @@ function collectAssistantTurn(entries, startIndex) {
         const entry = entries[index];
         if (entry.type !== "message")
             break;
-        const role = messageRole(entry);
-        if (role !== "assistant" && role !== "toolResult")
+        if (entry.role !== "assistant" && entry.role !== "tool")
             break;
         turnEntries.push({ entry, index });
         index += 1;
     }
     return { entries: turnEntries, nextIndex: index };
 }
-function createUserMessageNode(piboSessionId, entry, content, entryIndex, timing) {
-    const text = extractText(content);
+function createUserMessageNode(piboSessionId, entry, entryIndex, timing) {
+    const text = historyMessageText(entry);
     const notification = parseRunNotificationText(text);
+    const source = traceSource(entry.source);
+    const orderIndex = historyIndex(entry, entryIndex);
     if (notification) {
         return createRunNotificationNode({
-            id: `entry:${entry.id}`,
-            entryId: entry.id,
+            id: historyEntryNodeId(entry),
+            entryId: entry.nativeEntryId,
             piboSessionId,
-            startedAt: entry.timestamp,
-            orderKey: transcriptTraceOrder(entryIndex, 0, "yielded.run"),
-            source: "transcript",
-            stableKey: `entry:${entry.id}`,
+            startedAt: entry.createdAt,
+            orderKey: historyTraceOrder(orderIndex, 0, "yielded.run", source),
+            source,
+            stableKey: historyEntryStableKey(entry),
             notification,
         });
     }
     const userMessageType = timing?.userMessageType ?? "message_queued";
-    const eventIdentity = timing ? `event:${userMessageType}:${timing.eventId}` : undefined;
+    const eventId = entry.turnId ?? timing?.eventId;
+    const eventIdentity = eventId ? `event:${userMessageType}:${eventId}` : undefined;
     return {
-        id: eventIdentity ?? `entry:${entry.id}`,
-        entryId: entry.id,
+        id: eventIdentity ?? historyEntryNodeId(entry),
+        entryId: entry.nativeEntryId,
         piboSessionId,
+        eventId,
         type: "user.message",
         title: "User Message",
-        status: "done",
-        startedAt: entry.timestamp,
+        status: entry.status === "running" ? "running" : entry.status === "error" ? "error" : "done",
+        startedAt: entry.createdAt,
         summary: text,
         output: text,
-        source: "transcript",
-        stableKey: eventIdentity ?? `entry:${entry.id}`,
-        orderKey: transcriptTraceOrder(entryIndex, 0, "user.message"),
+        error: entry.error,
+        source,
+        stableKey: eventIdentity ?? historyEntryStableKey(entry),
+        orderKey: historyTraceOrder(orderIndex, 0, "user.message", source),
         children: [],
     };
 }
 function createAssistantTurnNodes(piboSessionId, entries, timing) {
-    const firstAssistant = entries.find(({ entry }) => messageRole(entry) === "assistant");
+    const firstAssistant = entries.find(({ entry }) => entry.role === "assistant");
     if (!firstAssistant)
         return [];
     const orderedNodes = [];
@@ -328,60 +315,59 @@ function createAssistantTurnNodes(piboSessionId, entries, timing) {
     let assistantPartOrdinal = 0;
     let reasoningPartOrdinal = 0;
     for (const { entry, index: entryIndex } of entries) {
-        if (messageRole(entry) === "toolResult") {
+        if (entry.role === "tool") {
             mergePersistedToolResult(toolsByCallId, orderedNodes, entry, piboSessionId, entryIndex);
             continue;
         }
-        const responseStatus = messageStatus(entry.message);
-        const responseError = messageError(entry.message);
+        const responseStatus = historyMessageStatus(entry);
         let responseNode;
-        for (const [index, part] of messageParts(entry).entries()) {
-            const typed = part;
-            if (typed.type === "thinking" && typeof typed.thinking === "string" && hasVisibleText(typed.thinking)) {
+        const parts = historyMessageParts(entry);
+        for (const [contentPartIndex, part] of parts.entries()) {
+            if (part.type === "reasoning" && hasVisibleText(part.text)) {
                 const thinkingIndex = timing?.reasoningIndices?.[reasoningPartOrdinal] ?? reasoningPartOrdinal;
                 orderedNodes.push(createReasoningNode({
                     piboSessionId,
                     entry,
                     entryIndex,
-                    contentPartIndex: index,
+                    contentPartIndex,
                     thinkingIndex,
-                    eventId: timing?.eventId,
-                    thinking: typed.thinking,
+                    eventId: entry.turnId ?? timing?.eventId,
+                    thinking: part.text,
                 }));
                 reasoningPartOrdinal += 1;
             }
-            else if (typed.type === "text" && typeof typed.text === "string" && typed.text !== "") {
+            else if (part.type === "text" && part.text !== "") {
                 if (!responseNode) {
-                    const assistantIndex = timing?.assistantIndices?.[assistantPartOrdinal] ?? assistantPartOrdinal;
+                    const assistantIndex = entry.assistantIndex ?? timing?.assistantIndices?.[assistantPartOrdinal] ?? assistantPartOrdinal;
                     responseNode = createAssistantMessageNode({
                         piboSessionId,
                         entry,
                         entryIndex,
-                        contentPartIndex: index,
+                        contentPartIndex,
                         assistantIndex,
-                        eventId: timing?.eventId,
+                        eventId: entry.turnId ?? timing?.eventId,
                         status: responseStatus,
-                        text: typed.text,
-                        error: responseError,
+                        text: part.text,
+                        error: entry.error,
                         children: [],
-                        startedAt: entry.timestamp,
+                        startedAt: entry.createdAt,
                     });
                     orderedNodes.push(responseNode);
                 }
                 else {
-                    responseNode.summary = `${typeof responseNode.summary === "string" ? responseNode.summary : ""}${typed.text}`;
-                    responseNode.output = `${typeof responseNode.output === "string" ? responseNode.output : ""}${typed.text}`;
+                    responseNode.summary = `${typeof responseNode.summary === "string" ? responseNode.summary : ""}${part.text}`;
+                    responseNode.output = `${typeof responseNode.output === "string" ? responseNode.output : ""}${part.text}`;
                 }
             }
-            else if (typed.type === "toolCall" && typeof typed.id === "string" && typeof typed.name === "string") {
-                const toolNode = createToolCallNode(piboSessionId, entry, entryIndex, index, typed);
+            else if (part.type === "tool_call") {
+                const toolNode = createToolCallNode(piboSessionId, entry, entryIndex, contentPartIndex, part);
                 orderedNodes.push(toolNode);
-                toolsByCallId.set(typed.id, toolNode);
+                toolsByCallId.set(part.toolCallId, toolNode);
             }
         }
         if (responseNode) {
             responseNode.status = responseStatus;
-            responseNode.error = responseError;
+            responseNode.error = entry.error;
             assistantPartOrdinal += 1;
         }
     }
@@ -394,44 +380,47 @@ function createAssistantTurnNodes(piboSessionId, entries, timing) {
 }
 function createReasoningNode(input) {
     const eventIdentity = input.eventId ? `${input.eventId}:thinking:${input.thinkingIndex}` : undefined;
+    const source = traceSource(input.entry.source);
     return {
-        id: eventIdentity ? thinkingNodeId(eventIdentity) : `entry:${input.entry.id}:thinking:${input.contentPartIndex}`,
-        entryId: input.entry.id,
+        id: eventIdentity ? thinkingNodeId(eventIdentity) : `${historyEntryNodeId(input.entry)}:thinking:${input.contentPartIndex}`,
+        entryId: input.entry.nativeEntryId,
         piboSessionId: input.piboSessionId,
+        eventId: input.eventId,
+        parentId: input.entry.source === "product" && input.eventId ? messageTurnNodeId(input.eventId) : undefined,
         type: "model.reasoning",
         title: "Thinking",
         status: "done",
-        startedAt: input.entry.timestamp,
+        startedAt: input.entry.createdAt,
         summary: input.thinking,
         output: input.thinking,
-        source: "transcript",
-        stableKey: eventIdentity ? `reasoning:${eventIdentity}` : `entry:${input.entry.id}:thinking:${input.contentPartIndex}`,
-        orderKey: transcriptTraceOrder(input.entryIndex, input.contentPartIndex, "model.reasoning"),
+        source,
+        stableKey: eventIdentity ? `reasoning:${eventIdentity}` : `${historyEntryStableKey(input.entry)}:thinking:${input.contentPartIndex}`,
+        orderKey: historyTraceOrder(historyIndex(input.entry, input.entryIndex), input.contentPartIndex, "model.reasoning", source),
         children: [],
     };
 }
 function createToolCallNode(piboSessionId, entry, entryIndex, contentPartIndex, part) {
-    const name = typeof part.name === "string" ? part.name : "Tool Call";
-    const toolCallId = typeof part.id === "string" ? part.id : undefined;
+    const source = traceSource(entry.source);
     return {
-        id: toolCallId ? `tool:${toolCallId}` : `entry:${entry.id}:tool:${contentPartIndex}`,
-        entryId: entry.id,
+        id: `tool:${part.toolCallId}`,
+        entryId: entry.nativeEntryId,
         piboSessionId,
-        toolCallId,
-        type: isSubagentToolName(name) ? "agent.delegation" : "tool.call",
-        title: name,
+        eventId: entry.turnId,
+        parentId: entry.source === "product" && entry.turnId ? messageTurnNodeId(entry.turnId) : undefined,
+        toolCallId: part.toolCallId,
+        type: isSubagentToolName(part.toolName) ? "agent.delegation" : "tool.call",
+        title: part.toolName,
         status: "done",
-        startedAt: entry.timestamp,
-        input: part.arguments ?? {},
-        source: "transcript",
-        stableKey: toolCallId ? `tool:${toolCallId}` : `entry:${entry.id}:tool:${contentPartIndex}`,
-        orderKey: transcriptTraceOrder(entryIndex, contentPartIndex, isSubagentToolName(name) ? "agent.delegation" : "tool.call"),
+        startedAt: entry.createdAt,
+        input: part.input ?? {},
+        source,
+        stableKey: `tool:${part.toolCallId}`,
+        orderKey: historyTraceOrder(historyIndex(entry, entryIndex), contentPartIndex, isSubagentToolName(part.toolName) ? "agent.delegation" : "tool.call", source),
         children: [],
     };
 }
 function mergePersistedToolResult(toolsByCallId, childNodes, entry, piboSessionId, entryIndex) {
-    const message = entry.message;
-    const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
+    const toolCallId = entry.toolCallId;
     if (!toolCallId)
         return;
     let toolNode = toolsByCallId.get(toolCallId);
@@ -440,87 +429,96 @@ function mergePersistedToolResult(toolsByCallId, childNodes, entry, piboSessionI
         childNodes.push(toolNode);
         toolsByCallId.set(toolCallId, toolNode);
     }
-    toolNode.status = message.isError === true ? "error" : "done";
-    toolNode.completedAt = entry.timestamp;
-    toolNode.output = toolResultOutput(message);
-    toolNode.error = message.isError === true ? stringifyPreview(toolNode.output) : undefined;
-    attachAsyncAgentRunNode(toolNode, piboSessionId, entry.timestamp);
+    toolNode.status = entry.isError === true || entry.status === "error" ? "error" : "done";
+    toolNode.completedAt = entry.createdAt;
+    toolNode.output = entry.result ?? { content: entry.content };
+    toolNode.error = toolNode.status === "error" ? stringifyPreview(toolNode.output) : undefined;
+    attachAsyncAgentRunNode(toolNode, piboSessionId, entry.createdAt);
 }
 function createMissingToolResultNode(piboSessionId, entry, entryIndex, toolCallId) {
-    const message = entry.message;
+    const source = traceSource(entry.source);
     return {
         id: `tool:${toolCallId}`,
-        entryId: entry.id,
+        entryId: entry.nativeEntryId,
         piboSessionId,
+        eventId: entry.turnId,
         toolCallId,
         type: "tool.result",
-        title: typeof message.toolName === "string" ? message.toolName : "Tool Result",
+        title: entry.toolName ?? "Tool Result",
         status: "done",
-        startedAt: entry.timestamp,
-        source: "transcript",
+        startedAt: entry.createdAt,
+        source,
         stableKey: `tool:${toolCallId}`,
-        orderKey: transcriptTraceOrder(entryIndex, 0, "tool.result"),
+        orderKey: historyTraceOrder(historyIndex(entry, entryIndex), 0, "tool.result", source),
         children: [],
     };
 }
-function toolResultOutput(message) {
-    if (message.details === undefined)
-        return { content: message.content };
-    return { content: message.content, details: message.details };
-}
 function createAssistantMessageNode(input) {
     const eventIdentity = input.eventId ? `${input.eventId}:assistant:${input.assistantIndex}` : undefined;
+    const source = traceSource(input.entry.source);
     return {
-        id: eventIdentity ? assistantMessageNodeId(eventIdentity) : `entry:${input.entry.id}:response`,
-        entryId: input.entry.id,
+        id: eventIdentity ? assistantMessageNodeId(eventIdentity) : `${historyEntryNodeId(input.entry)}:response`,
+        entryId: input.entry.nativeEntryId,
         piboSessionId: input.piboSessionId,
         eventId: input.eventId,
+        parentId: input.entry.source === "product" && input.eventId ? messageTurnNodeId(input.eventId) : undefined,
         type: "assistant.message",
         title: "Agent Message",
         status: input.status,
-        startedAt: input.startedAt ?? input.entry.timestamp,
+        startedAt: input.startedAt ?? input.entry.createdAt,
         completedAt: input.completedAt,
         summary: input.text,
         output: input.text,
         error: input.error,
-        source: "transcript",
-        stableKey: eventIdentity ? `assistant:${eventIdentity}` : `entry:${input.entry.id}:response:${input.contentPartIndex}`,
-        orderKey: transcriptTraceOrder(input.entryIndex, input.contentPartIndex, "assistant.message"),
+        source,
+        stableKey: eventIdentity ? `assistant:${eventIdentity}` : `${historyEntryStableKey(input.entry)}:response:${input.contentPartIndex}`,
+        orderKey: historyTraceOrder(historyIndex(input.entry, input.entryIndex), input.contentPartIndex, "assistant.message", source),
         children: input.children ?? [],
     };
 }
-function messageStatus(message) {
-    if (message && typeof message === "object") {
-        const stopReason = message.stopReason;
-        const errorMessage = message.errorMessage;
-        if (stopReason === "error" || typeof errorMessage === "string")
-            return "error";
-    }
+function historyMessageParts(entry) {
+    return typeof entry.content === "string" ? [{ type: "text", text: entry.content }] : [...entry.content];
+}
+function historyMessageText(entry) {
+    if (typeof entry.content === "string")
+        return entry.content;
+    return entry.content.map((part) => part.type === "text" ? part.text : "").join("");
+}
+function historyMessageStatus(entry) {
+    if (entry.status === "error" || entry.error)
+        return "error";
+    if (entry.status === "running")
+        return "running";
     return "done";
 }
-function messageError(message) {
-    if (!message || typeof message !== "object")
+function isSettledAssistantEntry(entry) {
+    return entry.status !== "running" && entry.metadata?.stopReason !== "toolUse" && entry.metadata?.stopReason !== "tool_use";
+}
+function historyEntryNodeId(entry) {
+    return entry.source === "native" && entry.nativeEntryId ? `entry:${entry.nativeEntryId}` : `history:${entry.id}`;
+}
+function historyEntryStableKey(entry) {
+    return historyEntryNodeId(entry);
+}
+function historyIndex(entry, fallback) {
+    return entry.sequence ?? fallback;
+}
+function traceSource(source) {
+    return source === "native" ? "transcript" : "product-history";
+}
+function normalizedPrompt(value) {
+    const normalized = value?.replace(/\s+/g, " ").trim();
+    return normalized || undefined;
+}
+function parsedTimestamp(value) {
+    if (!value)
         return undefined;
-    const errorMessage = message.errorMessage;
-    return typeof errorMessage === "string" ? errorMessage : undefined;
+    const timestamp = new Date(value).getTime();
+    return Number.isFinite(timestamp) ? timestamp : undefined;
 }
 function hasVisibleText(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
-function extractText(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((part) => {
-        const typed = part;
-        if (typed.type === "text" && typeof typed.text === "string")
-            return typed.text;
-        return "";
-    })
-        .join("");
-}
 function stringifyPreview(value) {
     if (typeof value === "string")
         return value;