@pasko70/pibo 1.9.9 → 1.9.10

package/dist/shared/trace-transcript.js

@@ -0,0 +1,371 @@
+import { transcriptTraceOrder } from "./trace-order.js";
+import { attachAsyncAgentRunNode, reconcileAsyncAgentRunStatuses } from "./trace-async-agent-runs.js";
+import { sortTraceNodes } from "./trace-nodes.js";
+import { createRunNotificationNode, parseRunNotificationText } from "./trace-run-notifications.js";
+import { isSubagentToolName } from "./trace-subagent-links.js";
+export function projectTranscriptEntries(entries, sessionStatus, openTranscriptEventIds) {
+    if (sessionStatus !== "running" || openTranscriptEventIds.size === 0)
+        return entries;
+    let lastUserMessageIndex = -1;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry.type === "message" && messageRole(entry) === "user") {
+            lastUserMessageIndex = index;
+            break;
+        }
+    }
+    return lastUserMessageIndex === -1 ? entries : entries.slice(0, lastUserMessageIndex);
+}
+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") {
+            const role = messageRole(entry);
+            if (role === "user") {
+                nodes.push(createUserMessageNode(piboSessionId, entry, messageContent(entry), index));
+            }
+            else if (role === "assistant" || role === "toolResult") {
+                const turn = collectAssistantTurn(entries, index);
+                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;
+            }
+        }
+        else if (entry.type === "session_info" && entry.name) {
+            nodes.push({
+                id: `entry:${entry.id}`,
+                entryId: entry.id,
+                piboSessionId,
+                type: "execution.command",
+                title: "Session Info",
+                status: "done",
+                startedAt: entry.timestamp,
+                output: { name: entry.name },
+                source: "transcript",
+                stableKey: `entry:${entry.id}`,
+                orderKey: transcriptTraceOrder(index, 0, "execution.command"),
+                children: [],
+            });
+        }
+    }
+    reconcileAsyncAgentRunStatuses(nodes);
+    sortTraceNodes(nodes);
+    return nodes;
+}
+function messageRole(entry) {
+    return entry.message.role;
+}
+function messageContent(entry) {
+    return entry.message.content;
+}
+function messageParts(entry) {
+    const content = messageContent(entry);
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    return Array.isArray(content) ? content : [];
+}
+function 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;
+    while (index < entries.length) {
+        const entry = entries[index];
+        if (entry.type !== "message")
+            break;
+        const role = messageRole(entry);
+        if (role !== "assistant" && role !== "toolResult")
+            break;
+        turnEntries.push({ entry, index });
+        index += 1;
+    }
+    return { entries: turnEntries, nextIndex: index };
+}
+function createUserMessageNode(piboSessionId, entry, content, entryIndex) {
+    const text = extractText(content);
+    const notification = parseRunNotificationText(text);
+    if (notification) {
+        return createRunNotificationNode({
+            id: `entry:${entry.id}`,
+            entryId: entry.id,
+            piboSessionId,
+            startedAt: entry.timestamp,
+            orderKey: transcriptTraceOrder(entryIndex, 0, "yielded.run"),
+            source: "transcript",
+            stableKey: `entry:${entry.id}`,
+            notification,
+        });
+    }
+    return {
+        id: `entry:${entry.id}`,
+        entryId: entry.id,
+        piboSessionId,
+        type: "user.message",
+        title: "User Message",
+        status: "done",
+        startedAt: entry.timestamp,
+        summary: text,
+        output: text,
+        source: "transcript",
+        stableKey: `entry:${entry.id}`,
+        orderKey: transcriptTraceOrder(entryIndex, 0, "user.message"),
+        children: [],
+    };
+}
+function createAssistantTurnNodes(piboSessionId, entries, timing) {
+    const firstAssistant = entries.find(({ entry }) => messageRole(entry) === "assistant");
+    if (!firstAssistant)
+        return [];
+    const orderedNodes = [];
+    const toolsByCallId = new Map();
+    for (const { entry, index: entryIndex } of entries) {
+        if (messageRole(entry) === "toolResult") {
+            mergePersistedToolResult(toolsByCallId, orderedNodes, entry, piboSessionId, entryIndex);
+            continue;
+        }
+        const responseStatus = messageStatus(entry.message);
+        const responseError = messageError(entry.message);
+        let responseNode;
+        for (const [index, part] of messageParts(entry).entries()) {
+            const typed = part;
+            if (typed.type === "thinking" && typeof typed.thinking === "string" && hasVisibleText(typed.thinking)) {
+                orderedNodes.push(createReasoningNode(piboSessionId, entry, entryIndex, index, typed.thinking));
+            }
+            else if (typed.type === "text" && typeof typed.text === "string" && typed.text !== "") {
+                if (!responseNode) {
+                    responseNode = createAssistantMessageNode({
+                        id: `entry:${entry.id}:response`,
+                        piboSessionId,
+                        entry,
+                        entryIndex,
+                        contentPartIndex: index,
+                        status: responseStatus,
+                        text: typed.text,
+                        error: responseError,
+                        children: [],
+                        startedAt: 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}`;
+                }
+            }
+            else if (typed.type === "toolCall" && typeof typed.id === "string" && typeof typed.name === "string") {
+                const toolNode = createToolCallNode(piboSessionId, entry, entryIndex, index, typed);
+                orderedNodes.push(toolNode);
+                toolsByCallId.set(typed.id, toolNode);
+            }
+        }
+        if (responseNode) {
+            responseNode.status = responseStatus;
+            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) {
+    return {
+        id: `entry:${entry.id}:thinking:${index}`,
+        entryId: entry.id,
+        piboSessionId,
+        type: "model.reasoning",
+        title: "Thinking",
+        status: "done",
+        startedAt: entry.timestamp,
+        summary: thinking,
+        output: thinking,
+        source: "transcript",
+        stableKey: `entry:${entry.id}:thinking:${index}`,
+        orderKey: transcriptTraceOrder(entryIndex, index, "model.reasoning"),
+        children: [],
+    };
+}
+function createToolCallNode(piboSessionId, entry, entryIndex, contentPartIndex, part) {
+    const name = typeof part.name === "string" ? part.name : "Tool Call";
+    const toolCallId = typeof part.id === "string" ? part.id : undefined;
+    return {
+        id: `entry:${entry.id}:tool:${String(part.id)}`,
+        entryId: entry.id,
+        piboSessionId,
+        toolCallId,
+        type: isSubagentToolName(name) ? "agent.delegation" : "tool.call",
+        title: name,
+        status: "done",
+        startedAt: entry.timestamp,
+        input: part.arguments ?? {},
+        source: "transcript",
+        stableKey: toolCallId ? `tool:${toolCallId}` : `entry:${entry.id}:tool:${contentPartIndex}`,
+        orderKey: transcriptTraceOrder(entryIndex, contentPartIndex, isSubagentToolName(name) ? "agent.delegation" : "tool.call"),
+        children: [],
+    };
+}
+function mergePersistedToolResult(toolsByCallId, childNodes, entry, piboSessionId, entryIndex) {
+    const message = entry.message;
+    const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
+    if (!toolCallId)
+        return;
+    let toolNode = toolsByCallId.get(toolCallId);
+    if (!toolNode) {
+        toolNode = createMissingToolResultNode(piboSessionId, entry, entryIndex, toolCallId);
+        childNodes.push(toolNode);
+        toolsByCallId.set(toolCallId, toolNode);
+    }
+    toolNode.status = message.isError === true ? "error" : "done";
+    toolNode.completedAt = entry.timestamp;
+    toolNode.output = toolResultOutput(message);
+    toolNode.error = message.isError === true ? stringifyPreview(toolNode.output) : undefined;
+    attachAsyncAgentRunNode(toolNode, piboSessionId, entry.timestamp);
+}
+function createMissingToolResultNode(piboSessionId, entry, entryIndex, toolCallId) {
+    const message = entry.message;
+    return {
+        id: `entry:${entry.id}:tool-result:${toolCallId}`,
+        entryId: entry.id,
+        piboSessionId,
+        toolCallId,
+        type: "tool.result",
+        title: typeof message.toolName === "string" ? message.toolName : "Tool Result",
+        status: "done",
+        startedAt: entry.timestamp,
+        source: "transcript",
+        stableKey: `tool:${toolCallId}`,
+        orderKey: transcriptTraceOrder(entryIndex, 0, "tool.result"),
+        children: [],
+    };
+}
+function toolResultOutput(message) {
+    if (message.details === undefined)
+        return { content: message.content };
+    return { content: message.content, details: message.details };
+}
+function createAssistantMessageNode(input) {
+    return {
+        id: input.id,
+        entryId: input.entry.id,
+        piboSessionId: input.piboSessionId,
+        type: "assistant.message",
+        title: "Agent Message",
+        status: input.status,
+        startedAt: input.startedAt ?? input.entry.timestamp,
+        completedAt: input.completedAt,
+        summary: input.text,
+        output: input.text,
+        error: input.error,
+        source: "transcript",
+        stableKey: `entry:${input.entry.id}:response:${input.contentPartIndex}`,
+        orderKey: transcriptTraceOrder(input.entryIndex, input.contentPartIndex, "assistant.message"),
+        children: input.children ?? [],
+    };
+}
+function messageStatus(message) {
+    if (message && typeof message === "object") {
+        const stopReason = message.stopReason;
+        const errorMessage = message.errorMessage;
+        if (stopReason === "error" || typeof errorMessage === "string")
+            return "error";
+    }
+    return "done";
+}
+function messageError(message) {
+    if (!message || typeof message !== "object")
+        return undefined;
+    const errorMessage = message.errorMessage;
+    return typeof errorMessage === "string" ? errorMessage : undefined;
+}
+function hasVisibleText(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        const typed = part;
+        if (typed.type === "text" && typeof typed.text === "string")
+            return typed.text;
+        return "";
+    })
+        .join("");
+}
+function stringifyPreview(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}

package/dist/shared/trace-types.js

@@ -0,0 +1 @@
+export {};

package/dist/signals/aggregate.js

@@ -0,0 +1,65 @@
+const ACTIVE_STATUSES = new Set(["queued", "starting", "running", "streaming", "waiting", "blocked", "retrying", "compacting", "pausing"]);
+const TERMINAL_STATUSES = new Set(["done", "error", "cancelled", "disposed", "interrupted"]);
+export function isActiveSignalStatus(status) {
+    return ACTIVE_STATUSES.has(status);
+}
+export function isTerminalSignalStatus(status) {
+    return TERMINAL_STATUSES.has(status);
+}
+export function rankStatus(status) {
+    switch (status) {
+        case "blocked": return 90;
+        case "retrying": return 80;
+        case "compacting": return 75;
+        case "streaming": return 70;
+        case "running": return 60;
+        case "starting": return 55;
+        case "waiting": return 50;
+        case "queued": return 40;
+        case "pausing": return 35;
+        case "paused": return 20;
+        case "unknown": return 10;
+        case "idle": return 0;
+        default: return isActiveSignalStatus(status) ? 45 : 5;
+    }
+}
+export function strongestStatus(statuses, fallback = "idle") {
+    let best = fallback;
+    let bestRank = rankStatus(fallback);
+    for (const status of statuses) {
+        const rank = rankStatus(status);
+        if (rank > bestRank) {
+            best = status;
+            bestRank = rank;
+        }
+    }
+    return best;
+}
+export function phaseForStatus(status, nodes) {
+    if (status === "blocked")
+        return "blocked";
+    if (status === "retrying")
+        return "retry";
+    if (status === "compacting")
+        return "compaction";
+    if (status === "streaming")
+        return "streaming";
+    if (nodes.some((node) => isActiveSignalStatus(node.status) && node.kind === "tool_call"))
+        return "tools";
+    if (nodes.some((node) => isActiveSignalStatus(node.status) && node.kind === "subagent_session"))
+        return "subagent";
+    if (nodes.some((node) => isActiveSignalStatus(node.status) && node.kind === "yielded_run"))
+        return "run";
+    if (status === "queued")
+        return "queued";
+    if (status === "running" || status === "starting" || status === "waiting")
+        return "prompting";
+    return undefined;
+}
+export function errorFromNode(node) {
+    if (node.error)
+        return node.error;
+    if (node.status !== "error")
+        return undefined;
+    return { message: `${node.kind} failed.`, source: "unknown" };
+}

package/dist/signals/events.js

@@ -0,0 +1 @@
+export {};

package/dist/signals/projector.js

@@ -0,0 +1,208 @@
+import { isActiveSignalStatus, isTerminalSignalStatus } from "./aggregate.js";
+function node(input, context) {
+    const existing = context.getNode(input.id);
+    const timestamp = context.now();
+    return {
+        ...input,
+        rootPiboSessionId: input.rootPiboSessionId ?? (input.piboSessionId ? context.getSessionRoot(input.piboSessionId) : input.id),
+        createdAt: existing?.createdAt ?? timestamp,
+        updatedAt: timestamp,
+    };
+}
+function runStatus(status) {
+    if (status === "completed")
+        return "done";
+    if (status === "failed")
+        return "error";
+    return status;
+}
+function settleActiveSessionNodes(piboSessionId, context, status, terminalSource) {
+    return context.getSessionNodes(piboSessionId)
+        .filter((node) => node.kind !== "session" && node.kind !== "yielded_run" && isActiveSignalStatus(node.status))
+        .filter((node) => terminalSource !== "processing_stopped" || node.kind !== "turn" || node.metadata?.accepted !== true)
+        .map((node) => ({
+        type: "patch_node",
+        nodeId: node.id,
+        patch: { status, completedAt: context.now(), metadata: { ...node.metadata, 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),
+    project(input, context) {
+        const data = input;
+        if (data.type === "session_created") {
+            const session = data.session;
+            const existing = context.getNode(`session:${session.id}`);
+            const rootPiboSessionId = session.parentId ? context.getSessionRoot(session.parentId) : session.id;
+            if (existing && existing.parentPiboSessionId === session.parentId && existing.rootPiboSessionId === rootPiboSessionId)
+                return [];
+            return [{ type: "upsert_node", node: node({
+                        id: `session:${session.id}`,
+                        kind: "session",
+                        status: existing?.status ?? "idle",
+                        rootPiboSessionId,
+                        piboSessionId: session.id,
+                        parentPiboSessionId: session.parentId,
+                        metadata: { kind: session.kind, channel: session.channel, profile: session.profile },
+                    }, context) }];
+        }
+        if (data.type === "message_accepted") {
+            const activeTurn = context.getSessionNodes(data.piboSessionId)
+                .find((candidate) => candidate.kind === "turn" && isActiveSignalStatus(candidate.status));
+            const mutations = [
+                { type: "patch_node", nodeId: `session:${data.piboSessionId}`, patch: { status: "running" } },
+                {
+                    type: "upsert_node",
+                    node: node({
+                        id: `message:${data.piboSessionId}:${data.eventId}`,
+                        kind: "message",
+                        status: "queued",
+                        piboSessionId: data.piboSessionId,
+                        metadata: { source: data.source },
+                    }, context),
+                },
+            ];
+            if (!activeTurn) {
+                mutations.push({
+                    type: "upsert_node",
+                    node: node({
+                        id: `turn:${data.piboSessionId}:${data.eventId}`,
+                        kind: "turn",
+                        status: "starting",
+                        piboSessionId: data.piboSessionId,
+                        startedAt: context.now(),
+                        metadata: { eventId: data.eventId, source: data.source, accepted: true },
+                    }, context),
+                });
+            }
+            return mutations;
+        }
+        if (data.type === "session_disposed") {
+            return [
+                ...settleActiveSessionNodes(data.piboSessionId, context, "cancelled", "session_disposed"),
+                { type: "patch_node", nodeId: `session:${data.piboSessionId}`, patch: { status: "disposed", completedAt: context.now(), metadata: { reason: data.reason } } },
+            ];
+        }
+        if (data.type === "session_interrupted") {
+            return [
+                ...settleActiveSessionNodes(data.piboSessionId, context, "interrupted", "session_interrupted"),
+                { type: "patch_node", nodeId: `session:${data.piboSessionId}`, patch: { status: "interrupted", completedAt: context.now(), metadata: { reason: data.reason } } },
+            ];
+        }
+        if (data.type === "session_processing_changed") {
+            const existing = context.getNode(`session:${data.piboSessionId}`);
+            const status = existing && isTerminalSignalStatus(existing.status) ? existing.status : data.processing ? "running" : "idle";
+            return [
+                { type: "patch_node", nodeId: `session:${data.piboSessionId}`, patch: { status } },
+                { type: "set_session_queue", piboSessionId: data.piboSessionId, queuedMessages: data.queuedMessages },
+                ...(data.processing ? [] : settleActiveSessionNodes(data.piboSessionId, context, "interrupted", "processing_stopped")),
+            ];
+        }
+        if (data.type === "queue_changed") {
+            return [
+                { type: "set_session_queue", piboSessionId: data.piboSessionId, queuedMessages: data.queuedMessages },
+                { type: "upsert_node", node: node({ id: `queue:${data.piboSessionId}`, kind: "queue", status: data.queuedMessages > 0 ? "queued" : "idle", piboSessionId: data.piboSessionId, metadata: { queuedMessages: data.queuedMessages } }, context) },
+            ];
+        }
+        if (data.type === "recovery") {
+            return [{ type: "patch_node", nodeId: `session:${data.piboSessionId}`, patch: { status: "unknown", metadata: { reason: data.reason } } }];
+        }
+        if (data.type === "signal_node_pruned") {
+            return [{ type: "remove_node", nodeId: data.nodeId }];
+        }
+        return [];
+    },
+};
+export const outputSignalProducer = {
+    name: "pibo-output",
+    accepts: (input) => input.type === "pibo_output",
+    project(input, context) {
+        const data = input;
+        if (data.type !== "pibo_output")
+            return [];
+        const event = data.event;
+        const piboSessionId = event.piboSessionId;
+        const mutations = [];
+        const eventTurn = event.eventId ? context.getNode(`turn:${piboSessionId}:${event.eventId}`) : undefined;
+        const explicitTerminalAfterFallback = eventTurn?.metadata?.terminalSource === "processing_stopped"
+            && (event.type === "message_finished" || event.type === "session_error");
+        if (eventTurn && isTerminalSignalStatus(eventTurn.status) && !explicitTerminalAfterFallback)
+            return [];
+        if (event.type === "message_queued") {
+            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_started") {
+            mutations.push({ type: "patch_node", nodeId: `session:${piboSessionId}`, patch: { status: "running" } });
+            if (event.eventId) {
+                mutations.push({ type: "patch_node", nodeId: `message:${piboSessionId}:${event.eventId}`, patch: { status: "done", completedAt: context.now() } });
+                mutations.push({ type: "upsert_node", node: node({ id: `turn:${piboSessionId}:${event.eventId}`, kind: "turn", status: "running", piboSessionId, startedAt: eventTurn?.startedAt ?? context.now(), metadata: { eventId: event.eventId, source: event.source } }, context) });
+            }
+        }
+        if (event.type === "assistant_delta") {
+            mutations.push({ type: "upsert_node", node: node({ id: `assistant_stream:${piboSessionId}:${event.eventId ?? "current"}:${event.assistantIndex ?? 0}`, kind: "assistant_stream", status: "streaming", piboSessionId, parentNodeId: event.eventId ? `turn:${piboSessionId}:${event.eventId}` : undefined }, context) });
+        }
+        if (event.type === "assistant_message") {
+            mutations.push({ type: "patch_node", nodeId: `assistant_stream:${piboSessionId}:${event.eventId ?? "current"}:${event.assistantIndex ?? 0}`, patch: { status: "done", completedAt: context.now() } });
+        }
+        if (event.type === "thinking_started" || event.type === "thinking_delta") {
+            mutations.push({ type: "upsert_node", node: node({ id: `thinking_stream:${piboSessionId}:${event.eventId ?? "current"}:${event.thinkingIndex ?? 0}`, kind: "thinking_stream", status: "streaming", piboSessionId, parentNodeId: event.eventId ? `turn:${piboSessionId}:${event.eventId}` : undefined }, context) });
+        }
+        if (event.type === "thinking_finished") {
+            mutations.push({ type: "patch_node", nodeId: `thinking_stream:${piboSessionId}:${event.eventId ?? "current"}:${event.thinkingIndex ?? 0}`, patch: { status: "done", completedAt: context.now() } });
+        }
+        if (event.type === "tool_call" || event.type === "tool_execution_started" || event.type === "tool_execution_updated") {
+            mutations.push({ type: "upsert_node", node: node({ id: `tool:${piboSessionId}:${event.toolCallId}`, kind: "tool_call", status: event.type === "tool_call" ? "starting" : "running", piboSessionId, parentNodeId: event.eventId ? `turn:${piboSessionId}:${event.eventId}` : undefined, metadata: { toolCallId: event.toolCallId, toolName: event.toolName, argsComplete: event.type === "tool_call" ? event.argsComplete : undefined } }, context) });
+        }
+        if (event.type === "tool_execution_finished") {
+            mutations.push({ type: "patch_node", nodeId: `tool:${piboSessionId}:${event.toolCallId}`, patch: { status: event.isError ? "error" : "done", completedAt: context.now(), error: event.isError ? { message: "Tool execution failed.", source: "tool" } : undefined, metadata: { toolCallId: event.toolCallId, toolName: event.toolName } } });
+        }
+        if (event.type === "subagent_session") {
+            mutations.push({ type: "upsert_node", node: node({ id: `subagent:${piboSessionId}:${event.childPiboSessionId}`, kind: "subagent_session", status: "running", piboSessionId, parentNodeId: event.toolCallId ? `tool:${piboSessionId}:${event.toolCallId}` : undefined, parentPiboSessionId: piboSessionId, childPiboSessionId: event.childPiboSessionId, metadata: { toolName: event.toolName, subagentName: event.subagentName, threadKey: event.threadKey } }, context) });
+        }
+        if (event.type === "compaction_start") {
+            mutations.push({ type: "upsert_node", node: node({ id: `compaction:${piboSessionId}:${event.reason}`, kind: "compaction", status: "compacting", piboSessionId, metadata: { reason: event.reason } }, context) });
+        }
+        if (event.type === "compaction_end") {
+            mutations.push({ type: "patch_node", nodeId: `compaction:${piboSessionId}:${event.reason}`, patch: { status: event.aborted ? "cancelled" : event.errorMessage ? "error" : "done", completedAt: context.now(), error: event.errorMessage ? { message: event.errorMessage, source: "pi" } : undefined } });
+        }
+        if (event.type === "message_finished") {
+            const existingSession = context.getNode(`session:${piboSessionId}`);
+            if (!existingSession || !isTerminalSignalStatus(existingSession.status)) {
+                mutations.push({ type: "patch_node", nodeId: `session:${piboSessionId}`, patch: { status: "idle" } });
+            }
+            if (event.eventId) {
+                mutations.push({ type: "patch_node", nodeId: `message:${piboSessionId}:${event.eventId}`, patch: { status: "done", completedAt: context.now() } });
+                mutations.push({ type: "patch_node", nodeId: `turn:${piboSessionId}:${event.eventId}`, patch: { status: "done", completedAt: context.now(), metadata: { ...eventTurn?.metadata, terminalSource: "message_finished" } } });
+            }
+            mutations.push(...settleActiveSessionNodes(piboSessionId, context, "done", "message_finished"));
+        }
+        if (event.type === "session_error") {
+            mutations.push({ type: "set_session_queue", piboSessionId, queuedMessages: 0 });
+            mutations.push(...settleActiveSessionNodes(piboSessionId, context, "error", "session_error"));
+            mutations.push({ type: "patch_node", nodeId: `session:${piboSessionId}`, patch: { status: "error", completedAt: context.now(), error: { message: event.error, source: "pi" } } });
+            if (event.eventId) {
+                mutations.push({ type: "patch_node", nodeId: `message:${piboSessionId}:${event.eventId}`, patch: { status: "error", completedAt: context.now(), error: { message: event.error, source: "pi" } } });
+                mutations.push({ type: "patch_node", nodeId: `turn:${piboSessionId}:${event.eventId}`, patch: { status: "error", completedAt: context.now(), error: { message: event.error, source: "pi" }, metadata: { ...eventTurn?.metadata, terminalSource: "session_error" } } });
+            }
+        }
+        return mutations;
+    },
+};
+export const runSignalProducer = {
+    name: "runs",
+    accepts: (input) => input.type === "run_changed" || input.type === "run_removed",
+    project(input, context) {
+        const data = input;
+        if (data.type === "run_removed")
+            return [{ type: "remove_node", nodeId: `run:${data.runId}` }];
+        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) }];
+    },
+};
+export function createDefaultSignalProducers() {
+    return [sessionLifecycleSignalProducer, outputSignalProducer, runSignalProducer];
+}