@vibesdotdev/runnable 0.0.0-stage → 1.0.0-rc.0

package/dist/svelte/index.js

@@ -0,0 +1,22 @@
+export { getRunStatusDisplay, getRunnableTypeAccent, isActiveRunStatus, normalizeRunStatus, } from "./lib/status.js";
+export { default as RunStatusBadge } from './components/RunStatusBadge.svelte';
+export { default as MetricCard } from './components/MetricCard.svelte';
+export { default as LogViewer } from './components/LogViewer.svelte';
+export { default as ArtifactList } from './components/ArtifactList.svelte';
+export { default as TypePicker } from './components/TypePicker.svelte';
+export { default as RunList } from './components/records/RunList.svelte';
+export { default as RunTree } from './components/records/RunTree.svelte';
+export { RunsStore } from "./runs.store.svelte.js";
+export { default as RunEvidence } from './components/RunEvidence.svelte';
+export { default as RunDetail } from './components/records/RunDetail.svelte';
+export { default as RunPanels } from './components/RunPanels.svelte';
+export { default as RunsView } from './components/RunsView.svelte';
+export { default as FleetRuns } from './components/FleetRuns.svelte';
+export { default as RunActivity } from './components/RunActivity.svelte';
+export { default as RunContext } from './components/RunContext.svelte';
+export { default as RunObservation } from './components/RunObservation.svelte';
+export { default as RunIssues } from './components/RunIssues.svelte';
+export { default as RunSummary } from './components/RunSummary.svelte';
+export { default as RunComparison } from './components/RunComparison.svelte';
+export { runnableQueryForm, RunnableQueryFormSchema } from "./query-form.js";
+export { default as ArtifactPreview } from './components/ArtifactPreview.svelte';

package/dist/svelte/lib/artifact-blob.d.ts

@@ -0,0 +1,2 @@
+export { artifactBlob } from '../../client/tracking/artifact-data.ts';
+//# sourceMappingURL=artifact-blob.d.ts.map

package/dist/svelte/lib/artifact-blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-blob.d.ts","sourceRoot":"","sources":["../../../src/svelte/lib/artifact-blob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAC"}

package/dist/svelte/lib/artifact-blob.js

@@ -0,0 +1 @@
+export { artifactBlob } from "../../client/tracking/artifact-data.js";

package/dist/svelte/lib/run-investigation.d.ts

@@ -0,0 +1,17 @@
+import type { JsonValue } from '@vibesdotdev/kernel/schemas/json';
+import type { RunnableCatalogRun, RunnableSnapshot } from '../../schemas/runs.ts';
+export type { RunEvidenceTarget } from '../../schemas/projection.ts';
+/** Only successes completed before this admission, within the same admitted identity. */
+export declare function previousSuccessfulRun(run: RunnableCatalogRun, candidates: readonly RunnableCatalogRun[]): RunnableCatalogRun | null;
+export declare function inputChanges(before: RunnableSnapshot, after: RunnableSnapshot): Array<{
+    key: string;
+    before: JsonValue | undefined;
+    after: JsonValue | undefined;
+}>;
+export declare function metricChanges(before: RunnableSnapshot, after: RunnableSnapshot): {
+    label: string;
+    before: number | undefined;
+    after: number | undefined;
+}[];
+export declare function formatEvidenceValue(value: JsonValue | undefined): string;
+//# sourceMappingURL=run-investigation.d.ts.map

package/dist/svelte/lib/run-investigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-investigation.d.ts","sourceRoot":"","sources":["../../../src/svelte/lib/run-investigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAElF,YAAY,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE,yFAAyF;AACzF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,kBAAkB,EAAE,UAAU,EAAE,SAAS,kBAAkB,EAAE,GAAG,kBAAkB,GAAG,IAAI,CAQnI;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,gBAAgB,GAAG,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;IAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CAAA;CAAE,CAAC,CAOnK;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,gBAAgB;;;;IAmB9E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAExE"}

package/dist/svelte/lib/run-investigation.js

@@ -0,0 +1,44 @@
+import { canonical } from "../../client/records/identity.js";
+/** Only successes completed before this admission, within the same admitted identity. */
+export function previousSuccessfulRun(run, candidates) {
+    if (!run.runnableId || !run.scope)
+        return null;
+    return candidates.filter(candidate => candidate.id !== run.id
+        && candidate.runnableId === run.runnableId && candidate.runnableType === run.runnableType
+        && candidate.scope === run.scope && candidate.hostId === run.hostId
+        && candidate.status === 'completed' && candidate.outcome?.status === 'done'
+        && candidate.startedAt < run.startedAt && candidate.endedAt != null && candidate.endedAt <= run.startedAt)
+        .sort((left, right) => right.endedAt - left.endedAt || right.startedAt - left.startedAt || left.id.localeCompare(right.id))[0] ?? null;
+}
+export function inputChanges(before, after) {
+    return [...new Set([...Object.keys(before.run.config), ...Object.keys(after.run.config)])].sort()
+        .flatMap(key => {
+        const previous = before.run.config[key];
+        const current = after.run.config[key];
+        return canonical(previous) === canonical(current) ? [] : [{ key, before: previous, after: current }];
+    });
+}
+export function metricChanges(before, after) {
+    function latest(snapshot) {
+        const values = new Map();
+        for (const metric of snapshot.metrics) {
+            const dimensions = metric.dimensions && Object.keys(metric.dimensions).length > 0 ? canonical(metric.dimensions) : '';
+            const identity = canonical([metric.key, metric.dimensions ?? {}]);
+            const previous = values.get(identity);
+            if (!previous || metric.ts >= previous.ts)
+                values.set(identity, {
+                    label: dimensions ? `${metric.key} · ${dimensions}` : metric.key, value: metric.value, ts: metric.ts
+                });
+        }
+        return values;
+    }
+    const previous = latest(before);
+    const current = latest(after);
+    return [...new Set([...previous.keys(), ...current.keys()])].map(key => ({
+        label: (current.get(key) ?? previous.get(key)).label,
+        before: previous.get(key)?.value, after: current.get(key)?.value
+    }));
+}
+export function formatEvidenceValue(value) {
+    return value === undefined ? 'Not recorded' : JSON.stringify(value, null, 2);
+}

package/dist/svelte/lib/run-issues.d.ts

@@ -0,0 +1,34 @@
+import type { RunnableCatalogRun } from '../../schemas/runs.ts';
+import type { RunIssueReport, RunIssueInvestigation } from '../../schemas/issues.ts';
+export interface RunIssueGroup {
+    investigation?: RunIssueInvestigation;
+    root: RunnableCatalogRun;
+    attempts: RunnableCatalogRun[];
+    latest: RunnableCatalogRun;
+}
+/** Preserve every failed attempt. Owner-reported relationships group the investigation without rewriting the run tree or outcomes. */
+export declare function groupRunIssues(runs: readonly RunnableCatalogRun[], report?: RunIssueReport): RunIssueGroup[];
+/** Cases are the queue; physical/child attempts remain visible as history. */
+export declare function summarizeRunIssues(groups: readonly RunIssueGroup[]): {
+    groups: number;
+    attempts: number;
+    counts: {
+        unresolved: {
+            groups: number;
+            attempts: number;
+        };
+        unverified: {
+            groups: number;
+            attempts: number;
+        };
+        resolved: {
+            groups: number;
+            attempts: number;
+        };
+        superseded: {
+            groups: number;
+            attempts: number;
+        };
+    };
+};
+//# sourceMappingURL=run-issues.d.ts.map

package/dist/svelte/lib/run-issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-issues.d.ts","sourceRoot":"","sources":["../../../src/svelte/lib/run-issues.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAIhE,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAErF,MAAM,WAAW,aAAa;IAC7B,aAAa,CAAC,EAAE,qBAAqB,CAAC;IACtC,IAAI,EAAE,kBAAkB,CAAC;IACzB,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IAC/B,MAAM,EAAE,kBAAkB,CAAC;CAC3B;AAED,sIAAsI;AACtI,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,kBAAkB,EAAE,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,aAAa,EAAE,CAqC5G;AAED,8EAA8E;AAC9E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE;;;;;;;;;;;;;;;;;;;;;EAWlE"}

package/dist/svelte/lib/run-issues.js

@@ -0,0 +1,59 @@
+import { buildRunForest } from "./run-tree.js";
+import { needsAttention } from "./run-presentation.js";
+/** Preserve every failed attempt. Owner-reported relationships group the investigation without rewriting the run tree or outcomes. */
+export function groupRunIssues(runs, report) {
+    const byId = new Map(runs.map(run => [run.id, run]));
+    const covered = new Set();
+    const investigated = [];
+    for (const investigation of report?.groups ?? []) {
+        const attempts = investigation.attemptIds.flatMap(id => {
+            const run = byId.get(id);
+            if (!run || !needsAttention(run) || covered.has(id))
+                return [];
+            covered.add(id);
+            return [run];
+        });
+        if (!attempts.length)
+            continue;
+        const latest = byId.get(investigation.latestId) ?? attempts[0];
+        const root = byId.get(investigation.rootId) ?? latest;
+        investigated.push({ root, latest, attempts, investigation });
+    }
+    const grouped = [...investigated, ...buildRunForest(runs).flatMap(root => {
+            const attempts = [];
+            const leaves = [];
+            function visit(node) {
+                const failed = needsAttention(node.run) && !covered.has(node.run.id);
+                if (failed)
+                    attempts.push(node);
+                const descendants = node.children.map(visit).some(Boolean);
+                if (failed && !descendants)
+                    leaves.push(node);
+                return failed || descendants;
+            }
+            visit(root);
+            if (attempts.length === 0)
+                return [];
+            const latest = (leaves.length ? leaves : attempts).map(node => node.run)
+                .sort((left, right) => (right.endedAt ?? right.startedAt) - (left.endedAt ?? left.startedAt))[0];
+            return [{ root: root.run, attempts: attempts.map(node => node.run), latest }];
+        })];
+    return grouped.sort((left, right) => {
+        const priority = { unresolved: 0, unverified: 1, resolved: 2, superseded: 3 };
+        return priority[left.investigation?.status ?? 'unverified'] - priority[right.investigation?.status ?? 'unverified'] ||
+            (right.latest.endedAt ?? right.latest.startedAt) - (left.latest.endedAt ?? left.latest.startedAt);
+    });
+}
+/** Cases are the queue; physical/child attempts remain visible as history. */
+export function summarizeRunIssues(groups) {
+    const counts = {
+        unresolved: { groups: 0, attempts: 0 }, unverified: { groups: 0, attempts: 0 },
+        resolved: { groups: 0, attempts: 0 }, superseded: { groups: 0, attempts: 0 }
+    };
+    for (const group of groups) {
+        const bucket = counts[group.investigation?.status ?? 'unverified'];
+        bucket.groups++;
+        bucket.attempts += group.attempts.length;
+    }
+    return { groups: groups.length, attempts: groups.reduce((sum, group) => sum + group.attempts.length, 0), counts };
+}

package/dist/svelte/lib/run-presentation.d.ts

@@ -0,0 +1,16 @@
+import type { RunnableCatalogRun } from '../../schemas/runs.ts';
+import type { RunViewFilter } from '../../schemas/projection.ts';
+export type { RunViewFilter } from '../../schemas/projection.ts';
+import { hasRecordedIssue as needsAttention } from '../../issues.ts';
+export { needsAttention };
+export declare function outcomeLabel(run: RunnableCatalogRun): string;
+export declare function outcomeReason(run: RunnableCatalogRun): string | undefined;
+export declare function shortRunId(id: string): string;
+export declare function formatDuration(milliseconds: number): string;
+export declare function formatRunTime(timestamp: number): string;
+export declare function runTitle(run: RunnableCatalogRun): string;
+export declare function runPhaseLabel(run: RunnableCatalogRun): string | undefined;
+/** A visible parent carries the goal; its child names its distinct contribution. */
+export declare function runTreeTitle(run: RunnableCatalogRun, parent?: RunnableCatalogRun): string;
+export declare function matchesRun(run: RunnableCatalogRun, filter: RunViewFilter, search: string): boolean;
+//# sourceMappingURL=run-presentation.d.ts.map

package/dist/svelte/lib/run-presentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-presentation.d.ts","sourceRoot":"","sources":["../../../src/svelte/lib/run-presentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAGhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,YAAY,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,OAAO,EAAE,gBAAgB,IAAI,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B,wBAAgB,YAAY,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CAO5D;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,GAAG,SAAS,CAKzE;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAM3D;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CAIxD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,GAAG,SAAS,CAGzE;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,GAAG,EAAE,kBAAkB,EAAE,MAAM,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAMzF;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,kBAAkB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAUlG"}

package/dist/svelte/lib/run-presentation.js

@@ -0,0 +1,69 @@
+import { isActiveRunStatus } from "./status.js";
+import { hasRecordedIssue as needsAttention } from "../../issues.js";
+export { needsAttention };
+export function outcomeLabel(run) {
+    const status = run.outcome?.status;
+    if (status === 'done')
+        return run.resultMode === 'outcome' ? 'Achieved' : 'Completed';
+    if (status === 'not-done')
+        return 'Incomplete';
+    if (status === 'disputed')
+        return 'Disputed';
+    if (status === 'skipped')
+        return 'Skipped';
+    return 'Not recorded';
+}
+export function outcomeReason(run) {
+    const outcome = run.outcome;
+    if (outcome?.status === 'disputed')
+        return outcome.why;
+    if (outcome?.status === 'not-done' || outcome?.status === 'skipped')
+        return outcome.reason;
+    return undefined;
+}
+export function shortRunId(id) {
+    return id.length > 24 ? `${id.slice(0, 14)}…${id.slice(-6)}` : id;
+}
+export function formatDuration(milliseconds) {
+    const seconds = Math.max(0, Math.floor(milliseconds / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${seconds % 60}s`;
+    return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+export function formatRunTime(timestamp) {
+    return new Date(timestamp).toLocaleString(undefined, { month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' });
+}
+export function runTitle(run) {
+    const title = run.context?.title || run.name || run.runnableId || run.id;
+    const phase = runPhaseLabel(run);
+    return run.context?.title && phase ? `${phase}: ${title}` : title;
+}
+export function runPhaseLabel(run) {
+    const phase = run.context?.phase?.trim().replace(/[-_]+/g, ' ');
+    return phase ? phase[0].toUpperCase() + phase.slice(1) : undefined;
+}
+/** A visible parent carries the goal; its child names its distinct contribution. */
+export function runTreeTitle(run, parent) {
+    const phase = runPhaseLabel(run);
+    if (run.context?.title && run.context.title === parent?.context?.title && phase) {
+        return phase;
+    }
+    return runTitle(run);
+}
+export function matchesRun(run, filter, search) {
+    if (filter === 'active' && !isActiveRunStatus(run.status))
+        return false;
+    if (filter === 'unverified' && run.status !== 'unverified')
+        return false;
+    if (filter === 'attention' && !needsAttention(run))
+        return false;
+    if (filter === 'done' && run.outcome?.status !== 'done')
+        return false;
+    const text = [run.name, run.runnableId, run.runnableType, run.id, run.parentRunId, run.hostId,
+        run.inputDigest, run.activity?.message, outcomeReason(run), run.context?.title, run.context?.subject,
+        run.context?.target, run.context?.phase, ...(run.context?.paths ?? []), ...Object.values(run.ref ?? {})].join(' ').toLowerCase();
+    return search.trim().toLowerCase().split(/\s+/).every(word => text.includes(word));
+}

package/dist/svelte/lib/run-tree.d.ts

@@ -0,0 +1,22 @@
+import type { RunnableCatalogRun } from '../../schemas/runs.ts';
+export interface RunTreeNode {
+    run: RunnableCatalogRun;
+    depth: number;
+    parentId: string | null;
+    children: RunTreeNode[];
+    active: boolean;
+}
+/** Keep recorded ancestors when a child matches, without inventing missing parents. */
+export declare function withRunAncestors(runs: readonly RunnableCatalogRun[], matches: readonly RunnableCatalogRun[]): RunnableCatalogRun[];
+export declare function runAncestors(runs: readonly RunnableCatalogRun[], ids: Iterable<string>): Set<string>;
+/** One node per record, including orphans and cycles; active branches come first. */
+export declare function buildRunForest(records: readonly RunnableCatalogRun[], rootId?: string): RunTreeNode[];
+export interface RunTreeReport {
+    run: RunnableCatalogRun;
+    message: string;
+    ts: number;
+    label: string;
+}
+/** One postorder pass; descendant facts retain their source and never become parent activity. */
+export declare function runTreeReports(forest: readonly RunTreeNode[]): Map<string, RunTreeReport>;
+//# sourceMappingURL=run-tree.d.ts.map

package/dist/svelte/lib/run-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-tree.d.ts","sourceRoot":"","sources":["../../../src/svelte/lib/run-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAIhE,MAAM,WAAW,WAAW;IAC3B,GAAG,EAAE,kBAAkB,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,MAAM,EAAE,OAAO,CAAC;CAChB;AAED,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,kBAAkB,EAAE,EAAE,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,kBAAkB,EAAE,CAWlI;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,kBAAkB,EAAE,EAAE,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAapG;AAED,qFAAqF;AACrF,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CA6BrG;AAED,MAAM,WAAW,aAAa;IAC7B,GAAG,EAAE,kBAAkB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACd;AAED,iGAAiG;AACjG,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAoBzF"}

package/dist/svelte/lib/run-tree.js

@@ -0,0 +1,93 @@
+import { isActiveRunStatus } from "./status.js";
+import { runTitle } from "./run-presentation.js";
+/** Keep recorded ancestors when a child matches, without inventing missing parents. */
+export function withRunAncestors(runs, matches) {
+    const byId = new Map(runs.map(run => [run.id, run]));
+    const included = new Set();
+    for (const match of matches) {
+        let run = match;
+        while (run && !included.has(run.id)) {
+            included.add(run.id);
+            run = run.parentRunId ? byId.get(run.parentRunId) : undefined;
+        }
+    }
+    return [...byId.values()].filter(run => included.has(run.id));
+}
+export function runAncestors(runs, ids) {
+    const byId = new Map(runs.map(run => [run.id, run]));
+    const ancestors = new Set();
+    for (const id of ids) {
+        const visited = new Set([id]);
+        let parent = byId.get(id)?.parentRunId;
+        while (parent && byId.has(parent) && !visited.has(parent)) {
+            visited.add(parent);
+            ancestors.add(parent);
+            parent = byId.get(parent)?.parentRunId;
+        }
+    }
+    return ancestors;
+}
+/** One node per record, including orphans and cycles; active branches come first. */
+export function buildRunForest(records, rootId) {
+    const byId = new Map();
+    for (const run of records)
+        if (!byId.has(run.id))
+            byId.set(run.id, run);
+    const childrenOf = new Map();
+    for (const run of byId.values()) {
+        const parent = run.parentRunId;
+        if (!parent || parent === run.id || !byId.has(parent))
+            continue;
+        const children = childrenOf.get(parent) ?? [];
+        children.push(run);
+        childrenOf.set(parent, children);
+    }
+    for (const children of childrenOf.values())
+        children.sort((left, right) => left.startedAt - right.startedAt || left.id.localeCompare(right.id));
+    const placed = new Set();
+    function walk(run, depth, parentId) {
+        placed.add(run.id);
+        const children = [];
+        for (const child of childrenOf.get(run.id) ?? []) {
+            if (!placed.has(child.id))
+                children.push(walk(child, depth + 1, run.id));
+        }
+        return { run, depth, parentId, children, active: isActiveRunStatus(run.status) || children.some(child => child.active) };
+    }
+    if (rootId) {
+        const root = byId.get(rootId);
+        return root ? [walk(root, 0, null)] : [];
+    }
+    const roots = [...byId.values()].filter(run => !run.parentRunId || run.parentRunId === run.id || !byId.has(run.parentRunId));
+    const nodes = roots.map(run => walk(run, 0, null));
+    for (const run of byId.values())
+        if (!placed.has(run.id))
+            nodes.push(walk(run, 0, null));
+    return nodes.sort((left, right) => Number(right.active) - Number(left.active) || right.run.startedAt - left.run.startedAt || left.run.id.localeCompare(right.run.id));
+}
+/** One postorder pass; descendant facts retain their source and never become parent activity. */
+export function runTreeReports(forest) {
+    const reports = new Map();
+    function walk(node) {
+        const run = node.run;
+        let latest = { run, ts: run.startedAt, label: 'Run recorded', message: runTitle(run) };
+        if (run.endedAt != null && ['completed', 'error', 'stopped'].includes(run.status)) {
+            const label = run.status === 'error' ? 'Execution failed' : run.status === 'stopped' ? 'Execution stopped' : 'Execution finished';
+            latest = { run, ts: run.endedAt, label, message: runTitle(run) };
+        }
+        if (run.activity && run.activity.ts >= latest.ts)
+            latest = { run, ...run.activity, label: 'Last report' };
+        if (run.observation && run.observation.ts >= latest.ts)
+            latest = { run, ...run.observation, label: run.observation.label ?? 'Last observed' };
+        for (const child of node.children) {
+            const report = walk(child);
+            if (report.ts > latest.ts)
+                latest = report;
+        }
+        reports.set(run.id, latest);
+        return latest;
+    }
+    for (const node of forest)
+        walk(node);
+    return reports;
+}

package/dist/svelte/lib/status.d.ts

@@ -0,0 +1,19 @@
+import type { RunStatus } from '@vibesdotdev/runnable';
+export type RunStatusTone = 'idle' | 'live' | 'paused' | 'success' | 'stopped' | 'error' | 'loading';
+export interface RunStatusDisplay {
+    status: string;
+    label: string;
+    tone: RunStatusTone;
+    badgeClass: string;
+    dotColor: string;
+    accentColor: string;
+    textColor: string;
+    backgroundColor: string;
+    borderColor: string;
+    active: boolean;
+}
+export declare function normalizeRunStatus(status: RunStatus | string): string;
+export declare function getRunStatusDisplay(status: RunStatus | string): RunStatusDisplay;
+export declare function isActiveRunStatus(status: RunStatus | string): boolean;
+export declare function getRunnableTypeAccent(typeOrCategory: string | null | undefined): string;
+//# sourceMappingURL=status.d.ts.map

package/dist/svelte/lib/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/svelte/lib/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,MAAM,aAAa,GACtB,MAAM,GACN,MAAM,GACN,QAAQ,GACR,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,CAAC;AAEb,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,aAAa,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;CAChB;AA2GD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,MAAM,CAErE;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,gBAAgB,CAQhF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,CAErE;AAED,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAOvF"}

package/dist/svelte/lib/status.js

@@ -0,0 +1,122 @@
+const RUNNABLE_COLORS = {
+    live: 'var(--runnable-color-live, #34d399)',
+    warning: 'var(--runnable-color-warning, #f59e0b)',
+    danger: 'var(--runnable-color-danger, #ef4444)',
+    info: 'var(--runnable-color-info, #60a5fa)',
+    accent: 'var(--runnable-color-accent, #14b8a6)',
+    muted: 'var(--muted-foreground, #64748b)',
+};
+function displayColors(color, mixPercent = 18) {
+    return {
+        accentColor: color,
+        textColor: color,
+        backgroundColor: `color-mix(in srgb, ${color} ${mixPercent}%, transparent)`,
+        borderColor: `color-mix(in srgb, ${color} 35%, transparent)`,
+    };
+}
+const STATUS_DISPLAY = {
+    idle: {
+        label: 'Idle',
+        tone: 'idle',
+        badgeClass: 'runnable-status-badge-idle',
+        dotColor: RUNNABLE_COLORS.muted,
+        ...displayColors(RUNNABLE_COLORS.muted, 14),
+        active: false,
+    },
+    loading: {
+        label: 'Loading',
+        tone: 'loading',
+        badgeClass: 'runnable-status-badge-loading',
+        dotColor: RUNNABLE_COLORS.info,
+        ...displayColors(RUNNABLE_COLORS.info),
+        active: true,
+    },
+    running: {
+        label: 'Running',
+        tone: 'live',
+        badgeClass: 'runnable-status-badge-live',
+        dotColor: RUNNABLE_COLORS.live,
+        ...displayColors(RUNNABLE_COLORS.live),
+        active: true,
+    },
+    unverified: {
+        label: 'Status unverified',
+        tone: 'idle',
+        badgeClass: 'runnable-status-badge-idle',
+        dotColor: RUNNABLE_COLORS.muted,
+        ...displayColors(RUNNABLE_COLORS.muted, 14),
+        active: true,
+    },
+    paused: {
+        label: 'Paused',
+        tone: 'paused',
+        badgeClass: 'runnable-status-badge-paused',
+        dotColor: RUNNABLE_COLORS.warning,
+        ...displayColors(RUNNABLE_COLORS.warning),
+        active: true,
+    },
+    stopping: {
+        label: 'Stopping',
+        tone: 'stopped',
+        badgeClass: 'runnable-status-badge-stopped',
+        dotColor: RUNNABLE_COLORS.muted,
+        ...displayColors(RUNNABLE_COLORS.muted, 14),
+        active: true,
+    },
+    stopped: {
+        label: 'Stopped',
+        tone: 'stopped',
+        badgeClass: 'runnable-status-badge-stopped',
+        dotColor: RUNNABLE_COLORS.muted,
+        ...displayColors(RUNNABLE_COLORS.muted, 14),
+        active: false,
+    },
+    error: {
+        label: 'Error',
+        tone: 'error',
+        badgeClass: 'runnable-status-badge-error',
+        dotColor: RUNNABLE_COLORS.danger,
+        ...displayColors(RUNNABLE_COLORS.danger),
+        active: false,
+    },
+    completed: {
+        label: 'Finished',
+        tone: 'success',
+        badgeClass: 'runnable-status-badge-success',
+        dotColor: RUNNABLE_COLORS.info,
+        ...displayColors(RUNNABLE_COLORS.info),
+        active: false,
+    },
+};
+const TYPE_ACCENTS = {
+    train: 'var(--runnable-type-train, var(--runnable-color-warning, #f59e0b))',
+    benchmark: 'var(--runnable-type-benchmark, var(--runnable-color-live, #34d399))',
+    sweep: 'var(--runnable-type-sweep, #06b6d4)',
+    eval: 'var(--runnable-type-eval, var(--runnable-color-info, #60a5fa))',
+    test: 'var(--runnable-type-test, var(--muted-foreground, #64748b))',
+    research: 'var(--runnable-type-research, var(--runnable-color-accent, #14b8a6))',
+};
+export function normalizeRunStatus(status) {
+    return String(status || 'idle').toLowerCase();
+}
+export function getRunStatusDisplay(status) {
+    const normalized = normalizeRunStatus(status);
+    if (normalized in STATUS_DISPLAY) {
+        // SAFETY: normalized is verified to be a known key of STATUS_DISPLAY via in operator.
+        const entry = STATUS_DISPLAY[normalized];
+        return { status: normalized, ...entry };
+    }
+    return { ...STATUS_DISPLAY.idle, status: normalized, label: normalized.charAt(0).toUpperCase() + normalized.slice(1) };
+}
+export function isActiveRunStatus(status) {
+    return getRunStatusDisplay(status).active;
+}
+export function getRunnableTypeAccent(typeOrCategory) {
+    if (!typeOrCategory)
+        return 'var(--muted-foreground, #64748b)';
+    if (typeOrCategory in TYPE_ACCENTS) {
+        // SAFETY: typeOrCategory is verified to be a known key of TYPE_ACCENTS via in operator.
+        return TYPE_ACCENTS[typeOrCategory];
+    }
+    return RUNNABLE_COLORS.accent;
+}

package/dist/svelte/query-form.d.ts

@@ -0,0 +1,50 @@
+import * as z from 'zod/v4';
+/** Blank form fields mean all runs; the Runnable query contract validates populated values. */
+export declare const RunnableQueryFormSchema: z.ZodPipe<z.ZodObject<{
+    runnable: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    type: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    under: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+}, z.core.$strict>, z.ZodTransform<import("@vibesdotdev/kernel/schemas/json").JsonObject, {
+    runnable?: string | undefined;
+    type?: string | undefined;
+    under?: string | undefined;
+}>>;
+export declare const runnableQueryForm: {
+    name: string;
+    schema: z.ZodPipe<z.ZodObject<{
+        runnable: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+        type: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+        under: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    }, z.core.$strict>, z.ZodTransform<import("@vibesdotdev/kernel/schemas/json").JsonObject, {
+        runnable?: string | undefined;
+        type?: string | undefined;
+        under?: string | undefined;
+    }>>;
+    fields: {
+        runnable: {
+            ui: {
+                label: string;
+                placeholder: string;
+                description: string;
+                order: number;
+            };
+        };
+        type: {
+            ui: {
+                label: string;
+                placeholder: string;
+                description: string;
+                order: number;
+            };
+        };
+        under: {
+            ui: {
+                label: string;
+                placeholder: string;
+                description: string;
+                order: number;
+            };
+        };
+    };
+};
+//# sourceMappingURL=query-form.d.ts.map

package/dist/svelte/query-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-form.d.ts","sourceRoot":"","sources":["../../src/svelte/query-form.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAO5B,+FAA+F;AAC/F,eAAO,MAAM,uBAAuB;;;;;;;;GAMjC,CAAC;AAEJ,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQV,CAAC"}

package/dist/svelte/query-form.js

@@ -0,0 +1,19 @@
+import * as z from 'zod/v4';
+import { JsonObjectSchema } from '@vibesdotdev/kernel/schemas/json';
+import { RunnableReadQuerySchema } from "../schemas/runs.js";
+const emptyToAbsent = (value) => typeof value === 'string' ? value.trim() || undefined : value;
+/** Blank form fields mean all runs; the Runnable query contract validates populated values. */
+export const RunnableQueryFormSchema = RunnableReadQuerySchema.pick({ runnable: true, type: true, under: true }).extend({
+    runnable: z.preprocess(emptyToAbsent, RunnableReadQuerySchema.shape.runnable),
+    type: z.preprocess(emptyToAbsent, RunnableReadQuerySchema.shape.type),
+    under: z.preprocess(emptyToAbsent, RunnableReadQuerySchema.shape.under)
+}).strict().transform(query => JsonObjectSchema.parse(Object.fromEntries(Object.entries(query).filter(([, value]) => value !== undefined))));
+export const runnableQueryForm = {
+    name: 'Run filters',
+    schema: RunnableQueryFormSchema,
+    fields: {
+        runnable: { ui: { label: 'Runnable', placeholder: 'All runnables', description: 'An exact runnable ID.', order: 1 } },
+        type: { ui: { label: 'Run type', placeholder: 'All types', description: 'For example, workers/job or runbook.', order: 2 } },
+        under: { ui: { label: 'Run subtree', placeholder: 'All runs', description: 'A parent run ID, including its descendants.', order: 3 } }
+    }
+};