@swirls/looms 0.4.0 → 0.5.0

package/dist/debugger/app/index.html

@@ -4,9 +4,9 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Looms debugger</title>
-    <script type="module" crossorigin src="./assets/index-D--9esm9.js"></script>
+    <script type="module" crossorigin src="./assets/index-C31SnCuN.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/rolldown-runtime-CbXtAM7H.js">
-    <link rel="stylesheet" crossorigin href="./assets/index-CgDzWJg7.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-B7GdT1UA.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/debugger/components/event-inspector.d.ts

@@ -1,6 +1,8 @@
+import type { OpenRunTarget } from '../context';
 import type { DebuggerEvent, ReplayLoader } from '../contracts';
-export declare function EventInspector({ event, loadReplayStep, onClose, }: {
+export declare function EventInspector({ event, loadReplayStep, onClose, onOpenRun, }: {
     event: DebuggerEvent;
     loadReplayStep?: ReplayLoader;
     onClose?: () => void;
+    onOpenRun?: (runId: string, target?: OpenRunTarget) => void;
 }): import("react").JSX.Element;

package/dist/debugger/components/event-inspector.js

@@ -1,7 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { X } from 'lucide-react';
+import { ExternalLink, X } from 'lucide-react';
 import { useEffect, useState } from 'react';
-import { asJson } from '@swirls/looms/core';
+import { asJson, readRunLaunchSource } from '@swirls/looms/core';
+import { jsonFields, jsonText } from '../lib/payload.js';
 import { Button } from '../ui/button.js';
 import { ScrollArea } from '../ui/scroll-area.js';
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '../ui/tabs.js';
@@ -12,9 +13,29 @@ function Pane({ value, children }) {
 function StepJson({ step, pick, }) {
     return step ? (_jsx(JsonTree, { value: pick(step), defaultExpandDepth: 2 })) : (_jsx("p", { className: "text-muted-foreground text-xs", children: "Loading\u2026" }));
 }
-export function EventInspector({ event, loadReplayStep, onClose, }) {
+/** The other run a launch event points at: the run it launched, or the run that launched it. */
+function linkedRun(event) {
+    const payload = jsonFields(event.payload);
+    if (event.type === 'runtime.run.launched') {
+        const runId = jsonText(payload.runId);
+        return runId ? { label: 'Open launched run', runId } : undefined;
+    }
+    if (event.type === 'runtime.run.started') {
+        const source = readRunLaunchSource(payload.launchedBy);
+        return source
+            ? {
+                label: 'Open launching run',
+                runId: source.runId,
+                target: { seq: source.causationSeq },
+            }
+            : undefined;
+    }
+    return undefined;
+}
+export function EventInspector({ event, loadReplayStep, onClose, onOpenRun, }) {
     const [step, setStep] = useState(null);
     const canReplay = loadReplayStep !== undefined;
+    const link = onOpenRun ? linkedRun(event) : undefined;
     useEffect(() => {
         if (!loadReplayStep) {
             setStep(null);
@@ -30,7 +51,7 @@ export function EventInspector({ event, loadReplayStep, onClose, }) {
             cancelled = true;
         };
     }, [event.runId, event.seq, loadReplayStep]);
-    return (_jsx("div", { className: "border-border bg-sidebar flex h-[45%] min-h-40 shrink-0 flex-col border-t", children: _jsxs(Tabs, { defaultValue: "payload", className: "min-h-0 flex-1 gap-0", children: [_jsxs("div", { className: "flex h-10 shrink-0 items-center gap-2 pr-2 pl-3", children: [_jsxs("span", { className: "text-muted-foreground font-mono text-[11px] tabular-nums", children: ["#", event.seq] }), _jsx("span", { className: "min-w-0 flex-1 truncate font-mono text-xs", children: event.type }), _jsxs(TabsList, { children: [_jsx(TabsTrigger, { value: "payload", children: "Payload" }), _jsx(TabsTrigger, { value: "envelope", children: "Envelope" }), canReplay ? _jsx(TabsTrigger, { value: "state", children: "State" }) : null, canReplay ? _jsx(TabsTrigger, { value: "effects", children: "Effects" }) : null] }), onClose ? (_jsx(Button, { variant: "ghost", size: "icon-sm", "aria-label": "Close inspector", onClick: onClose, children: _jsx(X, {}) })) : null] }), _jsx(Pane, { value: "payload", children: _jsx(JsonTree, { value: event.payload, defaultExpandDepth: 2 }) }), _jsx(Pane, { value: "envelope", children: _jsx(JsonTree, { value: asJson({
+    return (_jsx("div", { className: "border-border bg-sidebar flex h-[45%] min-h-40 shrink-0 flex-col border-t", children: _jsxs(Tabs, { defaultValue: "payload", className: "min-h-0 flex-1 gap-0", children: [_jsxs("div", { className: "flex h-10 shrink-0 items-center gap-2 pr-2 pl-3", children: [_jsxs("span", { className: "text-muted-foreground font-mono text-[11px] tabular-nums", children: ["#", event.seq] }), _jsx("span", { className: "min-w-0 flex-1 truncate font-mono text-xs", children: event.type }), link && onOpenRun ? (_jsxs(Button, { variant: "ghost", size: "sm", title: link.runId, onClick: () => onOpenRun(link.runId, link.target), children: [_jsx(ExternalLink, {}), link.label] })) : null, _jsxs(TabsList, { children: [_jsx(TabsTrigger, { value: "payload", children: "Payload" }), _jsx(TabsTrigger, { value: "envelope", children: "Envelope" }), canReplay ? _jsx(TabsTrigger, { value: "state", children: "State" }) : null, canReplay ? _jsx(TabsTrigger, { value: "effects", children: "Effects" }) : null] }), onClose ? (_jsx(Button, { variant: "ghost", size: "icon-sm", "aria-label": "Close inspector", onClick: onClose, children: _jsx(X, {}) })) : null] }), _jsx(Pane, { value: "payload", children: _jsx(JsonTree, { value: event.payload, defaultExpandDepth: 2 }) }), _jsx(Pane, { value: "envelope", children: _jsx(JsonTree, { value: asJson({
                             id: event.id,
                             runId: event.runId,
                             seq: event.seq,

package/dist/debugger/components/event-stream.d.ts

@@ -1,6 +1,7 @@
 import { type ReactNode } from 'react';
+import type { OpenRunTarget } from '../context';
 import type { DebuggerEvent, EventStreamCatalog, ReplayLoader } from '../contracts';
-export declare function EventStream<TEvent extends DebuggerEvent>({ events, startedAt, threadId, threadLabel, onClearThread, selectedSeq, onSelectSeq, catalog, loadReplayStep, renderInspector, }: {
+export declare function EventStream<TEvent extends DebuggerEvent>({ events, startedAt, threadId, threadLabel, onClearThread, selectedSeq, onSelectSeq, catalog, loadReplayStep, renderInspector, onOpenRun, }: {
     events: readonly TEvent[];
     startedAt?: number;
     threadId?: string;
@@ -11,4 +12,6 @@ export declare function EventStream<TEvent extends DebuggerEvent>({ events, star
     catalog?: EventStreamCatalog<TEvent>;
     loadReplayStep?: ReplayLoader;
     renderInspector?: (selected: TEvent) => ReactNode;
+    /** Follows launch links from the inspector to another run. */
+    onOpenRun?: (runId: string, target?: OpenRunTarget) => void;
 }): import("react").JSX.Element;

package/dist/debugger/components/event-stream.js

@@ -12,7 +12,7 @@ import { PanelHeader, PanelTitle } from '../ui/panel.js';
 import { EventInspector } from './event-inspector.js';
 import { FollowList } from './follow-list.js';
 const ROW_ESTIMATE = 26;
-export function EventStream({ events, startedAt, threadId, threadLabel, onClearThread, selectedSeq, onSelectSeq, catalog, loadReplayStep, renderInspector, }) {
+export function EventStream({ events, startedAt, threadId, threadLabel, onClearThread, selectedSeq, onSelectSeq, catalog, loadReplayStep, renderInspector, onOpenRun, }) {
     const eventCatalog = catalog ?? defaultEventCatalog;
     const [query, setQuery] = useState('');
     const [follow, setFollow] = useState(true);
@@ -49,7 +49,7 @@ export function EventStream({ events, startedAt, threadId, threadLabel, onClearT
     const hiddenFamilyCount = eventCatalog.families.length - families.size;
     const filtered = visible.length !== events.length;
     return (_jsxs("div", { className: "debugger-event-stream flex h-full min-h-0 flex-col", children: [_jsxs(PanelHeader, { className: "gap-1.5 pr-2", children: [_jsx(PanelTitle, { className: "hidden @md:flex", meta: filtered ? `${visible.length}/${events.length}` : events.length, children: "Events" }), _jsxs("div", { className: "relative ml-auto min-w-0 flex-1 @md:max-w-64", children: [_jsx(Search, { "aria-hidden": true, className: "text-muted-foreground pointer-events-none absolute top-1/2 left-2 size-3 -translate-y-1/2" }), _jsx(Input, { value: query, onChange: (event) => setQuery(event.target.value), placeholder: "Search events", "aria-label": "Search events", className: "h-7 w-full pl-7 text-xs" })] }), _jsxs(DropdownMenu, { children: [_jsx(DropdownMenuTrigger, { asChild: true, children: _jsxs(Button, { variant: "ghost", size: "icon-sm", className: "relative", "aria-label": "Filter event families", children: [_jsx(SlidersHorizontal, {}), hiddenFamilyCount > 0 ? (_jsx("span", { className: "bg-foreground text-background absolute top-0.5 right-0.5 flex size-3.5 items-center justify-center rounded-full font-mono text-[8px]", children: hiddenFamilyCount })) : null] }) }), _jsxs(DropdownMenuContent, { align: "end", children: [_jsx(DropdownMenuLabel, { children: "Event families" }), eventCatalog.families.map((family) => (_jsxs(DropdownMenuCheckboxItem, { checked: families.has(family), onCheckedChange: () => toggleFamily(family), onSelect: (event) => event.preventDefault(), className: "font-mono", children: [_jsx("span", { "aria-hidden": true, className: "size-1.5 rounded-full", style: { backgroundColor: eventCatalog.familyColor(family) } }), family] }, family)))] })] }), _jsxs(Button, { variant: "ghost", size: "sm", "aria-pressed": follow, "aria-label": "Follow newest events", onClick: () => setFollow(!follow), className: "aria-pressed:bg-accent aria-pressed:text-foreground px-2", children: [_jsx(ArrowDownToLine, {}), _jsx("span", { className: "hidden @lg:inline", children: "Follow" })] })] }), threadId ? (_jsxs("div", { className: "border-border flex h-8 shrink-0 items-center gap-2 border-b px-3 text-[11px]", children: [_jsx("span", { className: "text-muted-foreground", children: "Thread" }), _jsxs("span", { className: "bg-accent text-foreground inline-flex h-5 min-w-0 items-center gap-1 rounded-sm pr-0.5 pl-1.5 font-mono", children: [_jsx("span", { className: "truncate", title: threadId, children: threadLabel ?? shortId(threadId) }), onClearThread ? (_jsx("button", { type: "button", "aria-label": "Show all threads", onClick: onClearThread, className: "text-muted-foreground hover:text-foreground hover:bg-background/60 flex size-4 items-center justify-center rounded-sm", children: _jsx(X, { className: "size-3" }) })) : null] })] })) : null, _jsx(FollowList, { items: visible, getKey: (event) => event.id, estimateSize: ROW_ESTIMATE, overscan: 16, follow: follow, onFollowChange: setFollow, className: "min-h-32", itemClassName: "px-1.5", empty: _jsx("p", { className: "text-muted-foreground p-6 text-center text-xs", children: events.length === 0 ? 'Waiting for events…' : 'No events match these filters.' }), renderItem: (event) => (_jsx(EventRow, { event: event, catalog: eventCatalog, startedAt: startedAt, selected: selectedSeq === event.seq, onSelectSeq: onSelectSeq })) }), selected
-                ? (renderInspector?.(selected) ?? (_jsx(EventInspector, { event: selected, loadReplayStep: loadReplayStep, onClose: () => onSelectSeq(undefined) })))
+                ? (renderInspector?.(selected) ?? (_jsx(EventInspector, { event: selected, loadReplayStep: loadReplayStep, onClose: () => onSelectSeq(undefined), onOpenRun: onOpenRun })))
                 : null] }));
 }
 function EventRow({ event, catalog, startedAt, selected, onSelectSeq, }) {

package/dist/debugger/components/run-tree.d.ts

@@ -1,5 +1,5 @@
-import type { ThreadNode } from '@swirls/looms/core';
-export declare function RunTree({ runId, runStatus, tree, eventCounts, totalEventCount, selectedThread, onSelectThread, formatRunLabel, showHeading, }: {
+import type { RunLaunchSource, ThreadNode } from '@swirls/looms/core';
+export declare function RunTree({ runId, runStatus, tree, eventCounts, totalEventCount, selectedThread, onSelectThread, launchedBy, onOpenLauncher, formatRunLabel, showHeading, }: {
     runId: string;
     runStatus: string;
     tree: {
@@ -9,6 +9,9 @@ export declare function RunTree({ runId, runStatus, tree, eventCounts, totalEven
     totalEventCount?: number;
     selectedThread?: string;
     onSelectThread: (threadId: string | undefined) => void;
+    /** The effect in another run that launched this one. */
+    launchedBy?: RunLaunchSource;
+    onOpenLauncher?: (source: RunLaunchSource) => void;
     formatRunLabel?: (runId: string) => string;
     showHeading?: boolean;
 }): import("react").JSX.Element;

package/dist/debugger/components/run-tree.js

@@ -1,6 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useVirtualizer } from '@tanstack/react-virtual';
-import { ChevronRight } from 'lucide-react';
+import { ChevronRight, CornerLeftUp } from 'lucide-react';
 import { useCallback, useMemo, useRef, useState } from 'react';
 import { cn, shortId } from '../lib/cn.js';
 import { PanelHeader, PanelTitle } from '../ui/panel.js';
@@ -33,7 +33,13 @@ function NodeRow({ row, selected, count, collapsed, onToggle, onSelect, }) {
     const hasChildren = node.children.length > 0;
     return (_jsxs("div", { className: cn('group/row relative flex h-7 items-center rounded-md pr-2 text-xs', selected ? 'bg-accent text-foreground' : 'hover:bg-accent/50'), style: { paddingLeft: 4 + depth * INDENT }, title: `${node.definitionName} · ${node.kind} · ${node.status}`, children: [Array.from({ length: depth }, (_, level) => (_jsx("span", { "aria-hidden": true, className: "bg-border absolute inset-y-0 w-px", style: { left: 12 + level * INDENT } }, level))), hasChildren ? (_jsx("button", { type: "button", className: "text-muted-foreground hover:text-foreground hover:bg-background/40 flex size-4 shrink-0 items-center justify-center rounded-sm", onClick: () => onToggle(node.threadId), "aria-label": collapsed ? 'Expand thread' : 'Collapse thread', "aria-expanded": !collapsed, children: _jsx(ChevronRight, { className: cn('ease-snappy size-3 transition-transform duration-100', !collapsed && 'rotate-90') }) })) : (_jsx("span", { className: "size-4 shrink-0" })), _jsxs("button", { type: "button", className: "flex h-full min-w-0 flex-1 items-center gap-2 pl-1 text-left", onClick: () => onSelect(node.threadId), children: [_jsx(StatusDot, { status: node.status }), _jsxs("span", { className: "min-w-0 truncate", children: [_jsx("span", { className: "font-medium", children: node.definitionName }), _jsx("span", { className: "text-muted-foreground ml-1.5 font-mono text-[10px]", children: node.kind })] }), _jsx("span", { className: "text-muted-foreground ml-auto shrink-0 font-mono text-[10px] tabular-nums", children: count })] })] }));
 }
-export function RunTree({ runId, runStatus, tree, eventCounts, totalEventCount, selectedThread, onSelectThread, formatRunLabel = shortId, showHeading = true, }) {
+function LaunchedByRow({ source, onOpen, }) {
+    const label = (_jsxs(_Fragment, { children: [_jsx(CornerLeftUp, { className: "text-muted-foreground size-3.5 shrink-0" }), _jsx("span", { className: "text-muted-foreground shrink-0", children: "Launched by" }), _jsx("span", { className: "min-w-0 truncate font-mono text-[10px]", children: source.runId }), _jsxs("span", { className: "text-muted-foreground ml-auto shrink-0 font-mono text-[10px] tabular-nums", children: ["#", source.causationSeq] })] }));
+    const title = `Effect ${source.effectId} on thread ${source.threadId}, requested by event #${source.causationSeq} of ${source.runId}`;
+    const className = 'flex h-7 w-full items-center gap-2 rounded-md px-2 text-left text-xs';
+    return onOpen ? (_jsx("button", { type: "button", title: title, onClick: () => onOpen(source), className: cn(className, 'hover:bg-accent/50'), children: label })) : (_jsx("div", { title: title, className: className, children: label }));
+}
+export function RunTree({ runId, runStatus, tree, eventCounts, totalEventCount, selectedThread, onSelectThread, launchedBy, onOpenLauncher, formatRunLabel = shortId, showHeading = true, }) {
     const [collapsed, setCollapsed] = useState(() => new Set());
     const runCount = totalEventCount ?? eventCounts.get('run') ?? 0;
     const rows = useMemo(() => flatten(tree.root, collapsed), [tree.root, collapsed]);
@@ -58,7 +64,7 @@ export function RunTree({ runId, runStatus, tree, eventCounts, totalEventCount,
             return next;
         });
     }, []);
-    return (_jsxs("div", { className: "flex h-full min-h-0 flex-col", children: [showHeading ? (_jsxs(PanelHeader, { children: [_jsx(PanelTitle, { children: "Run tree" }), _jsx(StatusBadge, { status: runStatus, className: "ml-auto" })] })) : null, _jsx("div", { className: "px-2 pt-2", children: _jsxs("button", { type: "button", onClick: () => onSelectThread(undefined), className: cn('flex h-7 w-full items-center gap-2 rounded-md px-2 text-left text-xs', !selectedThread ? 'bg-accent text-foreground' : 'hover:bg-accent/50'), children: [_jsx("span", { className: "text-muted-foreground", children: "All threads" }), _jsx("span", { className: "text-muted-foreground/70 truncate font-mono text-[10px]", children: formatRunLabel(runId) }), _jsx("span", { className: "text-muted-foreground ml-auto font-mono text-[10px] tabular-nums", children: runCount })] }) }), rows.length === 0 ? (_jsx("p", { className: "text-muted-foreground px-4 py-2 text-xs", children: "Waiting for threads\u2026" })) : (_jsx(ScrollArea, { viewportRef: parentRef, className: "min-h-0 flex-1", children: _jsx("div", { className: "relative mx-2 mb-2", style: { height: virtualizer.getTotalSize() }, children: virtualizer.getVirtualItems().map((item) => {
+    return (_jsxs("div", { className: "flex h-full min-h-0 flex-col", children: [showHeading ? (_jsxs(PanelHeader, { children: [_jsx(PanelTitle, { children: "Run tree" }), _jsx(StatusBadge, { status: runStatus, className: "ml-auto" })] })) : null, _jsxs("div", { className: "px-2 pt-2", children: [launchedBy ? _jsx(LaunchedByRow, { source: launchedBy, onOpen: onOpenLauncher }) : null, _jsxs("button", { type: "button", onClick: () => onSelectThread(undefined), className: cn('flex h-7 w-full items-center gap-2 rounded-md px-2 text-left text-xs', !selectedThread ? 'bg-accent text-foreground' : 'hover:bg-accent/50'), children: [_jsx("span", { className: "text-muted-foreground", children: "All threads" }), _jsx("span", { className: "text-muted-foreground/70 truncate font-mono text-[10px]", children: formatRunLabel(runId) }), _jsx("span", { className: "text-muted-foreground ml-auto font-mono text-[10px] tabular-nums", children: runCount })] })] }), rows.length === 0 ? (_jsx("p", { className: "text-muted-foreground px-4 py-2 text-xs", children: "Waiting for threads\u2026" })) : (_jsx(ScrollArea, { viewportRef: parentRef, className: "min-h-0 flex-1", children: _jsx("div", { className: "relative mx-2 mb-2", style: { height: virtualizer.getTotalSize() }, children: virtualizer.getVirtualItems().map((item) => {
                         const row = rows[item.index];
                         if (!row) {
                             return null;

package/dist/debugger/context.d.ts

@@ -1,14 +1,21 @@
 import { type ReactNode } from 'react';
 import { type LoomsClient } from '@swirls/looms/client';
 import type { DebuggerPlugin } from './plugin';
+/** Where to land in a run another view links to. */
+export interface OpenRunTarget {
+    readonly seq?: number;
+}
 export interface DebuggerContextValue {
     readonly client: LoomsClient;
     readonly plugins: readonly DebuggerPlugin[];
+    /** Opens another run, for example the run a schedule fired or the run that launched this one. */
+    readonly openRun?: (runId: string, target?: OpenRunTarget) => void;
 }
 /** Supplies one Looms host to both the API client and the run stores. */
-export declare function DebuggerProvider({ endpoint, plugins, children, }: {
+export declare function DebuggerProvider({ endpoint, plugins, openRun, children, }: {
     endpoint?: string;
     plugins: readonly DebuggerPlugin[];
+    openRun?: (runId: string, target?: OpenRunTarget) => void;
     children: ReactNode;
 }): import("react").JSX.Element;
 export declare function useDebugger(): DebuggerContextValue;

package/dist/debugger/context.js

@@ -1,11 +1,23 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useMemo } from 'react';
+import { createContext, useCallback, useContext, useMemo, useRef } from 'react';
 import { createLoomsClient } from '@swirls/looms/client';
 import { LoomsProvider } from '@swirls/looms/react';
 const DebuggerContext = createContext(null);
 /** Supplies one Looms host to both the API client and the run stores. */
-export function DebuggerProvider({ endpoint = '', plugins, children, }) {
-    const value = useMemo(() => ({ client: createLoomsClient({ baseUrl: endpoint }), plugins }), [endpoint, plugins]);
+export function DebuggerProvider({ endpoint = '', plugins, openRun, children, }) {
+    const openRunRef = useRef(openRun);
+    openRunRef.current = openRun;
+    const hasOpenRun = openRun !== undefined;
+    const stableOpenRun = useCallback((runId, target) => {
+        openRunRef.current?.(runId, target);
+    }, []);
+    const value = useMemo(() => {
+        const client = createLoomsClient({ baseUrl: endpoint });
+        if (!hasOpenRun) {
+            return { client, plugins };
+        }
+        return { client, plugins, openRun: stableOpenRun };
+    }, [endpoint, plugins, hasOpenRun, stableOpenRun]);
     return (_jsx(LoomsProvider, { endpoint: endpoint, children: _jsx(DebuggerContext.Provider, { value: value, children: children }) }));
 }
 export function useDebugger() {

package/dist/debugger/events/protocol-summarize.js

@@ -1,4 +1,4 @@
-import { isJsonNumber, isJsonString, isProtocolType } from '@swirls/looms/core';
+import { isJsonNumber, isJsonString, isProtocolType, readRunLaunchSource } from '@swirls/looms/core';
 import { compactJson } from '../lib/cn.js';
 import { jsonFields, jsonNumberText, jsonText } from '../lib/payload.js';
 export function summarizeProtocolEvent(event) {
@@ -7,11 +7,14 @@ export function summarizeProtocolEvent(event) {
     }
     const payload = jsonFields(event.payload);
     switch (event.type) {
-        case 'runtime.run.started':
+        case 'runtime.run.started': {
+            const definition = `${jsonText(payload.kind) ?? 'run'}:${jsonText(payload.definitionName) ?? 'unknown'}`;
+            const launchedBy = readRunLaunchSource(payload.launchedBy);
             return {
                 title: 'run started',
-                detail: `${jsonText(payload.kind) ?? 'run'}:${jsonText(payload.definitionName) ?? 'unknown'}`,
+                detail: launchedBy ? `${definition} · launched by ${launchedBy.runId}` : definition,
             };
+        }
         case 'runtime.run.completed':
             return {
                 title: jsonText(payload.error) ? 'run failed' : 'run completed',
@@ -19,6 +22,18 @@ export function summarizeProtocolEvent(event) {
             };
         case 'runtime.run.cancelled':
             return { title: 'run cancelled', detail: jsonText(payload.reason) };
+        case 'runtime.run.launched':
+            return {
+                title: 'run launched',
+                detail: `${jsonText(payload.kind) ?? 'run'}:${jsonText(payload.definitionName) ?? 'unknown'} · ${jsonText(payload.runId) ?? 'unknown'}`,
+            };
+        case 'runtime.child.settled':
+            return {
+                title: 'child settled',
+                detail: `${jsonText(payload.status) ?? 'done'} · ${jsonText(payload.runId) ?? ''}`,
+            };
+        case 'runtime.child.close.requested':
+            return { title: 'child close requested', detail: jsonText(payload.policy) };
         case 'runtime.run.forked':
             return {
                 title: 'run forked',

package/dist/debugger/index.d.ts

@@ -1,7 +1,7 @@
 export type { DebuggerEvent, EventStreamCatalog, EventSummary, ReplayLoader, ReplayStep, RunTreeModel, ThreadTree, } from './contracts';
 export { createEventCatalog, defaultEventCatalog } from './events/catalog';
 export { summarizeProtocolEvent } from './events/protocol-summarize';
-export { DebuggerProvider, useDebugger, type DebuggerContextValue } from './context';
+export { DebuggerProvider, useDebugger, type DebuggerContextValue, type OpenRunTarget, } from './context';
 export { projectionFor, workspaceFor, type DebuggerPlugin, type EventFamilyView, type ProjectionView, type WorkspaceContext, type WorkspaceView, } from './plugin';
 export { DebuggerShell, type DebuggerSelection } from './shell/debugger-shell';
 export { StartForm } from './shell/start-form';

package/dist/debugger/index.js

@@ -1,6 +1,6 @@
 export { createEventCatalog, defaultEventCatalog } from './events/catalog.js';
 export { summarizeProtocolEvent } from './events/protocol-summarize.js';
-export { DebuggerProvider, useDebugger } from './context.js';
+export { DebuggerProvider, useDebugger, } from './context.js';
 export { projectionFor, workspaceFor, } from './plugin.js';
 export { DebuggerShell } from './shell/debugger-shell.js';
 export { StartForm } from './shell/start-form.js';

package/dist/debugger/shell/debugger-shell.js

@@ -39,5 +39,5 @@ function DebuggerFrame({ selection, onSelectionChange, }) {
                         }) }), _jsxs("div", { className: "ml-auto flex min-w-0 items-center gap-2", children: [error ? (_jsx("p", { className: "text-status-failed truncate text-[11px]", title: error, children: error })) : null, selection.run ? (_jsx(RunControls, { runId: selection.run, onForked: (run) => onSelectionChange({ kind, name, run }) })) : null] })] }), _jsxs(ResizablePanelGroup, { id: "looms-debugger-columns", className: "min-h-0 flex-1", defaultLayout: layout.defaultLayout, onLayoutChanged: layout.onLayoutChanged, children: [_jsx(ResizablePanel, { id: "tree", defaultSize: "17%", minSize: "12rem", maxSize: "30%", className: "bg-sidebar", children: _jsx("section", { "aria-label": "Run tree", className: "h-full min-h-0 overflow-hidden", children: selection.run ? (_jsx(RunTreePane, { runId: selection.run, threadId: selection.thread, onSelectThread: (thread) => onSelectionChange({ ...selection, thread, seq: undefined }) })) : (_jsxs("div", { className: "flex h-full flex-col", children: [_jsx(PanelHeader, { children: _jsx(PanelTitle, { children: "Run tree" }) }), _jsx(EmptyState, { icon: _jsx(ListTree, {}), title: "No run selected", children: "Threads and child runs appear here once a run starts." })] })) }) }), _jsx(ResizableHandle, {}), _jsx(ResizablePanel, { id: "workspace", defaultSize: "29%", minSize: "16rem", children: _jsx("section", { "aria-label": "Workspace", className: "@container h-full min-h-0 overflow-hidden", children: _jsx(Workspace, { definition: selected, runId: selection.run, onStarted: (run) => onSelectionChange({ kind, name, run }) }) }) }), _jsx(ResizableHandle, {}), _jsx(ResizablePanel, { id: "events", defaultSize: "32%", minSize: "16rem", children: _jsx("section", { "aria-label": "Events", className: "h-full min-h-0 overflow-hidden", children: selection.run ? (_jsx(EventsPane, { runId: selection.run, threadId: selection.thread, seq: selection.seq, onSelectSeq: (seq) => onSelectionChange({ ...selection, seq }), onClearThread: () => onSelectionChange({ ...selection, thread: undefined }) })) : (_jsxs("div", { className: "flex h-full flex-col", children: [_jsx(PanelHeader, { children: _jsx(PanelTitle, { children: "Events" }) }), _jsx(EmptyState, { icon: _jsx(Activity, {}), title: "No events yet", children: "Events stream in live once a run starts." })] })) }) }), _jsx(ResizableHandle, {}), _jsx(ResizablePanel, { id: "projections", defaultSize: "22%", minSize: "14rem", className: "bg-sidebar", children: _jsx("section", { "aria-label": "Projections", className: "h-full min-h-0 overflow-hidden", children: _jsx(ProjectionsPanel, { runId: selection.run, names: catalog.projections }) }) })] })] }));
 }
 export function DebuggerShell({ plugins, selection, onSelectionChange, endpoint, }) {
-    return (_jsx(DebuggerProvider, { endpoint: endpoint, plugins: plugins, children: _jsx(DebuggerFrame, { selection: selection, onSelectionChange: onSelectionChange }) }));
+    return (_jsx(DebuggerProvider, { endpoint: endpoint, plugins: plugins, openRun: (runId, target) => onSelectionChange({ run: runId, seq: target?.seq }), children: _jsx(DebuggerFrame, { selection: selection, onSelectionChange: onSelectionChange }) }));
 }

package/dist/debugger/shell/events-pane.js

@@ -7,19 +7,20 @@ import { RunTree } from '../components/run-tree.js';
 import { useDebugger } from '../context.js';
 import { createEventCatalog } from '../events/catalog.js';
 export function EventsPane({ runId, threadId, seq, onSelectSeq, onClearThread, }) {
-    const { client, plugins } = useDebugger();
+    const { client, plugins, openRun } = useDebugger();
     const catalog = useMemo(() => createEventCatalog(plugins), [plugins]);
     const store = useRunStore(runId);
     const events = useRunEvents(store);
     const summary = useRunSummary(store);
     const tree = useThreadTree(store);
     const loadReplayStep = useCallback(({ runId: replayRunId, seq: replaySeq }) => client.replayTo(replayRunId, replaySeq).then((result) => result.step), [client]);
-    return (_jsx(EventStream, { events: events, startedAt: summary.startedAt, threadId: threadId, threadLabel: findThreadName(tree.root, threadId), onClearThread: onClearThread, selectedSeq: seq, onSelectSeq: onSelectSeq, loadReplayStep: loadReplayStep, catalog: catalog }));
+    return (_jsx(EventStream, { events: events, startedAt: summary.startedAt, threadId: threadId, threadLabel: findThreadName(tree.root, threadId), onClearThread: onClearThread, selectedSeq: seq, onSelectSeq: onSelectSeq, loadReplayStep: loadReplayStep, catalog: catalog, onOpenRun: openRun }));
 }
 export function RunTreePane({ runId, threadId, onSelectThread, }) {
+    const { openRun } = useDebugger();
     const store = useRunStore(runId);
     const summary = useRunSummary(store);
     const tree = useThreadTree(store);
     const counts = useEventCounts(store);
-    return (_jsx(RunTree, { runId: runId, runStatus: summary.status, tree: tree, eventCounts: counts, selectedThread: threadId, onSelectThread: onSelectThread }));
+    return (_jsx(RunTree, { runId: runId, runStatus: summary.status, tree: tree, eventCounts: counts, selectedThread: threadId, onSelectThread: onSelectThread, launchedBy: summary.launchedBy, onOpenLauncher: openRun ? (source) => openRun(source.runId, { seq: source.causationSeq }) : undefined }));
 }

package/dist/debugger/styles.css

@@ -2,6 +2,7 @@
 @source "../agent/debugger/**/*.js";
 @source "../workflow/debugger/**/*.js";
 @source "../approval/debugger/**/*.js";
+@source "../schedule/debugger/**/*.js";
 
 @theme inline {
   --color-background: var(--background);

package/dist/evaluator/definitions-store.d.ts

@@ -1,11 +1,10 @@
 import { Context, Layer } from 'effect';
+import { type DefinitionStore } from '@swirls/looms/core';
 import type { EvaluatorDefinition } from './definitions';
-export interface EvaluatorDefinitionStore {
-    get(name: string): EvaluatorDefinition | undefined;
-}
+export type EvaluatorDefinitionStore = DefinitionStore<EvaluatorDefinition>;
 declare const EvaluatorDefinitionsTag_base: Context.ServiceClass<EvaluatorDefinitionsTag, "looms/EvaluatorDefinitions", EvaluatorDefinitionStore>;
 export declare class EvaluatorDefinitionsTag extends EvaluatorDefinitionsTag_base {
 }
 export declare function makeEvaluatorDefinitionStore(definitions: ReadonlyArray<EvaluatorDefinition>): EvaluatorDefinitionStore;
-export declare const EvaluatorDefinitionsLive: (definitions: ReadonlyArray<EvaluatorDefinition>) => Layer.Layer<EvaluatorDefinitionsTag, never, never>;
+export declare const EvaluatorDefinitionsLive: (definitions: EvaluatorDefinitionStore) => Layer.Layer<EvaluatorDefinitionsTag, never, never>;
 export {};

package/dist/evaluator/definitions-store.js

@@ -1,8 +1,8 @@
 import { Context, Layer } from 'effect';
+import { makeDefinitionStore } from '@swirls/looms/core';
 export class EvaluatorDefinitionsTag extends Context.Service()('looms/EvaluatorDefinitions') {
 }
 export function makeEvaluatorDefinitionStore(definitions) {
-    const map = new Map(definitions.map((def) => [def.name, def]));
-    return { get: (name) => map.get(name) };
+    return makeDefinitionStore('evaluator', definitions);
 }
-export const EvaluatorDefinitionsLive = (definitions) => Layer.succeed(EvaluatorDefinitionsTag, makeEvaluatorDefinitionStore(definitions));
+export const EvaluatorDefinitionsLive = (definitions) => Layer.succeed(EvaluatorDefinitionsTag, definitions);

package/dist/evaluator/definitions.d.ts

@@ -5,6 +5,7 @@ import type { EvaluatorQuestions, EvaluatorRouteArgs, EvaluatorRouteDecision, Ev
 export interface EvaluatorDefinition<TName extends string = string, TInput = JsonValue> {
     readonly kind: 'evaluator';
     readonly name: TName;
+    readonly version: string;
     readonly description?: string;
     /** Provider model id. Omit it to use the adapter default. */
     readonly model?: string;
@@ -15,4 +16,6 @@ export interface EvaluatorDefinition<TName extends string = string, TInput = Jso
     route?(this: void, args: EvaluatorRouteArgs): EvaluatorRouteDecision;
 }
 export type AnyEvaluatorDefinition = EvaluatorDefinition;
-export declare function defineEvaluator<TName extends string, TInput = JsonValue>(def: Omit<EvaluatorDefinition<TName, TInput>, 'kind'>): EvaluatorDefinition<TName, TInput>;
+export declare function defineEvaluator<TName extends string, TInput = JsonValue>(def: Omit<EvaluatorDefinition<TName, TInput>, 'kind' | 'version'> & {
+    readonly version?: string;
+}): EvaluatorDefinition<TName, TInput>;

package/dist/evaluator/definitions.js

@@ -1,4 +1,7 @@
-import { defineKind } from '@swirls/looms/core';
+import { DEFAULT_DEFINITION_VERSION, defineKind } from '@swirls/looms/core';
 export function defineEvaluator(def) {
-    return defineKind('evaluator', def);
+    return defineKind('evaluator', {
+        ...def,
+        version: def.version ?? DEFAULT_DEFINITION_VERSION,
+    });
 }

package/dist/evaluator/effects.d.ts

@@ -4,8 +4,55 @@ import { EvaluatorTag } from './evaluator';
 export declare const evaluateEffect: NoInfer<import("@swirls/looms/core").EffectDefinition<{
     readonly evaluationId: string;
     readonly definitionName?: string | undefined;
+    readonly definitionVersion?: string | undefined;
     readonly input?: Schema.Json | undefined;
 }, EvaluatorDefinitionsTag | EvaluatorTag, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "evaluator.evaluated";
+    readonly payload: {
+        readonly evaluationId: string;
+        readonly definitionName?: string | undefined;
+        readonly answers: {
+            readonly [x: string]: {
+                readonly type: "boolean";
+                readonly value: boolean;
+                readonly probability: number;
+            } | {
+                readonly type: "choice";
+                readonly value: string;
+            } | {
+                readonly type: "score";
+                readonly value: number;
+            };
+        };
+        readonly route: string;
+        readonly reason: "model" | "skipped" | "unavailable" | "uncertain";
+        readonly usage?: {
+            readonly input: number;
+            readonly output: number;
+        } | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "evaluator.requested";
+    readonly payload: {
+        readonly evaluationId: string;
+        readonly definitionName?: string | undefined;
+        readonly state: string;
+        readonly model?: string | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.child.close.requested";
+    readonly payload: {
+        readonly policy: "terminate" | "wait";
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.child.settled";
+    readonly payload: {
+        readonly runId: string;
+        readonly status: "cancelled" | "completed" | "failed";
+        readonly output: Schema.Json;
+        readonly error: string | null;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.effect.ambiguous";
     readonly payload: {
         readonly effectId: string;
@@ -49,6 +96,8 @@ export declare const evaluateEffect: NoInfer<import("@swirls/looms/core").Effect
     readonly payload: {
         readonly effectId: string;
         readonly error: string;
+        readonly nonRetryable?: boolean | undefined;
+        readonly retryAfterMs?: number | undefined;
     };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.effect.heartbeat";
@@ -57,6 +106,7 @@ export declare const evaluateEffect: NoInfer<import("@swirls/looms/core").Effect
         readonly attempt: number;
         readonly heartbeatAt: number;
         readonly deadlineAt: number | null;
+        readonly details?: Schema.Json | undefined;
     };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.effect.queued";
@@ -109,6 +159,16 @@ export declare const evaluateEffect: NoInfer<import("@swirls/looms/core").Effect
         readonly sourceRunId: string;
         readonly sourceSeq: number;
     };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.run.launched";
+    readonly payload: {
+        readonly runId: string;
+        readonly kind: string;
+        readonly definitionName: string;
+        readonly definitionVersion: string;
+        readonly effectId: string;
+        readonly close: "terminate" | "wait";
+    };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.run.started";
     readonly payload: {
@@ -118,6 +178,20 @@ export declare const evaluateEffect: NoInfer<import("@swirls/looms/core").Effect
         readonly definitionVersion: string;
         readonly input: Schema.Json;
         readonly requestedThreadId?: string | null | undefined;
+        readonly launchedBy?: {
+            readonly runId: string;
+            readonly threadId: string;
+            readonly effectId: string;
+            readonly causationId: string;
+            readonly causationSeq: number;
+        } | undefined;
+        readonly attributes?: {
+            readonly [x: string]: string;
+        } | undefined;
+        readonly trace?: {
+            readonly traceparent: string;
+            readonly tracestate?: string | undefined;
+        } | undefined;
     };
 }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
     readonly type: "runtime.signal.received";
@@ -202,37 +276,4 @@ export declare const evaluateEffect: NoInfer<import("@swirls/looms/core").Effect
             readonly payload: Schema.Json;
         };
     };
-}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
-    readonly type: "evaluator.evaluated";
-    readonly payload: {
-        readonly evaluationId: string;
-        readonly definitionName?: string | undefined;
-        readonly answers: {
-            readonly [x: string]: {
-                readonly type: "boolean";
-                readonly value: boolean;
-                readonly probability: number;
-            } | {
-                readonly type: "choice";
-                readonly value: string;
-            } | {
-                readonly type: "score";
-                readonly value: number;
-            };
-        };
-        readonly route: string;
-        readonly reason: "model" | "skipped" | "unavailable" | "uncertain";
-        readonly usage?: {
-            readonly input: number;
-            readonly output: number;
-        } | undefined;
-    };
-}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
-    readonly type: "evaluator.requested";
-    readonly payload: {
-        readonly evaluationId: string;
-        readonly definitionName?: string | undefined;
-        readonly state: string;
-        readonly model?: string | undefined;
-    };
 })>>;

package/dist/evaluator/effects.js

@@ -1,11 +1,12 @@
 import { Effect, Schema } from 'effect';
-import { stringifyJson, validateInputEffect } from '@swirls/looms/core';
+import { DEFAULT_DEFINITION_VERSION, stringifyJson, validateInputEffect, } from '@swirls/looms/core';
 import { EvaluatorDefinitionsTag } from './definitions-store.js';
 import { EvaluatorTag } from './evaluator.js';
 import { evaluatorModule } from './scope.js';
 const EvaluateInput = Schema.Struct({
     evaluationId: Schema.String,
     definitionName: Schema.optional(Schema.String),
+    definitionVersion: Schema.optional(Schema.String),
     input: Schema.optional(Schema.Json),
 });
 function errorMessage(cause) {
@@ -36,7 +37,10 @@ export const evaluateEffect = evaluatorModule.effect({
         const threadId = ctx.threadId;
         const definitions = yield* EvaluatorDefinitionsTag;
         const evaluator = yield* EvaluatorTag;
-        const definition = input.definitionName ? definitions.get(input.definitionName) : undefined;
+        const version = input.definitionVersion ?? DEFAULT_DEFINITION_VERSION;
+        const definition = input.definitionName
+            ? yield* definitions.resolve(input.definitionName, version)
+            : undefined;
         if (!definition) {
             const name = input.definitionName ?? 'unknown';
             return failed(threadId, `Unknown evaluator definition for ${name}`);