@pasko70/pibo 1.10.0 → 1.11.0

package/dist/runs/lifecycle.js

@@ -0,0 +1,59 @@
+export class PiboRunExecutionTimeoutError extends Error {
+    timeoutPhase;
+    constructor(message, timeoutPhase) {
+        super(message);
+        this.timeoutPhase = timeoutPhase;
+        this.name = "PiboRunExecutionTimeoutError";
+    }
+}
+export function resolveRunTimeoutMs(toolName, params) {
+    if (!params || typeof params !== "object" || Array.isArray(params))
+        return undefined;
+    const input = params;
+    if (typeof input.timeoutMs === "number")
+        return normalizePositiveTimeout(input.timeoutMs, "arguments.timeoutMs");
+    if (toolName === "bash" && typeof input.timeout === "number")
+        return normalizePositiveTimeout(input.timeout * 1000, "arguments.timeout");
+    return undefined;
+}
+export function foregroundServiceWarning(toolName, params, timeoutMs) {
+    if (toolName !== "bash" || timeoutMs === undefined || !params || typeof params !== "object" || Array.isArray(params))
+        return undefined;
+    const command = typeof params.command === "string" ? String(params.command) : "";
+    if (!isKnownForegroundServiceCommand(command))
+        return undefined;
+    return `Known long-lived service command is running in a finite yielded run (${timeoutMs}ms). It can start successfully and later end as timed_out. Use the managed gateway CLI, or launch a detached/background service with a separate bounded health check.`;
+}
+export function isConfiguredTimeoutError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /(?:timed?\s*out|timeout)/i.test(message);
+}
+export function hasMeaningfulTimeoutOutput(value) {
+    const text = extractText(value);
+    if (!text)
+        return false;
+    return text.split(/\r?\n/).some((line) => {
+        const trimmed = line.trim();
+        return !!trimmed && !/(?:timed?\s*out|timeout|command exited with code|process exited with code)/i.test(trimmed);
+    });
+}
+function isKnownForegroundServiceCommand(command) {
+    return /(?:^|[;&|]\s*|\b)(?:pibo\s+gateway(?::web|\s+web|\s+dev)?(?:\s|$)|node\s+[^\n]*pibo(?:\.js)?\s+gateway:web(?:\s|$)|(?:\.\/)?(?:scripts\/)?docker-entrypoint\.sh\s+gateway:web(?:\s|$)|npm\s+(?:run\s+)?gateway(?::web)?(?:\s|$)|(?:npm\s+run\s+)?(?:dev|start)\s+--[^\n]*\bgateway(?::web)?\b|vite(?:\s|$))/i.test(command);
+}
+function normalizePositiveTimeout(value, field) {
+    if (!Number.isFinite(value) || value <= 0)
+        throw new Error(`${field} must be a positive number`);
+    return Math.max(1, Math.round(value));
+}
+function extractText(value) {
+    if (typeof value === "string")
+        return value;
+    if (!value || typeof value !== "object")
+        return "";
+    const candidate = value;
+    if (typeof candidate.text === "string")
+        return candidate.text;
+    if (!Array.isArray(candidate.content))
+        return "";
+    return candidate.content.map((part) => part && typeof part === "object" && typeof part.text === "string" ? String(part.text) : "").filter(Boolean).join("\n");
+}

package/dist/runs/registry.js

@@ -4,6 +4,14 @@ const DEFAULT_DETACHED_TERMINAL_TTL_MS = 60 * 1000;
 function now() {
     return new Date().toISOString();
 }
+function runTimeoutAt(createdAt, timeoutMs) {
+    return timeoutMs === undefined ? undefined : new Date(Date.parse(createdAt) + timeoutMs).toISOString();
+}
+function formatTimeout(timeoutMs) {
+    if (timeoutMs === undefined)
+        return "its configured timeout";
+    return timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}s timeout` : `${timeoutMs}ms timeout`;
+}
 function snapshot(record) {
     const output = {
         runId: record.runId,
@@ -18,12 +26,20 @@ function snapshot(record) {
     };
     if (record.summary)
         output.summary = record.summary;
+    if (record.timeoutMs !== undefined)
+        output.timeoutMs = record.timeoutMs;
+    if (record.timeoutAt)
+        output.timeoutAt = record.timeoutAt;
+    if (record.timeoutPhase)
+        output.timeoutPhase = record.timeoutPhase;
+    if (record.serviceWarning)
+        output.serviceWarning = record.serviceWarning;
     if (record.completedAt)
         output.completedAt = record.completedAt;
     return output;
 }
 function terminal(status) {
-    return status === "completed" || status === "failed" || status === "cancelled";
+    return status === "completed" || status === "failed" || status === "timed_out" || status === "cancelled";
 }
 export class PiboRunRegistry {
     options;
@@ -53,6 +69,8 @@ export class PiboRunRegistry {
                 params: input.params,
                 retryable: input.retryable ?? false,
                 maxAttempts: input.maxAttempts ?? 1,
+                timeoutMs: input.timeoutMs,
+                serviceWarning: input.serviceWarning,
             });
             const record = recordFromStored(stored);
             this.runs.set(record.runId, record);
@@ -75,6 +93,8 @@ export class PiboRunRegistry {
             summary: `${input.toolName} run is running.`,
             retryable: input.retryable ?? false,
             maxAttempts: Math.max(1, input.maxAttempts ?? 1),
+            ...(input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs, timeoutAt: runTimeoutAt(timestamp, input.timeoutMs) } : {}),
+            ...(input.serviceWarning ? { serviceWarning: input.serviceWarning } : {}),
         };
         this.runs.set(runId, record);
         const output = snapshot(record);
@@ -113,6 +133,25 @@ export class PiboRunRegistry {
         this.notify({ type: "run_changed", run: output, previousStatus, reason: error });
         return output;
     }
+    timeOut(runId, error, timeoutPhase) {
+        const record = this.runs.get(runId);
+        if (!record || terminal(record.status))
+            return undefined;
+        const previousStatus = record.status;
+        record.status = "timed_out";
+        record.error = error;
+        record.timeoutPhase = timeoutPhase;
+        record.summary = timeoutPhase === "lifetime"
+            ? `${record.toolName} run started successfully, then reached ${formatTimeout(record.timeoutMs)}.`
+            : `${record.toolName} run reached ${formatTimeout(record.timeoutMs)} before startup was confirmed.`;
+        this.finish(record);
+        this.options.store?.updateRun(runId, record);
+        if (record.jobId)
+            this.options.store?.fail(record.jobId, `run-registry:${process.pid}`, error);
+        const output = snapshot(record);
+        this.notify({ type: "run_changed", run: output, previousStatus, reason: error });
+        return output;
+    }
     list(controllerPiboSessionId, options = {}) {
         this.prune();
         return [...this.runs.values()]
@@ -219,6 +258,7 @@ export class PiboRunRegistry {
         const notification = {
             completed: [],
             failed: [],
+            timedOut: [],
             cancelled: [],
             running: [],
         };
@@ -228,6 +268,8 @@ export class PiboRunRegistry {
                 notification.completed.push(item);
             else if (record.status === "failed")
                 notification.failed.push(item);
+            else if (record.status === "timed_out")
+                notification.timedOut.push(item);
             else if (record.status === "cancelled")
                 notification.cancelled.push(item);
             else
@@ -356,5 +398,9 @@ function recordFromStored(record) {
         jobId: record.jobId,
         retryable: record.retryable,
         maxAttempts: record.maxAttempts,
+        timeoutMs: record.timeoutMs,
+        timeoutAt: record.timeoutAt,
+        timeoutPhase: record.timeoutPhase,
+        serviceWarning: record.serviceWarning,
     };
 }

package/dist/runs/tools.js

@@ -1,5 +1,6 @@
 import { StringEnum, Type } from "@earendil-works/pi-ai";
 import { defineTool } from "@earendil-works/pi-coding-agent";
+import { foregroundServiceWarning, hasMeaningfulTimeoutOutput, isConfiguredTimeoutError, PiboRunExecutionTimeoutError, resolveRunTimeoutMs } from "./lifecycle.js";
 function resultText(prefix, value) {
     return `${prefix}\n${JSON.stringify(value, null, 2)}`;
 }
@@ -30,7 +31,7 @@ export function createRunToolDefinitions(yieldableTools, controller) {
         defineTool({
             name: "pibo_run_start",
             label: "Pibo Run Start",
-            description: "Start a yieldable tool as a yielded run. Use tracked when the result may matter later; use detached only for intentional fire-and-forget work.",
+            description: "Start a yieldable tool as a yielded run. The run records its configured timeout and classifies lifetime expiry separately from command failure. Use detached only for intentional fire-and-forget work.",
             promptSnippet: "Use pibo_run_start to run a yieldable tool in the background. It returns a runId. Use pibo_run_read for completed results and pibo_run_wait/status/list/cancel/ack to manage runs.",
             executionMode: "parallel",
             parameters: Type.Object({
@@ -43,25 +44,42 @@ export function createRunToolDefinitions(yieldableTools, controller) {
             }),
             async execute(toolCallId, params, signal, onUpdate, ctx) {
                 const tool = requireTool(yieldableTools, params.toolName);
+                const timeoutMs = resolveRunTimeoutMs(tool.name, params.arguments);
+                const serviceWarning = foregroundServiceWarning(tool.name, params.arguments, timeoutMs);
+                let observedOutput = false;
                 const run = controller.startToolRun({
                     toolName: tool.name,
                     params: params.arguments,
                     completionPolicy: params.completionPolicy,
+                    timeoutMs,
+                    serviceWarning,
                     async execute() {
-                        const result = await tool.execute(toolCallId, params.arguments, signal, onUpdate, ctx);
-                        const resultObject = result;
-                        const text = textFromToolResult(resultObject);
-                        if (resultObject.isError === true) {
-                            throw new Error(text ?? `${tool.name} returned an error result.`);
+                        try {
+                            const result = await tool.execute(toolCallId, params.arguments, signal, (update) => {
+                                observedOutput ||= hasMeaningfulTimeoutOutput(update);
+                                onUpdate?.(update);
+                            }, ctx);
+                            const resultObject = result;
+                            const text = textFromToolResult(resultObject);
+                            if (resultObject.isError === true) {
+                                if (timeoutMs !== undefined && isConfiguredTimeoutError(text ?? ""))
+                                    throw new PiboRunExecutionTimeoutError(text ?? `${tool.name} timed out.`, observedOutput || hasMeaningfulTimeoutOutput(text) ? "lifetime" : "startup");
+                                throw new Error(text ?? `${tool.name} returned an error result.`);
+                            }
+                            return { text, details: resultObject.details ?? result };
+                        }
+                        catch (error) {
+                            if (error instanceof PiboRunExecutionTimeoutError)
+                                throw error;
+                            if (timeoutMs !== undefined && isConfiguredTimeoutError(error))
+                                throw new PiboRunExecutionTimeoutError(error instanceof Error ? error.message : String(error), observedOutput ? "lifetime" : "startup");
+                            throw error;
                         }
-                        return {
-                            text,
-                            details: resultObject.details ?? result,
-                        };
                     },
                 });
+                const prefix = serviceWarning ? `Started yielded run ${run.runId}.\nWarning: ${serviceWarning}` : `Started yielded run ${run.runId}.`;
                 return {
-                    content: [{ type: "text", text: resultText(`Started yielded run ${run.runId}.`, run) }],
+                    content: [{ type: "text", text: resultText(prefix, run) }],
                     details: run,
                 };
             },
@@ -132,8 +150,8 @@ export function createRunToolDefinitions(yieldableTools, controller) {
         defineTool({
             name: "pibo_run_read",
             label: "Pibo Run Read",
-            description: "Read the terminal result or error for a yielded run.",
-            promptSnippet: "Use pibo_run_read to retrieve a completed or failed run result. Reading terminal tracked runs consumes reminders.",
+            description: "Read the terminal result, timeout reason, or error for a yielded run.",
+            promptSnippet: "Use pibo_run_read to retrieve a completed, failed, or timed_out run result. Reading terminal tracked runs consumes reminders.",
             executionMode: "parallel",
             parameters: Type.Object({
                 runId: Type.String({ description: "Run id returned by pibo_run_start" }),

package/dist/session-ui/terminalRows.js

@@ -11,7 +11,7 @@ export function buildCompactTerminalRows(traceView, options) {
         .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);
+    return groupRelatedToolCandidates(reconcileConceptualRowCandidates(candidates)).map((candidate) => candidate.row);
 }
 export function findActiveTurnStartedAt(traceView) {
     if (!traceView)
@@ -100,7 +100,71 @@ function createRowCandidate(node, turnId) {
             };
             break;
     }
-    return { ...candidate, row: { ...candidate.row, ...debugFields(node) } };
+    return {
+        ...candidate,
+        row: {
+            ...candidate.row,
+            id: compactTerminalRowIdentity(node),
+            ...debugFields(node),
+        },
+    };
+}
+export function compactTerminalRowIdentity(node) {
+    if (node.type === "tool.call" || node.type === "tool.result" || node.type === "agent.delegation") {
+        const toolCallId = node.toolCallId ?? stableKeySuffix(node.stableKey, "tool:");
+        if (toolCallId)
+            return `terminal:tool:${toolCallId}`;
+        if (node.type === "agent.delegation" && node.linkedPiboSessionId) {
+            return `terminal:delegation:${node.linkedPiboSessionId}`;
+        }
+    }
+    if ((node.type === "agent.async" || node.type === "yielded.run") && node.runId) {
+        return `terminal:run:${node.runId}`;
+    }
+    if (node.type === "assistant.message") {
+        const assistantId = stableKeySuffix(node.stableKey, "assistant:");
+        if (assistantId)
+            return `terminal:assistant:${assistantId}`;
+    }
+    if (node.type === "model.reasoning") {
+        const reasoningId = stableKeySuffix(node.stableKey, "reasoning:");
+        if (reasoningId)
+            return `terminal:reasoning:${reasoningId}`;
+    }
+    return node.id;
+}
+function stableKeySuffix(stableKey, prefix) {
+    if (!stableKey?.startsWith(prefix))
+        return undefined;
+    const suffix = stableKey.slice(prefix.length);
+    return suffix && suffix !== "undefined" ? suffix : undefined;
+}
+function reconcileConceptualRowCandidates(candidates) {
+    const reconciled = [];
+    const indexById = new Map();
+    for (const candidate of candidates) {
+        const existingIndex = indexById.get(candidate.row.id);
+        if (existingIndex === undefined) {
+            indexById.set(candidate.row.id, reconciled.length);
+            reconciled.push(candidate);
+            continue;
+        }
+        const existing = reconciled[existingIndex];
+        reconciled[existingIndex] = {
+            ...candidate,
+            turnId: candidate.turnId ?? existing.turnId,
+            row: {
+                ...existing.row,
+                ...candidate.row,
+                sourceNodeIds: [...new Set([...existing.row.sourceNodeIds, ...candidate.row.sourceNodeIds])],
+                input: candidate.row.input ?? existing.row.input,
+                output: candidate.row.output ?? existing.row.output,
+                error: candidate.row.error ?? existing.row.error,
+                payloadRefs: { ...existing.row.payloadRefs, ...candidate.row.payloadRefs },
+            },
+        };
+    }
+    return reconciled;
 }
 function applyCompletedTurnTiming(candidates, turnById) {
     for (const turn of turnById.values()) {

package/dist/shared/trace-async-agent-runs.js

@@ -34,12 +34,12 @@ export function reconcileAsyncAgentRunStatuses(nodes) {
         if (!latest)
             continue;
         const status = stringValue(latest.snapshot.status);
-        if (status !== "completed" && status !== "cancelled" && status !== "failed")
+        if (status !== "completed" && status !== "cancelled" && status !== "failed" && status !== "timed_out")
             continue;
-        node.status = status === "failed" ? "error" : "done";
+        node.status = status === "failed" || status === "timed_out" ? "error" : "done";
         node.completedAt = latest.completedAt ?? node.completedAt;
         node.output = latest.snapshot;
-        if (status === "failed")
+        if (status === "failed" || status === "timed_out")
             node.error = stringValue(latest.snapshot.summary) ?? node.error;
     }
 }
@@ -67,7 +67,7 @@ function createAsyncAgentRunNode(parent, piboSessionId, startedAt, delegation) {
         title: subagentName,
         status: asyncAgentStatus(parent, runStatus),
         startedAt: delegation?.startedAt ?? startedAt ?? parent.startedAt,
-        completedAt: runStatus === "completed" || runStatus === "cancelled" ? parent.completedAt : undefined,
+        completedAt: runStatus === "completed" || runStatus === "cancelled" || runStatus === "failed" || runStatus === "timed_out" ? parent.completedAt : undefined,
         summary: `Started by ${parent.title}`,
         input: {
             startedBy: parent.title,

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

@@ -5,6 +5,13 @@ import { createRunNotificationNode, parseRunNotificationText } from "./trace-run
 import { findLikelyTraceChildSession, isSubagentToolName, } from "./trace-subagent-links.js";
 export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent, childByParent, linkedChildByToolCallId, hasPersistedTranscript, openTranscriptEventIds, sessionStatus) {
     const payload = storedEvent.payload;
+    const confirmedUserMessage = hasPersistedTranscript ? confirmedUserMessageEchoNode(nodes, storedEvent) : undefined;
+    if (confirmedUserMessage) {
+        if (payload.type === "message_steered" && payload.activeEventId) {
+            confirmedUserMessage.parentId = messageTurnNodeId(payload.activeEventId);
+        }
+        return;
+    }
     if (hasPersistedTranscript &&
         isTranscriptEchoEvent(payload) &&
         !shouldKeepTranscriptEchoEvent(payload, openTranscriptEventIds)) {
@@ -84,8 +91,14 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
             return;
         }
     }
-    if (node.eventId && byId.has(node.id))
-        return;
+    if (node.eventId) {
+        const existing = byId.get(node.id);
+        if (existing) {
+            if (node.type === "user.message" && node.parentId)
+                existing.parentId = node.parentId;
+            return;
+        }
+    }
     attachExecutionCommandToOpenTurn(node, byId);
     attachAsyncAgentRunNode(node, piboSessionId, storedEvent.createdAt);
     nodes.push(node);
@@ -174,7 +187,7 @@ export function reconcileTranscriptUserMessageTimestamps(nodes, events) {
     let userCursor = 0;
     for (const storedEvent of events) {
         const event = storedEvent.payload;
-        if (event.type !== "message_queued" || event.source !== "user")
+        if ((event.type !== "message_queued" && event.type !== "message_steered") || event.source !== "user")
             continue;
         const eventId = typeof event.eventId === "string" ? event.eventId : storedEvent.eventId;
         const text = typeof event.text === "string" ? event.text : undefined;
@@ -192,12 +205,15 @@ export function reconcileTranscriptUserMessageTimestamps(nodes, events) {
     }
 }
 export function isConfirmedUserMessageEcho(nodes, event) {
+    return Boolean(confirmedUserMessageEchoNode(nodes, event));
+}
+function confirmedUserMessageEchoNode(nodes, event) {
     const payload = event.payload;
-    if (payload.type !== "message_queued" || payload.source !== "user")
-        return false;
+    if ((payload.type !== "message_queued" && payload.type !== "message_steered") || payload.source !== "user")
+        return undefined;
     const eventId = typeof payload.eventId === "string" ? payload.eventId : event.eventId;
     const text = typeof payload.text === "string" ? payload.text : undefined;
-    return nodes.some((node) => {
+    return flattenTraceNodes([...nodes]).find((node) => {
         if (node.type !== "user.message" || node.source !== "transcript")
             return false;
         if (eventId && (node.entryId === eventId || node.stableKey === `entry:${eventId}`))
@@ -261,7 +277,8 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
         children: [],
     };
     switch (event.type) {
-        case "message_queued": {
+        case "message_queued":
+        case "message_steered": {
             const notification = parseRunNotificationText(event.text);
             if (event.source === "service" && notification) {
                 return createRunNotificationNode({
@@ -277,6 +294,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
             }
             return {
                 ...base,
+                ...(event.type === "message_steered" && event.activeEventId ? { parentId: messageTurnNodeId(event.activeEventId) } : {}),
                 type: "user.message",
                 title: "User Message",
                 status: "done",
@@ -368,10 +386,12 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 children: [],
             };
         }
-        case "subagent_session":
+        case "subagent_session": {
+            const childPiboSessionId = nonEmptyString(event.childPiboSessionId);
+            const eventInstanceKey = traceEventInstanceKey(eventSequence, streamId, event);
             return {
                 ...base,
-                id: event.toolCallId ? `tool:${event.toolCallId}` : id,
+                id: event.toolCallId ? `tool:${event.toolCallId}` : `event:subagent_session:${eventInstanceKey}`,
                 eventId,
                 toolCallId: event.toolCallId,
                 type: "agent.delegation",
@@ -379,10 +399,13 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 status: sessionStatus === "running" ? "running" : "done",
                 summary: event.subagentName,
                 input: { subagentName: event.subagentName, threadKey: event.threadKey },
-                linkedPiboSessionId: event.childPiboSessionId,
-                stableKey: event.toolCallId ? `tool:${event.toolCallId}` : `subagent:${event.childPiboSessionId}`,
+                linkedPiboSessionId: childPiboSessionId,
+                stableKey: event.toolCallId
+                    ? `tool:${event.toolCallId}`
+                    : childPiboSessionId ? `subagent:${childPiboSessionId}` : `subagent:event:${eventInstanceKey}`,
                 children: [],
             };
+        }
         case "execution_result":
             if (isInternalSessionOperation(event.action))
                 return undefined;
@@ -394,21 +417,24 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 input: { action: event.action },
                 output: event.result,
             };
-        case "compaction_start":
+        case "compaction_start": {
+            const eventInstanceKey = traceEventInstanceKey(eventSequence, streamId, event);
             return {
                 ...base,
-                id: `event:compaction:${eventSequence ?? streamId ?? cryptoSafeId(event)}`,
+                id: `event:compaction:${eventInstanceKey}`,
                 type: "execution.compaction",
                 title: "compact",
                 status: "running",
                 summary: "Compacting",
                 input: { reason: event.reason },
-                stableKey: "compaction:active",
+                stableKey: `compaction:${eventInstanceKey}`,
             };
-        case "compaction_end":
+        }
+        case "compaction_end": {
+            const eventInstanceKey = traceEventInstanceKey(eventSequence, streamId, event);
             return {
                 ...base,
-                id: `event:compaction:end:${eventSequence ?? streamId ?? cryptoSafeId(event)}`,
+                id: `event:compaction:end:${eventInstanceKey}`,
                 type: "execution.compaction",
                 title: "compact",
                 status: event.errorMessage ? "error" : "done",
@@ -417,8 +443,9 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 input: { reason: event.reason },
                 output: event.result,
                 error: event.errorMessage,
-                stableKey: "compaction:active",
+                stableKey: `compaction:${eventInstanceKey}`,
             };
+        }
         case "session_error":
             return {
                 ...base,
@@ -435,7 +462,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
     }
 }
 function mergeAssistantDeltaEvent(nodes, byId, event, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex) {
-    if (event.text.length === 0)
+    if (typeof event.text !== "string" || event.text.length === 0)
         return;
     const assistantId = assistantEventNodeId(event);
     const id = assistantId ? assistantMessageNodeId(assistantId) : `event:assistant_delta:${cryptoSafeId(event)}`;
@@ -474,7 +501,7 @@ function mergeAssistantMessageEvent(target, update) {
     target.completedAt = update.completedAt ?? target.completedAt;
 }
 function mergeThinkingDeltaEvent(nodes, byId, event, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex) {
-    if (event.text.length === 0)
+    if (typeof event.text !== "string" || event.text.length === 0)
         return;
     const thinkingId = thinkingEventNodeId(event);
     const id = thinkingId ? thinkingNodeId(thinkingId) : `event:thinking_delta:${cryptoSafeId(event)}`;
@@ -642,6 +669,7 @@ function eventTraceNodeOrder(eventSequence, type, streamId, streamFrameIndex) {
 function eventNodeKind(type) {
     switch (type) {
         case "message_queued":
+        case "message_steered":
             return "user.message";
         case "message_started":
         case "message_finished":
@@ -792,6 +820,18 @@ function parseTimestamp(value) {
     const timestamp = new Date(value).getTime();
     return Number.isFinite(timestamp) ? timestamp : undefined;
 }
+function traceEventInstanceKey(eventSequence, streamId, event) {
+    if (eventSequence !== undefined)
+        return `sequence:${eventSequence}`;
+    if (streamId !== undefined)
+        return `stream:${streamId}`;
+    return cryptoSafeId(event);
+}
+function nonEmptyString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    return value.trim() || undefined;
+}
 function cryptoSafeId(value) {
     return base64UrlEncode(new TextEncoder().encode(JSON.stringify(value))).slice(0, 48);
 }

package/dist/shared/trace-nodes.js

@@ -22,6 +22,11 @@ export function compareTraceNodes(left, right) {
     const bySameTurnPhase = compareSameTurnPhase(left, right);
     if (bySameTurnPhase !== 0)
         return bySameTurnPhase;
+    if (left.orderKey?.sourceRank === right.orderKey?.sourceRank) {
+        const bySameSourceOrder = compareTraceOrder(left.orderKey, right.orderKey);
+        if (bySameSourceOrder !== 0)
+            return bySameSourceOrder;
+    }
     const byStartTime = compareOptionalIsoTime(left.startedAt, right.startedAt);
     if (byStartTime !== 0)
         return byStartTime;

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

@@ -23,6 +23,21 @@ export function mergeOlderTracePage(current, older) {
         eventLimit: (current.eventLimit ?? 0) + (older.eventLimit ?? older.pageSize ?? 0),
     };
 }
+export function mergeRefreshedTracePage(current, refreshed) {
+    if (current.piboSessionId !== refreshed.piboSessionId)
+        return refreshed;
+    return {
+        ...refreshed,
+        nodes: mergeTraceNodes(current.nodes, refreshed.nodes),
+        rawEvents: current.rawEvents.length ? current.rawEvents : refreshed.rawEvents,
+        beforeCursor: current.beforeCursor,
+        firstEventSequence: current.firstEventSequence ?? refreshed.firstEventSequence,
+        nextBeforeSequence: current.nextBeforeSequence,
+        nextBeforeCursor: current.nextBeforeCursor,
+        hasOlderEvents: current.hasOlderEvents,
+        eventLimit: current.eventLimit ?? refreshed.eventLimit,
+    };
+}
 function mergeTraceNodes(olderNodes, currentNodes) {
     const byId = new Map();
     for (const node of flattenTraceNodes([...olderNodes])) {

package/dist/shared/trace-run-notifications.js

@@ -19,7 +19,7 @@ export function parseRunNotificationText(text) {
 export function createRunNotificationNode(input) {
     const runs = runNotificationRuns(input.notification);
     const singleRun = runs.length === 1 ? runs[0] : undefined;
-    const failedCount = countRunGroup(input.notification.failed);
+    const failedCount = countRunGroup(input.notification.failed) + countRunGroup(input.notification.timedOut);
     const runningCount = countRunGroup(input.notification.running);
     return {
         id: input.id,
@@ -43,6 +43,7 @@ function runNotificationRuns(notification) {
     return [
         ...runGroup(notification.completed),
         ...runGroup(notification.failed),
+        ...runGroup(notification.timedOut),
         ...runGroup(notification.cancelled),
         ...runGroup(notification.running),
     ];
@@ -57,6 +58,7 @@ function runNotificationSummary(notification) {
     const parts = [
         [countRunGroup(notification.completed), "completed"],
         [countRunGroup(notification.failed), "failed"],
+        [countRunGroup(notification.timedOut), "timed out"],
         [countRunGroup(notification.cancelled), "cancelled"],
         [countRunGroup(notification.running), "running"],
     ]

package/dist/signals/projector.js

@@ -12,7 +12,7 @@ function node(input, context) {
 function runStatus(status) {
     if (status === "completed")
         return "done";
-    if (status === "failed")
+    if (status === "failed" || status === "timed_out")
         return "error";
     return status;
 }
@@ -28,7 +28,7 @@ function settleActiveSessionNodes(piboSessionId, context, status, terminalSource
 }
 export const sessionLifecycleSignalProducer = {
     name: "session-lifecycle",
-    accepts: (input) => ["session_created", "session_disposed", "session_processing_changed", "message_accepted", "queue_changed", "recovery", "session_interrupted", "signal_node_pruned"].includes(input.type),
+    accepts: (input) => ["session_created", "session_disposed", "session_processing_changed", "message_accepted", "message_rejected", "queue_changed", "recovery", "session_interrupted", "signal_node_pruned"].includes(input.type),
     project(input, context) {
         const data = input;
         if (data.type === "session_created") {
@@ -78,6 +78,15 @@ export const sessionLifecycleSignalProducer = {
             }
             return mutations;
         }
+        if (data.type === "message_rejected") {
+            const acceptedTurn = context.getNode(`turn:${data.piboSessionId}:${data.eventId}`);
+            return [
+                { type: "remove_node", nodeId: `message:${data.piboSessionId}:${data.eventId}` },
+                ...(acceptedTurn?.metadata?.accepted === true
+                    ? [{ type: "remove_node", nodeId: acceptedTurn.id }]
+                    : []),
+            ];
+        }
         if (data.type === "session_disposed") {
             return [
                 ...settleActiveSessionNodes(data.piboSessionId, context, "cancelled", "session_disposed"),
@@ -133,6 +142,10 @@ export const outputSignalProducer = {
             mutations.push({ type: "set_session_queue", piboSessionId, queuedMessages: event.queuedMessages });
             mutations.push({ type: "upsert_node", node: node({ id: `message:${piboSessionId}:${event.eventId ?? context.now()}`, kind: "message", status: "queued", piboSessionId, metadata: { source: event.source } }, context) });
         }
+        if (event.type === "message_steered") {
+            mutations.push({ type: "patch_node", nodeId: `session:${piboSessionId}`, patch: { status: "running" } });
+            mutations.push({ type: "upsert_node", node: node({ id: `message:${piboSessionId}:${event.eventId ?? context.now()}`, kind: "message", status: "done", piboSessionId, parentNodeId: event.activeEventId ? `turn:${piboSessionId}:${event.activeEventId}` : undefined, completedAt: context.now(), metadata: { source: event.source, delivery: "steer" } }, context) });
+        }
         if (event.type === "message_started") {
             mutations.push({ type: "patch_node", nodeId: `session:${piboSessionId}`, patch: { status: "running" } });
             if (event.eventId) {
@@ -200,7 +213,7 @@ export const runSignalProducer = {
         if (data.type !== "run_changed")
             return [];
         const run = data.run;
-        return [{ type: "upsert_node", node: node({ id: `run:${run.runId}`, kind: "yielded_run", status: runStatus(run.status), piboSessionId: run.controllerPiboSessionId, startedAt: run.createdAt, completedAt: run.completedAt, error: run.status === "failed" ? { message: run.summary ?? "Run failed.", source: "run" } : undefined, metadata: { runId: run.runId, toolName: run.toolName, completionPolicy: run.completionPolicy, consumed: run.consumed, summary: run.summary, previousStatus: data.previousStatus, reason: data.reason } }, context) }];
+        return [{ type: "upsert_node", node: node({ id: `run:${run.runId}`, kind: "yielded_run", status: runStatus(run.status), piboSessionId: run.controllerPiboSessionId, startedAt: run.createdAt, completedAt: run.completedAt, error: run.status === "failed" || run.status === "timed_out" ? { message: run.summary ?? "Run failed.", source: "run" } : undefined, metadata: { runId: run.runId, toolName: run.toolName, completionPolicy: run.completionPolicy, consumed: run.consumed, summary: run.summary, timeoutMs: run.timeoutMs, timeoutAt: run.timeoutAt, timeoutPhase: run.timeoutPhase, serviceWarning: run.serviceWarning, previousStatus: data.previousStatus, reason: data.reason } }, context) }];
     },
 };
 export function createDefaultSignalProducers() {