@pasko70/pibo 1.8.2 → 1.9.2

package/dist/session-ui/activeTurn.js

@@ -0,0 +1,126 @@
+export const EMPTY_STABLE_ACTIVE_TURN = { active: false };
+export function resolveStableActiveTurn(previous, observation) {
+    const sessionId = observation.sessionId ?? previous.sessionId;
+    const sameSession = !previous.sessionId || !sessionId || previous.sessionId === sessionId;
+    const current = sameSession ? previous : { active: false, sessionId };
+    const terminalKey = observation.terminal?.key;
+    const observedStartedAt = validTimestamp(observation.startedAt) ? observation.startedAt : undefined;
+    if (observedStartedAt && terminalClosesTurn(observation.terminal, observedStartedAt)) {
+        return inactiveState(current, sessionId, terminalKey);
+    }
+    if (observedStartedAt) {
+        if (current.active &&
+            current.sessionId === sessionId &&
+            current.startedAt === observedStartedAt &&
+            current.terminalBaselineKey === terminalKey)
+            return current;
+        return {
+            sessionId,
+            active: true,
+            startedAt: observedStartedAt,
+            terminalBaselineKey: terminalKey,
+        };
+    }
+    if (current.active) {
+        if (terminalKey && terminalKey !== current.terminalBaselineKey) {
+            return inactiveState(current, sessionId, terminalKey);
+        }
+        return current;
+    }
+    if (observation.activeEvidence && terminalKey !== current.endedByTerminalKey) {
+        return {
+            sessionId,
+            active: true,
+            terminalBaselineKey: terminalKey,
+        };
+    }
+    if (current.sessionId === sessionId)
+        return current;
+    return { ...current, sessionId };
+}
+export function findLatestActiveTurnTerminal(traceView) {
+    if (!traceView)
+        return undefined;
+    let latest;
+    for (const event of traceView.rawEvents) {
+        const payload = record(event.payload);
+        const type = typeof payload?.type === "string" ? payload.type : event.type;
+        const isTerminal = type === "message_finished" || type === "session_error" ||
+            (type === "execution_result" && isTurnStoppingAction(payload?.action));
+        if (!isTerminal)
+            continue;
+        latest = latestActiveTurnTerminal(latest, {
+            key: `${type}:${event.eventSequence ?? event.streamId ?? event.id}`,
+            at: event.createdAt,
+        });
+    }
+    for (const node of flattenTraceNodes(traceView.nodes)) {
+        const terminalAt = node.type === "agent.turn" ? node.completedAt : node.type === "error" ? node.completedAt ?? node.startedAt : undefined;
+        if (!terminalAt)
+            continue;
+        latest = latestActiveTurnTerminal(latest, { key: `node:${node.id}:${node.status}`, at: terminalAt });
+    }
+    return latest;
+}
+export function findSignalActiveTurnStartedAt(sessionSignal, signalTree) {
+    if (!sessionSignal?.isTreeActive || !signalTree)
+        return undefined;
+    const currentTurn = sessionSignal.currentTurnId ? signalTree.nodes[sessionSignal.currentTurnId] : undefined;
+    if (currentTurn?.startedAt)
+        return currentTurn.startedAt;
+    return Object.values(signalTree.nodes)
+        .filter((node) => node.piboSessionId === sessionSignal.piboSessionId && node.kind === "turn" && isActiveSignalStatus(node.status) && node.startedAt)
+        .sort((left, right) => Date.parse(left.startedAt ?? left.createdAt) - Date.parse(right.startedAt ?? right.createdAt))
+        .at(-1)?.startedAt;
+}
+export function findSignalActiveTurnTerminal(sessionSignal) {
+    if (!sessionSignal || sessionSignal.isTreeActive)
+        return undefined;
+    const status = [sessionSignal.localStatus, sessionSignal.aggregateStatus].find(isTerminalSignalStatus);
+    return status ? { key: `signal:${status}:${sessionSignal.updatedAt}`, at: sessionSignal.updatedAt } : undefined;
+}
+export function latestActiveTurnTerminal(left, right) {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    return Date.parse(right.at) >= Date.parse(left.at) ? right : left;
+}
+function flattenTraceNodes(nodes) {
+    return nodes.flatMap((node) => [node, ...flattenTraceNodes(node.children)]);
+}
+function inactiveState(current, sessionId, terminalKey) {
+    if (!current.active &&
+        current.sessionId === sessionId &&
+        current.endedByTerminalKey === terminalKey)
+        return current;
+    return {
+        sessionId,
+        active: false,
+        endedByTerminalKey: terminalKey,
+    };
+}
+function terminalClosesTurn(terminal, startedAt) {
+    if (!terminal)
+        return false;
+    const terminalMs = Date.parse(terminal.at);
+    const startedMs = Date.parse(startedAt);
+    return Number.isFinite(terminalMs) && Number.isFinite(startedMs) && terminalMs >= startedMs;
+}
+function isTurnStoppingAction(value) {
+    return value === "abort" || value === "kill" || value === "kill_all" || value === "dispose";
+}
+function isActiveSignalStatus(status) {
+    return status === "queued" || status === "starting" || status === "running" || status === "streaming" || status === "compacting" || status === "blocked" || status === "paused";
+}
+function isTerminalSignalStatus(status) {
+    return status === "error" || status === "failed" || status === "cancelled" || status === "interrupted" || status === "disposed";
+}
+function validTimestamp(value) {
+    return Boolean(value && Number.isFinite(Date.parse(value)));
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/dist/session-ui/delegation.js

@@ -0,0 +1,89 @@
+export function resolveAgentDelegationStatus(childSignal, fallbackStatus = "done", traceTerminal = false) {
+    if (!childSignal)
+        return fallbackStatus === "running" ? "running" : fallbackStatus === "error" ? "failed" : "completed";
+    if (traceTerminal)
+        return fallbackStatus === "error" ? "failed" : "completed";
+    const statuses = [childSignal.localStatus, childSignal.aggregateStatus];
+    if (statuses.some(isCancelledSignalStatus))
+        return "cancelled";
+    if (childSignal.hasError || childSignal.hasErrorDescendant || statuses.some(isFailedSignalStatus))
+        return "failed";
+    if (childSignal.isSettled === false || childSignal.isTreeActive || childSignal.isLocalActive || childSignal.hasActiveDescendant || statuses.some(isRunningSignalStatus))
+        return "running";
+    if (fallbackStatus === "running" && statuses.every(isIdleSignalStatus))
+        return "running";
+    return "completed";
+}
+export function extractAgentDelegationName(input, title, summary) {
+    const record = isRecord(input) ? input : undefined;
+    const rawName = stringValue(record?.subagentName)
+        ?? subagentNameFromToolName(title)
+        ?? stringValue(summary)
+        ?? stringValue(title)
+        ?? "Subagent";
+    return titleCaseAgentName(rawName);
+}
+export function extractAgentDelegationTask(input) {
+    if (typeof input === "string")
+        return nonEmpty(input);
+    if (!isRecord(input))
+        return undefined;
+    for (const key of ["message", "task", "prompt", "query"]) {
+        const value = nonEmpty(input[key]);
+        if (value)
+            return value;
+    }
+    return extractAgentDelegationTask(input.arguments);
+}
+export function compactAgentDelegationTask(input, maxLength = 180) {
+    const task = extractAgentDelegationTask(input)?.replace(/\s+/g, " ").trim();
+    if (!task || maxLength < 1)
+        return undefined;
+    return task.length <= maxLength ? task : `${task.slice(0, Math.max(1, maxLength - 1)).trimEnd()}…`;
+}
+export function formatAgentDelegationDuration(durationMs) {
+    const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+    if (totalSeconds < 60)
+        return `${totalSeconds}s`;
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    if (hours > 0)
+        return `${hours}h ${minutes}m ${seconds}s`;
+    return `${minutes}m ${seconds}s`;
+}
+function isRunningSignalStatus(status) {
+    return ["queued", "starting", "running", "streaming", "waiting", "blocked", "retrying", "compacting", "pausing", "paused"].includes(status);
+}
+function isIdleSignalStatus(status) {
+    return status === "idle" || status === "unknown";
+}
+function isFailedSignalStatus(status) {
+    return status === "error";
+}
+function isCancelledSignalStatus(status) {
+    return status === "cancelled" || status === "interrupted" || status === "disposed";
+}
+function subagentNameFromToolName(value) {
+    const name = nonEmpty(value);
+    if (!name)
+        return undefined;
+    return name.replace(/^pibo_subagent_/, "");
+}
+function titleCaseAgentName(value) {
+    return value
+        .replace(/^pibo_subagent_/, "")
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+        .join(" ") || "Subagent";
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function stringValue(value) {
+    return nonEmpty(value);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/session-ui/index.js

@@ -1,5 +1,6 @@
 export * from "./commandCatalog.js";
 export * from "./commandResults.js";
+export * from "./delegation.js";
 export * from "./roomSessionViewModel.js";
 export * from "./statusViewModel.js";
 export * from "./terminalCards.js";

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);
 }