@pasko70/pibo 3.1.3 → 3.1.4

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

@@ -150,7 +150,7 @@ export class PiboDataSessionStore {
     claimOrAttachOutputPart(input) {
         return this.dataStore.transaction(() => {
             const indexAttribute = outputPartIndexAttribute(input.kind);
-            const eventTypes = outputPartEventTypes(input.kind);
+            const eventTypes = [...outputPartEventTypes(input.kind), "message_finished"];
             const placeholders = eventTypes.map(() => "?").join(", ");
             const rows = this.db.prepare(`
 				SELECT type, attributes_json
@@ -159,26 +159,33 @@ export class PiboDataSessionStore {
 				ORDER BY stream_id ASC
 			`).all(input.piboSessionId, input.eventId, ...eventTypes);
             let maximum = -1;
-            const latestTypeByIndex = new Map();
+            let turnCompleted = false;
+            const persistedParts = [];
             for (const row of rows) {
+                if (row.type === "message_finished") {
+                    turnCompleted = true;
+                    continue;
+                }
                 const attributes = parseJsonObject(row.attributes_json);
                 const index = attributes[indexAttribute];
                 if (typeof index !== "number" || !Number.isSafeInteger(index) || index < 0)
                     continue;
                 maximum = Math.max(maximum, index);
-                if (attributes.outputPartFingerprint === input.fingerprint
-                    || attributes.identityFingerprint === input.identityFingerprint) {
-                    this.observeOutputPartIndex(input, index);
-                    return index;
-                }
-                latestTypeByIndex.set(index, row.type);
+                persistedParts.push({ index, attributes });
             }
-            const latestOpen = [...latestTypeByIndex.entries()]
-                .filter(([, eventType]) => !outputPartEventIsTerminal(eventType))
-                .sort(([left], [right]) => right - left)[0]?.[0];
-            if (latestOpen !== undefined) {
-                this.observeOutputPartIndex(input, latestOpen);
-                return latestOpen;
+            // An unfinished durable part may still belong to another process. Only a
+            // completed turn provides enough evidence to reattach an exact replay.
+            if (turnCompleted) {
+                const matchesReplay = ({ attributes }) => attributes.outputPartFingerprint === input.fingerprint
+                    || attributes.identityFingerprint === input.identityFingerprint;
+                const replay = (input.suppliedIndex === undefined
+                    ? undefined
+                    : persistedParts.find((part) => part.index === input.suppliedIndex && matchesReplay(part)))
+                    ?? persistedParts.find(matchesReplay);
+                if (replay) {
+                    this.observeOutputPartIndex(input, replay.index);
+                    return replay.index;
+                }
             }
             const minimum = Math.max(input.proposedIndex, maximum + 1);
             const row = this.db.prepare(`
@@ -193,6 +200,11 @@ export class PiboDataSessionStore {
             return row.part_index;
         });
     }
+    observeOutputPart(input) {
+        this.dataStore.transaction(() => {
+            this.observeOutputPartIndex(input, input.index);
+        });
+    }
     observeOutputPartIndex(input, index) {
         this.db.prepare(`
 			INSERT INTO session_output_part_counters (
@@ -639,12 +651,6 @@ function outputPartEventTypes(kind) {
         case "compaction": return ["compaction_start", "compaction_end"];
     }
 }
-function outputPartEventIsTerminal(eventType) {
-    return eventType === "assistant_message"
-        || eventType === "thinking_finished"
-        || eventType === "assistant_usage"
-        || eventType === "compaction_end";
-}
 function parseJsonObject(json) {
     if (!json)
         return {};

package/dist/shared/trace-engine.js

@@ -1,5 +1,5 @@
 import { reconcileAsyncAgentRunStatuses } from "./trace-async-agent-runs.js";
-import { applySingleEventToNodes, dedupeTraceEvents, findOpenTranscriptEventIds, latestTraceStreamId, mergeMessageTurnTimings, messageTurnTimingsFromEvents, reconcileTranscriptUserMessages, } from "./trace-event-projection.js";
+import { applySingleEventToNodes, dedupeTraceEvents, findOpenTranscriptEventIds, latestTraceStreamId, markIncompletePersistedTurns, mergeMessageTurnTimings, messageTurnTimingsFromEvents, reconcileTranscriptUserMessages, } from "./trace-event-projection.js";
 import { flattenTraceNodes, mapTraceNodesById, nestTraceNodes } from "./trace-nodes.js";
 import { mapTraceChildSessionsByParent, mapTraceSubagentSessionLinks, } from "./trace-subagent-links.js";
 import { projectHistoryEntries, traceNodesFromHistoryEntries } from "./trace-history.js";
@@ -18,7 +18,8 @@ export function buildTraceViewFromEvents(input) {
     const openHistoryEventIds = findOpenTranscriptEventIds(events, sessionStatus);
     const suppliedTurnTimings = input.turnTimings ?? [];
     const eventTurnTimings = messageTurnTimingsFromEvents(events);
-    const timingOverflow = suppliedTurnTimings.length + eventTurnTimings.length > TRACE_RECONCILIATION_TIMING_CAP;
+    const timingOverflow = input.turnTimingOverflow === true
+        || suppliedTurnTimings.length + eventTurnTimings.length > TRACE_RECONCILIATION_TIMING_CAP;
     const turnTimings = timingOverflow
         ? []
         : mergeMessageTurnTimings(suppliedTurnTimings, eventTurnTimings);
@@ -42,11 +43,13 @@ export function buildTraceViewFromEvents(input) {
     for (const storedEvent of events) {
         applySingleEventToNodes(nodes, byId, input.session.id, storedEvent, childByParent, linkedChildByToolCallId, historyCoverage, openHistoryEventIds, sessionStatus);
     }
+    const hasIncompleteTurns = markIncompletePersistedTurns(nodes, byId, input.session.id, events, turnTimings, sessionStatus);
     const nestedNodes = nestTraceNodes(nodes);
     reconcileAsyncAgentRunStatuses(nestedNodes);
     return {
         piboSessionId: input.session.id,
         piSessionId: input.session.piSessionId,
+        ...(hasIncompleteTurns ? { integrityStatus: "incomplete" } : {}),
         title: input.session.title ?? "Untitled Session",
         version: "",
         latestStreamId: latestTraceStreamId(events, input.latestStreamId),

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

@@ -232,6 +232,80 @@ function turnClosedAt(turn, byId) {
         .at(0);
     return error?.startedAt;
 }
+const INCOMPLETE_TURN_SUMMARY = "Incomplete output lifecycle";
+const INCOMPLETE_TURN_ERROR = "Persisted output has message_started but no message_finished or session_error event.";
+export function markIncompletePersistedTurns(nodes, byId, piboSessionId, events, turnTimings, sessionStatus) {
+    const lifecycleByEventId = new Map();
+    for (const timing of turnTimings) {
+        const lifecycle = lifecycleByEventId.get(timing.eventId) ?? { started: false, completed: false };
+        lifecycle.started ||= timing.startedAt !== undefined;
+        lifecycle.completed ||= timing.completedAt !== undefined;
+        lifecycleByEventId.set(timing.eventId, lifecycle);
+    }
+    const incompleteEventIds = new Set([...lifecycleByEventId].flatMap(([eventId, lifecycle]) => lifecycle.started && !lifecycle.completed ? [eventId] : []));
+    if (sessionStatus === "running") {
+        const currentTurn = [...turnTimings].reverse().find((timing) => timing.userMessageType !== "message_steered" &&
+            timing.startedAt !== undefined);
+        if (currentTurn?.startedAt !== undefined && currentTurn.completedAt === undefined) {
+            incompleteEventIds.delete(currentTurn.eventId);
+        }
+    }
+    if (incompleteEventIds.size === 0)
+        return false;
+    const startByEventId = new Map();
+    const lastByEventId = new Map();
+    for (const storedEvent of events) {
+        const event = storedEvent.payload;
+        const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
+        if (!eventId || !incompleteEventIds.has(eventId))
+            continue;
+        if (event.type === "message_started" && !startByEventId.has(eventId))
+            startByEventId.set(eventId, storedEvent);
+        lastByEventId.set(eventId, storedEvent);
+    }
+    for (const eventId of incompleteEventIds) {
+        const start = startByEventId.get(eventId);
+        if (!start)
+            continue;
+        const startEvent = start.payload;
+        const turnId = messageTurnNodeId(eventId);
+        let turn = byId.get(turnId);
+        if (!turn) {
+            turn = traceNodeFromEvent(piboSessionId, startEvent, new Map(), new Map(), sessionStatus, start.createdAt, start.eventSequence, start.streamId, start.streamFrameIndex, start.traceSource, start.id);
+            if (!turn)
+                continue;
+            nodes.push(turn);
+            byId.set(turn.id, turn);
+        }
+        turn.status = "error";
+        turn.summary = INCOMPLETE_TURN_SUMMARY;
+        turn.error = INCOMPLETE_TURN_ERROR;
+        const markerId = `event:incomplete-turn:${eventId}`;
+        if (byId.has(markerId))
+            continue;
+        const last = lastByEventId.get(eventId) ?? start;
+        const marker = {
+            id: markerId,
+            parentId: turnId,
+            piboSessionId,
+            eventId,
+            type: "error",
+            title: "Incomplete Turn",
+            status: "error",
+            startedAt: last.createdAt,
+            summary: INCOMPLETE_TURN_SUMMARY,
+            error: INCOMPLETE_TURN_ERROR,
+            output: INCOMPLETE_TURN_ERROR,
+            source: "event-log",
+            stableKey: `incomplete-turn:${eventId}`,
+            orderKey: eventTraceNodeOrder(last.eventSequence, "session_error", last.streamId, last.streamFrameIndex, last.traceSource, undefined, last.createdAt),
+            children: [],
+        };
+        nodes.push(marker);
+        byId.set(marker.id, marker);
+    }
+    return [...incompleteEventIds].some((eventId) => byId.has(`event:incomplete-turn:${eventId}`));
+}
 export function eventsCanAffectAsyncAgentRunStatus(events) {
     return events.some((event) => {
         const type = event.payload.type;

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

@@ -4,10 +4,12 @@ export function mergeOlderTracePage(current, older) {
     if (current.piboSessionId !== older.piboSessionId)
         return current;
     const rawEvents = mergeTraceRawEvents(older.rawEvents, current.rawEvents, false);
+    const nodes = mergeTraceNodes(older.nodes, current.nodes);
     return {
         ...current,
         version: current.version,
-        nodes: mergeTraceNodes(older.nodes, current.nodes),
+        integrityStatus: traceIntegrityStatus(nodes) ?? current.integrityStatus ?? older.integrityStatus,
+        nodes,
         rawEvents,
         beforeCursor: older.beforeCursor ?? current.beforeCursor,
         firstEventSequence: older.firstEventSequence ?? current.firstEventSequence,
@@ -20,9 +22,11 @@ export function mergeOlderTracePage(current, older) {
 export function mergeRefreshedTracePage(current, refreshed) {
     if (current.piboSessionId !== refreshed.piboSessionId)
         return refreshed;
+    const nodes = mergeRefreshedTraceNodes(current.nodes, refreshed);
     return {
         ...refreshed,
-        nodes: mergeRefreshedTraceNodes(current.nodes, refreshed),
+        integrityStatus: traceIntegrityStatus(nodes) ?? refreshed.integrityStatus,
+        nodes,
         rawEvents: mergeTraceRawEvents(current.rawEvents, refreshed.rawEvents, true),
         beforeCursor: current.beforeCursor,
         firstEventSequence: current.firstEventSequence ?? refreshed.firstEventSequence,
@@ -36,10 +40,13 @@ function mergeRefreshedTraceNodes(currentNodes, refreshed) {
     const flattenedCurrentNodes = flattenTraceNodes([...currentNodes]);
     const refreshedNodes = flattenTraceNodes([...refreshed.nodes]);
     const refreshedIds = new Set(refreshedNodes.map((node) => node.id));
+    const refreshedTerminalEventIds = terminalEventIds(refreshedNodes);
     const canonicalTranscriptEventIds = transcriptEventIds([...flattenedCurrentNodes, ...refreshedNodes]);
     const refreshedOrderBoundaries = earliestTraceNodeOrdersBySource(refreshedNodes);
     const refreshedStartedAt = earliestTraceNodeTimestamp(refreshedNodes);
     const retainedOlderNodes = flattenedCurrentNodes.filter((node) => {
+        if (isIncompleteTurnMarker(node) && node.eventId && refreshedTerminalEventIds.has(node.eventId))
+            return false;
         if (refreshedIds.has(node.id))
             return true;
         if (node.type === "agent.turn" &&
@@ -71,9 +78,28 @@ function mergeRefreshedTraceNodes(currentNodes, refreshed) {
     return mergeTraceNodes(clearRemovedParentIds(retainedOlderNodes, removedCurrentIds), clearRemovedParentIds(refreshedNodes, removedCurrentIds));
 }
 function clearRemovedParentIds(nodes, removedIds) {
-    return nodes.map((node) => node.parentId && removedIds.has(node.parentId)
-        ? { ...node, parentId: undefined }
-        : node);
+    return nodes.map((node) => ({
+        ...node,
+        ...(node.parentId && removedIds.has(node.parentId) ? { parentId: undefined } : {}),
+        children: [],
+    }));
+}
+function traceIntegrityStatus(nodes) {
+    return flattenTraceNodes([...nodes]).some(isIncompleteTurnMarker) ? "incomplete" : undefined;
+}
+function isIncompleteTurnMarker(node) {
+    return node.id.startsWith("event:incomplete-turn:") || node.stableKey?.startsWith("incomplete-turn:") === true;
+}
+function terminalEventIds(nodes) {
+    return new Set(nodes.flatMap((node) => {
+        if (!node.eventId)
+            return [];
+        if (node.type === "agent.turn" && node.completedAt)
+            return [node.eventId];
+        if (node.type === "error" && node.title === "Session Error")
+            return [node.eventId];
+        return [];
+    }));
 }
 function transcriptEventIds(nodes) {
     const eventIds = new Set();

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.1.3",
+  "version": "3.1.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "3.1.3",
+      "version": "3.1.4",
       "workspaces": [
         "packages/workflows"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.1.3",
+  "version": "3.1.4",
   "type": "module",
   "workspaces": [
     "packages/workflows"