@signal9/era-ui 4.15.4 → 4.16.0

package/dist/ai/swarm/swarm.js

@@ -25,6 +25,31 @@
  * host that already holds swarm state in its own store calls these functions
  * directly and never constructs one.
  */
+/** Whether a sandbox id names a live fork of another VM. */
+export function isSwarmSandboxFork(id) {
+    return /-fk-[0-9a-z]+$/i.test(id);
+}
+/** The parent VM a forked sandbox was cloned from, or null for a fresh VM. */
+export function swarmSandboxForkOf(sandbox) {
+    if (sandbox.forkOf)
+        return sandbox.forkOf;
+    if (sandbox.id && isSwarmSandboxFork(sandbox.id))
+        return sandbox.id.slice(0, sandbox.id.lastIndexOf('-fk-'));
+    return null;
+}
+/** Narrow an agent's progress to the retrying arm (gates the countdown chip). */
+export function isSwarmAgentRetrying(progress) {
+    return progress?.phase === 'retrying';
+}
+/**
+ * The countdown a retrying agent renders: `attempt 2 — resuming in 8s`.
+ * Same clock rule as everything here — `now` is an argument.
+ */
+export function formatSwarmRetry(progress, now) {
+    const seconds = Math.ceil((progress.resumeAt - now) / 1000);
+    const when = seconds > 0 ? `resuming in ${seconds}s` : 'resuming now';
+    return `attempt ${progress.attempt} — ${when}`;
+}
 /**
  * Build the delegation forest from a flat agent list.
  *
@@ -96,12 +121,15 @@ export function summarizeSwarm(agents) {
         failed: 0,
         cancelled: 0,
         active: 0,
+        settled: 0,
         sandboxes: 0
     };
     for (const agent of agents) {
         counts[agent.status]++;
         if (isSwarmAgentActive(agent))
             counts.active++;
+        else
+            counts.settled++;
         if (agent.sandbox && agent.sandbox.status !== 'terminated')
             counts.sandboxes++;
     }
@@ -194,3 +222,124 @@ export function formatSwarmDuration(ms) {
         return `${minutes}m ${String(Math.floor(seconds % 60)).padStart(2, '0')}s`;
     return `${Math.floor(minutes / 60)}h ${String(minutes % 60).padStart(2, '0')}m`;
 }
+/**
+ * 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 function parseSwarmContent(payload) {
+    if (payload == null)
+        return null;
+    if (typeof payload !== 'object')
+        return { kind: 'json', data: payload };
+    const p = payload;
+    if (typeof p.exitCode === 'number' && typeof p.stdout === 'string') {
+        return {
+            kind: 'exec',
+            exitCode: p.exitCode,
+            stdout: p.stdout,
+            stderr: typeof p.stderr === 'string' ? p.stderr : '',
+            hint: typeof p.hint === 'string' ? p.hint : undefined,
+            command: typeof p.command === 'string' ? p.command : undefined
+        };
+    }
+    const viz = p.viz;
+    const data = p.data;
+    if (viz &&
+        typeof viz.type === 'string' &&
+        data &&
+        Array.isArray(data.columns) &&
+        Array.isArray(data.rows)) {
+        return {
+            kind: 'chart',
+            viz: viz,
+            data: data,
+            title: typeof p.title === 'string' ? p.title : undefined
+        };
+    }
+    if (typeof p.component === 'string') {
+        return {
+            kind: 'component',
+            component: p.component,
+            props: p.props ?? undefined,
+            inline: p.inline !== false
+        };
+    }
+    const text = p.markdown ?? p.text;
+    if (typeof text === 'string' && Object.keys(p).length <= 2) {
+        return { kind: 'markdown', text };
+    }
+    return { kind: 'json', data: payload };
+}
+/** An artifact's rich body, when it has one — `parseSwarmContent` over `payload`. */
+export function swarmArtifactContent(artifact) {
+    return parseSwarmContent(artifact.payload ?? null);
+}
+/**
+ * Summarize each delegation tree in a flat agent list to a table row.
+ * Rows come back in first-seen order; the caller sorts.
+ */
+export function summarizeSwarmRoots(agents) {
+    const byRoot = new Map();
+    for (const root of buildSwarmTree(agents)) {
+        byRoot.set(root.agent.id, flattenSwarmTree([root]).map((node) => node.agent));
+    }
+    const rows = [];
+    for (const [rootId, members] of byRoot) {
+        const root = members[0];
+        let updatedAt;
+        for (const agent of members) {
+            const at = agent.endedAt ?? agent.startedAt;
+            if (at != null && (updatedAt == null || at > updatedAt))
+                updatedAt = at;
+        }
+        rows.push({
+            rootId,
+            title: root.task,
+            status: root.status,
+            counts: summarizeSwarm(members),
+            updatedAt
+        });
+    }
+    return rows;
+}
+/**
+ * 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 function swarmSubtree(agents, agentId) {
+    const byParent = new Map();
+    let self;
+    for (const agent of agents) {
+        if (agent.id === agentId)
+            self = agent;
+        if (agent.parentId) {
+            const siblings = byParent.get(agent.parentId);
+            if (siblings)
+                siblings.push(agent);
+            else
+                byParent.set(agent.parentId, [agent]);
+        }
+    }
+    if (!self)
+        return [];
+    const out = [];
+    const seen = new Set();
+    const walk = (agent) => {
+        if (seen.has(agent.id))
+            return;
+        seen.add(agent.id);
+        out.push(agent);
+        for (const child of byParent.get(agent.id) ?? [])
+            walk(child);
+    };
+    walk(self);
+    return out;
+}

package/dist/apps/llm-shell/llm-shell.svelte

@@ -48,6 +48,7 @@
 		onStop,
 		onOpenAgent,
 		onCancelAgent,
+		swarmRenderers,
 		empty,
 		class: className
 	}: {
@@ -72,6 +73,12 @@
 		onOpenAgent?: (agent: AI.Swarm.SwarmAgent) => void;
 		/** Cancel a swarm agent. Offered only while the agent has work left to stop. */
 		onCancelAgent?: (agent: AI.Swarm.SwarmAgent) => void;
+		/**
+		 * Inline renderers for swarm artifact payloads, one per content kind
+		 * (chart, exec, component, …) — see `SwarmContentRenderers`. The host
+		 * registers them once here; every swarm block resolves the same registry.
+		 */
+		swarmRenderers?: AI.Swarm.SwarmContentRenderers;
 		/** Replaces the built-in empty state for a conversation with no messages. */
 		empty?: Snippet;
 		class?: string;
@@ -278,7 +285,14 @@
 			</AI.Tool.Content>
 		</AI.Tool.Root>
 	{:else if block.kind === 'swarm'}
-		<LlmSwarmBlock swarm={block.swarm} view={block.view} {now} {onOpenAgent} {onCancelAgent} />
+		<LlmSwarmBlock
+			swarm={block.swarm}
+			view={block.view}
+			{now}
+			{onOpenAgent}
+			{onCancelAgent}
+			renderers={swarmRenderers}
+		/>
 	{:else if block.kind === 'approval'}
 		<AI.Confirmation.Root state={approvalState}>
 			Approve <span class="font-mono text-fg">{block.toolName}</span>? Review the arguments before

package/dist/apps/llm-shell/llm-shell.svelte.d.ts

@@ -42,6 +42,12 @@ type $$ComponentProps = {
     onOpenAgent?: (agent: AI.Swarm.SwarmAgent) => void;
     /** Cancel a swarm agent. Offered only while the agent has work left to stop. */
     onCancelAgent?: (agent: AI.Swarm.SwarmAgent) => void;
+    /**
+     * Inline renderers for swarm artifact payloads, one per content kind
+     * (chart, exec, component, …) — see `SwarmContentRenderers`. The host
+     * registers them once here; every swarm block resolves the same registry.
+     */
+    swarmRenderers?: AI.Swarm.SwarmContentRenderers;
     /** Replaces the built-in empty state for a conversation with no messages. */
     empty?: Snippet;
     class?: string;

package/dist/apps/llm-shell/llm-swarm.svelte

@@ -17,7 +17,8 @@
 		view = 'tree',
 		now = Date.now(),
 		onOpenAgent,
-		onCancelAgent
+		onCancelAgent,
+		renderers
 	}: {
 		swarm: LlmSwarm;
 		/** `tree` keeps the delegation shape; `grid` is the console layout. */
@@ -25,6 +26,8 @@
 		now?: number;
 		onOpenAgent?: (agent: AI.Swarm.SwarmAgent) => void;
 		onCancelAgent?: (agent: AI.Swarm.SwarmAgent) => void;
+		/** Host renderers for artifact payloads — handed to `Swarm.Root`'s registry. */
+		renderers?: AI.Swarm.SwarmContentRenderers;
 	} = $props();
 
 	// A plain record, not a Map: it is rebuilt whole by the derived, so it never
@@ -42,13 +45,17 @@
 	const artifactsFor = (agent: AI.Swarm.SwarmAgent) => byAgent[agent.id] ?? NONE;
 </script>
 
-<AI.Swarm.Root {now} onOpen={onOpenAgent} onCancel={onCancelAgent}>
+<AI.Swarm.Root {now} onOpen={onOpenAgent} onCancel={onCancelAgent} {renderers}>
 	<AI.Swarm.Header title={swarm.plan?.title} status={swarm.plan?.status}>
 		<AI.Swarm.Counts agents={swarm.agents} />
 	</AI.Swarm.Header>
 
 	{#if view === 'grid'}
 		<AI.Swarm.Grid agents={swarm.agents} />
+		<!-- The console view was dropping artifacts on the floor — cards show the
+		     agents, and nothing showed what they PRODUCED. The tree hangs them off
+		     each agent's detail chip; the grid gets them as one labelled section. -->
+		<AI.Swarm.Artifacts artifacts={swarm.artifacts ?? []} />
 	{:else}
 		<!-- The chip names what it opens, so the section heading inside would say it
 		     twice — the detail is just the cards. -->

package/dist/apps/llm-shell/llm-swarm.svelte.d.ts

@@ -17,6 +17,8 @@ type $$ComponentProps = {
     now?: number;
     onOpenAgent?: (agent: AI.Swarm.SwarmAgent) => void;
     onCancelAgent?: (agent: AI.Swarm.SwarmAgent) => void;
+    /** Host renderers for artifact payloads — handed to `Swarm.Root`'s registry. */
+    renderers?: AI.Swarm.SwarmContentRenderers;
 };
 declare const LlmSwarm: import("svelte").Component<$$ComponentProps, {}, "">;
 type LlmSwarm = ReturnType<typeof LlmSwarm>;

package/dist/apps/notes/notes.svelte

@@ -295,7 +295,7 @@
 		{#if store.loading}
 			<div class="flex flex-col gap-gutter p-gutter">
 				{#each Array.from({ length: 5 }, (_, i) => i) as i (i)}
-					<Skeleton class="h-md rounded-item" />
+					<Skeleton class="h-md rounded-md" />
 				{/each}
 			</div>
 		{:else if visible.length === 0}
@@ -321,13 +321,18 @@
 							     the row instead of wrapping it, so the row stays a direct
 							     role="option" child of the listbox. A wrapper element there
 							     would put a non-option between them and break the relationship
-							     screen readers rely on. -->
+							     screen readers rely on.
+							     rounded-md, not rounded-item: item-rd is the FLOATING-MENU row
+							     radius, gated by --era-item-rd-scale = 0 on flat — it ignores
+							     the corners axis there. A list row on a plain surface takes its
+							     own tier radius (the conversations-rail pattern), which rides
+							     the corners toggle. -->
 							<ContextMenu.Root>
 								<ContextMenu.Trigger>
 									{#snippet child({ props })}
 										<div
 											{...props}
-											class="group/row flex h-md cursor-pointer items-center gap-(--era-xxs-inset-md) rounded-item px-(--era-xxs-inset-md) era-text-trim {current
+											class="group/row flex h-md cursor-pointer items-center gap-(--era-xxs-inset-md) rounded-md px-(--era-xxs-inset-md) era-text-trim {current
 												? 'bg-hover text-bright shadow-(--era-shadow-pressed)'
 												: 'hover:bg-highlight hover:shadow-highlight'}"
 											role="option"
@@ -366,7 +371,7 @@
 												{formatAge(note.updatedAt)}
 											</span>
 											<span
-												class="hidden shrink-0 items-center gap-(--era-xs-inset-md) group-hover/row:flex"
+												class="hidden shrink-0 items-center gap-(--era-xxs-inset-md) group-hover/row:flex"
 											>
 												<Button
 													icon