@pasko70/pibo 1.8.2 → 1.9.1

package/dist/session-ui/terminalRows.js

@@ -5,12 +5,43 @@ export const COMPACT_TERMINAL_EXPLORING_PREVIEW_LINES = 6;
 export function buildCompactTerminalRows(traceView, options) {
     if (!traceView)
         return [];
+    const turnById = mapTurnNodes(traceView.nodes);
     const flatNodes = flattenTraceNodes(traceView.nodes)
         .sort((left, right) => compareTraceNodes(left.node, right.node))
         .filter((item) => item.node.type !== "agent.turn" && (options.showThinking || item.node.type !== "model.reasoning"));
     const candidates = syncThinkingToolRows(flatNodes.map((item) => createRowCandidate(item.node, item.turnId)));
+    applyCompletedTurnTiming(candidates, turnById);
     return groupRelatedToolCandidates(candidates).map((candidate) => candidate.row);
 }
+export function findActiveTurnStartedAt(traceView) {
+    if (!traceView)
+        return undefined;
+    const terminalErrorEventIds = new Set(flattenTraceNodes(traceView.nodes)
+        .map(({ node }) => node)
+        .filter((node) => node.type === "error" && node.eventId)
+        .map((node) => node.eventId));
+    return [...mapTurnNodes(traceView.nodes).values()]
+        .filter((turn) => turn.startedAt && !turn.completedAt && (!turn.eventId || !terminalErrorEventIds.has(turn.eventId)))
+        .sort(compareTraceNodes)
+        .at(-1)?.startedAt;
+}
+export function formatTerminalDuration(durationMs) {
+    const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    return [hours, minutes, seconds].map((value) => String(value).padStart(2, "0")).join(":");
+}
+function mapTurnNodes(nodes) {
+    const turns = new Map();
+    for (const node of nodes) {
+        if (node.type === "agent.turn")
+            turns.set(node.id, node);
+        for (const [id, turn] of mapTurnNodes(node.children))
+            turns.set(id, turn);
+    }
+    return turns;
+}
 function flattenTraceNodes(nodes, turnId) {
     const result = [];
     for (const node of nodes) {
@@ -71,6 +102,26 @@ function createRowCandidate(node, turnId) {
     }
     return { ...candidate, row: { ...candidate.row, ...debugFields(node) } };
 }
+function applyCompletedTurnTiming(candidates, turnById) {
+    for (const turn of turnById.values()) {
+        if (!turn.completedAt)
+            continue;
+        const turnCandidates = candidates.filter((candidate) => candidate.turnId === turn.id);
+        const finalCandidate = turnCandidates.at(-1);
+        if (finalCandidate?.row.kind !== "message.assistant" || finalCandidate.row.status === "running")
+            continue;
+        finalCandidate.row.startedAt = turn.startedAt;
+        finalCandidate.row.completedAt = turn.completedAt;
+        finalCandidate.row.durationMs = turn.durationMs ?? durationBetween(turn.startedAt, turn.completedAt);
+    }
+}
+function durationBetween(startedAt, completedAt) {
+    if (!startedAt || !completedAt)
+        return undefined;
+    const start = new Date(startedAt).getTime();
+    const end = new Date(completedAt).getTime();
+    return Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : undefined;
+}
 function debugFields(node) {
     return {
         eventId: node.eventId,
@@ -90,6 +141,7 @@ function createUserMessageRow(node) {
         lines: [{ prefix: "prompt", tokens: [token(text)] }],
         sourceNodeIds: [node.id],
         forkEntryId: node.entryId,
+        startedAt: node.startedAt,
         output: text,
         payloadRefs: node.payloadRefs,
     };
@@ -101,6 +153,9 @@ function createAssistantMessageRow(node) {
         status: mapStatus(node.status),
         lines: [],
         sourceNodeIds: [node.id],
+        startedAt: node.startedAt,
+        completedAt: node.source === "transcript" ? node.completedAt : undefined,
+        durationMs: node.source === "transcript" ? node.durationMs : undefined,
         output: stringValue(node.output) || stringValue(node.summary) || "",
         error: node.error,
         payloadRefs: node.payloadRefs,
@@ -261,6 +316,9 @@ function createDelegationRow(node) {
         id: node.id,
         kind: "agent.delegation",
         status: mapStatus(node.status),
+        errorKind: node.status === "error" ? "tool" : undefined,
+        title: node.title,
+        summary: node.summary,
         lines: [
             {
                 prefix: "bullet",
@@ -270,6 +328,9 @@ function createDelegationRow(node) {
         ],
         sourceNodeIds: [node.id],
         linkedPiboSessionId: node.linkedPiboSessionId,
+        startedAt: node.startedAt,
+        completedAt: node.completedAt,
+        durationMs: node.durationMs,
         input: node.input,
         output: node.output,
         error: node.error,

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, traceEventDedupeKey, } from "./trace-event-projection.js";
+import { applySingleEventToNodes, contentDeltaPatchNodeId, dedupeTraceEvents, eventsCanAffectAsyncAgentRunStatus, findOpenTranscriptEventIds, isConfirmedUserMessageEcho, latestTraceStreamId, messageTurnTimingsFromEvents, reconcileTranscriptUserMessageTimestamps, 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";
@@ -14,7 +14,8 @@ export function buildTraceViewFromEvents(input) {
     const allEntries = input.transcriptEntries ?? [];
     const openTranscriptEventIds = findOpenTranscriptEventIds(events, sessionStatus);
     const entries = projectTranscriptEntries(allEntries, sessionStatus, openTranscriptEventIds);
-    const nodes = traceNodesFromEntries(input.session.id, entries);
+    const nodes = traceNodesFromEntries(input.session.id, entries, messageTurnTimingsFromEvents(events));
+    reconcileTranscriptUserMessageTimestamps(nodes, events);
     const byId = mapTraceNodesById(nodes);
     const childByParent = mapTraceChildSessionsByParent(input.sessions ?? []);
     const linkedChildByToolCallId = mapTraceSubagentSessionLinks(events);

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

@@ -26,10 +26,8 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
         const existing = byId.get(node.id);
         if (existing) {
             mergeAssistantMessageEvent(existing, node);
-            closeParentTurnForFinalAssistant(byId, existing);
             return;
         }
-        closeParentTurnForFinalAssistant(byId, node);
         nodes.push(node);
         byId.set(node.id, node);
         return;
@@ -49,10 +47,8 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
         const existing = byId.get(node.id);
         if (existing) {
             mergeAssistantMessageEvent(existing, node);
-            closeParentTurnForFinalAssistant(byId, existing);
             return;
         }
-        closeParentTurnForFinalAssistant(byId, node);
     }
     if (node.type === "execution.compaction") {
         const existing = findLatestCompactionNode(nodes);
@@ -68,6 +64,13 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
             return;
         }
     }
+    if (node.type === "agent.delegation" && !node.toolCallId && node.linkedPiboSessionId) {
+        const existing = findLegacySubagentLinkTarget([...byId.values()], node);
+        if (existing) {
+            mergeSubagentSessionLink(existing, node);
+            return;
+        }
+    }
     if (node.toolCallId) {
         const existing = [...byId.values()].find((candidate) => candidate.toolCallId === node.toolCallId &&
             (candidate.type === "tool.call" || candidate.type === "agent.delegation"));
@@ -102,6 +105,7 @@ function assistantMessageNodeFromEvent(piboSessionId, event, createdAt, eventSeq
         title: "Agent Message",
         status: "done",
         startedAt: createdAt,
+        completedAt: createdAt,
         summary: event.text,
         output: event.text,
         source: "event-log",
@@ -165,6 +169,28 @@ export function contentDeltaPatchNodeId(event) {
     }
     return undefined;
 }
+export function reconcileTranscriptUserMessageTimestamps(nodes, events) {
+    const transcriptUsers = nodes.filter((node) => node.type === "user.message" && node.source === "transcript");
+    let userCursor = 0;
+    for (const storedEvent of events) {
+        const event = storedEvent.payload;
+        if (event.type !== "message_queued" || event.source !== "user")
+            continue;
+        const eventId = typeof event.eventId === "string" ? event.eventId : storedEvent.eventId;
+        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);
+        });
+        if (matchIndex === -1)
+            continue;
+        transcriptUsers[matchIndex].startedAt = storedEvent.createdAt;
+        userCursor = matchIndex + 1;
+    }
+}
 export function isConfirmedUserMessageEcho(nodes, event) {
     const payload = event.payload;
     if (payload.type !== "message_queued" || payload.source !== "user")
@@ -266,6 +292,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 ...base,
                 id: eventId ? messageTurnNodeId(eventId) : id,
                 type: "agent.turn",
+                startedAt: event.type === "message_started" ? createdAt : undefined,
                 title: "Agent Turn",
                 status: event.type === "message_finished" || sessionStatus !== "running" ? "done" : "running",
                 completedAt: event.type === "message_finished" ? createdAt : undefined,
@@ -296,6 +323,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 type: "assistant.message",
                 title: "Agent Message",
                 status: "done",
+                completedAt: createdAt,
                 summary: event.text,
                 output: event.text,
                 stableKey: assistantId ? `assistant:${assistantId}` : base.stableKey,
@@ -483,15 +511,6 @@ function mergeReasoningEvent(target, update) {
     target.output = update.output ?? target.output;
     target.completedAt = update.completedAt ?? target.completedAt;
 }
-function closeParentTurnForFinalAssistant(byId, assistant) {
-    if (!assistant.parentId || assistant.status !== "done")
-        return;
-    const parent = byId.get(assistant.parentId);
-    if (!parent || parent.type !== "agent.turn")
-        return;
-    parent.status = "done";
-    parent.completedAt = assistant.completedAt ?? assistant.startedAt ?? parent.completedAt;
-}
 function isInternalSessionOperation(action) {
     return action === "session.fork" || action === "session.clone" || action === "session.switch";
 }
@@ -512,6 +531,55 @@ function shouldKeepTranscriptEchoEvent(event, openTranscriptEventIds) {
 function isStaleToolCallEchoEvent(event, sessionStatus) {
     return sessionStatus !== "running" && event.type === "tool_call";
 }
+export function messageTurnTimingsFromEvents(events) {
+    const timings = new Map();
+    const completedEventIds = [];
+    const completedEventIdSet = new Set();
+    const ignoredEventIds = new Set();
+    for (const storedEvent of events) {
+        const event = storedEvent.payload;
+        if (event.type !== "message_started" && event.type !== "message_finished")
+            continue;
+        const eventId = typeof event.eventId === "string" ? event.eventId : undefined;
+        if (!eventId)
+            continue;
+        if (event.type === "message_started" && event.source === "service") {
+            ignoredEventIds.add(eventId);
+            continue;
+        }
+        if (ignoredEventIds.has(eventId))
+            continue;
+        const timing = timings.get(eventId) ?? {};
+        if (event.type === "message_started") {
+            timing.userText ??= event.text;
+            timing.startedAt ??= storedEvent.createdAt;
+        }
+        else {
+            timing.completedAt = storedEvent.createdAt;
+            if (!completedEventIdSet.has(eventId)) {
+                completedEventIds.push(eventId);
+                completedEventIdSet.add(eventId);
+            }
+        }
+        timings.set(eventId, timing);
+    }
+    return completedEventIds.flatMap((eventId) => {
+        const timing = timings.get(eventId);
+        if (!timing?.completedAt)
+            return [];
+        const startedAtMs = parseTimestamp(timing.startedAt);
+        const completedAtMs = parseTimestamp(timing.completedAt);
+        return [{
+                eventId,
+                userText: timing.userText,
+                startedAt: timing.startedAt,
+                completedAt: timing.completedAt,
+                durationMs: startedAtMs === undefined || completedAtMs === undefined
+                    ? undefined
+                    : Math.max(0, completedAtMs - startedAtMs),
+            }];
+    });
+}
 export function findOpenTranscriptEventIds(events, sessionStatus) {
     if (sessionStatus !== "running")
         return new Set();
@@ -626,12 +694,48 @@ function thinkingEventNodeId(event) {
 function mergeToolEvent(target, update) {
     target.status = update.status;
     target.summary = update.summary ?? target.summary;
-    target.input = update.input ?? target.input;
+    target.input = mergeDelegationInput(target, update);
     target.output = update.output ?? target.output;
     target.error = update.error ?? target.error;
     target.completedAt = update.completedAt ?? target.completedAt;
     target.linkedPiboSessionId = update.linkedPiboSessionId ?? target.linkedPiboSessionId;
 }
+function mergeSubagentSessionLink(target, update) {
+    target.summary = update.summary ?? target.summary;
+    target.input = mergeDelegationInput(target, update);
+    target.linkedPiboSessionId = update.linkedPiboSessionId ?? target.linkedPiboSessionId;
+}
+function findLegacySubagentLinkTarget(nodes, update) {
+    const delegations = [...nodes].reverse().filter((candidate) => candidate.type === "agent.delegation");
+    const agentName = delegationAgentName(update);
+    const candidates = delegations.filter((candidate) => !candidate.linkedPiboSessionId && delegationAgentName(candidate) === agentName);
+    const threadKey = delegationThreadKey(update.input);
+    const matchingCandidate = threadKey
+        ? candidates.find((candidate) => delegationThreadKey(candidate.input) === threadKey)
+        : candidates.length === 1 ? candidates[0] : undefined;
+    if (matchingCandidate)
+        return matchingCandidate;
+    return delegations.find((candidate) => candidate.linkedPiboSessionId === update.linkedPiboSessionId);
+}
+function delegationAgentName(node) {
+    const input = isObjectRecord(node.input) ? node.input : undefined;
+    const value = typeof input?.subagentName === "string" ? input.subagentName : node.summary ?? node.title;
+    return typeof value === "string" ? value.replace(/^pibo_subagent_/, "").trim().toLowerCase() || undefined : undefined;
+}
+function delegationThreadKey(value) {
+    if (!isObjectRecord(value) || typeof value.threadKey !== "string")
+        return undefined;
+    return value.threadKey.trim() || undefined;
+}
+function mergeDelegationInput(target, update) {
+    if (target.type !== "agent.delegation" || !isObjectRecord(target.input) || !isObjectRecord(update.input)) {
+        return update.input ?? target.input;
+    }
+    return Object.fromEntries(Object.entries({ ...target.input, ...update.input }).filter(([, value]) => value !== undefined));
+}
+function isObjectRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 function findLatestCompactionNode(nodes) {
     return flattenTraceNodes([...nodes]).reverse().find((node) => node.type === "execution.compaction" && node.status === "running");
 }
@@ -656,6 +760,12 @@ function stringifyPreview(value) {
         return String(value);
     }
 }
+function parseTimestamp(value) {
+    if (!value)
+        return undefined;
+    const timestamp = new Date(value).getTime();
+    return Number.isFinite(timestamp) ? timestamp : undefined;
+}
 function cryptoSafeId(value) {
     return base64UrlEncode(new TextEncoder().encode(JSON.stringify(value))).slice(0, 48);
 }

package/dist/shared/trace-transcript.js

@@ -16,8 +16,10 @@ export function projectTranscriptEntries(entries, sessionStatus, openTranscriptE
     }
     return lastUserMessageIndex === -1 ? entries : entries.slice(0, lastUserMessageIndex);
 }
-export function traceNodesFromEntries(piboSessionId, entries) {
+export function traceNodesFromEntries(piboSessionId, entries, turnTimings = []) {
     const nodes = [];
+    const turnTimingAssignments = assignTranscriptTurnTimings(entries, turnTimings);
+    let assistantTurnIndex = 0;
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
         if (entry.type === "message") {
@@ -27,7 +29,11 @@ export function traceNodesFromEntries(piboSessionId, entries) {
             }
             else if (role === "assistant" || role === "toolResult") {
                 const turn = collectAssistantTurn(entries, index);
-                nodes.push(...createAssistantTurnNodes(piboSessionId, turn.entries));
+                const hasAssistant = turn.entries.some(({ entry: turnEntry }) => messageRole(turnEntry) === "assistant");
+                const timing = hasAssistant ? turnTimingAssignments[assistantTurnIndex] : undefined;
+                nodes.push(...createAssistantTurnNodes(piboSessionId, turn.entries, timing));
+                if (hasAssistant)
+                    assistantTurnIndex += 1;
                 index = turn.nextIndex - 1;
             }
         }
@@ -64,6 +70,65 @@ function messageParts(entry) {
         return [{ type: "text", text: content }];
     return Array.isArray(content) ? content : [];
 }
+function assignTranscriptTurnTimings(entries, turnTimings) {
+    const transcriptTurns = [];
+    let latestUserText;
+    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)));
+            continue;
+        }
+        if (role !== "assistant" && role !== "toolResult")
+            continue;
+        const turn = collectAssistantTurn(entries, index);
+        const lastAssistant = [...turn.entries].reverse().find(({ entry: turnEntry }) => messageRole(turnEntry) === "assistant");
+        if (lastAssistant) {
+            transcriptTurns.push({ prompt: latestUserText, assistantAt: parsedTimestamp(lastAssistant.entry.timestamp) });
+        }
+        index = turn.nextIndex - 1;
+    }
+    const assignments = Array(transcriptTurns.length).fill(undefined);
+    let timingCursor = turnTimings.length - 1;
+    for (let turnIndex = transcriptTurns.length - 1; turnIndex >= 0; turnIndex -= 1) {
+        const transcriptTurn = transcriptTurns[turnIndex];
+        if (!transcriptTurn?.prompt)
+            continue;
+        let matchedIndex;
+        let matchedDistance = Number.POSITIVE_INFINITY;
+        for (let timingIndex = timingCursor; timingIndex >= 0; timingIndex -= 1) {
+            const timing = turnTimings[timingIndex];
+            if (normalizedPrompt(timing?.userText) !== transcriptTurn.prompt)
+                continue;
+            const completedAt = parsedTimestamp(timing?.completedAt);
+            const distance = completedAt === undefined || transcriptTurn.assistantAt === undefined
+                ? Number.POSITIVE_INFINITY
+                : Math.abs(completedAt - transcriptTurn.assistantAt);
+            if (matchedIndex === undefined || distance < matchedDistance) {
+                matchedIndex = timingIndex;
+                matchedDistance = distance;
+            }
+        }
+        if (matchedIndex === undefined)
+            continue;
+        assignments[turnIndex] = turnTimings[matchedIndex];
+        timingCursor = matchedIndex - 1;
+    }
+    return assignments;
+}
+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;
@@ -110,7 +175,7 @@ function createUserMessageNode(piboSessionId, entry, content, entryIndex) {
         children: [],
     };
 }
-function createAssistantTurnNodes(piboSessionId, entries) {
+function createAssistantTurnNodes(piboSessionId, entries, timing) {
     const firstAssistant = entries.find(({ entry }) => messageRole(entry) === "assistant");
     if (!firstAssistant)
         return [];
@@ -142,14 +207,12 @@ function createAssistantTurnNodes(piboSessionId, entries) {
                         error: responseError,
                         children: [],
                         startedAt: entry.timestamp,
-                        completedAt: entry.timestamp,
                     });
                     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.completedAt = entry.timestamp;
                 }
             }
             else if (typed.type === "toolCall" && typeof typed.id === "string" && typeof typed.name === "string") {
@@ -163,6 +226,11 @@ function createAssistantTurnNodes(piboSessionId, entries) {
             responseNode.error = responseError;
         }
     }
+    const finalNode = orderedNodes.at(-1);
+    if (finalNode?.type === "assistant.message" && finalNode.status === "done") {
+        finalNode.completedAt = timing?.completedAt ?? finalNode.startedAt;
+        finalNode.durationMs = timing?.durationMs;
+    }
     return orderedNodes;
 }
 function createReasoningNode(piboSessionId, entry, entryIndex, index, thinking) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.8.2",
+  "version": "1.9.1",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"