@pasko70/pibo 1.9.7 → 1.9.9

package/dist/shared/trace-transcript.js

@@ -1,371 +0,0 @@
-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

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

package/dist/signals/aggregate.js

@@ -1,65 +0,0 @@
-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

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

package/dist/signals/projector.js

@@ -1,205 +0,0 @@
-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;
-            if (context.getNode(`session:${session.id}`))
-                return [];
-            return [{ type: "upsert_node", node: node({
-                        id: `session:${session.id}`,
-                        kind: "session",
-                        status: "idle",
-                        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];
-}