@signal9/era-ui 4.15.4 → 4.16.0

package/dist/ai/swarm/context.d.ts

@@ -1,4 +1,4 @@
-import type { SwarmAgent } from './swarm.js';
+import type { SwarmAgent, SwarmContentRenderers } from './swarm.js';
 /**
  * What `Swarm.Root` shares with every part below it.
  *
@@ -21,6 +21,12 @@ export interface SwarmContext {
     readonly onOpen?: (agent: SwarmAgent) => void;
     /** Cancel an agent (the host decides whether that means its subtree too). */
     readonly onCancel?: (agent: SwarmAgent) => void;
+    /**
+     * Inline renderers for artifact payloads, one per content kind — see
+     * `SwarmContentRenderers`. Registered once here so every artifact in the
+     * tree resolves the same registry without prop drilling.
+     */
+    readonly renderers?: SwarmContentRenderers;
 }
 export declare function setSwarmContext(ctx: SwarmContext): void;
 export declare function getSwarmContext(): SwarmContext;

package/dist/ai/swarm/index.d.ts

@@ -13,5 +13,5 @@ export { default as Footer } from './swarm-footer.svelte';
 export { default as Dot, SWARM_DOT } from './swarm-dot.svelte';
 export { default as Role, SWARM_ROLE } from './swarm-role.svelte';
 export { SwarmController } from './swarm.svelte.js';
-export { buildSwarmTree, isSwarmAgentActive, flattenSwarmTree, summarizeSwarm, summarizeBarrier, swarmElapsed, formatSwarmAge, formatSwarmDuration, type SwarmAgent, type SwarmAgentStatus, type SwarmArtifact, type SwarmBarrier, type SwarmBarrierStatus, type SwarmConnection, type SwarmCounts, type SwarmEvent, type SwarmNode, type SwarmPlan, type SwarmPlanStatus, type SwarmRole, type SwarmSandbox, type SwarmSnapshot } from './swarm.js';
+export { buildSwarmTree, isSwarmAgentActive, isSwarmAgentRetrying, isSwarmSandboxFork, flattenSwarmTree, parseSwarmContent, summarizeSwarm, summarizeBarrier, summarizeSwarmRoots, swarmArtifactContent, swarmElapsed, swarmSandboxForkOf, swarmSubtree, formatSwarmAge, formatSwarmDuration, formatSwarmRetry, type SwarmAgent, type SwarmAgentProgress, type SwarmAgentStatus, type SwarmArtifact, type SwarmBarrier, type SwarmBarrierStatus, type SwarmChartContent, type SwarmComponentContent, type SwarmConnection, type SwarmContentKind, type SwarmContentOf, type SwarmContentRenderers, type SwarmCounts, type SwarmEvent, type SwarmEventKind, type SwarmExecContent, type SwarmExecEvent, type SwarmExecSegment, type SwarmJsonContent, type SwarmMarkdownContent, type SwarmNode, type SwarmPlan, type SwarmPlanStatus, type SwarmRichContent, type SwarmRole, type SwarmRootSummary, type SwarmSandbox, type SwarmSandboxForkId, type SwarmSandboxStatus, type SwarmSnapshot } from './swarm.js';
 export type { SwarmContext } from './context.js';

package/dist/ai/swarm/index.js

@@ -13,4 +13,4 @@ export { default as Footer } from './swarm-footer.svelte';
 export { default as Dot, SWARM_DOT } from './swarm-dot.svelte';
 export { default as Role, SWARM_ROLE } from './swarm-role.svelte';
 export { SwarmController } from './swarm.svelte.js';
-export { buildSwarmTree, isSwarmAgentActive, flattenSwarmTree, summarizeSwarm, summarizeBarrier, swarmElapsed, formatSwarmAge, formatSwarmDuration } from './swarm.js';
+export { buildSwarmTree, isSwarmAgentActive, isSwarmAgentRetrying, isSwarmSandboxFork, flattenSwarmTree, parseSwarmContent, summarizeSwarm, summarizeBarrier, summarizeSwarmRoots, swarmArtifactContent, swarmElapsed, swarmSandboxForkOf, swarmSubtree, formatSwarmAge, formatSwarmDuration, formatSwarmRetry } from './swarm.js';

package/dist/ai/swarm/swarm-artifact.svelte

@@ -3,7 +3,13 @@
 	import { Card } from '../../ui/card/index.js';
 	import { cn } from '../../utils/index.js';
 	import { getSwarmContext } from './context.js';
-	import { formatSwarmAge, type SwarmArtifact } from './swarm.js';
+	import {
+		formatSwarmAge,
+		swarmArtifactContent,
+		type SwarmArtifact,
+		type SwarmRichContent
+	} from './swarm.js';
+	import type { Snippet } from 'svelte';
 
 	let {
 		artifact,
@@ -17,6 +23,15 @@
 	const age = $derived(
 		artifact.createdAt != null ? formatSwarmAge(artifact.createdAt, ctx.now) : null
 	);
+
+	// The payload's classified body, and the host's renderer for it, if both
+	// exist. The cast erases the per-kind narrowing the registry's mapped type
+	// enforces at REGISTRATION — the lookup pairs each snippet with content of
+	// its own kind by construction, TS just can't see across the indexed access.
+	const content = $derived(swarmArtifactContent(artifact));
+	const render = $derived(
+		content ? (ctx.renderers?.[content.kind] as Snippet<[SwarmRichContent]> | undefined) : undefined
+	);
 </script>
 
 <!-- What a branch actually produced: the merged finding, the report, the diff.
@@ -37,5 +52,12 @@
 			<span class="shrink-0 font-mono text-body text-muted tabular-nums">{age}</span>
 		{/if}
 	</div>
-	<p class="text-body leading-body text-muted">{artifact.summary}</p>
+	{#if content && render}
+		<!-- The host's inline renderer for this payload kind — a chart, a terminal,
+		     an embedded component. The summary stays out of the way: the rich body
+		     IS the artifact, and the one-liner under it would say it twice. -->
+		{@render render(content)}
+	{:else}
+		<p class="text-body leading-body text-muted">{artifact.summary}</p>
+	{/if}
 </Card>

package/dist/ai/swarm/swarm-node.svelte

@@ -8,7 +8,13 @@
 	import Role from './swarm-role.svelte';
 	import Sandbox from './swarm-sandbox.svelte';
 	import Actions, { swarmActions } from './swarm-actions.svelte';
-	import { formatSwarmDuration, swarmElapsed, type SwarmAgent } from './swarm.js';
+	import {
+		formatSwarmDuration,
+		formatSwarmRetry,
+		isSwarmAgentRetrying,
+		swarmElapsed,
+		type SwarmAgent
+	} from './swarm.js';
 
 	let {
 		agent,
@@ -160,12 +166,26 @@
 			active
 				? 'bg-hover text-bright'
 				: 'text-fg hover:bg-(--era-highlight) hover:shadow-(--era-highlight-shadow)',
-			'group-focus-visible/node:outline group-focus-visible/node:-outline-offset-1 group-focus-visible/node:outline-primary'
+			// Scoped to the DIRECT parent, not the group: every node in the tree is
+			// a group/node, and a named group matches ANY ancestor — focusing a
+			// parent row was outlining every visible child row. `:focus-visible > &`
+			// can only mean this row's own treeitem.
+			'[:focus-visible>&]:outline [:focus-visible>&]:-outline-offset-1 [:focus-visible>&]:outline-primary'
 		)}
 	>
 		{#if hasChildren}
+			<!-- Rotation keys off the component's own bound `open`, NOT the
+			     group-data-[state=open]/node selector it used to ride: nested nodes
+			     all share the group name, and a named group matches ANY ancestor —
+			     so the moment a parent expanded (which it must, for a child to be
+			     visible at all), every child chevron rotated and stayed rotated.
+			     `open` is bind:open on this node's own Collapsible.Root — the same
+			     single source of truth, without the ancestry. -->
 			<ChevronRight
-				class="size-(--era-h-xs) shrink-0 text-muted transition-transform duration-(--era-duration) ease-(--era-ease) group-data-[state=open]/node:rotate-90"
+				class={cn(
+					'size-(--era-h-xs) shrink-0 text-muted transition-transform duration-(--era-duration) ease-(--era-ease)',
+					open && 'rotate-90'
+				)}
 				aria-hidden="true"
 			/>
 		{:else}
@@ -215,6 +235,18 @@
 			<Sandbox sandbox={agent.sandbox} />
 		{/if}
 
+		{#if isSwarmAgentRetrying(agent.progress)}
+			<!-- The retry ladder, visible: the runtime is waiting out a provider
+			     outage, and a live countdown is the difference between "stuck" and
+			     "resuming in 8s". Warning ink — it is a degraded state, not an
+			     error. Ticks with ctx.now like every clock here. -->
+			<span class="shrink-0 font-mono text-body text-warning tabular-nums">
+				{formatSwarmRetry(agent.progress, ctx.now)}
+			</span>
+		{:else if agent.progress?.phase === 'waiting'}
+			<span class="shrink-0 font-mono text-body text-muted">{agent.progress.label}</span>
+		{/if}
+
 		{#if elapsed != null}
 			<span class="shrink-0 font-mono text-body text-muted tabular-nums">
 				{formatSwarmDuration(elapsed)}

package/dist/ai/swarm/swarm-root.svelte

@@ -3,13 +3,14 @@
 	import type { HTMLAttributes } from 'svelte/elements';
 	import { cn } from '../../utils/index.js';
 	import { setSwarmContext } from './context.js';
-	import type { SwarmAgent } from './swarm.js';
+	import type { SwarmAgent, SwarmContentRenderers } from './swarm.js';
 
 	let {
 		ref = $bindable(null),
 		now = Date.now(),
 		onOpen,
 		onCancel,
+		renderers,
 		children,
 		class: className,
 		...restProps
@@ -21,6 +22,8 @@
 		onOpen?: (agent: SwarmAgent) => void;
 		/** Cancel an agent. Nodes show the affordance only while one is still active. */
 		onCancel?: (agent: SwarmAgent) => void;
+		/** Inline renderers for artifact payloads (charts, exec output, components). */
+		renderers?: SwarmContentRenderers;
 		children?: Snippet;
 	} = $props();
 
@@ -35,6 +38,9 @@
 		},
 		get onCancel() {
 			return onCancel;
+		},
+		get renderers() {
+			return renderers;
 		}
 	});
 </script>

package/dist/ai/swarm/swarm-root.svelte.d.ts

@@ -1,6 +1,6 @@
 import type { Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
-import type { SwarmAgent } from './swarm.js';
+import type { SwarmAgent, SwarmContentRenderers } from './swarm.js';
 type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
     ref?: HTMLDivElement | null;
     /** Epoch ms for every elapsed readout. Tick it in `$state` for live counters. */
@@ -9,6 +9,8 @@ type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
     onOpen?: (agent: SwarmAgent) => void;
     /** Cancel an agent. Nodes show the affordance only while one is still active. */
     onCancel?: (agent: SwarmAgent) => void;
+    /** Inline renderers for artifact payloads (charts, exec output, components). */
+    renderers?: SwarmContentRenderers;
     children?: Snippet;
 };
 declare const SwarmRoot: import("svelte").Component<$$ComponentProps, {}, "ref">;

package/dist/ai/swarm/swarm-sandbox.svelte

@@ -15,7 +15,10 @@
 
 <script lang="ts">
 	import Box from '@lucide/svelte/icons/box';
+	import Camera from '@lucide/svelte/icons/camera';
+	import GitBranch from '@lucide/svelte/icons/git-branch';
 	import { cn } from '../../utils/index.js';
+	import { swarmSandboxForkOf } from './swarm.js';
 
 	let {
 		sandbox,
@@ -27,6 +30,18 @@
 		label?: boolean;
 		class?: string;
 	} = $props();
+
+	const forkOf = $derived(swarmSandboxForkOf(sandbox));
+	const title = $derived(
+		[
+			`sandbox ${sandbox.id ?? ''} (${sandbox.status})`,
+			forkOf && `forked from ${forkOf}`,
+			sandbox.checkpoint && 'checkpoint',
+			sandbox.busy && 'command running'
+		]
+			.filter(Boolean)
+			.join(' — ')
+	);
 </script>
 
 <!-- Deliberately a signal of its own, never folded into the status dot: an agent
@@ -38,8 +53,21 @@
 		SANDBOX_TONE[sandbox.status],
 		className
 	)}
-	title="sandbox {sandbox.id ?? ''} ({sandbox.status})"
+	{title}
 >
-	<Box class="size-(--era-h-xs) shrink-0" aria-hidden="true" />
+	<!-- busy: the box PULSES rather than gaining a second glyph — "a command is
+	     streaming through this VM" is motion, and motion is what says it. -->
+	<Box
+		class={cn('size-(--era-h-xs) shrink-0', sandbox.busy && 'animate-pulse')}
+		aria-hidden="true"
+	/>
+	{#if sandbox.checkpoint}
+		<!-- A paused VM kept as a restore point — the camera badge, as the
+		     reference console draws it. -->
+		<Camera class="size-(--era-icon-xxs) shrink-0" aria-hidden="true" />
+	{:else if forkOf}
+		<!-- Live-forked from a parent VM; the lineage is in the title. -->
+		<GitBranch class="size-(--era-icon-xxs) shrink-0" aria-hidden="true" />
+	{/if}
 	{#if label}<span class="truncate">{sandbox.status}</span>{/if}
 </span>

package/dist/ai/swarm/swarm.d.ts

@@ -53,12 +53,87 @@ export type SwarmBarrierStatus = 'open' | 'done' | 'failed' | 'cancelled';
  * `Swarm.Footer`) for exactly that reason.
  */
 export type SwarmConnection = 'idle' | 'loading' | 'live' | 'reconnecting' | 'error';
-/** The VM an agent executes in, when it has one. */
+/** A sandbox VM's lifecycle. `paused` includes checkpoints — see `checkpoint`. */
+export type SwarmSandboxStatus = 'running' | 'paused' | 'terminated';
+/**
+ * The id convention live-forked VMs carry: `<parent>-fk-<hex>`. A template
+ * literal type rather than a boolean field, because the LINEAGE is in the id —
+ * `swarmSandboxForkOf` recovers the parent from it with no extra data.
+ */
+export type SwarmSandboxForkId = `${string}-fk-${string}`;
+/** Whether a sandbox id names a live fork of another VM. */
+export declare function isSwarmSandboxFork(id: string): id is SwarmSandboxForkId;
+/** The parent VM a forked sandbox was cloned from, or null for a fresh VM. */
+export declare function swarmSandboxForkOf(sandbox: SwarmSandbox): string | null;
+/**
+ * The VM an agent executes in, when it has one.
+ *
+ * Everything beyond `status` is optional because sandbox truth is usually a
+ * SEPARATE, slower channel than the swarm's own event stream (the reference
+ * implementation snapshots it on a poll and deliberately never journals it) —
+ * a host reports what it knows and the parts render what is there.
+ */
 export interface SwarmSandbox {
-    /** Provider id, shown on hover. */
+    /** Provider id, shown on hover. Fork lineage is readable from it — see `SwarmSandboxForkId`. */
     id?: string;
-    status: 'running' | 'paused' | 'terminated';
+    status: SwarmSandboxStatus;
+    /** Parent VM this one was live-forked from. Omit to derive from the id. */
+    forkOf?: string | null;
+    /** A paused VM kept as a restore point (rendered with the checkpoint badge). */
+    checkpoint?: boolean;
+    /** A command is streaming through this VM right now. */
+    busy?: boolean;
+    /** Epoch ms the grace-window VM will be reaped, for a countdown. */
+    expiresAt?: number | null;
+}
+/** One chunk of live process output from a sandbox exec. */
+export interface SwarmExecSegment {
+    stream: 'stdout' | 'stderr';
+    data: string;
 }
+/**
+ * The exec stream's wire shape: interleaved output, then exactly one exit.
+ * `hint` is a sandbox-side diagnostic (timeout, missing interpreter) — NOT
+ * process output, which is why it is on the exit and not in the segments.
+ */
+export type SwarmExecEvent = {
+    type: 'output';
+    segments: SwarmExecSegment[];
+} | {
+    type: 'exit';
+    exitCode: number;
+    hint?: string;
+};
+/**
+ * A transient runtime phase on a live agent — the retry ladder made visible.
+ *
+ * Discriminated on `phase` so the retrying arm can REQUIRE its countdown
+ * fields: a "retrying" chip with no resume time is exactly the half-state this
+ * type exists to make unrepresentable.
+ */
+export type SwarmAgentProgress = {
+    phase: 'retrying';
+    /** Retry attempt number, 1-based. */
+    attempt: number;
+    /** Epoch ms when the runtime resumes after the backoff. */
+    resumeAt: number;
+    /** What is being waited out ("provider overloaded"). */
+    label?: string;
+} | {
+    phase: 'waiting';
+    label: string;
+};
+/** Narrow an agent's progress to the retrying arm (gates the countdown chip). */
+export declare function isSwarmAgentRetrying(progress: SwarmAgentProgress | null | undefined): progress is Extract<SwarmAgentProgress, {
+    phase: 'retrying';
+}>;
+/**
+ * The countdown a retrying agent renders: `attempt 2 — resuming in 8s`.
+ * Same clock rule as everything here — `now` is an argument.
+ */
+export declare function formatSwarmRetry(progress: Extract<SwarmAgentProgress, {
+    phase: 'retrying';
+}>, now: number): string;
 /** One agent in the swarm. */
 export interface SwarmAgent {
     id: string;
@@ -76,6 +151,18 @@ export interface SwarmAgent {
     result?: string;
     /** Fan-in gate this agent reports into. */
     barrierId?: string | null;
+    /** The plan this agent belongs to, when the host tracks more than one. */
+    planId?: string | null;
+    /**
+     * The host's execution handle — what sandbox operations (exec, terminate,
+     * lifecycle) are keyed by in most runtimes. Opaque to era.
+     */
+    executionId?: string | null;
+    /**
+     * Transient runtime phase (a provider-retry countdown, a named wait).
+     * Cleared with `null`; rendered inline on the row while present.
+     */
+    progress?: SwarmAgentProgress | null;
     /**
      * The agent's own transcript, when it has one. This GATES the open
      * affordance: a row or card shows the open button only when the host has both
@@ -121,6 +208,12 @@ export interface SwarmArtifact {
     kind: string;
     title?: string;
     summary: string;
+    /**
+     * The artifact's full structured body — what `summary` is a compression of.
+     * Parsed structurally by `parseSwarmContent` for inline rich rendering
+     * (charts, exec output, embedded components); see `SwarmContentRenderers`.
+     */
+    payload?: Record<string, unknown> | null;
     /** Epoch ms. */
     createdAt?: number;
 }
@@ -142,6 +235,8 @@ export interface SwarmCounts {
     cancelled: number;
     /** blocked + queued + running — everything that has not landed yet. */
     active: number;
+    /** done + failed + cancelled — the determinate progress bar's value. */
+    settled: number;
     /** Agents holding a VM that is not terminated. */
     sandboxes: number;
 }
@@ -206,10 +301,18 @@ export declare function formatSwarmDuration(ms: number): string;
  * differ the moment an event updates an agent already in the map, which is most
  * events, and confusing the two silently re-requests or skips history.
  */
+/**
+ * The event labels the reference journal emits, template-literal-typed so a
+ * status change is spelled from the same union the status field uses — and
+ * widened with `(string & {})`, the intersection trick that keeps arbitrary
+ * producer strings assignable WITHOUT collapsing the union (a bare `| string`
+ * would swallow the literals and take autocomplete with it).
+ */
+export type SwarmEventKind = 'agent.spawned' | `agent.${SwarmAgentStatus}` | `plan.${'created' | 'updated'}` | `barrier.${'created' | 'updated'}` | 'artifact.published' | (string & {});
 export interface SwarmEvent {
     seq: number;
-    /** Free-form producer label ("agent.completed"), passed through untouched. */
-    kind?: string;
+    /** Producer label — see `SwarmEventKind`. Passed through untouched. */
+    kind?: SwarmEventKind;
     agent?: SwarmAgent;
     plan?: SwarmPlan;
     barrier?: SwarmBarrier;
@@ -224,3 +327,114 @@ export interface SwarmSnapshot {
     barriers?: SwarmBarrier[];
     artifacts?: SwarmArtifact[];
 }
+/**
+ * Tabular data with a visualization spec — the chart shape the reference
+ * runtime streams (`viz.type` names the mark, `data` is columnar rows).
+ * era ships no chart renderer; the HOST registers one (see
+ * `SwarmContentRenderers`) and receives this, fully typed.
+ */
+export interface SwarmChartContent {
+    kind: 'chart';
+    viz: {
+        type: string;
+    } & Record<string, unknown>;
+    data: {
+        columns: string[];
+        rows: Record<string, unknown>[];
+        rowCount?: number;
+    };
+    title?: string;
+}
+/** A finished command's output — the sandbox exec result, inline. */
+export interface SwarmExecContent {
+    kind: 'exec';
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    /** Sandbox-side diagnostic (timeout, missing interpreter) — not process output. */
+    hint?: string;
+    command?: string;
+}
+/**
+ * An embedded component by registry name — the "spawn an app inline" shape.
+ * Generic over its props so a host with a typed registry can narrow `props`
+ * per component id; the default keeps it structural.
+ */
+export interface SwarmComponentContent<P extends Record<string, unknown> = Record<string, unknown>> {
+    kind: 'component';
+    /** Registry id the host resolves to a Svelte component. */
+    component: string;
+    props?: P;
+    /** Render in place (true) vs. "opens elsewhere" affordance (false). */
+    inline?: boolean;
+}
+/** Prose — rendered by the host's markdown pipeline. */
+export interface SwarmMarkdownContent {
+    kind: 'markdown';
+    text: string;
+}
+/** The structured fallback: anything JSON-shaped the parsers above declined. */
+export interface SwarmJsonContent {
+    kind: 'json';
+    data: unknown;
+}
+/** Everything an artifact payload can render as, discriminated on `kind`. */
+export type SwarmRichContent = SwarmChartContent | SwarmExecContent | SwarmComponentContent | SwarmMarkdownContent | SwarmJsonContent;
+export type SwarmContentKind = SwarmRichContent['kind'];
+/** The union member for one kind — `SwarmContentOf<'chart'>` is `SwarmChartContent`. */
+export type SwarmContentOf<K extends SwarmContentKind> = Extract<SwarmRichContent, {
+    kind: K;
+}>;
+/**
+ * The host's inline renderers, one optional snippet per content kind, each
+ * typed to exactly its member of the union — a mapped type over the
+ * discriminant, so registering a `chart` snippet that expects exec output is a
+ * compile error, not a runtime surprise.
+ *
+ * Registered once on `Swarm.Root` and read through context by every artifact
+ * in the tree — the era analogue of the reference app's component registry.
+ * Kinds without a renderer fall back to the artifact's summary text.
+ */
+export type SwarmContentRenderers = {
+    [K in SwarmContentKind]?: import('svelte').Snippet<[SwarmContentOf<K>]>;
+};
+/**
+ * Classify a payload STRUCTURALLY — by the fields it carries, never by a tool
+ * name or a declared type tag (producers rename tools; shapes are the
+ * contract). Detection order mirrors the reference implementation: exec
+ * (exitCode + stdout) → chart (viz.type + data.columns[]) → component
+ * (component string) → markdown (a lone text/markdown field) → json.
+ * Returns null only for empty input, so a renderer switch is total.
+ */
+export declare function parseSwarmContent(payload: unknown): SwarmRichContent | null;
+/** An artifact's rich body, when it has one — `parseSwarmContent` over `payload`. */
+export declare function swarmArtifactContent(artifact: SwarmArtifact): SwarmRichContent | null;
+/**
+ * One swarm summarized to a list row — what a hunts/runs table renders.
+ * The reference app's "hunt" IS this: a swarm root plus aggregate counts,
+ * under a domain label.
+ */
+export interface SwarmRootSummary {
+    rootId: string;
+    /** The root agent's task — the row's title. */
+    title: string;
+    /** The root agent's own status. */
+    status: SwarmAgentStatus;
+    counts: SwarmCounts;
+    /** Epoch ms of the newest agent activity, for the "updated" cell. */
+    updatedAt?: number;
+}
+/**
+ * Summarize each delegation tree in a flat agent list to a table row.
+ * Rows come back in first-seen order; the caller sorts.
+ */
+export declare function summarizeSwarmRoots(agents: SwarmAgent[]): SwarmRootSummary[];
+/**
+ * An agent and every transitive descendant, in tree order.
+ *
+ * The cascade selector: the reference runtime cancels SUBTREES (and cancels
+ * dependents when a dependency fails), so a host wiring `onCancel` calls this
+ * to know what a cancellation will take with it — and to filter it to
+ * `isSwarmAgentActive` for the confirm prompt's count.
+ */
+export declare function swarmSubtree(agents: SwarmAgent[], agentId: string): SwarmAgent[];