@dxos/react-ui-trace 0.11.1

package/dist/lib/index.mjs

@@ -0,0 +1,2868 @@
+import { translationKey } from "./translations.mjs";
+import { format } from "date-fns";
+import React, { forwardRef, memo, useCallback, useContext, useDeferredValue, useEffect, useMemo, useRef, useState } from "react";
+import { createContext, useComposedRefs } from "@dxos/react-hooks";
+import { Accordion, HoverCard, Icon, IconButton, Panel, ScrollArea, ScrollContainer, Tooltip, composable, composableProps, useDynamicRef, useForwardedRef, useTranslation } from "@dxos/react-ui";
+import { mx } from "@dxos/ui-theme";
+import { Unit, trim } from "@dxos/util";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { RegistryContext } from "@effect/atom-react/RegistryContext";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Process from "@dxos/compute/Process";
+import { Tree, createStaticTreeModel } from "@dxos/react-ui-list";
+import { addEventListener } from "@dxos/async";
+import { LogLevel, log } from "@dxos/log";
+import { Shimmer } from "@dxos/react-ui-components";
+import { ActionToolbar, MenuBuilder, useMenuBuilder } from "@dxos/react-ui-menu";
+import { JsonHighlighter } from "@dxos/react-ui-syntax-highlighter";
+import * as Array$1 from "effect/Array";
+import { pipe } from "effect/Function";
+import * as Pipeable from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import * as Struct from "effect/Struct";
+import { RUN_AGAIN_ERROR_CODE, RUN_AGAIN_MESSAGE } from "@dxos/compute";
+import * as Trace from "@dxos/compute/Trace";
+import { Annotation, Filter, Query } from "@dxos/echo";
+import { EID } from "@dxos/keys";
+import { useAtomValue } from "@effect/atom-react/Hooks";
+import * as Duration from "effect/Duration";
+import * as Atom from "effect/unstable/reactivity/Atom";
+import { FeedTraceSink } from "@dxos/compute-runtime";
+import { Task } from "@dxos/types";
+//#region src/components/Gantt/Gantt.tsx
+var ROW_HEIGHT = 28;
+var HEADER_HEIGHT = 20;
+var PAD_X = 12;
+var NODE_RADIUS = 5;
+/** Upper bound on axis ticks; the count shrinks with the width so `HH:mm:ss` labels never overlap. */
+var MAX_TICKS = 5;
+var TICK_MIN_WIDTH = 72;
+var BAR_HEIGHT = 15;
+/**
+* A bar reaches half its height past its first and last instant, so a node sitting on either one is
+* as far from the bar's end as it is from its top and bottom.
+*/
+var BAR_OVERHANG = BAR_HEIGHT / 2;
+/** Gap between adjacent session rectangles, halved on each. */
+var GROUP_INSET = 2;
+/** The rectangle's clearance around its bars, the same on every side, so its corners stay concentric with theirs. */
+var GROUP_PAD = ROW_HEIGHT / 2 - BAR_HEIGHT / 2 - GROUP_INSET;
+var GROUP_RADIUS = 12;
+/** Radius of the delegation connector's bend from the drop into the child bar. */
+var BEND_RADIUS = BAR_HEIGHT / 2;
+/**
+* Bar, node, thread and label colours per status: nodes and the thread through them are the bar's
+* hue in a lighter shade.
+*/
+var STATUS_COLOR = {
+	pending: {
+		fill: "fill-neutral-500/40",
+		node: "fill-neutral-300",
+		thread: "stroke-neutral-300",
+		text: "text-neutral-400"
+	},
+	blocked: {
+		fill: "fill-orange-500/40",
+		node: "fill-orange-300",
+		thread: "stroke-orange-300",
+		text: "text-orange-500"
+	},
+	running: {
+		fill: "fill-sky-500/40",
+		node: "fill-sky-300",
+		thread: "stroke-sky-300",
+		text: "text-sky-500"
+	},
+	review: {
+		fill: "fill-cyan-500/40",
+		node: "fill-cyan-300",
+		thread: "stroke-cyan-300",
+		text: "text-cyan-500"
+	},
+	done: {
+		fill: "fill-green-500/40",
+		node: "fill-green-300",
+		thread: "stroke-green-300",
+		text: "text-green-500"
+	},
+	failed: {
+		fill: "fill-red-500/40",
+		node: "fill-red-300",
+		thread: "stroke-red-300",
+		text: "text-red-500"
+	}
+};
+/**
+* Rows grouped by the session that processes them: a session, then the tasks (and subtasks) it
+* works itself, then — after that block — every session those tasks spawned, recursively. Keeping a
+* session's own rows contiguous is what lets one rectangle enclose them.
+*/
+var orderRows = (lanes) => {
+	const rows = [];
+	const groups = [];
+	const childrenOf = (parentId) => lanes.filter((lane) => lane.parentId === parentId);
+	const visitSession = (session, depth) => {
+		const first = rows.length;
+		rows.push({
+			lane: session,
+			depth,
+			index: rows.length,
+			sessionId: session.id
+		});
+		const spawned = [];
+		const visitTasks = (parentId, taskDepth) => {
+			for (const child of childrenOf(parentId)) if (child.kind === "task") {
+				rows.push({
+					lane: child,
+					depth: taskDepth,
+					index: rows.length,
+					sessionId: session.id
+				});
+				visitTasks(child.id, taskDepth + 1);
+			} else spawned.push({
+				lane: child,
+				depth: taskDepth
+			});
+		};
+		visitTasks(session.id, depth + 1);
+		groups.push({
+			session,
+			first,
+			last: rows.length - 1
+		});
+		for (const child of spawned) visitSession(child.lane, child.depth);
+	};
+	for (const lane of childrenOf(void 0)) if (lane.kind === "session") visitSession(lane, 0);
+	else rows.push({
+		lane,
+		depth: 0,
+		index: rows.length,
+		sessionId: void 0
+	});
+	return {
+		rows,
+		groups
+	};
+};
+var formatTokens = (tokens) => tokens.total >= 1e3 ? Unit.Thousand(tokens.total).toString() : String(tokens.total);
+var [GanttProvider, useGanttContext] = createContext("Gantt");
+/**
+* Gantt view of sessions and tasks on a shared time axis. The root resolves the rows and the axis;
+* the parts lay out side by side in the order given, sharing one row grid: `Legend` names the
+* lanes, `Chart` draws them, `Meta` shows per-lane totals. A host that already lists the lanes
+* renders the chart alone.
+*/
+var GanttRoot = composable(({ lanes, markers = [], range: rangeProp, now, showNow, onLaneSelect, onMarkerSelect, children, ...props }, forwardedRef) => {
+	const { rows, groups } = useMemo(() => orderRows(lanes), [lanes]);
+	const rowById = useMemo(() => new Map(rows.map((row) => [row.lane.id, row])), [rows]);
+	const markerById = useMemo(() => new Map(markers.map((marker) => [marker.id, marker])), [markers]);
+	const range = useMemo(() => {
+		if (rangeProp) return rangeProp;
+		const times = [...lanes.flatMap((lane) => [lane.start, lane.end]), ...markers.map((marker) => marker.timestamp)].filter((time) => time !== void 0).concat(now === void 0 ? [] : [now]);
+		const start = times.length > 0 ? Math.min(...times) : 0;
+		return {
+			start,
+			end: times.length > 0 ? Math.max(...times) : start
+		};
+	}, [
+		rangeProp,
+		lanes,
+		markers,
+		now
+	]);
+	return /* @__PURE__ */ jsx(GanttProvider, {
+		rows,
+		groups,
+		rowById,
+		markers,
+		markerById,
+		range,
+		now,
+		showNow,
+		onLaneSelect,
+		onMarkerSelect,
+		children: /* @__PURE__ */ jsx("div", {
+			...composableProps(props, { classNames: "flex w-full items-start text-xs font-mono overflow-hidden" }),
+			ref: forwardedRef,
+			children
+		})
+	});
+});
+GanttRoot.displayName = "Gantt.Root";
+/** The lane names, one per row, indented by depth; each row is the lane's keyboard path. */
+var GanttLegend = composable((props, forwardedRef) => {
+	const { rows, onLaneSelect } = useGanttContext("Gantt.Legend");
+	return /* @__PURE__ */ jsxs("div", {
+		...composableProps(props, { classNames: "shrink-0 w-[min(20rem,40%)] min-w-40 flex flex-col" }),
+		ref: forwardedRef,
+		children: [/* @__PURE__ */ jsx("div", { style: { height: HEADER_HEIGHT } }), rows.map(({ lane, depth }) => /* @__PURE__ */ jsxs("div", {
+			className: mx("flex items-center gap-2 truncate", onLaneSelect && "cursor-pointer hover:bg-hover-surface-subtle"),
+			style: {
+				height: ROW_HEIGHT,
+				paddingInlineStart: `${.5 + depth}rem`
+			},
+			...onLaneSelect && {
+				role: "button",
+				tabIndex: 0,
+				onClick: () => onLaneSelect(lane),
+				onKeyDown: (event) => {
+					if (event.key === "Enter" || event.key === " ") {
+						event.preventDefault();
+						onLaneSelect(lane);
+					}
+				}
+			},
+			children: [/* @__PURE__ */ jsx("span", { className: mx("shrink-0 w-2 h-2 rounded-full bg-current", STATUS_COLOR[lane.status].text) }), /* @__PURE__ */ jsx("span", {
+				className: "truncate text-base-fg",
+				children: lane.label
+			})]
+		}, lane.id))]
+	});
+});
+GanttLegend.displayName = "Gantt.Legend";
+/** Per-lane totals — tokens and tool calls — aligned to the rows. */
+var GanttMeta = composable((props, forwardedRef) => {
+	const { rows } = useGanttContext("Gantt.Meta");
+	return /* @__PURE__ */ jsxs("div", {
+		...composableProps(props, { classNames: "shrink-0 flex flex-col" }),
+		ref: forwardedRef,
+		children: [/* @__PURE__ */ jsx("div", { style: { height: HEADER_HEIGHT } }), rows.map(({ lane }) => /* @__PURE__ */ jsxs("div", {
+			className: "flex items-center justify-end gap-2 px-2 text-subdued whitespace-nowrap",
+			style: { height: ROW_HEIGHT },
+			children: [lane.tokens && /* @__PURE__ */ jsx("span", {
+				title: `${lane.tokens.input} in / ${lane.tokens.output} out`,
+				children: formatTokens(lane.tokens)
+			}), lane.toolCalls !== void 0 && /* @__PURE__ */ jsxs("span", { children: [lane.toolCalls, " tools"] })]
+		}, lane.id))]
+	});
+});
+GanttMeta.displayName = "Gantt.Meta";
+/**
+* The drawing: every lane is a rounded bar with its markers threaded through it as nodes, a session's
+* rectangle encloses the tasks it works, and connectors draw dependencies and delegations.
+*/
+var GanttChart = forwardRef(({ classNames }, forwardedRef) => {
+	const { rows, groups, rowById, markers, markerById, range, now, showNow, onLaneSelect, onMarkerSelect } = useGanttContext("Gantt.Chart");
+	const svgRef = useRef(null);
+	const ref = useComposedRefs(svgRef, forwardedRef);
+	const [width, setWidth] = useState(600);
+	useEffect(() => {
+		const element = svgRef.current;
+		if (!element) return;
+		const observer = new ResizeObserver(([entry]) => entry && setWidth(entry.contentRect.width));
+		observer.observe(element);
+		return () => observer.disconnect();
+	}, []);
+	const span = Math.max(range.end - range.start, 1);
+	const x = (time) => PAD_X + (time - range.start) / span * (width - 24);
+	const rowY = (index) => HEADER_HEIGHT + index * ROW_HEIGHT + ROW_HEIGHT / 2;
+	const laneTimes = (lane) => markers.filter((marker) => marker.laneId === lane.id).map((marker) => marker.timestamp);
+	const laneEnd = (lane) => {
+		const times = laneTimes(lane);
+		return times.length > 0 ? Math.max(...times) : lane.end ?? now;
+	};
+	const delegationSource = (lane) => lane.delegatedFrom && markerById.get(lane.delegatedFrom.markerId);
+	const barStart = (lane, start) => {
+		const source = delegationSource(lane);
+		const edge = x(start) - BAR_OVERHANG;
+		return source ? Math.max(edge, x(source.timestamp) + 2 * BEND_RADIUS) : edge;
+	};
+	const nodeX = (lane, time) => lane.start === void 0 ? x(time) : Math.max(x(time), barStart(lane, lane.start) + BAR_OVERHANG);
+	const height = HEADER_HEIGHT + rows.length * ROW_HEIGHT;
+	const tickCount = Math.max(2, Math.min(MAX_TICKS, Math.floor((width - 24) / TICK_MIN_WIDTH)));
+	const ticks = Array.from({ length: tickCount }, (_, index) => range.start + span * index / (tickCount - 1));
+	return /* @__PURE__ */ jsxs("svg", {
+		className: mx("flex-1 min-w-0", classNames),
+		ref,
+		style: { height },
+		children: [
+			ticks.map((tick, index) => /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("line", {
+				x1: x(tick),
+				x2: x(tick),
+				y1: HEADER_HEIGHT,
+				y2: height,
+				className: "stroke-separator"
+			}), /* @__PURE__ */ jsx("text", {
+				x: x(tick),
+				y: 14,
+				textAnchor: index === 0 ? "start" : index === tickCount - 1 ? "end" : "middle",
+				className: "fill-current text-subdued",
+				children: format(tick, "HH:mm:ss")
+			})] }, index)),
+			now !== void 0 && showNow && /* @__PURE__ */ jsx("line", {
+				x1: x(now),
+				x2: x(now),
+				y1: 0,
+				y2: height,
+				strokeDasharray: "3 3",
+				className: STATUS_COLOR.running.thread
+			}),
+			groups.flatMap(({ session, first, last }) => {
+				const members = rows.slice(first, last + 1).map((row) => row.lane);
+				const starts = members.flatMap((lane) => lane.start === void 0 ? [] : [barStart(lane, lane.start)]);
+				const ends = members.flatMap((lane) => {
+					const end = lane.start === void 0 ? void 0 : laneEnd(lane);
+					return end === void 0 ? [] : [x(end) + BAR_OVERHANG];
+				});
+				if (starts.length === 0 || ends.length === 0) return [];
+				const left = Math.min(...starts) - GROUP_PAD;
+				const right = Math.max(...ends) + GROUP_PAD;
+				return [/* @__PURE__ */ jsx("rect", {
+					x: left,
+					y: rowY(first) - ROW_HEIGHT / 2 + GROUP_INSET,
+					width: Math.max(right - left, ROW_HEIGHT),
+					height: (last - first + 1) * ROW_HEIGHT - 4,
+					rx: GROUP_RADIUS,
+					className: "fill-input-surface"
+				}, `group:${session.id}`)];
+			}),
+			rows.flatMap(({ lane, index }) => (lane.blockedOn ?? []).flatMap((depId) => {
+				const dep = rowById.get(depId);
+				const anchor = dep && (laneEnd(dep.lane) ?? dep.lane.start);
+				if (!dep || anchor === void 0) return [];
+				const anchorX = nodeX(dep.lane, anchor);
+				return [/* @__PURE__ */ jsx("line", {
+					x1: anchorX,
+					x2: anchorX,
+					y1: rowY(dep.index),
+					y2: rowY(index),
+					strokeDasharray: "2 2",
+					className: STATUS_COLOR.blocked.thread
+				}, `${lane.id}:${depId}`), ...lane.start === void 0 ? [/* @__PURE__ */ jsx("circle", {
+					cx: anchorX,
+					cy: rowY(index),
+					r: NODE_RADIUS,
+					strokeDasharray: "2 2",
+					className: mx("fill-base-surface", STATUS_COLOR.blocked.thread)
+				}, `${lane.id}:${depId}:hold`)] : []];
+			})),
+			rows.flatMap(({ lane, index }) => {
+				const source = delegationSource(lane);
+				const sourceRow = lane.delegatedFrom && rowById.get(lane.delegatedFrom.laneId);
+				if (!source || !sourceRow || lane.start === void 0) return [];
+				const sourceX = x(source.timestamp);
+				const y = rowY(index);
+				const firstNode = Math.min(...laneTimes(lane));
+				const targetX = Number.isFinite(firstNode) ? nodeX(lane, firstNode) : barStart(lane, lane.start) + BAR_OVERHANG;
+				return [/* @__PURE__ */ jsx("path", {
+					d: `M ${sourceX} ${rowY(sourceRow.index)} V ${y - BEND_RADIUS} Q ${sourceX} ${y} ${sourceX + BEND_RADIUS} ${y} H ${targetX}`,
+					fill: "none",
+					className: "stroke-fuchsia-500"
+				}, `delegation:${lane.id}`)];
+			}),
+			rows.map(({ lane, index }) => {
+				const end = laneEnd(lane);
+				if (lane.start === void 0 || end === void 0) return null;
+				const bar = {
+					x: barStart(lane, lane.start),
+					y: rowY(index) - BAR_HEIGHT / 2,
+					width: Math.max(x(end) + BAR_OVERHANG - barStart(lane, lane.start), BAR_HEIGHT),
+					height: BAR_HEIGHT,
+					rx: BAR_HEIGHT / 2
+				};
+				return /* @__PURE__ */ jsxs("g", {
+					className: "cursor-pointer",
+					onClick: () => onLaneSelect?.(lane),
+					children: [/* @__PURE__ */ jsx("rect", {
+						...bar,
+						className: "fill-base-surface"
+					}), /* @__PURE__ */ jsx("rect", {
+						...bar,
+						className: STATUS_COLOR[lane.status].fill
+					})]
+				}, lane.id);
+			}),
+			rows.map(({ lane, index }) => {
+				const times = laneTimes(lane);
+				if (times.length < 2) return null;
+				return /* @__PURE__ */ jsx("line", {
+					x1: nodeX(lane, Math.min(...times)),
+					x2: nodeX(lane, Math.max(...times)),
+					y1: rowY(index),
+					y2: rowY(index),
+					className: STATUS_COLOR[lane.status].thread
+				}, `thread:${lane.id}`);
+			}),
+			markers.map((marker) => {
+				const row = rowById.get(marker.laneId);
+				return row ? /* @__PURE__ */ jsxs(HoverCard.Root, { children: [/* @__PURE__ */ jsx(HoverCard.Trigger, {
+					asChild: true,
+					children: /* @__PURE__ */ jsx("circle", {
+						cx: nodeX(row.lane, marker.timestamp),
+						cy: rowY(row.index),
+						r: NODE_RADIUS,
+						className: mx("cursor-pointer stroke-base-surface transition-[stroke-width] hover:stroke-[3px] hover:stroke-base-fg", STATUS_COLOR[row.lane.status].node),
+						onClick: () => onMarkerSelect?.(marker)
+					})
+				}), /* @__PURE__ */ jsx(HoverCard.Portal, { children: /* @__PURE__ */ jsxs(HoverCard.Content, {
+					classNames: "p-2 max-w-72 text-xs font-mono",
+					children: [
+						/* @__PURE__ */ jsx("div", {
+							className: "font-medium truncate",
+							children: marker.label
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "text-description",
+							children: [
+								marker.kind,
+								" · ",
+								format(marker.timestamp, "HH:mm:ss.SSS"),
+								marker.level && marker.level !== "info" && /* @__PURE__ */ jsx("span", {
+									className: mx("ms-2", marker.level === "error" ? "text-error-text" : "text-warning-text"),
+									children: marker.level
+								})
+							]
+						}),
+						/* @__PURE__ */ jsx("div", {
+							className: "text-description truncate",
+							children: row.lane.label
+						}),
+						/* @__PURE__ */ jsx(HoverCard.Arrow, {})
+					]
+				}) })] }, marker.id) : null;
+			})
+		]
+	});
+});
+GanttChart.displayName = "Gantt.Chart";
+var Gantt = {
+	Root: GanttRoot,
+	Legend: GanttLegend,
+	Chart: GanttChart,
+	Meta: GanttMeta
+};
+//#endregion
+//#region src/components/ProcessTree/ProcessTree.tsx
+var DEFAULT_DEPTH = 1;
+/** Nested subprocess rows (level > 1) only surface still-active processes. */
+var NESTED_ACTIVE_STATES = /* @__PURE__ */ new Set([
+	Process.State.RUNNING,
+	Process.State.HYBERNATING,
+	Process.State.TERMINATING
+]);
+/** Synthetic root; the tree renders its children, never the root itself. */
+var ROOT_ID = "processes";
+var NO_SELECTION$1 = [];
+/**
+* The agent's running processes as a tree, one row per process with its status glyph and metrics
+* in trailing columns. The forest is rebuilt on every metrics tick, so open state lives outside the
+* model and is re-seeded — a collapse must survive the next tick. Renders through `Tree`.
+*/
+var ProcessTree = React.memo(composable(({ processes, depth = DEFAULT_DEPTH, resolveLabel, selected = NO_SELECTION$1, onSelectedChange, onProcessTerminate, ...props }, forwardedRef) => {
+	const openRef = useRef(/* @__PURE__ */ new Map());
+	const registry = useContext(RegistryContext);
+	const root = useMemo(() => buildProcessForest(processes, depth), [processes, depth]);
+	const model = useMemo(() => createStaticTreeModel(root, {
+		getChildren: (node) => node.children,
+		getProps: (node) => ({ label: (node.process && resolveLabel?.(node.process)) ?? node.process?.params.name ?? node.id }),
+		isOpen: (_node, path) => openRef.current.get(path.join("/")) ?? true,
+		isCurrent: (node) => node.process !== void 0 && selected.includes(node.process.pid)
+	}), [
+		root,
+		resolveLabel,
+		selected
+	]);
+	const handleOpenChange = useCallback(({ path, open }) => {
+		openRef.current.set(path.join("/"), open);
+		const atom = model.stateAtom(path);
+		registry.set(atom, {
+			...registry.get(atom),
+			open
+		});
+	}, [model, registry]);
+	const handleSelect = useCallback(({ item, current, meta }) => {
+		if (!item.process) return;
+		const pid = item.process.pid.toString();
+		onSelectedChange?.(!meta ? [pid] : current ? [...selected, pid] : selected.filter((candidate) => candidate !== pid));
+	}, [selected, onSelectedChange]);
+	const renderIcon = useMemo(() => makeIconRenderer(), []);
+	const renderColumns = useMemo(() => makeColumnRenderer(onProcessTerminate), [onProcessTerminate]);
+	return /* @__PURE__ */ jsx(ScrollArea.Root, {
+		...composableProps(props),
+		thin: true,
+		ref: forwardedRef,
+		children: /* @__PURE__ */ jsx(ScrollArea.Viewport, { children: /* @__PURE__ */ jsx(Tree, {
+			id: ROOT_ID,
+			model,
+			density: "sm",
+			selectionMode: "multiple",
+			classNames: "text-sm tabular-nums font-thin",
+			gridTemplateColumns: "[tree-row-start] var(--dx-control) minmax(0, 1fr) min-content min-content [tree-row-end]",
+			renderIcon,
+			renderColumns,
+			onOpenChange: handleOpenChange,
+			onSelect: handleSelect
+		}) })
+	});
+}));
+/** Status glyph — animated, coloured and tooltipped per state, which `TreeItemDataProps.icon` cannot express. */
+var makeIconRenderer = () => ({ item: { process } }) => process === void 0 ? null : /* @__PURE__ */ jsx(Tooltip.Trigger, {
+	content: process.state.toString(),
+	children: /* @__PURE__ */ jsx(Icon, {
+		size: 4,
+		synchronized: true,
+		classNames: mx("shrink-0", process.state === Process.State.RUNNING && "animate-spin", process.state === Process.State.FAILED && "text-error-text", process.state === Process.State.SUCCEEDED && "text-success-text"),
+		icon: Match.value(process.state).pipe(Match.when(Process.State.RUNNING, () => "ph--spinner-gap--regular"), Match.when(Process.State.SUCCEEDED, () => "ph--check-circle--regular"), Match.when(Process.State.FAILED, () => "ph--warning--regular"), Match.when(Process.State.HYBERNATING, () => "ph--spinner--regular"), Match.when(Process.State.IDLE, () => "ph--moon-stars--regular"), Match.when(Process.State.TERMINATING, () => "ph--x-circle--regular"), Match.when(Process.State.TERMINATED, () => "ph--x-circle--regular"), Match.orElse(() => "ph--spinner-gap--regular"))
+	})
+});
+/** Trailing columns: elapsed time for finished processes, and the terminate control. */
+var makeColumnRenderer = (onProcessTerminate) => ({ item: { process } }) => process === void 0 ? null : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("div", {
+	className: "flex items-center justify-end text-xs text-description tabular-nums",
+	children: [Process.State.FAILED, Process.State.SUCCEEDED].includes(process.state) && /* @__PURE__ */ jsx("span", {
+		className: "whitespace-nowrap",
+		children: Unit.Duration(process.metrics.wallTime).toString()
+	})
+}), /* @__PURE__ */ jsx("div", {
+	className: "flex items-center",
+	children: onProcessTerminate && /* @__PURE__ */ jsx(IconButton, {
+		classNames: "min-h-0 p-1",
+		icon: "ph--x--regular",
+		iconOnly: true,
+		density: "sm",
+		variant: "ghost",
+		label: "Actions",
+		onClick: (event) => {
+			event.stopPropagation();
+			onProcessTerminate(process);
+		}
+	})
+})] });
+var sortProcesses = (processes) => {
+	return [
+		...processes.filter((process) => [Process.State.RUNNING, Process.State.HYBERNATING].includes(process.state)),
+		...processes.filter((process) => [Process.State.IDLE].includes(process.state)).slice(0, 3),
+		...processes.filter((process) => [
+			Process.State.SUCCEEDED,
+			Process.State.FAILED,
+			Process.State.TERMINATED
+		].includes(process.state))
+	].sort((left, right) => {
+		const leftCompletedAt = Option.getOrElse(left.completedAt, () => Infinity);
+		return Option.getOrElse(right.completedAt, () => Infinity) - leftCompletedAt;
+	});
+};
+var sortNestedActive = (processes) => processes.filter((process) => NESTED_ACTIVE_STATES.has(process.state)).sort((left, right) => {
+	const priority = (state) => state === Process.State.RUNNING ? 0 : state === Process.State.HYBERNATING ? 1 : 2;
+	return priority(left.state) - priority(right.state);
+});
+/**
+* Builds the process forest, pruned to `maxDepth` from each root. Nested levels surface only still-
+* active processes, so a deep tree stays readable while completed work collapses out of view.
+*/
+var buildProcessForest = (processes, maxDepth) => {
+	const pidSet = new Set(processes.map((process) => String(process.pid)));
+	const childrenByParent = /* @__PURE__ */ new Map();
+	const roots = [];
+	for (const process of processes) {
+		const parent = process.parentPid;
+		if (parent === null || !pidSet.has(String(parent))) {
+			roots.push(process);
+			continue;
+		}
+		const key = String(parent);
+		const siblings = childrenByParent.get(key) ?? [];
+		siblings.push(process);
+		childrenByParent.set(key, siblings);
+	}
+	const visit = (process, level) => {
+		const children = level >= maxDepth ? [] : sortNestedActive(childrenByParent.get(String(process.pid)) ?? []);
+		return {
+			id: String(process.pid),
+			process,
+			children: children.map((child) => visit(child, level + 1))
+		};
+	};
+	return {
+		id: ROOT_ID,
+		children: sortProcesses(roots).map((process) => visit(process, 1))
+	};
+};
+//#endregion
+//#region src/components/Timeline/timeline-options.ts
+var defaultOptions = {
+	lineHeight: 24,
+	columnWidth: 14,
+	nodeRadius: 5,
+	lineStyle: "stroke-1"
+};
+var compactOptions = {
+	lineHeight: 20,
+	columnWidth: 12,
+	nodeRadius: 4,
+	lineStyle: "stroke-1"
+};
+//#endregion
+//#region src/components/Timeline/Timeline.tsx
+var SHIMMER_EFFECT_TAG$1 = "effect:shimmer";
+/** Wall-clock to the second: a trace line is read against its neighbours, and milliseconds only widen the column. */
+var TIMESTAMP_FORMAT = "HH:mm:ss";
+var hasShimmerEffect = (commit) => commit.tags?.includes(SHIMMER_EFFECT_TAG$1) ?? false;
+var empty = Object.freeze([]);
+/**
+* GitGraph-style timeline.
+*/
+var Timeline = memo(composable(({ branches: branchesProp, branch, commits = empty, showTimestamp = false, showIcon = true, compact = false, options = compact ? compactOptions : defaultOptions, debug = false, onChange, onSelect, ...props }, forwardedRef) => {
+	const { t } = useTranslation(translationKey);
+	const containerRef = useForwardedRef(forwardedRef);
+	const branches = useMemo(() => {
+		if (branchesProp) return branchesProp;
+		return commits.reduce((branches, commit) => {
+			if (!branches.includes(commit.branch)) branches.push(commit.branch);
+			return branches;
+		}, []);
+	}, [branchesProp, commits]);
+	const getCommitIndex = (id) => commits.findIndex((c) => c.id === id);
+	const getBranch = (id) => commits.find((c) => c.id === id)?.branch;
+	/**
+	* Assign branches to lanes, reusing lanes once a branch has been merged.
+	* Unmerged branches keep their lane active (they may still be in progress).
+	*/
+	const { branchLane, laneCount } = useMemo(() => {
+		const visibleBranches = new Set(branches);
+		const commitBranch = /* @__PURE__ */ new Map();
+		for (const commit of commits) commitBranch.set(commit.id, commit.branch);
+		const mergeRow = /* @__PURE__ */ new Map();
+		for (let row = 0; row < commits.length; row++) {
+			const commit = commits[row];
+			for (const parentId of commit.parents ?? []) {
+				const parentBranch = commitBranch.get(parentId);
+				if (parentBranch && parentBranch !== commit.branch && visibleBranches.has(parentBranch)) mergeRow.set(parentBranch, Math.max(mergeRow.get(parentBranch) ?? row, row));
+			}
+		}
+		const branchLane = /* @__PURE__ */ new Map();
+		if (branches.length > 0) branchLane.set(branches[0], 0);
+		const activeLanes = /* @__PURE__ */ new Set([0]);
+		let maxLane = 0;
+		for (let row = 0; row < commits.length; row++) {
+			const commit = commits[row];
+			if (visibleBranches.has(commit.branch) && !branchLane.has(commit.branch)) {
+				let lane = 1;
+				while (activeLanes.has(lane)) lane++;
+				branchLane.set(commit.branch, lane);
+				activeLanes.add(lane);
+				maxLane = Math.max(maxLane, lane);
+			}
+			for (const [branch, endRow] of mergeRow) if (endRow === row && branch !== branches[0] && branchLane.has(branch)) activeLanes.delete(branchLane.get(branch));
+		}
+		return {
+			branchLane,
+			laneCount: maxLane + 1
+		};
+	}, [commits, branches]);
+	const getBranchIndex = (branch) => branchLane.get(branch) ?? -1;
+	/**
+	* Create spans for each branch.
+	*/
+	const spans = useMemo(() => {
+		const spans = /* @__PURE__ */ new Map();
+		commits.forEach((commit, index) => {
+			let span = spans.get(commit.branch);
+			if (!span) {
+				span = {
+					start: index,
+					end: index
+				};
+				spans.set(commit.branch, span);
+			} else span.end = index;
+			const parents = commit.parents ?? [];
+			for (const parent of parents) {
+				const branch = getBranch(parent);
+				if (branch && branch !== commit.branch) {
+					span.start = Math.min(span.start, getCommitIndex(parent));
+					if (parents.length > 1) {
+						const parentSpan = spans.get(branch);
+						if (parentSpan) parentSpan.end = Math.max(parentSpan.end, index);
+					}
+				}
+			}
+		});
+		return spans;
+	}, [commits, branches]);
+	const [current, setCurrent] = useState(void 0);
+	const currentRef = useDynamicRef(current);
+	const selectedRef = useDynamicRef(void 0);
+	const currentCommit = useMemo(() => current !== void 0 ? commits[current] : void 0, [current, commits]);
+	const highlightedBranch = branch ?? currentCommit?.branch;
+	useEffect(() => {
+		onChange?.({
+			current,
+			commit: current === void 0 ? void 0 : commits[current]
+		});
+		(containerRef.current?.querySelector(`[data-index="${current}"]`))?.scrollIntoView({
+			behavior: "instant",
+			block: "nearest"
+		});
+	}, [onChange, current]);
+	useEffect(() => {
+		if (!branch) return;
+		if (currentRef.current !== void 0 && commits[currentRef.current]?.branch === branch) return;
+		const index = commits.findIndex((commit) => commit.branch === branch);
+		if (index >= 0) setCurrent(index);
+	}, [branch]);
+	useEffect(() => {
+		if (!containerRef.current) return;
+		return addEventListener(containerRef.current, "keydown", (event) => {
+			switch (event.key) {
+				case "ArrowUp":
+					event.preventDefault();
+					if (event.metaKey || currentRef.current === void 0) setCurrent(0);
+					else setCurrent((selected) => {
+						if (event.shiftKey && selected !== void 0) {
+							const branch = commits[selected].branch;
+							for (let i = selected - 1; i >= 0; i--) if (commits[i].branch === branch) return i;
+							return selected;
+						} else return selected === void 0 ? commits.length - 1 : Math.max(0, selected - 1);
+					});
+					break;
+				case "ArrowDown":
+					event.preventDefault();
+					if (event.metaKey || currentRef.current === void 0) setCurrent(commits.length - 1);
+					else setCurrent((selected) => {
+						if (event.shiftKey && selected !== void 0) {
+							const branch = commits[selected].branch;
+							for (let i = selected + 1; i <= commits.length - 1; i++) if (commits[i].branch === branch) return i;
+							return selected;
+						} else return selected === void 0 ? 0 : Math.min(commits.length - 1, selected + 1);
+					});
+					break;
+				case "Enter":
+					event.preventDefault();
+					if (currentRef.current !== void 0) {
+						selectedRef.current = currentRef.current === selectedRef.current ? void 0 : currentRef.current;
+						onSelect?.(selectedRef.current !== void 0 ? commits[selectedRef.current] : void 0);
+					}
+			}
+		});
+	}, [commits, containerRef.current]);
+	return /* @__PURE__ */ jsx("div", {
+		...composableProps(props, { classNames: "grid auto-rows-min outline-none" }),
+		tabIndex: 0,
+		style: { gridTemplateColumns: [
+			"min-content",
+			showIcon && "1.25rem",
+			"1fr",
+			showTimestamp && "max-content"
+		].filter(Boolean).join(" ") },
+		ref: containerRef,
+		children: commits.length < 1 ? /* @__PURE__ */ jsx("p", {
+			className: "col-span-full text-description p-trim-md",
+			children: t("no-commits.message")
+		}) : commits.map((commit, index) => {
+			if (getBranchIndex(commit.branch) === -1) return null;
+			const hasLink = !!commit.link && !!onSelect;
+			const handleClick = () => {
+				if (selectedRef.current === index) {
+					selectedRef.current = void 0;
+					setCurrent(void 0);
+					onSelect?.(void 0);
+					return;
+				}
+				setCurrent(index);
+				selectedRef.current = index;
+				onSelect?.(commit);
+			};
+			const message = debug ? JSON.stringify({
+				id: commit.id,
+				parents: commit.parents
+			}) : commit.message;
+			return /* @__PURE__ */ jsxs("div", {
+				"data-index": index,
+				"aria-current": current === index,
+				className: mx("group/row col-span-full grid grid-cols-subgrid gap-1 px-[2px] overflow-hidden items-center cursor-pointer pe-2", "aria-current:bg-current-surface! hover:bg-hover-surface-subtle"),
+				style: { height: `${options.lineHeight}px` },
+				onClick: handleClick,
+				children: [
+					/* @__PURE__ */ jsx("div", {
+						className: "px-2",
+						children: /* @__PURE__ */ jsx(LineVector, {
+							branchLane,
+							laneCount,
+							spans,
+							index,
+							commit,
+							highlightedBranch,
+							options
+						})
+					}),
+					showIcon && /* @__PURE__ */ jsx(CommitIcon, { commit }),
+					/* @__PURE__ */ jsx("div", {
+						className: mx("text-sm truncate cursor-pointer text-description font-thin group-aria-current/row:text-current-fg hover:text-current-fg", hasLink && "underline decoration-dotted underline-offset-2"),
+						children: hasShimmerEffect(commit) ? /* @__PURE__ */ jsx(Shimmer, { children: message }) : message
+					}),
+					showTimestamp && /* @__PURE__ */ jsx("div", {
+						className: "text-xs tabular-nums items-center text-description font-thin",
+						children: commit.timestamp && format(commit.timestamp, TIMESTAMP_FORMAT)
+					})
+				]
+			}, commit.id);
+		})
+	});
+}));
+Timeline.displayName = "Timeline";
+var CommitIcon = memo(({ commit }) => {
+	if (!commit.icon) return /* @__PURE__ */ jsx("div", {});
+	return /* @__PURE__ */ jsx(Icon, {
+		icon: commit.icon,
+		size: 4,
+		synchronized: true,
+		classNames: mx(commit.icon === "ph--spinner-gap--regular" && "animate-spin", commit.level !== void 0 && levelColors[commit.level])
+	});
+});
+var colors = [
+	{
+		stroke: "stroke-orange-500",
+		fill: "group-aria-[current=true]:fill-orange-500"
+	},
+	{
+		stroke: "stroke-sky-500",
+		fill: "group-aria-[current=true]:fill-sky-500"
+	},
+	{
+		stroke: "stroke-green-500",
+		fill: "group-aria-[current=true]:fill-green-500"
+	},
+	{
+		stroke: "stroke-fuchsia-500",
+		fill: "group-aria-[current=true]:fill-fuchsia-500"
+	},
+	{
+		stroke: "stroke-cyan-500",
+		fill: "group-aria-[current=true]:fill-cyan-500"
+	},
+	{
+		stroke: "stroke-emerald-500",
+		fill: "group-aria-[current=true]:fill-emerald-500"
+	},
+	{
+		stroke: "stroke-violet-500",
+		fill: "group-aria-[current=true]:fill-violet-500"
+	},
+	{
+		stroke: "stroke-teal-500",
+		fill: "group-aria-[current=true]:fill-teal-500"
+	}
+];
+var levelColors = {
+	[LogLevel.TRACE]: "text-gray-500",
+	[LogLevel.DEBUG]: "text-gray-500",
+	[LogLevel.VERBOSE]: "text-gray-500",
+	[LogLevel.INFO]: "text-green-500",
+	[LogLevel.WARN]: "text-orange-500",
+	[LogLevel.ERROR]: "text-red-500"
+};
+/**
+* SVG for node and connector paths.
+*/
+var LineVector = memo(({ branchLane, laneCount, spans, index, commit, highlightedBranch, options }) => {
+	const halfHeight = options.lineHeight / 2;
+	const cx = (c) => c * options.columnWidth + options.columnWidth / 2;
+	const getBranchIndex = (branch) => branchLane.get(branch) ?? -1;
+	const createPath = (index, commit, branch, span) => {
+		const parents = commit.parents ?? [];
+		const commitIndex = getBranchIndex(commit.branch);
+		const branchIndex = getBranchIndex(branch);
+		if (span.start < index && index < span.end) return `M ${cx(branchIndex)} 0 l 0 ${options.lineHeight}`;
+		else if (commit.branch === branch && parents.length > 0) return `M ${cx(branchIndex)} 0 l 0 ${halfHeight}`;
+		else if (commit.branch === branch && index < span.end) return `M ${cx(branchIndex)} ${halfHeight} l 0 ${options.lineHeight}`;
+		if (commit.branch !== branch && index === span.start) return trim`
+        M ${cx(commitIndex)} ${halfHeight}
+        L ${cx(branchIndex) - halfHeight} ${halfHeight}
+        a ${halfHeight} ${halfHeight} 0 0 1 ${halfHeight} ${halfHeight}
+      `;
+		if (commit.branch !== branch && index === span.end) return trim`
+        M ${cx(commitIndex)} ${halfHeight}
+        L ${cx(branchIndex) - halfHeight} ${halfHeight}
+        a ${halfHeight} ${halfHeight} -90 0 0 ${halfHeight} ${-halfHeight}
+      `;
+	};
+	const col = getBranchIndex(commit.branch);
+	const color = colors[col % colors.length];
+	const opacity = (branch) => ["duration-500 transition-opacity", highlightedBranch === void 0 || branch === highlightedBranch ? "opacity-100" : "opacity-50"];
+	return /* @__PURE__ */ jsxs("svg", {
+		width: laneCount * options.columnWidth,
+		height: options.lineHeight,
+		children: [
+			[...spans.entries()].map(([branch, span]) => {
+				const lane = getBranchIndex(branch);
+				if (lane < 0) return null;
+				const color = colors[lane % colors.length];
+				const path = createPath(index, commit, branch, span);
+				if (!path) return null;
+				return /* @__PURE__ */ jsx("path", {
+					d: path,
+					fill: "none",
+					className: mx(options.lineStyle, color.stroke, color.fill, opacity(branch))
+				}, branch);
+			}),
+			/* @__PURE__ */ jsx("circle", {
+				cx: cx(col),
+				cy: halfHeight,
+				r: options.nodeRadius,
+				className: mx("fill-base-surface stroke-base-surface")
+			}),
+			/* @__PURE__ */ jsx("circle", {
+				cx: cx(col),
+				cy: halfHeight,
+				r: options.nodeRadius,
+				className: mx("fill-base-surface", options.lineStyle, color?.stroke, color?.fill, opacity(commit.branch))
+			})
+		]
+	});
+});
+//#endregion
+//#region src/components/Timeline/timeline-printer.ts
+var NODE = "●";
+var MERGE_NODE = "◆";
+var RAIL = "│";
+var HORIZ = "─";
+var COL_WIDTH = 3;
+/**
+* Renders commits as a monospace ASCII graph with rounded box-drawing arcs and vertical rails.
+* Commits must be ordered chronologically (oldest first, newest last). Parents must refer to older commits.
+*/
+var renderTimelineAscii = (commits, branches) => {
+	if (commits.length === 0) return "";
+	const laneById = assignLanes(commits, branches);
+	const lanes = commits.map((commit) => laneById.get(commit.id));
+	const maxLane = Math.max(...lanes);
+	if (maxLane === 0) return commits.map((commit) => `${NODE}  ${formatLabel(commit)}`).join("\n");
+	const active = computeActiveColumns(commits, lanes, laneById);
+	const graphParts = commits.map((commit, row) => renderRow(commit, lanes[row], maxLane, active[row], laneById));
+	const maxGraphWidth = Math.max(...graphParts.map((part) => part.length));
+	return commits.map((commit, row) => `${graphParts[row].padEnd(maxGraphWidth)}  ${formatLabel(commit)}`).join("\n");
+};
+var renderRow = (commit, commitLane, maxLane, activeRow, laneById) => {
+	const totalChars = (maxLane + 1) * COL_WIDTH;
+	const chars = Array(totalChars).fill(" ");
+	const merge = isMergeCommit(commit);
+	const fork = !merge && isForkCommit(commit, laneById, commitLane);
+	let connectLane = -1;
+	if (fork) {
+		const parentLane = laneById.get(commit.parents[0]);
+		if (parentLane !== void 0) connectLane = parentLane;
+	} else if (merge) for (const parentId of commit.parents ?? []) {
+		const parentLane = laneById.get(parentId);
+		if (parentLane !== void 0 && parentLane !== commitLane) {
+			connectLane = parentLane;
+			break;
+		}
+	}
+	for (let col = 0; col <= maxLane; col++) {
+		if (col === commitLane) continue;
+		if (activeRow[col]) chars[col * COL_WIDTH] = RAIL;
+	}
+	chars[commitLane * COL_WIDTH] = merge ? MERGE_NODE : NODE;
+	if (connectLane >= 0) {
+		const connectPos = connectLane * COL_WIDTH;
+		if (fork) chars[connectPos] = connectLane < commitLane ? "├" : "┤";
+		else chars[connectPos] = connectLane > commitLane ? "╯" : "╰";
+		const minCol = Math.min(commitLane, connectLane);
+		const maxCol = Math.max(commitLane, connectLane);
+		for (let pos = minCol * COL_WIDTH + 1; pos < maxCol * COL_WIDTH; pos++) if (pos % COL_WIDTH === 0) {
+			if (activeRow[pos / COL_WIDTH]) chars[pos] = "┼";
+			else chars[pos] = HORIZ;
+		} else chars[pos] = HORIZ;
+	}
+	return chars.join("").trimEnd();
+};
+var formatLabel = (commit) => {
+	const icon = commit.icon?.replace(/^ph--/, "").replace(/--regular$/, "").replace(/--bold$/, "").replace(/--fill$/, "");
+	return icon ? `[${icon}] ${commit.message}` : commit.message;
+};
+/**
+* Assigns each commit to a lane (column), reusing lanes once a branch has been merged.
+* A branch is considered "merged" when a commit on another branch references it as a parent.
+* Unmerged branches keep their lane active (they may still be in progress).
+* Lane 0 is reserved for the first branch (typically 'main').
+*/
+var assignLanes = (commits, branches) => {
+	const commitBranch = /* @__PURE__ */ new Map();
+	for (const commit of commits) commitBranch.set(commit.id, commit.branch);
+	const mergeRow = /* @__PURE__ */ new Map();
+	for (let row = 0; row < commits.length; row++) {
+		const commit = commits[row];
+		for (const parentId of commit.parents ?? []) {
+			const parentBranch = commitBranch.get(parentId);
+			if (parentBranch && parentBranch !== commit.branch) mergeRow.set(parentBranch, Math.max(mergeRow.get(parentBranch) ?? row, row));
+		}
+	}
+	const branchLane = /* @__PURE__ */ new Map();
+	if (branches.length > 0) branchLane.set(branches[0], 0);
+	const activeLanes = /* @__PURE__ */ new Set([0]);
+	const laneById = /* @__PURE__ */ new Map();
+	for (let row = 0; row < commits.length; row++) {
+		const commit = commits[row];
+		if (!branchLane.has(commit.branch)) {
+			let lane = 1;
+			while (activeLanes.has(lane)) lane++;
+			branchLane.set(commit.branch, lane);
+			activeLanes.add(lane);
+		}
+		laneById.set(commit.id, branchLane.get(commit.branch));
+		for (const [branch, endRow] of mergeRow) if (endRow === row && branch !== branches[0] && branchLane.has(branch)) activeLanes.delete(branchLane.get(branch));
+	}
+	return laneById;
+};
+var isMergeCommit = (commit) => (commit.parents?.length ?? 0) > 1;
+var isForkCommit = (commit, laneById, lane) => {
+	const parents = commit.parents;
+	if (!parents || parents.length !== 1) return false;
+	const parentLane = laneById.get(parents[0]);
+	return parentLane !== void 0 && parentLane !== lane;
+};
+/**
+* Column `col` is active on `row` when `row` falls inside the vertical span
+* of that column (the range of rows that include commits on that lane plus
+* merge rows referencing parents on that lane) AND the row's own commit
+* is not on that column.
+*/
+var computeActiveColumns = (commits, lanes, laneById) => {
+	const rows = commits.length;
+	const cols = Math.max(...lanes, 0) + 1;
+	const rowIndicesByCol = Array.from({ length: cols }, () => []);
+	for (let row = 0; row < rows; row++) rowIndicesByCol[lanes[row]].push(row);
+	for (let row = 0; row < rows; row++) for (const parentId of commits[row]?.parents ?? []) {
+		const parentLane = laneById.get(parentId);
+		if (parentLane === void 0) continue;
+		rowIndicesByCol[parentLane].push(row);
+	}
+	const active = Array.from({ length: rows }, () => Array(cols).fill(false));
+	for (let col = 0; col < cols; col++) {
+		const indices = rowIndicesByCol[col];
+		if (indices.length === 0) continue;
+		const minR = Math.min(...indices);
+		const maxR = Math.max(...indices);
+		for (let row = minR; row <= maxR; row++) if (lanes[row] !== col) active[row][col] = true;
+	}
+	return active;
+};
+//#endregion
+//#region src/components/TracePanel/trace-filter.ts
+/**
+* What a running process is working on behalf of, as a single bucket.
+*
+* Bucketed from the inherited {@link Process.Environment}, so filtering keeps whole subtrees together.
+*/
+var ProcessEnvironment = {
+	/** Not scoped to a space: layout, navigation, identity, settings, space lifecycle. */
+	App: "app",
+	/** Scoped to a space, but not to a conversation within it. */
+	Space: "space",
+	/** Serving a conversation: an agent's turn and every tool call it spawns. */
+	Conversation: "conversation"
+};
+/** Every environment, in menu order — widening scope, so the filter reads the same on every trace. */
+var ALL_PROCESS_ENVIRONMENTS = [
+	ProcessEnvironment.App,
+	ProcessEnvironment.Space,
+	ProcessEnvironment.Conversation
+];
+/** App-level processes start hidden: that bucket fires on every click, whatever the user is watching. */
+var DEFAULT_PROCESS_ENVIRONMENTS = [ProcessEnvironment.Space, ProcessEnvironment.Conversation];
+var ENVIRONMENT_ICONS = {
+	[ProcessEnvironment.App]: "ph--app-window--regular",
+	[ProcessEnvironment.Space]: "ph--planet--regular",
+	[ProcessEnvironment.Conversation]: "ph--chat-teardrop-text--regular"
+};
+var environmentIcon = (environment) => ENVIRONMENT_ICONS[environment];
+/** `conversation` outranks `space`, since a conversation always runs inside one. */
+var processEnvironment = (process) => {
+	if (process.environment.conversation !== void 0) return ProcessEnvironment.Conversation;
+	if (process.environment.space !== void 0) return ProcessEnvironment.Space;
+	return ProcessEnvironment.App;
+};
+var filterProcesses = (processes, selected) => {
+	if (selected.length === ALL_PROCESS_ENVIRONMENTS.length) return processes;
+	const selection = new Set(selected);
+	return processes.filter((process) => selection.has(processEnvironment(process)));
+};
+/** Toggles an environment, preserving the canonical order. */
+var toggleProcessEnvironment = (selected, environment) => ALL_PROCESS_ENVIRONMENTS.filter((candidate) => candidate === environment ? !selected.includes(environment) : selected.includes(candidate));
+/**
+* Narrows a persisted selection to the known environments, in canonical order.
+*
+* Settings outlive the vocabulary that wrote them; an unrecognized value would filter the panel to nothing.
+*/
+var parseProcessEnvironments = (selected) => selected === void 0 ? DEFAULT_PROCESS_ENVIRONMENTS : ALL_PROCESS_ENVIRONMENTS.filter((environment) => selected.includes(environment));
+/**
+* Narrows trace messages to the selected processes and their descendants: a tool call or sub-agent
+* runs as a child of the process it serves, so its events are that process's work. An empty
+* selection is no filter.
+*/
+var filterTraceMessages = (messages, selected) => {
+	if (selected.length === 0) return messages;
+	const parentByPid = /* @__PURE__ */ new Map();
+	for (const message of messages) if (message.meta.pid !== void 0) parentByPid.set(message.meta.pid, message.meta.parentPid);
+	const selection = new Set(selected);
+	const matches = /* @__PURE__ */ new Map();
+	const isSelected = (pid) => {
+		const known = matches.get(pid);
+		if (known !== void 0) return known;
+		matches.set(pid, false);
+		const parent = parentByPid.get(pid);
+		const result = selection.has(pid) || parent !== void 0 && isSelected(parent);
+		matches.set(pid, result);
+		return result;
+	};
+	return messages.filter((message) => message.meta.pid !== void 0 && isSelected(message.meta.pid));
+};
+//#endregion
+//#region src/components/TracePanel/useTraceMenu.ts
+/**
+* Environment filter menu for the trace panel's toolbar.
+* The group collapses to a funnel trigger, so the panel's own rows keep the width.
+*/
+var useTraceMenu = ({ selected, onSelectedChange, selectionCount = 0, onClearSelection }) => {
+	const handleToggle = useCallback((environment) => onSelectedChange(toggleProcessEnvironment(selected, environment)), [selected, onSelectedChange]);
+	return useMenuBuilder(() => MenuBuilder.make().action("clearSelection", {
+		label: ["trace-clear-selection.label", { ns: translationKey }],
+		icon: "ph--selection-slash--regular",
+		iconOnly: true,
+		hidden: selectionCount === 0,
+		testId: "tracePanel.clearSelection"
+	}, () => onClearSelection?.()).group("processEnvironments", {
+		label: ["trace-filter.menu", { ns: translationKey }],
+		icon: "ph--funnel--regular",
+		iconOnly: true,
+		variant: "dropdownMenu",
+		selectCardinality: "multiple",
+		value: [...selected],
+		testId: "tracePanel.filter"
+	}, (group) => {
+		for (const environment of ALL_PROCESS_ENVIRONMENTS) group.action(environment, {
+			label: [`trace-environment-${environment}.label`, { ns: translationKey }],
+			icon: environmentIcon(environment),
+			checked: selected.includes(environment)
+		}, () => handleToggle(environment));
+		group.separator("line");
+		group.action("all", {
+			label: ["trace-filter-all.label", { ns: translationKey }],
+			icon: "ph--list-checks--regular"
+		}, () => onSelectedChange([...ALL_PROCESS_ENVIRONMENTS]));
+		group.action("none", {
+			label: ["trace-filter-none.label", { ns: translationKey }],
+			icon: "ph--prohibit--regular"
+		}, () => onSelectedChange([]));
+	}).build(), [
+		handleToggle,
+		selected,
+		onSelectedChange,
+		selectionCount,
+		onClearSelection
+	]);
+};
+//#endregion
+//#region src/components/TracePanel/TracePanel.tsx
+/**
+* A space's runtime: its processes as a tree, its trace as a commit graph, and the picked commit's
+* event. Presentation only — the host resolves the process monitor, the trace feed, settings and
+* navigation and hands them in as props.
+*/
+var TracePanel = composable(({ classNames, processes, graph, environments, onEnvironmentsChange, debug = false, resolveLabel, selected = NO_SELECTION, onSelectedChange, onProcessTerminate, onOpenLink, ...props }, forwardedRef) => {
+	const { t } = useTranslation(translationKey);
+	const handleClearSelection = useCallback(() => onSelectedChange?.([]), [onSelectedChange]);
+	const menu = useTraceMenu({
+		selected: environments,
+		onSelectedChange: onEnvironmentsChange,
+		selectionCount: selected.length,
+		onClearSelection: handleClearSelection
+	});
+	const { branches, commits, spanTree, details } = useDeferredValue(graph);
+	const [selectedCommit, setSelectedCommit] = useState();
+	const [openSections, setOpenSections] = useState(SECTIONS.map((section) => section.id));
+	const handleCommitSelect = useCallback((commit) => {
+		setSelectedCommit(commit);
+		if (commit?.link) onOpenLink?.(commit.link);
+	}, [onOpenLink]);
+	const currentBranch = useMemo(() => {
+		const last = selected.at(-1);
+		return last !== void 0 && branches.includes(last) ? last : null;
+	}, [selected, branches]);
+	return /* @__PURE__ */ jsxs(Panel.Root, {
+		...composableProps(props, { classNames: ["h-full", classNames] }),
+		ref: forwardedRef,
+		children: [/* @__PURE__ */ jsx(Panel.Toolbar, {
+			asChild: true,
+			children: /* @__PURE__ */ jsx(ActionToolbar, {
+				...menu,
+				alwaysActive: true,
+				classNames: "justify-end"
+			})
+		}), /* @__PURE__ */ jsx(Panel.Content, { children: /* @__PURE__ */ jsx(Accordion.Root, {
+			items: SECTIONS,
+			value: openSections,
+			onValueChange: setOpenSections,
+			classNames: "h-full min-h-0 rounded-none border-y-0",
+			children: ({ items }) => items.map((section) => {
+				switch (section.id) {
+					case "processes": return /* @__PURE__ */ jsxs(Accordion.Item, {
+						item: section,
+						classNames: "border-x-0",
+						children: [/* @__PURE__ */ jsx(Accordion.ItemHeader, {
+							hover: true,
+							children: /* @__PURE__ */ jsx("span", {
+								className: "text-sm text-description",
+								children: t("trace-processes.label")
+							})
+						}), /* @__PURE__ */ jsx(Accordion.ItemBody, {
+							classNames: "p-0",
+							children: /* @__PURE__ */ jsx(ProcessTreeContainer, {
+								classNames: "max-h-[8lh]",
+								processes,
+								environments,
+								resolveLabel,
+								selected,
+								onSelectedChange,
+								onProcessTerminate
+							})
+						})]
+					}, section.id);
+					case "trace": return /* @__PURE__ */ jsxs(Accordion.Item, {
+						item: section,
+						classNames: mx("border-x-0 dx-grow flex flex-col", "[&>[data-part=item-content]]:dx-grow [&>[data-part=item-content]]:flex [&>[data-part=item-content]]:flex-col [&>[data-part=item-content]]:animate-none"),
+						children: [/* @__PURE__ */ jsx(Accordion.ItemHeader, {
+							hover: true,
+							children: /* @__PURE__ */ jsx("span", {
+								className: "text-sm text-description",
+								children: t("trace.label")
+							})
+						}), /* @__PURE__ */ jsx(Accordion.ItemBody, {
+							classNames: "dx-grow grid grid-rows-[minmax(0,1fr)]",
+							children: /* @__PURE__ */ jsx(ScrollContainer.Root, {
+								pin: true,
+								children: /* @__PURE__ */ jsxs(ScrollContainer.Content, {
+									thin: true,
+									children: [
+										/* @__PURE__ */ jsx(ScrollContainer.Fade, {}),
+										/* @__PURE__ */ jsx(ScrollContainer.Viewport, { children: debug ? /* @__PURE__ */ jsx(JsonHighlighter, {
+											data: spanTree,
+											classNames: "text-xs"
+										}) : /* @__PURE__ */ jsx(Timeline, {
+											branches,
+											branch: currentBranch,
+											commits,
+											showTimestamp: true,
+											onSelect: handleCommitSelect
+										}) }),
+										/* @__PURE__ */ jsx(ScrollContainer.ScrollDownButton, {})
+									]
+								})
+							})
+						})]
+					}, section.id);
+					case "details": {
+						const commit = debug ? void 0 : selectedCommit;
+						return /* @__PURE__ */ jsxs(Accordion.Item, {
+							item: section,
+							disabled: !commit,
+							classNames: "border-x-0",
+							children: [/* @__PURE__ */ jsx(Accordion.ItemHeader, {
+								hover: true,
+								children: /* @__PURE__ */ jsx("span", {
+									className: "block truncate text-sm text-description",
+									children: commit?.message ?? t("trace-details.label")
+								})
+							}), commit && /* @__PURE__ */ jsx(Accordion.ItemBody, {
+								classNames: "p-0",
+								children: /* @__PURE__ */ jsx(JsonHighlighter, {
+									data: details[commit.id] ?? commit,
+									classNames: "max-h-[20lh] text-xs"
+								})
+							})]
+						}, section.id);
+					}
+				}
+			})
+		}) })]
+	});
+});
+TracePanel.displayName = "TracePanel";
+var SECTIONS = [
+	{ id: "processes" },
+	{ id: "trace" },
+	{ id: "details" }
+];
+var NO_SELECTION = [];
+var ProcessTreeContainer = ({ classNames, processes, environments, resolveLabel, selected, onSelectedChange, onProcessTerminate }) => {
+	const processesDeferred = useDeferredValue(processes);
+	const visibleProcesses = useMemo(() => filterProcesses(processesDeferred, environments), [processesDeferred, environments]);
+	return /* @__PURE__ */ jsx(ProcessTree, {
+		classNames,
+		depth: 3,
+		processes: visibleProcesses,
+		resolveLabel,
+		selected,
+		onSelectedChange,
+		onProcessTerminate
+	});
+};
+//#endregion
+//#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 = 12e5;
+/**
+* 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, Trace.AgentRequestBegin.key]);
+var END_EVENT_TYPES = /* @__PURE__ */ new Set([Trace.OperationEnd.key, Trace.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`, `Trace.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`, `Trace.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`, `Trace.AgentRequestBegin` → `Trace.AgentRequestEnd`).
+*/
+var makeTimeoutEndEvent = (span, timestamp) => {
+	const beginEvent = span.events[0];
+	if (beginEvent.type === Trace.AgentRequestBegin.key) return {
+		type: Trace.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 = "/Users/burdon/Code/dxos/dxos/.claude/worktrees/resume-project-tasks-6ed628/packages/ui/react-ui-trace/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
+	},
+	operationEndIncomplete: {
+		icon: "ph--arrows-clockwise--regular",
+		level: LogLevel.WARN
+	},
+	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: 144,
+		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 !== Trace.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 `Trace.AgentRequestEnd` payload, accepting legacy traces that omitted `status`.
+*/
+var parseAgentRequestEnd = (data) => {
+	if (Schema.is(Trace.AgentRequestEnd.schema)(data)) return data;
+	if (data != null && typeof data === "object" && Object.keys(data).length === 0) return { status: "success" };
+	log("invalid trace event", { type: Trace.AgentRequestEnd.key }, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 210,
+		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(Trace.AgentRequestBegin, event)) {
+		if (!Schema.is(Trace.AgentRequestBegin.schema)(event.data)) {
+			log("invalid trace event", { type: event.type }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 240,
+				S: void 0
+			});
+			return;
+		}
+		return {
+			icon: ICONS.agentRequestBegin.icon,
+			level: ICONS.agentRequestBegin.level,
+			message: "Agent processing request..."
+		};
+	}
+	if (Trace.isOfType(Trace.AgentRequestEnd, event)) {
+		const endData = parseAgentRequestEnd(event.data);
+		if (!endData) return;
+		return presentAgentRequestEnd(endData);
+	}
+	if (Trace.isOfType(Trace.CompleteBlock, event)) {
+		if (!Schema.is(Trace.CompleteBlock.schema)(event.data)) {
+			log("invalid trace event", { type: event.type }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 258,
+				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 (!Schema.is(Trace.OperationStart.schema)(event.data)) {
+			log("invalid trace event", { type: event.type }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 318,
+				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 (!Schema.is(Trace.OperationEnd.schema)(event.data)) {
+			log("invalid trace event", { type: event.type }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 330,
+				S: void 0
+			});
+			return;
+		}
+		const incomplete = event.data.outcome === "failure" && (event.data.errorCode === RUN_AGAIN_ERROR_CODE || event.data.errorCode === void 0 && event.data.error === RUN_AGAIN_MESSAGE);
+		const presentation = event.data.outcome === "success" ? {
+			icon: ICONS.operationEndSuccess.icon,
+			level: ICONS.operationEndSuccess.level,
+			suffix: ""
+		} : incomplete ? {
+			icon: ICONS.operationEndIncomplete.icon,
+			level: ICONS.operationEndIncomplete.level,
+			suffix: " - Incomplete"
+		} : {
+			icon: ICONS.operationEndError.icon,
+			level: ICONS.operationEndError.level,
+			suffix: " - Error"
+		};
+		return {
+			icon: event.data.icon ?? presentation.icon,
+			level: presentation.level,
+			message: `${event.data.name ?? event.data.key}${presentation.suffix}`,
+			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(Trace.AgentRequestBegin, event)) {
+			agentRequestOpen = true;
+			lastLine = "Generating...";
+			continue;
+		}
+		if (Trace.isOfType(Trace.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(Trace.CompleteBlock, event)) return false;
+	if (event.data.block._tag !== "toolCall") return false;
+	return !toolCallContext.resultByCallId.has(event.data.block.toolCallId);
+};
+/**
+* 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.isHarnessHost(process) && 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.firstOf(CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last())), CommitSelector.branch(MAIN_BRANCH).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 = isPendingToolCallEvent(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$1.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$1.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$1.dedupeWith((a, b) => a.id === b.id), Array$1.map(Struct.evolve({ parents: (parents) => parents ? Array$1.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(Trace.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
+//#region src/hooks/useTraceMessages.ts
+var atomEmpty$1 = Atom.make(() => []);
+/**
+* Atom of raw trace messages for a space — the input to `buildExecutionGraph`.
+*/
+var getTraceMessagesAtom = (space) => pipe(space.db.query(FeedTraceSink.query).atom, Atom.map((feeds) => space.db.query(feeds.length > 0 ? Query.type(Trace.Message).from([...feeds]) : Query.select(Filter.nothing())).atom), (atom) => Atom.make((get) => get(get(atom))));
+/**
+* Subscribes to the space invocation trace feed.
+*/
+var useTraceMessages = (space, { debounce } = {}) => {
+	const atom = useMemo(() => {
+		if (!space) return atomEmpty$1;
+		const traces = getTraceMessagesAtom(space);
+		return debounce ? traces.pipe(Atom.debounce(debounce)) : traces;
+	}, [space, debounce]);
+	return useAtomValue(atom);
+};
+//#endregion
+//#region src/hooks/useExecutionGraph.ts
+var atomEmpty = Atom.make(() => []);
+var NO_PIDS = [];
+var SPAN_TIMEOUT_CHECK_INTERVAL_MS = 6e4;
+/**
+* The commit graph of a space's trace, rebuilt as messages land and as the process tree changes.
+* `processesAtom` is the host's live process tree (a running agent draws a spinner commit); without
+* it the graph is the durable trace alone.
+*/
+var useExecutionGraph = (space, processesAtom, { collapseCompletedSpans, eventLimit, selectedPids = NO_PIDS } = {}) => {
+	const [now, setNow] = useState(() => Date.now());
+	useEffect(() => {
+		const id = setInterval(() => setNow(Date.now()), SPAN_TIMEOUT_CHECK_INTERVAL_MS);
+		return () => clearInterval(id);
+	}, []);
+	const atom = useMemo(() => getExecutionGraph(space, processesAtom ?? atomEmpty, {
+		collapseCompletedSpans,
+		eventLimit,
+		selectedPids,
+		now
+	}), [
+		space,
+		processesAtom,
+		collapseCompletedSpans,
+		eventLimit,
+		selectedPids,
+		now
+	]);
+	return useAtomValue(atom);
+};
+/** Identity for the graph: only a process appearing, disappearing or changing state redraws it. */
+var sameProcesses = (left, right) => left.length === right.length && left.every((process, index) => process.pid === right[index].pid && process.state === right[index].state);
+var getExecutionGraph = (space, processesAtom, { collapseCompletedSpans = true, eventLimit = 100, selectedPids = NO_PIDS, now }) => {
+	const traceMessages = getTraceMessagesAtom(space).pipe(Atom.map((messages) => filterTraceMessages(messages, selectedPids)));
+	const activeProcesses = pipe(processesAtom, Atom.debounce(Duration.millis(500)), Atom.map((processes) => processes.filter((process) => (process.state === Process.State.RUNNING || process.state === Process.State.HYBERNATING) && (selectedPids.length === 0 || selectedPids.includes(process.pid)))), Atom.withEquality(sameProcesses));
+	return Atom.make((get) => buildExecutionGraph({
+		traceMessages: get(traceMessages),
+		activeProcesses: get(activeProcesses),
+		collapseCompletedSpans,
+		eventLimit,
+		now
+	}));
+};
+//#endregion
+//#region src/session-timeline/session-timeline.ts
+var ACTIVE_STATES = /* @__PURE__ */ new Set([Process.State.RUNNING, Process.State.HYBERNATING]);
+/** How long an open lane may be silent before the axis stops following `now`. */
+var OPEN_LANE_STALE_MS = 6e5;
+var TASK_STATUS = {
+	todo: "pending",
+	backlog: "pending",
+	blocked: "blocked",
+	started: "running",
+	review: "review",
+	done: "done",
+	failed: "failed"
+};
+/** Entity id of an ECHO URI, the join key between a process target, a trace meta and a chat. */
+var entityKey = (uri) => {
+	const eid = EID.tryParse(uri);
+	return (eid && EID.getEntityId(eid)) ?? uri;
+};
+var eventFeedKey = (event) => event.meta.conversation ? entityKey(event.meta.conversation.uri) : void 0;
+var decode = (schema, data) => Option.getOrUndefined(Schema.decodeUnknownOption(schema)(data));
+var sessionLaneId = (key) => `session:${key}`;
+var taskLaneId = (taskId) => `task:${taskId}`;
+/**
+* Cuts a session's events into one segment per task worked, from the status events its task tools
+* write. Only tasks in `taskIds` — the session's own checklist — take part: an agent is free to move
+* a task belonging to nothing on this chart, and such an event must not close the segment that is
+* open or move the boundary.
+*
+* A `started` event opens a segment and closes the one still open — the agent keeps exactly one task
+* in progress. Any other status ends the agent's work on the task: `todo` puts it down as surely as
+* `done`, and whatever the agent does next is no longer that task's. A task can also finish without
+* a start: delegation marks every task it hands over
+* `started` before the agent's first turn, so the run's only event for that task is the one closing
+* it. Such a task gets the stretch since the last boundary, which is where its work happened — but
+* only on the transition out of `started` and only while no other task holds the stretch: a task
+* merely dismissed (`todo` → `blocked`) claims nothing, a second close (`review` → `done`) mints
+* nothing, and a close arriving after the next task has started leaves that task's segment alone
+* rather than overlapping it.
+*/
+var buildTaskSegments = (events, sessionStart, taskIds) => {
+	const segments = [];
+	let open;
+	let boundary = sessionStart;
+	const close = (segment, timestamp) => {
+		segment.end = timestamp;
+		boundary = timestamp;
+		if (open === segment) open = void 0;
+	};
+	for (const event of events) {
+		if (event.type !== Trace.TaskStatusChanged.key) continue;
+		const data = decode(Trace.TaskStatusChanged.schema, event.data);
+		if (!data || !taskIds.has(data.taskId)) continue;
+		if (data.status === "started") {
+			if (open && open.taskId !== data.taskId) close(open, event.timestamp);
+			if (!open) {
+				open = {
+					taskId: data.taskId,
+					laneId: taskLaneId(data.taskId),
+					start: event.timestamp
+				};
+				segments.push(open);
+				boundary = event.timestamp;
+			}
+		} else {
+			const started = segments.findLast((candidate) => candidate.taskId === data.taskId && candidate.end === void 0);
+			if (started) close(started, event.timestamp);
+			else if (data.previousStatus === "started" && open === void 0) {
+				const segment = {
+					taskId: data.taskId,
+					laneId: taskLaneId(data.taskId),
+					start: Math.min(boundary ?? event.timestamp, event.timestamp)
+				};
+				segments.push(segment);
+				close(segment, event.timestamp);
+			}
+		}
+	}
+	return segments;
+};
+/**
+* The segment an event belongs to. Segments meet where one task starts over another, so a
+* status event is matched to its own task's segment, and any other event at a shared boundary
+* goes to the later segment — the newcomer's start is the first thing the agent did on it.
+*/
+var segmentFor = (segments, event) => {
+	if (!segments) return;
+	const contains = (segment) => event.timestamp >= segment.start && event.timestamp <= (segment.end ?? Number.MAX_SAFE_INTEGER);
+	if (event.type === Trace.TaskStatusChanged.key) {
+		const data = decode(Trace.TaskStatusChanged.schema, event.data);
+		return data && segments.findLast((segment) => segment.taskId === data.taskId && contains(segment));
+	}
+	return segments.findLast(contains);
+};
+/**
+* Builds the gantt-shaped view of one or more assistant sessions from their trace: session lanes
+* (supervisors and the sub-agents they delegate to), task lanes, and the markers on each.
+*/
+var buildSessionTimeline = ({ traceMessages, processes = [], sessions, tasks = [], now }) => {
+	const spans = flattenSpanTree(buildSpanTree(traceMessages));
+	const events = spans.flatMap((span) => span.events).sort((a, b) => a.timestamp - b.timestamp);
+	const requestBegins = events.filter((event) => event.type === Trace.AgentRequestBegin.key && event.meta.pid !== void 0);
+	const agentPidsByChat = /* @__PURE__ */ new Map();
+	for (const process of processes) {
+		if (!Process.isHarnessHost(process)) continue;
+		const target = Option.getOrUndefined(Annotation.getDictionary(process.params.annotations, Process.TargetAnnotation));
+		if (target !== void 0) {
+			const key = entityKey(target.toString());
+			agentPidsByChat.set(key, [...agentPidsByChat.get(key) ?? [], process.pid]);
+		}
+	}
+	const sources = [];
+	if (sessions) for (const session of sessions) {
+		if (session.taskIds.length === 0) continue;
+		const feed = session.feedId;
+		const pids = new Set(agentPidsByChat.get(entityKey(session.uri)) ?? []);
+		for (const event of requestBegins) if (feed !== void 0 && eventFeedKey(event) === feed) pids.add(event.meta.pid);
+		sources.push({
+			key: session.id,
+			label: session.label?.trim() || "Session",
+			session,
+			pids
+		});
+	}
+	else {
+		const byKey = /* @__PURE__ */ new Map();
+		for (const event of requestBegins) {
+			const pid = event.meta.pid;
+			const key = eventFeedKey(event) ?? pid;
+			const source = byKey.get(key) ?? {
+				key,
+				label: eventFeedKey(event) ?? event.meta.processName ?? pid,
+				pids: /* @__PURE__ */ new Set()
+			};
+			source.pids.add(pid);
+			byKey.set(key, source);
+		}
+		sources.push(...byKey.values());
+	}
+	const processByPid = new Map(processes.map((process) => [process.pid, process]));
+	const taskById = new Map(tasks.map((task) => [task.id, task]));
+	const laneByPid = /* @__PURE__ */ new Map();
+	const lanes = [];
+	const markers = [];
+	const childSessions = [];
+	const replacedTaskLanes = /* @__PURE__ */ new Map();
+	/** Per session lane: the task segments its markers are attributed to. */
+	const segmentsBySession = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const laneId = sessionLaneId(source.key);
+		const sessionEvents = events.filter((event) => event.meta.pid && source.pids.has(event.meta.pid));
+		const begins = sessionEvents.filter((event) => event.type === Trace.AgentRequestBegin.key);
+		const ends = sessionEvents.filter((event) => event.type === Trace.AgentRequestEnd.key);
+		const requestOpen = begins.length > ends.length;
+		const processActive = [...source.pids].some((pid) => {
+			const process = processByPid.get(pid);
+			return process !== void 0 && ACTIVE_STATES.has(process.state);
+		});
+		const lastEnd = ends.at(-1);
+		const lastEndStatus = lastEnd ? decode(Trace.AgentRequestEnd.schema, lastEnd.data)?.status : void 0;
+		const processKnown = [...source.pids].some((pid) => processByPid.has(pid));
+		const died = requestOpen && processKnown && !processActive;
+		const open = requestOpen && !died;
+		const status = processActive || open ? "running" : died || lastEndStatus === "error" ? "failed" : "done";
+		lanes.push({
+			id: laneId,
+			kind: "session",
+			label: source.label,
+			status,
+			start: begins[0]?.timestamp,
+			end: open ? void 0 : died ? sessionEvents.at(-1)?.timestamp : lastEnd?.timestamp,
+			sessionId: source.session?.id,
+			pid: [...source.pids].at(-1)
+		});
+		for (const pid of source.pids) laneByPid.set(pid, laneId);
+		const taskByPid = /* @__PURE__ */ new Map();
+		for (const event of sessionEvents) if (event.type === Trace.DelegationSpawned.key) {
+			const data = decode(Trace.DelegationSpawned.schema, event.data);
+			if (data) taskByPid.set(data.pid, data.taskId);
+		}
+		const subAgentSpans = spans.flatMap((span) => {
+			const startEvent = span.events[0];
+			const pid = span.meta.pid;
+			if (pid === void 0 || span.meta.parentPid === void 0 || !source.pids.has(span.meta.parentPid) || startEvent?.type !== Trace.OperationStart.key) return [];
+			return taskByPid.has(pid) || span.events.some((event) => event.type === Trace.CompleteBlock.key) ? [{
+				span,
+				pid,
+				startEvent
+			}] : [];
+		});
+		const chatTasks = (source.session?.taskIds ?? []).map((id) => taskById.get(id)).filter((task) => task !== void 0);
+		const chatTaskIds = new Set(chatTasks.map((task) => task.id));
+		const taskLanes = /* @__PURE__ */ new Map();
+		for (const task of chatTasks) {
+			const taskLane = {
+				id: taskLaneId(task.id),
+				kind: "task",
+				label: task.title,
+				status: taskLaneStatus(task, tasks),
+				parentId: laneId,
+				sessionId: source.session?.id,
+				taskId: task.id
+			};
+			const blockedOn = (task.dependsOn ?? []).map((ref) => Task.refEntityId(ref)).filter((id) => id !== void 0 && chatTaskIds.has(id)).map(taskLaneId);
+			if (blockedOn.length > 0) taskLane.blockedOn = blockedOn;
+			taskLanes.set(task.id, taskLane);
+			lanes.push(taskLane);
+		}
+		const subAgentPids = /* @__PURE__ */ new Set([...subAgentSpans.map(({ pid }) => pid), ...taskByPid.keys()]);
+		const segments = buildTaskSegments(events.filter((event) => event.meta.pid !== void 0 && source.pids.has(event.meta.pid) || event.meta.parentPid !== void 0 && source.pids.has(event.meta.parentPid) && !(event.meta.pid !== void 0 && subAgentPids.has(event.meta.pid))), begins[0]?.timestamp, chatTaskIds);
+		segmentsBySession.set(laneId, segments);
+		for (const segment of segments) {
+			const taskLane = taskLanes.get(segment.taskId);
+			if (!taskLane) continue;
+			taskLane.start = Math.min(taskLane.start ?? segment.start, segment.start);
+			taskLane.end = segment.end === void 0 ? void 0 : Math.max(taskLane.end ?? segment.end, segment.end);
+		}
+		for (const subPid of subAgentPids) {
+			const match = subAgentSpans.find((candidate) => candidate.pid === subPid);
+			const process = processByPid.get(subPid);
+			if (!match && !process) continue;
+			const taskId = taskByPid.get(subPid);
+			const task = taskId === void 0 ? void 0 : taskById.get(taskId);
+			const startName = match ? decode(Trace.OperationStart.schema, match.startEvent.data)?.name : void 0;
+			const endEvent = match?.span.events.find((event) => event.type === Trace.OperationEnd.key);
+			const start = match?.startEvent.timestamp ?? process?.startedAt;
+			const end = endEvent?.timestamp ?? (process ? Option.getOrUndefined(process.completedAt) : void 0);
+			const subLane = {
+				id: sessionLaneId(subPid),
+				kind: "session",
+				label: task?.title ?? startName ?? process?.params.name ?? subPid,
+				status: subSessionStatus(endEvent, process),
+				start,
+				end,
+				parentId: laneId,
+				sessionId: source.session?.id,
+				taskId,
+				pid: subPid
+			};
+			laneByPid.set(subPid, subLane.id);
+			childSessions.push({
+				lane: subLane,
+				sessionLaneId: laneId
+			});
+			const taskLane = taskId === void 0 ? void 0 : taskLanes.get(taskId);
+			if (taskLane) {
+				subLane.blockedOn = taskLane.blockedOn;
+				lanes.splice(lanes.indexOf(taskLane), 1, subLane);
+				replacedTaskLanes.set(taskLane.id, subLane.id);
+			} else lanes.push(subLane);
+		}
+	}
+	for (const [sessionId, segments] of segmentsBySession) segmentsBySession.set(sessionId, segments.filter((segment) => !replacedTaskLanes.has(segment.laneId)));
+	for (const lane of lanes) if (lane.blockedOn) lane.blockedOn = lane.blockedOn.map((id) => replacedTaskLanes.get(id) ?? id);
+	const tokens = /* @__PURE__ */ new Map();
+	const spawnMarkerByPid = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const laneId = (event.meta.pid && laneByPid.get(event.meta.pid)) ?? (event.meta.parentPid && laneByPid.get(event.meta.parentPid)) ?? void 0;
+		if (laneId === void 0) continue;
+		const markerLaneId = event.type === Trace.AgentRequestBegin.key || event.type === Trace.AgentRequestEnd.key ? laneId : segmentFor(segmentsBySession.get(laneId), event)?.laneId ?? laneId;
+		const marker = toMarker(event, `${markerLaneId}:${markers.length}`, markerLaneId);
+		if (marker) {
+			markers.push(marker);
+			if (marker.kind === "delegation") {
+				const data = decode(Trace.DelegationSpawned.schema, event.data);
+				if (data) spawnMarkerByPid.set(data.pid, marker.id);
+			}
+		}
+		if (event.type === Trace.CompleteBlock.key) {
+			const data = decode(Trace.CompleteBlock.schema, event.data);
+			if (data?.block._tag === "stats") {
+				const entry = tokens.get(laneId) ?? {
+					usage: {
+						input: 0,
+						output: 0,
+						total: 0
+					},
+					toolCalls: 0
+				};
+				const input = data.block.usage?.inputTokens ?? 0;
+				const output = data.block.usage?.outputTokens ?? 0;
+				const total = data.block.usage?.totalTokens ?? input + output;
+				entry.usage = {
+					input: entry.usage.input + input,
+					output: entry.usage.output + output,
+					total: entry.usage.total + total
+				};
+				entry.toolCalls += data.block.toolCalls ?? 0;
+				tokens.set(laneId, entry);
+			}
+		}
+	}
+	for (const lane of lanes) {
+		const entry = tokens.get(lane.id);
+		if (entry) {
+			lane.tokens = entry.usage;
+			lane.toolCalls = entry.toolCalls;
+		}
+	}
+	for (const { lane, sessionLaneId } of childSessions) {
+		const markerId = (lane.pid && spawnMarkerByPid.get(lane.pid)) ?? markers.filter((marker) => marker.laneId === sessionLaneId && marker.timestamp <= (lane.start ?? 0)).at(-1)?.id;
+		if (markerId !== void 0) lane.delegatedFrom = {
+			laneId: sessionLaneId,
+			markerId
+		};
+	}
+	for (const session of lanes.filter((lane) => lane.kind === "session" && lane.parentId === void 0)) {
+		const children = lanes.filter((lane) => lane.parentId === session.id);
+		const [task] = children;
+		if (children.length !== 1 || task.kind !== "task" || lanes.some((lane) => lane.blockedOn?.includes(task.id))) continue;
+		lanes.splice(lanes.indexOf(task), 1);
+		session.taskId = task.taskId;
+		if (task.status === "blocked" || task.status === "review" || task.status === "pending") session.status = task.status;
+		markers.forEach((marker, index) => {
+			if (marker.laneId === task.id) markers[index] = {
+				...marker,
+				laneId: session.id
+			};
+		});
+	}
+	const times = [...lanes.flatMap((lane) => [lane.start, lane.end]).filter((time) => time !== void 0), ...markers.map((marker) => marker.timestamp)];
+	const hasOpen = lanes.some((lane) => lane.start !== void 0 && lane.end === void 0);
+	const latest = times.length > 0 ? Math.max(...times) : void 0;
+	if (hasOpen && now !== void 0 && (latest === void 0 || now - latest <= OPEN_LANE_STALE_MS)) times.push(now);
+	const start = times.length > 0 ? Math.min(...times) : now ?? 0;
+	return {
+		lanes,
+		markers,
+		range: {
+			start,
+			end: times.length > 0 ? Math.max(...times) : start
+		}
+	};
+};
+var taskLaneStatus = (task, tasks) => {
+	if (task.status === "todo" && !Task.isTaskReady(tasks, task)) return "blocked";
+	return (task.status && TASK_STATUS[task.status]) ?? "pending";
+};
+var subSessionStatus = (endEvent, process) => {
+	if (endEvent) return decode(Trace.OperationEnd.schema, endEvent.data)?.outcome === "failure" ? "failed" : "done";
+	if (process && !ACTIVE_STATES.has(process.state)) return process.state === Process.State.FAILED ? "failed" : "done";
+	return "running";
+};
+var toMarker = (event, id, laneId) => {
+	const base = {
+		id,
+		laneId,
+		timestamp: event.timestamp,
+		pid: event.meta.pid
+	};
+	switch (event.type) {
+		case Trace.AgentRequestBegin.key: return {
+			...base,
+			kind: "request",
+			label: "Request started"
+		};
+		case Trace.AgentRequestEnd.key: {
+			const data = decode(Trace.AgentRequestEnd.schema, event.data);
+			return {
+				...base,
+				kind: "request",
+				label: `Request ${data?.status ?? "ended"}`,
+				level: data?.status === "error" ? "error" : data?.status === "interrupted" ? "warn" : void 0,
+				detail: data?.error
+			};
+		}
+		case Trace.TaskStatusChanged.key: {
+			const data = decode(Trace.TaskStatusChanged.schema, event.data);
+			return {
+				...base,
+				kind: "task",
+				label: data?.status === "started" ? "Task started" : `Task ${data?.status ?? "updated"}`,
+				level: data?.status === "failed" ? "error" : void 0,
+				detail: data
+			};
+		}
+		case Trace.DelegationSpawned.key: {
+			const data = decode(Trace.DelegationSpawned.schema, event.data);
+			return {
+				...base,
+				kind: "delegation",
+				label: "Delegated",
+				detail: data
+			};
+		}
+		case Trace.OperationStart.key: {
+			const data = decode(Trace.OperationStart.schema, event.data);
+			return {
+				...base,
+				kind: "operation",
+				label: data?.name ?? data?.key ?? "Operation"
+			};
+		}
+		case Trace.OperationEnd.key: {
+			const data = decode(Trace.OperationEnd.schema, event.data);
+			const failed = data?.outcome === "failure";
+			return {
+				...base,
+				kind: "operation",
+				label: data?.name ?? data?.key ?? "Operation",
+				level: failed ? "error" : void 0,
+				detail: failed ? data?.error : void 0
+			};
+		}
+		case Trace.CompleteBlock.key: {
+			const data = decode(Trace.CompleteBlock.schema, event.data);
+			if (data?.block._tag === "toolCall") return {
+				...base,
+				kind: "tool",
+				label: data.block.name
+			};
+			if (data?.block._tag === "text" && data.role === "user") return {
+				...base,
+				kind: "message",
+				label: data.block.text.split("\n")[0] ?? ""
+			};
+			return;
+		}
+		default: return;
+	}
+};
+//#endregion
+//#region src/session-timeline/types.ts
+var LaneKind = Schema.Literals(["session", "task"]);
+var LaneStatus = Schema.Literals([
+	"pending",
+	"blocked",
+	"running",
+	"review",
+	"done",
+	"failed"
+]);
+var TokenUsage = Schema.Struct({
+	input: Schema.Number,
+	output: Schema.Number,
+	total: Schema.Number
+});
+/**
+* A conversation the timeline draws as a session lane: the chat, reduced to what the join needs so
+* the builder does not depend on the chat's schema. `uri` is what the agent process targets and
+* `feedId` what its trace meta names; `taskIds` is the checklist.
+*/
+var Session = Schema.Struct({
+	id: Schema.String,
+	label: Schema.optional(Schema.String),
+	uri: Schema.String,
+	feedId: Schema.optional(Schema.String),
+	taskIds: Schema.Array(Schema.String)
+});
+/**
+* Node in the supervisor lane a child session was spawned from, so the connector can start at the
+* exact marker rather than at the lane's edge.
+*/
+var DelegationSource = Schema.Struct({
+	laneId: Schema.String,
+	markerId: Schema.String
+});
+/**
+* One row of the timeline: a session (supervisor or delegated sub-agent) rendered as a box spanning
+* `start`..`end`, or a task rendered as a thin line grouped under its session.
+*/
+var Lane = Schema.Struct({
+	id: Schema.String,
+	kind: LaneKind,
+	label: Schema.String,
+	status: LaneStatus,
+	/** Epoch ms. */
+	start: Schema.optional(Schema.Number),
+	end: Schema.optional(Schema.Number),
+	parentId: Schema.optional(Schema.String),
+	sessionId: Schema.optional(Schema.String),
+	taskId: Schema.optional(Schema.String),
+	pid: Schema.optional(Schema.String),
+	/** Lane ids this lane waits on (task dependencies). */
+	blockedOn: Schema.optional(Schema.Array(Schema.String)),
+	delegatedFrom: Schema.optional(DelegationSource),
+	tokens: Schema.optional(TokenUsage),
+	toolCalls: Schema.optional(Schema.Number)
+});
+var MarkerKind = Schema.Literals([
+	"request",
+	"operation",
+	"tool",
+	"message",
+	"error",
+	"delegation",
+	"task"
+]);
+var MarkerLevel = Schema.Literals([
+	"info",
+	"warn",
+	"error"
+]);
+/**
+* A point event on a lane, rendered as a node inside the session box.
+*/
+var Marker = Schema.Struct({
+	id: Schema.String,
+	laneId: Schema.String,
+	kind: MarkerKind,
+	timestamp: Schema.Number,
+	label: Schema.String,
+	level: Schema.optional(MarkerLevel),
+	pid: Schema.optional(Schema.String),
+	detail: Schema.optional(Schema.Unknown)
+});
+var TimeRange = Schema.Struct({
+	start: Schema.Number,
+	end: Schema.Number
+});
+var SessionTimeline = Schema.Struct({
+	lanes: Schema.Array(Lane),
+	markers: Schema.Array(Marker),
+	range: TimeRange
+});
+//#endregion
+//#region src/hooks/useSessionTimeline.ts
+/** How often `now` advances while a session is open, so a running lane's range keeps growing. */
+var TICK_MS = 5e3;
+var TRACE_DEBOUNCE = Duration.millis(500);
+var NO_PROCESSES = [];
+/**
+* The live gantt-shaped view of the given sessions: rebuilt as trace events land on the space's
+* trace feed and as the process tree changes, and ticked so open lanes keep extending.
+*/
+var useSessionTimeline = (space, { sessions, tasks, processes = NO_PROCESSES }) => {
+	const traceMessages = useTraceMessages(space, { debounce: TRACE_DEBOUNCE });
+	const [now, setNow] = useState(() => Date.now());
+	useEffect(() => {
+		const interval = setInterval(() => setNow(Date.now()), TICK_MS);
+		return () => clearInterval(interval);
+	}, []);
+	return useMemo(() => buildSessionTimeline({
+		traceMessages,
+		processes,
+		sessions,
+		tasks,
+		now
+	}), [
+		traceMessages,
+		processes,
+		sessions,
+		tasks,
+		now
+	]);
+};
+//#endregion
+export { ALL_PROCESS_ENVIRONMENTS, BEGIN_EVENT_TYPES, CommitSelector, DEFAULT_PROCESS_ENVIRONMENTS, DEFAULT_SPAN_TIMEOUT_MS, DelegationSource, END_EVENT_TYPES, Gantt, Lane, LaneKind, LaneStatus, Marker, MarkerKind, MarkerLevel, ProcessEnvironment, ProcessTree, ROOT_SPAN_ID, Session, SessionTimeline, TimeRange, Timeline, TokenUsage, TracePanel, buildExecutionGraph, buildSessionTimeline, buildSpanTree, collectProcessActivityLines, compactOptions, defaultOptions, deriveInFlightActivityLine, environmentIcon, estimateTokenCount, filterProcesses, filterTraceMessages, flattenSpanTree, formatPendingBlockStatus, getTraceMessagesAtom, isSpanBeginEvent, isSpanEndEvent, parseProcessEnvironments, pendingStatusFromEphemeralMessage, processEnvironment, renderTimelineAscii, resolveEphemeralStatusUpdate, toggleProcessEnvironment, useExecutionGraph, useSessionTimeline, useTraceMenu, useTraceMessages, walkSpanTree };
+
+//# sourceMappingURL=index.mjs.map