@dxos/plugin-assistant 0.10.0 → 0.11.1

package/dist/lib/execution-graph.mjs

@@ -0,0 +1,961 @@
+import { AgentRequestBegin, AgentRequestEnd, CompleteBlock, PartialBlock } from "@dxos/assistant";
+import { Process, Trace } from "@dxos/compute";
+import { EID } from "@dxos/keys";
+import * as Schema from "effect/Schema";
+import { Annotation } from "@dxos/echo";
+import * as Option from "effect/Option";
+import { LogLevel, log } from "@dxos/log";
+import * as Array from "effect/Array";
+import { pipe } from "effect/Function";
+import * as Either from "effect/Either";
+import * as Pipeable from "effect/Pipeable";
+import * as Struct from "effect/Struct";
+import { AGENT_PROCESS_KEY } from "@dxos/agent-runtime";
+//#region src/execution-graph/span-tree.ts
+/**
+* Default duration a span may sit open with no new events before it's considered abandoned
+* (the runtime crashed, lost connectivity, or otherwise never wrote the closing event).
+*/
+var DEFAULT_SPAN_TIMEOUT_MS = 1200 * 1e3;
+/**
+* Synthetic id assigned to the root span.
+* The root is a virtual container for top-level spans (those without a parent in the captured trace).
+*/
+var ROOT_SPAN_ID = "<main>";
+var BEGIN_EVENT_TYPES = /* @__PURE__ */ new Set([Trace.OperationStart.key, AgentRequestBegin.key]);
+var END_EVENT_TYPES = /* @__PURE__ */ new Set([Trace.OperationEnd.key, AgentRequestEnd.key]);
+var isSpanBeginEvent = (event) => BEGIN_EVENT_TYPES.has(event.type);
+var isSpanEndEvent = (event) => END_EVENT_TYPES.has(event.type);
+var computeMeta = (rawMeta) => ({
+	pid: rawMeta.pid,
+	parentPid: rawMeta.parentPid,
+	processName: rawMeta.processName,
+	conversationId: rawMeta.conversation ? EID.getEntityId(EID.parse(rawMeta.conversation.uri)) : void 0,
+	triggerId: rawMeta.trigger ? EID.getEntityId(EID.parse(rawMeta.trigger.uri)) : void 0,
+	toolCallId: rawMeta.toolCallId,
+	runtimeName: rawMeta.runtimeName
+});
+var makeMutableSpan = (id, meta) => ({
+	id,
+	meta,
+	events: [],
+	children: [],
+	firstTimestamp: Number.POSITIVE_INFINITY
+});
+var freezeSpan = (span) => ({
+	id: span.id,
+	meta: span.meta,
+	events: span.events,
+	children: span.children.map(freezeSpan)
+});
+/**
+* Builds a hierarchical span tree from a list of trace messages.
+*
+* Algorithm:
+*   1. Flatten messages into events and sort them chronologically.
+*   2. For each event:
+*      - Begin events (`OperationStart`, `AgentRequestBegin`) open a new span whose parent
+*        is the currently-open span of the event's `meta.parentPid`, or the root if there is
+*        none. The begin event itself becomes the first event of the new span.
+*      - End events (`OperationEnd`, `AgentRequestEnd`) close the currently-open span for
+*        the event's `meta.pid` and become its last event.
+*      - Other events attach to the currently-open span for their `meta.pid`, or to the
+*        root span if no span is currently open for that pid (or the event has no pid).
+*   3. Sort each span's children by their earliest event timestamp.
+*/
+var buildSpanTree = (messages, options = {}) => {
+	const allEvents = messages.flatMap((message) => Trace.flatten(message));
+	allEvents.sort((a, b) => a.timestamp - b.timestamp);
+	const events = applyEventLimit(allEvents, options.eventLimit);
+	const root = makeMutableSpan(ROOT_SPAN_ID, {});
+	const openSpans = /* @__PURE__ */ new Map();
+	const lastSpanByPid = /* @__PURE__ */ new Map();
+	const allSpans = [];
+	let spanCounter = 0;
+	const allocSpanId = (pid) => {
+		const id = `${pid}#${spanCounter}`;
+		spanCounter += 1;
+		return id;
+	};
+	const noteTimestamp = (span, timestamp) => {
+		if (timestamp < span.firstTimestamp) span.firstTimestamp = timestamp;
+	};
+	for (const event of events) {
+		const pid = event.meta.pid;
+		if (!pid) {
+			root.events.push(event);
+			noteTimestamp(root, event.timestamp);
+			continue;
+		}
+		if (BEGIN_EVENT_TYPES.has(event.type)) {
+			const parentPid = event.meta.parentPid;
+			const parent = parentPid && (openSpans.get(parentPid) ?? lastSpanByPid.get(parentPid)) || root;
+			const span = makeMutableSpan(allocSpanId(pid), computeMeta(event.meta));
+			span.events.push(event);
+			noteTimestamp(span, event.timestamp);
+			parent.children.push(span);
+			allSpans.push(span);
+			openSpans.set(pid, span);
+			lastSpanByPid.set(pid, span);
+			continue;
+		}
+		if (END_EVENT_TYPES.has(event.type)) {
+			const span = openSpans.get(pid);
+			if (span) {
+				span.events.push(event);
+				noteTimestamp(span, event.timestamp);
+				openSpans.delete(pid);
+			} else {
+				root.events.push(event);
+				noteTimestamp(root, event.timestamp);
+			}
+			continue;
+		}
+		const open = openSpans.get(pid);
+		if (open) {
+			open.events.push(event);
+			noteTimestamp(open, event.timestamp);
+		} else {
+			root.events.push(event);
+			noteTimestamp(root, event.timestamp);
+		}
+	}
+	if (options.now !== void 0) {
+		const now = options.now;
+		const spanTimeoutMs = options.spanTimeoutMs ?? 12e5;
+		for (const span of allSpans) {
+			const lastEvent = span.events[span.events.length - 1];
+			if (isSpanEndEvent(lastEvent)) continue;
+			const timeoutAt = lastEvent.timestamp + spanTimeoutMs;
+			if (now < timeoutAt) continue;
+			const endEvent = makeTimeoutEndEvent(span, timeoutAt);
+			span.events.push(endEvent);
+			noteTimestamp(span, endEvent.timestamp);
+		}
+	}
+	const sortChildren = (span) => {
+		span.children.sort((a, b) => a.firstTimestamp - b.firstTimestamp);
+		for (const child of span.children) sortChildren(child);
+	};
+	sortChildren(root);
+	return freezeSpan(root);
+};
+/**
+* Message stamped on synthetic end events produced when a span times out.
+*/
+var SPAN_TIMEOUT_MESSAGE = "No end event was recorded for this span; it was closed after a timeout.";
+/**
+* Synthesizes the end event that closes an abandoned span, matching the event type its begin
+* event opened it with (`OperationStart` → `OperationEnd`, `AgentRequestBegin` → `AgentRequestEnd`).
+*/
+var makeTimeoutEndEvent = (span, timestamp) => {
+	const beginEvent = span.events[0];
+	if (beginEvent.type === AgentRequestBegin.key) return {
+		type: AgentRequestEnd.key,
+		timestamp,
+		meta: beginEvent.meta,
+		isEphemeral: false,
+		data: {
+			status: "interrupted",
+			error: SPAN_TIMEOUT_MESSAGE
+		}
+	};
+	const fallback = { key: "unknown" };
+	const beginData = Option.getOrElse(Schema.decodeUnknownOption(Trace.OperationStart.schema)(beginEvent.data), () => fallback);
+	return {
+		type: Trace.OperationEnd.key,
+		timestamp,
+		meta: beginEvent.meta,
+		isEphemeral: false,
+		data: {
+			key: beginData.key,
+			name: beginData.name,
+			icon: beginData.icon,
+			outcome: "failure",
+			error: SPAN_TIMEOUT_MESSAGE
+		}
+	};
+};
+/**
+* Caps the number of non-boundary events while retaining every span boundary event.
+*
+* Boundary events define the span tree's structure: dropping a begin event detaches every
+* descendant span (its `parentPid` lookup fails, so children fall back to the root), and
+* dropping an end event leaves a span open and corrupts the open-span map for sibling spans
+* that share a pid. Status/partial-block events are the noisy bulk and the only ones the
+* limit needs to control.
+*
+* The returned array stays in chronological order.
+*/
+var applyEventLimit = (events, eventLimit) => {
+	if (eventLimit === void 0) return [...events];
+	let nonBoundaryCount = 0;
+	for (const event of events) if (!isBoundary(event)) nonBoundaryCount += 1;
+	if (nonBoundaryCount <= eventLimit) return [...events];
+	const dropCount = nonBoundaryCount - eventLimit;
+	let dropped = 0;
+	const result = [];
+	for (const event of events) {
+		if (!isBoundary(event) && dropped < dropCount) {
+			dropped += 1;
+			continue;
+		}
+		result.push(event);
+	}
+	return result;
+};
+var isBoundary = (event) => BEGIN_EVENT_TYPES.has(event.type) || END_EVENT_TYPES.has(event.type);
+/**
+* Walks the span tree in depth-first pre-order, invoking `visit` for each span (root included).
+*/
+var walkSpanTree = (root, visit, depth = 0) => {
+	visit(root, depth);
+	for (const child of root.children) walkSpanTree(child, visit, depth + 1);
+};
+/**
+* Returns all spans in the tree in depth-first pre-order, root first.
+*/
+var flattenSpanTree = (root) => {
+	const result = [];
+	walkSpanTree(root, (span) => result.push(span));
+	return result;
+};
+//#endregion
+//#region src/execution-graph/execution-graph.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/execution-graph/execution-graph.ts";
+/**
+* Branch name for top-level operation invocations.
+*/
+var MAIN_BRANCH = "main";
+/** Timeline tag that applies a shimmer message effect. */
+var SHIMMER_EFFECT_TAG = "effect:shimmer";
+var ICONS = {
+	agentRequestBegin: {
+		icon: "ph--atom--regular",
+		level: LogLevel.VERBOSE
+	},
+	agentRequestEndSuccess: {
+		icon: "ph--atom--regular",
+		level: LogLevel.INFO
+	},
+	agentRequestEndError: {
+		icon: "ph--atom--regular",
+		level: LogLevel.ERROR
+	},
+	agentRequestEndInterrupted: {
+		icon: "ph--atom--regular",
+		level: LogLevel.WARN
+	},
+	userMessage: {
+		icon: "ph--user--regular",
+		level: LogLevel.VERBOSE
+	},
+	statusMessage: {
+		icon: "ph--info--regular",
+		level: LogLevel.VERBOSE
+	},
+	operationStart: {
+		icon: "ph--function--regular",
+		level: LogLevel.VERBOSE
+	},
+	operationEndSuccess: {
+		icon: "ph--function--regular",
+		level: LogLevel.INFO
+	},
+	operationEndError: {
+		icon: "ph--function--regular",
+		level: LogLevel.ERROR
+	},
+	toolCall: {
+		icon: "ph--wrench--regular",
+		level: LogLevel.VERBOSE
+	},
+	toolResultSuccess: {
+		icon: "ph--wrench--regular",
+		level: LogLevel.INFO
+	},
+	toolResultError: {
+		icon: "ph--wrench--regular",
+		level: LogLevel.ERROR
+	},
+	agentRequestRunning: {
+		icon: "ph--spinner-gap--regular",
+		level: LogLevel.VERBOSE
+	},
+	processRunning: {
+		icon: "ph--spinner-gap--regular",
+		level: LogLevel.VERBOSE
+	}
+};
+var buildExecutionGraph = ({ traceMessages, activeProcesses = [], collapseCompletedSpans = false, eventLimit = 500, spanTimeoutMs, now }) => {
+	const spanTree = buildSpanTree(traceMessages, {
+		eventLimit,
+		spanTimeoutMs,
+		now
+	});
+	const built = spanTreeToCommits(spanTree, activeProcesses, buildToolCallContext(traceMessages), collapseCompletedSpans);
+	log("trace execution graph", {
+		traceMessages: traceMessages.length,
+		commits: built.commits.length,
+		branches: built.branches.length,
+		activeProcesses: activeProcesses.length
+	}, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 141,
+		S: void 0
+	});
+	return {
+		...built,
+		spanTree
+	};
+};
+var buildToolCallContext = (messages) => {
+	const callById = /* @__PURE__ */ new Map();
+	const resultByCallId = /* @__PURE__ */ new Map();
+	for (const message of messages) for (const event of message.events) {
+		if (event.type !== CompleteBlock.key) continue;
+		const block = event.data?.block;
+		if (!block) continue;
+		if (block._tag === "toolCall") callById.set(block.toolCallId, block);
+		else if (block._tag === "toolResult") resultByCallId.set(block.toolCallId, block);
+	}
+	return {
+		callById,
+		resultByCallId
+	};
+};
+/**
+* Parses `AgentRequestEnd` payload, accepting legacy traces that omitted `status`.
+*/
+var parseAgentRequestEnd = (data) => {
+	const validated = Schema.validateEither(AgentRequestEnd.schema)(data);
+	if (Either.isRight(validated)) return validated.right;
+	if (data != null && typeof data === "object" && Object.keys(data).length === 0) return { status: "success" };
+	log("invalid trace event", { type: AgentRequestEnd.key }, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 208,
+		S: void 0
+	});
+};
+var presentAgentRequestEnd = (data) => {
+	switch (data.status) {
+		case "error": return {
+			icon: ICONS.agentRequestEndError.icon,
+			level: ICONS.agentRequestEndError.level,
+			message: data.error ? trimText(`Agent request failed: ${data.error}`) : "Agent request failed"
+		};
+		case "interrupted": return {
+			icon: ICONS.agentRequestEndInterrupted.icon,
+			level: ICONS.agentRequestEndInterrupted.level,
+			message: "Agent request interrupted"
+		};
+		default: return {
+			icon: ICONS.agentRequestEndSuccess.icon,
+			level: ICONS.agentRequestEndSuccess.level,
+			message: "Agent completed request"
+		};
+	}
+};
+var presentEvent = (event, toolCallContext) => {
+	if (Trace.isOfType(AgentRequestBegin, event)) {
+		if (Either.isLeft(Schema.validateEither(AgentRequestBegin.schema)(event.data))) {
+			log("invalid trace event", { type: event.type }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 238,
+				S: void 0
+			});
+			return;
+		}
+		return {
+			icon: ICONS.agentRequestBegin.icon,
+			level: ICONS.agentRequestBegin.level,
+			message: "Agent processing request..."
+		};
+	}
+	if (Trace.isOfType(AgentRequestEnd, event)) {
+		const endData = parseAgentRequestEnd(event.data);
+		if (!endData) return;
+		return presentAgentRequestEnd(endData);
+	}
+	if (Trace.isOfType(CompleteBlock, event)) {
+		if (Either.isLeft(Schema.validateEither(CompleteBlock.schema)(event.data))) {
+			log("invalid trace event", { type: event.type }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 256,
+				S: void 0
+			});
+			return;
+		}
+		switch (event.data.block._tag) {
+			case "text": return event.data.role === "user" ? {
+				icon: ICONS.userMessage.icon,
+				level: ICONS.userMessage.level,
+				message: trimText(event.data.block.text)
+			} : void 0;
+			case "status": return {
+				icon: ICONS.statusMessage.icon,
+				level: ICONS.statusMessage.level,
+				message: trimText(event.data.block.statusText)
+			};
+			case "toolCall":
+				if (event.data.block.operationKey) return;
+				if (toolCallContext.resultByCallId.has(event.data.block.toolCallId)) return;
+				return {
+					icon: ICONS.toolCall.icon,
+					level: ICONS.toolCall.level,
+					message: event.data.block.name,
+					idSuffix: `toolCall:${event.data.block.toolCallId}`
+				};
+			case "toolResult": {
+				const call = toolCallContext.callById.get(event.data.block.toolCallId);
+				if (call?.operationKey) return;
+				const success = event.data.block.error === void 0;
+				const name = call?.name ?? event.data.block.name;
+				return {
+					icon: success ? ICONS.toolResultSuccess.icon : ICONS.toolResultError.icon,
+					level: success ? ICONS.toolResultSuccess.level : ICONS.toolResultError.level,
+					message: `${name}${!success ? " - Error" : ""}`,
+					idSuffix: `toolResult:${event.data.block.toolCallId}`
+				};
+			}
+			default: return;
+		}
+	}
+	if (Trace.isOfType(Trace.OperationStart, event)) {
+		if (Either.isLeft(Schema.validateEither(Trace.OperationStart.schema)(event.data))) {
+			log("invalid trace event", { type: event.type }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 316,
+				S: void 0
+			});
+			return;
+		}
+		return {
+			icon: event.data.icon ?? ICONS.operationStart.icon,
+			level: ICONS.operationStart.level,
+			message: event.data.name ?? event.data.key,
+			idSuffix: `${event.data.key}:start`
+		};
+	}
+	if (Trace.isOfType(Trace.OperationEnd, event)) {
+		if (Either.isLeft(Schema.validateEither(Trace.OperationEnd.schema)(event.data))) {
+			log("invalid trace event", { type: event.type }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 328,
+				S: void 0
+			});
+			return;
+		}
+		const success = event.data.outcome === "success";
+		return {
+			icon: event.data.icon ?? (success ? ICONS.operationEndSuccess.icon : ICONS.operationEndError.icon),
+			level: success ? ICONS.operationEndSuccess.level : ICONS.operationEndError.level,
+			message: `${event.data.name ?? event.data.key}${!success ? " - Error" : ""}`,
+			idSuffix: `${event.data.key}:end`
+		};
+	}
+};
+/**
+* Collects human-readable activity lines for a process subtree (root pid and descendants).
+* Used to surface live sub-agent status in the task list.
+*/
+var collectProcessActivityLines = (messages, rootPid, options = {}) => {
+	const { conversationId, eventLimit = 50 } = options;
+	const descendantPids = collectDescendantPids(messages, rootPid);
+	const filtered = messages.filter((message) => {
+		const pid = message.meta.pid;
+		if (!pid || !descendantPids.has(pid)) return false;
+		const metaConvId = message.meta.conversation ? EID.getEntityId(EID.parse(message.meta.conversation.uri)) : void 0;
+		if (conversationId && metaConvId !== void 0 && metaConvId !== conversationId) return false;
+		return true;
+	});
+	const events = filtered.flatMap((message) => Trace.flatten(message)).sort((left, right) => left.timestamp - right.timestamp).slice(-eventLimit);
+	const toolCallContext = buildToolCallContext(filtered);
+	const lines = [];
+	for (const event of events) {
+		const presentation = presentEvent(event, toolCallContext);
+		if (presentation) lines.push(presentation.message);
+	}
+	return lines;
+};
+/**
+* Derives a single in-flight status line from durable trace when ephemeral subscription
+* is unavailable (e.g. between partial blocks or while a child operation is running).
+*/
+var deriveInFlightActivityLine = (messages, rootPid, options = {}) => {
+	const { conversationId, eventLimit = 50 } = options;
+	const descendantPids = collectDescendantPids(messages, rootPid);
+	const events = messages.filter((message) => {
+		const pid = message.meta.pid;
+		if (!pid || !descendantPids.has(pid)) return false;
+		const metaConvId = message.meta.conversation ? EID.getEntityId(EID.parse(message.meta.conversation.uri)) : void 0;
+		if (conversationId && metaConvId !== void 0 && metaConvId !== conversationId) return false;
+		return true;
+	}).flatMap((message) => Trace.flatten(message)).sort((left, right) => left.timestamp - right.timestamp).slice(-eventLimit);
+	const openOperations = /* @__PURE__ */ new Map();
+	let agentRequestOpen = false;
+	let lastLine;
+	for (const event of events) {
+		const pid = event.meta.pid ?? rootPid;
+		if (Trace.isOfType(Trace.OperationStart, event)) {
+			const key = `${pid}:${event.data.key}`;
+			const name = event.data.name ?? event.data.key;
+			openOperations.set(key, {
+				name,
+				timestamp: event.timestamp
+			});
+			lastLine = `${name}...`;
+			continue;
+		}
+		if (Trace.isOfType(Trace.OperationEnd, event)) {
+			openOperations.delete(`${pid}:${event.data.key}`);
+			continue;
+		}
+		if (Trace.isOfType(AgentRequestBegin, event)) {
+			agentRequestOpen = true;
+			lastLine = "Generating...";
+			continue;
+		}
+		if (Trace.isOfType(AgentRequestEnd, event)) agentRequestOpen = false;
+	}
+	if (agentRequestOpen) return "Generating...";
+	const latestOperation = [...openOperations.values()].sort((left, right) => right.timestamp - left.timestamp)[0];
+	if (latestOperation) return `${latestOperation.name}...`;
+	return lastLine;
+};
+var collectDescendantPids = (messages, rootPid) => {
+	const pids = /* @__PURE__ */ new Set([rootPid]);
+	let expanded = true;
+	while (expanded) {
+		expanded = false;
+		for (const message of messages) {
+			const pid = message.meta.pid;
+			const parentPid = message.meta.parentPid;
+			if (pid && parentPid && pids.has(parentPid) && !pids.has(pid)) {
+				pids.add(pid);
+				expanded = true;
+			}
+		}
+	}
+	return pids;
+};
+var isPendingToolCallEvent = (event, toolCallContext) => {
+	if (!Trace.isOfType(CompleteBlock, event)) return false;
+	if (event.data.block._tag !== "toolCall") return false;
+	return !toolCallContext.resultByCallId.has(event.data.block.toolCallId);
+};
+/**
+* Marks commits that represent work still in flight for Timeline shimmer styling.
+*/
+var shouldShimmerInProgressCommit = (event, toolCallContext) => isPendingToolCallEvent(event, toolCallContext);
+/**
+* A span is completed when its last recorded event is a matching end boundary.
+*/
+var isCompletedSpan = (span) => {
+	if (span.id === "<main>") return false;
+	const lastEvent = span.events[span.events.length - 1];
+	return lastEvent !== void 0 && isSpanEndEvent(lastEvent);
+};
+/**
+* A span is "collapsible" when it would otherwise render as an empty fork-and-merge:
+* exactly two events that form a begin/end pair and no child sub-spans. In that case
+* we emit a single commit for the end event on the parent branch.
+*
+* When `collapseCompletedSpans` is enabled, any completed span collapses to that single
+* end commit — middle events, child sub-spans, and the begin fork are all omitted.
+*
+* A *pending* span (one whose end event has not yet been recorded) is never collapsed:
+* its trailing events should keep rendering as middle commits on the span's own branch
+* — never as a fake "end" commit on the parent branch.
+*
+* Both nested spans and top-level spans (whose parent is the synthetic root) are eligible
+* once they have completed: a span with no inner activity is collapsed regardless of where
+* it sits in the tree.
+*/
+var isCollapsibleSpan = (span, parent, collapseCompletedSpans) => {
+	if (span.id === "<main>") return false;
+	if (parent === null) return false;
+	if (span.events.length === 2 && span.children.length === 0) {
+		const firstEvent = span.events[0];
+		const lastEvent = span.events[span.events.length - 1];
+		if (isSpanBeginEvent(firstEvent) && isSpanEndEvent(lastEvent)) return true;
+	}
+	if (collapseCompletedSpans && isCompletedSpan(span)) return true;
+	return false;
+};
+/**
+* Converts a span tree into a flat list of commits + branches suitable for `Timeline` rendering.
+*
+* For every span the algorithm:
+*  - emits the **first** event as a "begin" commit on the parent span's branch (fork);
+*  - emits **middle** events as commits on the span's own branch;
+*  - emits the **last** event as an "end" commit on the parent span's branch with two parents
+*    (the begin commit and the last commit on the span's own branch — a merge).
+*
+* Collapsible spans (`isCollapsibleSpan`) emit only the end commit on the parent branch with
+* a single parent — a tidier rendering for sub-operations that have no inner detail.
+*
+* Events are processed in categorical span-tree order: each span's begin events, its child
+* subtrees (depth-first), then its remaining events. Active-process running rows are inserted
+* at the end of each matching span block — not appended after the entire tree.
+*/
+var spanTreeToCommits = (root, activeProcesses, toolCallContext, collapseCompletedSpans) => {
+	const builder = new GraphBuilder();
+	const details = {};
+	builder.addBranch(MAIN_BRANCH);
+	const parentBySpan = /* @__PURE__ */ new Map();
+	parentBySpan.set(root, null);
+	const indexParents = (span) => {
+		for (const child of span.children) {
+			parentBySpan.set(child, span);
+			indexParents(child);
+		}
+	};
+	indexParents(root);
+	const findParentSpan = (span) => parentBySpan.get(span) ?? null;
+	const collapsedSpanIds = /* @__PURE__ */ new Set();
+	walkSpanTree(root, (span) => {
+		if (isCollapsibleSpan(span, findParentSpan(span), collapseCompletedSpans)) collapsedSpanIds.add(span.id);
+	});
+	const isUnderCollapsedAncestor = (span) => {
+		let ancestor = findParentSpan(span);
+		while (ancestor) {
+			if (collapsedSpanIds.has(ancestor.id)) return true;
+			ancestor = findParentSpan(ancestor);
+		}
+		return false;
+	};
+	const branchOf = (span) => {
+		if (!span || span.id === "<main>") return MAIN_BRANCH;
+		return span.meta.pid ?? span.id;
+	};
+	const beginCommitIdBySpan = /* @__PURE__ */ new Map();
+	const lastInSpanContext = (span) => {
+		if (!span || span.id === "<main>") return CommitSelector.branch(MAIN_BRANCH).pipe(CommitSelector.compose(CommitSelector.last()));
+		const ownBranch = branchOf(span);
+		const beginId = beginCommitIdBySpan.get(span.id);
+		return CommitSelector.firstOf(CommitSelector.branch(ownBranch).pipe(CommitSelector.compose(CommitSelector.last())), beginId ? CommitSelector.id(beginId) : CommitSelector.filter(() => false), lastInSpanContext(findParentSpan(span)));
+	};
+	const lastCommitIdBySpan = /* @__PURE__ */ new Map();
+	let globalIndex = 0;
+	const insertedRunningPids = /* @__PURE__ */ new Set();
+	const activeProcessByPid = new Map(activeProcesses.map((process) => [process.pid, process]));
+	const emitRunningIndicator = (pid) => {
+		if (insertedRunningPids.has(pid)) return;
+		const process = activeProcessByPid.get(pid);
+		if (!process) return;
+		if (process.key === AGENT_PROCESS_KEY && Option.isSome(Annotation.getDictionary(process.params.annotations, Process.TargetAnnotation)) && (process.state === Process.State.RUNNING || process.state === Process.State.HYBERNATING)) {
+			builder.addCommit({
+				id: `running:${process.pid}`,
+				branch: process.pid,
+				parents: builder.computeParents(CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last()))),
+				icon: ICONS.agentRequestRunning.icon,
+				level: ICONS.agentRequestRunning.level,
+				message: "Generating...",
+				timestamp: /* @__PURE__ */ new Date(),
+				tags: [SHIMMER_EFFECT_TAG]
+			});
+			insertedRunningPids.add(pid);
+		} else if (process.state === Process.State.RUNNING && builder.hasBranch(process.pid)) {
+			builder.addCommit({
+				id: `running:${process.pid}`,
+				branch: process.pid,
+				parents: builder.computeParents(CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last()))),
+				icon: ICONS.processRunning.icon,
+				level: ICONS.processRunning.level,
+				message: "Running...",
+				timestamp: /* @__PURE__ */ new Date(),
+				tags: [SHIMMER_EFFECT_TAG]
+			});
+			insertedRunningPids.add(pid);
+		}
+	};
+	const emitEventCommit = (span, event, eventIndex) => {
+		const presentation = presentEvent(event, toolCallContext);
+		if (!presentation) return;
+		const isBeginEvent = isSpanBeginEvent(event);
+		const isEndEvent = isSpanEndEvent(event);
+		const parentSpan = findParentSpan(span);
+		const collapsible = isCollapsibleSpan(span, parentSpan, collapseCompletedSpans);
+		if (isUnderCollapsedAncestor(span)) return;
+		if (collapsible && !isEndEvent) return;
+		const parentBranch = branchOf(parentSpan);
+		const ownBranch = branchOf(span);
+		const ownPid = span.meta.pid;
+		const parentPid = parentSpan?.meta.pid;
+		const spanHasMiddle = span.events.some((spanEvent) => !isSpanBeginEvent(spanEvent) && !isSpanEndEvent(spanEvent));
+		const isProcessBoundary = ownPid != null && parentPid != null && ownPid !== parentPid && spanHasMiddle;
+		let branch;
+		let parents;
+		if (span.id === "<main>") {
+			branch = MAIN_BRANCH;
+			parents = builder.computeParents(lastInSpanContext(null));
+		} else if (collapsible) {
+			branch = parentBranch;
+			parents = builder.computeParents(lastInSpanContext(parentSpan));
+		} else if (isBeginEvent) {
+			branch = isProcessBoundary ? ownBranch : parentBranch;
+			parents = builder.computeParents(lastInSpanContext(parentSpan));
+		} else if (isEndEvent) {
+			branch = isProcessBoundary ? MAIN_BRANCH : parentBranch;
+			parents = builder.computeParents(CommitSelector.unionAll(CommitSelector.branch(branch).pipe(CommitSelector.compose(CommitSelector.last())), CommitSelector.branch(ownBranch).pipe(CommitSelector.compose(CommitSelector.last()))));
+		} else {
+			branch = ownBranch;
+			parents = builder.computeParents(lastInSpanContext(span));
+		}
+		const commitId = formatCommitId(span, globalIndex++, presentation.idSuffix);
+		const shimmer = shouldShimmerInProgressCommit(event, toolCallContext);
+		const commit = {
+			id: commitId,
+			branch,
+			parents,
+			timestamp: new Date(event.timestamp),
+			icon: presentation.icon,
+			level: presentation.level,
+			message: presentation.message,
+			...shimmer && { tags: [SHIMMER_EFFECT_TAG] }
+		};
+		builder.addCommit(commit);
+		details[commitId] = event;
+		lastCommitIdBySpan.set(span.id, commitId);
+		if (isBeginEvent && !collapsible && span.id !== "<main>") beginCommitIdBySpan.set(span.id, commitId);
+	};
+	const finishSpan = (span) => {
+		const pid = span.meta.pid;
+		if (pid) emitRunningIndicator(Process.ID.make(pid));
+		if (span.id === "<main>" || isCompletedSpan(span)) return;
+		if (pid && insertedRunningPids.has(pid)) return;
+		const lastCommitId = lastCommitIdBySpan.get(span.id);
+		if (lastCommitId) builder.addTag(lastCommitId, SHIMMER_EFFECT_TAG);
+	};
+	const emitSpanCommits = (span) => {
+		for (let eventIndex = 0; eventIndex < span.events.length; eventIndex += 1) {
+			const event = span.events[eventIndex];
+			if (isSpanBeginEvent(event)) emitEventCommit(span, event, eventIndex);
+		}
+		for (const child of span.children) emitSpanCommits(child);
+		for (let eventIndex = 0; eventIndex < span.events.length; eventIndex += 1) {
+			const event = span.events[eventIndex];
+			if (!isSpanBeginEvent(event)) emitEventCommit(span, event, eventIndex);
+		}
+		finishSpan(span);
+	};
+	emitSpanCommits(root);
+	for (const process of activeProcesses) emitRunningIndicator(process.pid);
+	const { commits, branches } = builder.build();
+	return {
+		commits,
+		branches,
+		details
+	};
+};
+var formatCommitId = (span, globalIndex, suffix) => {
+	const base = `${span.id}:${globalIndex}`;
+	return suffix ? `${base}:${suffix}` : base;
+};
+var trimText = (text) => text.slice(0, 100).trim().split("\n")[0];
+var CommitSelector = {
+	make: (select) => ({
+		select,
+		pipe(...args) {
+			return Pipeable.pipeArguments(this, args);
+		}
+	}),
+	identity: () => CommitSelector.make((commits) => commits),
+	/**
+	* Selects commits that match the given predicate.
+	*/
+	filter: (predicate) => CommitSelector.make((commits) => commits.filter(predicate)),
+	/**
+	* Selects commits by id.
+	*/
+	id: (id) => CommitSelector.filter((commit) => commit.id === id),
+	/**
+	* Selects commits by tag.
+	*/
+	tag: (tag) => CommitSelector.filter((commit) => tag && commit.tags?.includes(tag)),
+	/**
+	* Selects commits by if any of the given tags are present.
+	*/
+	anyTags: (tags) => CommitSelector.filter((commit) => tags.some((tag) => tag && commit.tags?.includes(tag))),
+	/**
+	* Selects commits by branch.
+	*/
+	branch: (branch) => CommitSelector.filter((commit) => branch && commit.branch === branch),
+	/**
+	* Chains two selectors together, applying the second selector to the result of the first.
+	*
+	* Example:
+	*
+	* ```
+	* CommitSelector.tag('tag').pipe(CommitSelector.compose(CommitSelector.branch('main')));
+	* ```
+	*/
+	compose: (next) => (prev) => CommitSelector.make((commits) => next.select(prev.select(commits))),
+	/**
+	* If `prev` selector matches no commits, return `next` selector, otherwise return `prev` selector.
+	* Same as `CommitSelector.firstOf(prev, next)`.
+	*
+	* Example:
+	*
+	* ```
+	* CommitSelector.tag('tag').pipe(CommitSelector.orElse(CommitSelector.branch('main')));
+	* ```
+	*/
+	orElse: (next) => (prev) => CommitSelector.make((commits) => {
+		const selected = prev.select(commits);
+		if (selected.length > 0) return selected;
+		return next.select(commits);
+	}),
+	/**
+	* Selects commits that match either of the given selectors.
+	*/
+	andAlso: (next) => (prev) => CommitSelector.unionAll(prev, next),
+	/**
+	* Selects the first n commits.
+	*/
+	first: (n = 1) => CommitSelector.make((commits) => commits.slice(0, n)),
+	/**
+	* Selects the last n commits (reverses the order of the commits).
+	*/
+	last: (n = 1) => CommitSelector.make((commits) => commits.toReversed().slice(0, n)),
+	/**
+	* Selects commits that do not match the given selector.
+	*/
+	not: (selector) => CommitSelector.make((commits) => {
+		const selected = selector.select(commits);
+		return commits.filter((commit) => !selected.includes(commit));
+	}),
+	/**
+	* Selects commits that match any of the given selectors.
+	*/
+	unionAll: (...selectors) => CommitSelector.make((commits) => {
+		return Array.dedupeWith(selectors.flatMap((selector) => selector.select(commits)), (a, b) => a.id === b.id);
+	}),
+	/**
+	* Selects commits that match all of the given selectors.
+	*/
+	intersectAll: (...selectors) => CommitSelector.make((commits) => {
+		const selected = selectors.map((selector) => selector.select(commits));
+		if (selected.length === 0) return [];
+		return selected[0].filter((commit) => selected.every((selected) => selected.some((c) => c.id === commit.id)));
+	}),
+	/**
+	* Returns the result of the first selector that matches any commits.
+	*/
+	firstOf: (...selectors) => CommitSelector.make((commits) => {
+		for (const selector of selectors) {
+			const selected = selector.select(commits);
+			if (selected.length > 0) return selected;
+		}
+		return [];
+	})
+};
+var GraphBuilder = class {
+	#commits = [];
+	#branches = /* @__PURE__ */ new Set();
+	findCommits(selector) {
+		return selector.select(this.#commits);
+	}
+	hasBranch(branch) {
+		return this.#branches.has(branch);
+	}
+	addCommit(commit) {
+		this.addBranch(commit.branch);
+		this.#commits.push(commit);
+	}
+	addTag(commitId, tag) {
+		const index = this.#commits.findIndex((commit) => commit.id === commitId);
+		if (index < 0) return;
+		const commit = this.#commits[index];
+		if (commit.tags?.includes(tag)) return;
+		this.#commits[index] = {
+			...commit,
+			tags: [...commit.tags ?? [], tag]
+		};
+	}
+	/**
+	* Computes parents — picks first matching commit's id.
+	*/
+	computeParents(selector) {
+		return Array.dedupe(selector.select(this.#commits).map((commit) => commit.id));
+	}
+	addBranch(branch) {
+		this.#branches.add(branch);
+	}
+	/**
+	* Removes duplicate commits and dangling parents.
+	*/
+	doctor() {
+		this.#commits = pipe(this.#commits, Array.dedupeWith((a, b) => a.id === b.id), Array.map(Struct.evolve({ parents: (parents) => parents ? Array.filter(parents, (id) => this.#commits.some((commit) => commit.id === id)) : void 0 })));
+	}
+	build() {
+		this.doctor();
+		return {
+			commits: this.#commits,
+			branches: [...this.#branches]
+		};
+	}
+};
+//#endregion
+//#region src/execution-graph/pending-block-status.ts
+/**
+* Approximate streamed token count from partial text (UTF-8 length / 4).
+*/
+var estimateTokenCount = (text) => Math.max(1, Math.ceil(new TextEncoder().encode(text).length / 4));
+var formatOperationInputStatus = (data) => {
+	return `Calling ${data.name ?? data.key} (${new TextEncoder().encode(JSON.stringify(data.input)).length} bytes)...`;
+};
+/** Raw routine status updates (e.g. `Running 01KVB9WBRG…`) carry an opaque ULID, not a useful label. */
+var ROUTINE_ULID_STATUS = /^Running [0-9A-HJKMNP-TV-Z]{26}$/i;
+/**
+* Formats a pending assistant block for the delegated-task status line.
+*/
+var formatPendingBlockStatus = (block) => {
+	if (!block.pending) return;
+	if (block._tag === "text") return `Generating ${estimateTokenCount(block.text)} tokens....`;
+	if (block._tag === "toolCall") {
+		const bytes = new TextEncoder().encode(block.input).length;
+		return `Calling ${block.operationName ?? block.name} (${bytes} bytes)...`;
+	}
+};
+/**
+* Reads the latest pending partial block from an ephemeral trace message.
+*/
+var pendingStatusFromEphemeralMessage = (message) => {
+	for (const event of message.events) {
+		if (Trace.isOfType(PartialBlock, event)) {
+			const status = formatPendingBlockStatus(event.data.block);
+			if (status) return status;
+			continue;
+		}
+		if (Trace.isOfType(Trace.OperationInput, event)) return formatOperationInputStatus(event.data);
+		if (Trace.isOfType(Trace.StatusUpdate, event)) {
+			const message = event.data.message?.trim();
+			if (!message || ROUTINE_ULID_STATUS.test(message)) continue;
+			return message;
+		}
+	}
+};
+/**
+* Maps an ephemeral trace message to a task-status update.
+*
+* The status line is "sticky": a message without a pending line (e.g. a completed block during an
+* LLM-thinking gap) leaves the previous line in place rather than clearing it, so the row keeps
+* showing the latest meaningful activity until a new line arrives or the subscription ends.
+*/
+var resolveEphemeralStatusUpdate = (message) => {
+	const line = pendingStatusFromEphemeralMessage(message);
+	if (line) return { line };
+	return "unchanged";
+};
+//#endregion
+export { BEGIN_EVENT_TYPES, CommitSelector, DEFAULT_SPAN_TIMEOUT_MS, END_EVENT_TYPES, ROOT_SPAN_ID, buildExecutionGraph, buildSpanTree, collectProcessActivityLines, deriveInFlightActivityLine, estimateTokenCount, flattenSpanTree, formatPendingBlockStatus, isSpanBeginEvent, isSpanEndEvent, pendingStatusFromEphemeralMessage, resolveEphemeralStatusUpdate, walkSpanTree };
+
+//# sourceMappingURL=execution-graph.mjs.map