@genesislcap/ai-assistant 14.467.1 → 14.467.2

package/dist/esm/main/main.js

@@ -45,8 +45,10 @@ import { AI_COLOUR_AMBER, AI_COLOUR_CYAN, AI_COLOUR_PINK, AI_COLOUR_VIOLET, } fr
 import { ChatSuggestions } from '../suggestions/chat-suggestions';
 import { AnimatedPanelToggle } from '../utils/animated-panel-toggle';
 import { resolveExclusiveLoadingStyle } from '../utils/animation-exclusivity';
+import { flattenSubAgentMessages } from '../utils/flatten-sub-agent-messages';
 import { logger } from '../utils/logger';
 import { filterVisibleMessages, trailingInteractionRow } from '../utils/message-partition';
+import { stripAgentHandlers } from '../utils/strip-agent-handlers';
 import { sumCosts } from '../utils/sum-costs';
 import { expandToolTree } from '../utils/tool-fold';
 import { styles } from './main.styles';
@@ -95,37 +97,6 @@ const COMPOSER_MAX_HEIGHT_PX = 400;
 const COMPOSER_MIN_MESSAGES_PX = 80;
 // Register supporting components when the main component module is imported.
 avoidTreeShaking(AiChatMarkdown, AiChatInteractionWrapper, AiHaloOverlay, AiWavesIndicator, AiFlowingWavesIndicator, AiPlasmaOrbIndicator, AiChatBubble, AiActivityHalo, ChatSuggestions, AgentPicker);
-/**
- * Recursively strips non-serializable fields from an agent before storing in
- * Redux. Drops **every function-valued property** — `toolHandlers`, the
- * lifecycle/dispatch hooks (`onActivate`, `onDeactivate`, `getDebugSnapshot`,
- * `onUnresolvedTool`), and the function form of the per-turn resolvers
- * (`systemPrompt`, `toolDefinitions`, `displayName`, `provider`, `temperature`,
- * `toolChoice`). Static forms (string / number / array / plain object) pass
- * through unchanged; `subAgents` are stripped recursively.
- *
- * Filtering by *value* (any function) rather than by an explicit field list
- * means a new function-valued field added to `AgentConfig` is handled
- * automatically and can never leak a live function into serialized store
- * state — no denylist to keep in sync. The live config on the driver stays the
- * source of truth; the slice only holds this serializable projection, and
- * functions are never read back from it.
- */
-function stripHandlers(agent) {
-    var _a;
-    const serializable = {};
-    for (const [key, value] of Object.entries(agent)) {
-        // `subAgents` is handled separately (recursively, below); drop everything
-        // function-valued.
-        if (key === 'subAgents' || typeof value === 'function')
-            continue;
-        serializable[key] = value;
-    }
-    if ((_a = agent.subAgents) === null || _a === void 0 ? void 0 : _a.length) {
-        serializable.subAgents = agent.subAgents.map(stripHandlers);
-    }
-    return serializable;
-}
 /**
  * Foundation AI Assistant component.
  *
@@ -342,7 +313,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         // and Redux serializable-state middleware will warn. toolHandlers are never read
         // back from the store; they are always sourced from this.agents when the driver
         // is built.
-        (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setActiveAgent(value ? stripHandlers(value) : undefined);
+        (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setActiveAgent(value ? stripAgentHandlers(value) : undefined);
     }
     get suggestionsState() {
         var _a, _b;
@@ -1431,9 +1402,13 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             turn: 1,
             message: 2,
         };
+        // Sub-agent conversations are stored nested on the parent tool call's
+        // `subAgentTrace`; `flattenSubAgentMessages` hoists them to top-level
+        // `kind: 'message'` entries (breadcrumbed + correlated, the nested copy moved
+        // out — not duplicated) so the timeline reads as one chronological sequence.
         const messages = (_h = (_g = (_f = this.driver) === null || _f === void 0 ? void 0 : _f.getRawHistory) === null || _g === void 0 ? void 0 : _g.call(_f)) !== null && _h !== void 0 ? _h : this.messages;
         const timeline = [
-            ...messages.map((m) => (Object.assign({ kind: 'message' }, m))),
+            ...flattenSubAgentMessages(messages),
             ...turns,
             ...(stateKey ? getMetaEvents(stateKey) : []).map((e) => (Object.assign({ kind: 'event' }, e))),
         ].sort((a, b) => {
@@ -1456,13 +1431,14 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             meta: {
                 timestamp,
                 host: window.location.host,
-                // stripHandlers drops every function-valued field (handlers, lifecycle
-                // hooks, onUnresolvedTool, function-form resolvers) and recurses
-                // subAgents — no manual exclusion list to keep in sync. We only override
-                // toolDefinitions afterwards to expand the fold tree for the log.
+                // stripAgentHandlers drops every function-valued field (handlers, lifecycle
+                // hooks, onUnresolvedTool, function-form resolvers) AND object handler bags
+                // like an object-form `toolHandlers`, and recurses subAgents — no manual
+                // exclusion list to keep in sync. We only override toolDefinitions
+                // afterwards to expand the fold tree for the log.
                 agentSummary: (_j = this.agents) === null || _j === void 0 ? void 0 : _j.map((a) => {
                     var _a;
-                    return (Object.assign(Object.assign({}, stripHandlers(a)), { toolDefinitions: Array.isArray(a.toolDefinitions)
+                    return (Object.assign(Object.assign({}, stripAgentHandlers(a)), { toolDefinitions: Array.isArray(a.toolDefinitions)
                             ? typeof a.toolHandlers === 'function'
                                 ? // Static defs + dynamic handlers — can't walk fold tree
                                     // because the handler map isn't materialized at log time.

package/dist/esm/state/debug-event-log.js

@@ -128,6 +128,51 @@ export function getMetaEvents(key) {
     var _a, _b;
     return (_b = (_a = registry.get(key)) === null || _a === void 0 ? void 0 : _a.events) !== null && _b !== void 0 ? _b : [];
 }
+/**
+ * Merge pre-built meta events into the timeline for `targetKey`, **preserving each
+ * event's original `timestamp`** (so it interleaves chronologically on export)
+ * while re-indexing onto the target buffer's monotonic counter. Used to fold a
+ * sub-agent's harvested events into the parent session — see
+ * `ChatDriver.invokeSubAgent`. Unlike {@link recordMetaEvent} it does not stamp a
+ * fresh timestamp; the same non-`high` eviction policy is applied once after the
+ * batch so the buffer stays bounded.
+ */
+export function mergeMetaEvents(targetKey, events) {
+    if (events.length === 0)
+        return;
+    let buffer = registry.get(targetKey);
+    if (!buffer) {
+        buffer = { events: [], next: 0 };
+        registry.set(targetKey, buffer);
+    }
+    for (const event of events) {
+        buffer.events.push(Object.assign(Object.assign({}, event), { index: buffer.next }));
+        buffer.next += 1;
+    }
+    // Evict oldest non-`high` events until back under the cap — same policy as
+    // recordMetaEvent; `high` events (failures/limits) are never dropped. Single
+    // pass: take the overflow count, then drop that many of the oldest non-`high`
+    // events in order (if there aren't enough non-`high`, the buffer floats above
+    // the cap rather than losing a failure signal).
+    let toEvict = buffer.events.length - DEFAULT_MAX_META_EVENTS;
+    if (toEvict > 0) {
+        buffer.events = buffer.events.filter((e) => {
+            if (toEvict > 0 && e.importance !== 'high') {
+                toEvict -= 1;
+                return false;
+            }
+            return true;
+        });
+    }
+}
+/**
+ * Drop the entire timeline for `key`. Used to discard a sub-agent's transient
+ * per-invocation session once its events have been harvested into the parent, so
+ * the module registry doesn't accumulate one orphaned bucket per sub-agent run.
+ */
+export function clearSession(key) {
+    registry.delete(key);
+}
 /**
  * Human/agent-facing guide emitted as the first key of the exported debug log,
  * so whoever opens the JSON (often an AI agent) knows how to read it without
@@ -139,11 +184,13 @@ export const DEBUG_LOG_README = [
     '`timeline` is the entire session as one array, already sorted chronologically by `timestamp` (ISO 8601). Every entry has a `kind`.',
     'Timestamps are millisecond-resolution; entries that share the same millisecond are ordered by a fixed kind rank (event, then turn, then message), which is a heuristic and may not reflect exact causal order within that millisecond — e.g. a user message and the turn it triggered, or a final assistant message and its turn.end event, can appear in either order depending on whether they landed in the same millisecond. Read the logical structure of a turn rather than over-interpreting the micro-ordering of co-timestamped entries of different kinds.',
     "kind:'message' — the conversation. `role` is user/assistant/tool/system-event/synthetic-user; `agentName` says which agent produced it; `toolCalls`/`toolResult`/`interaction` carry tool and widget activity; `inputTokens`/`outputTokens`/`cost` are per-message LLM usage, and `externalCostUsd` is any non-LLM cost a widget reported for its own external service calls (folded into the session cost total alongside `cost`). On model-produced assistant messages, `model` is the concrete model id that generated it (e.g. 'gemini-2.5-flash-lite') and `providerName` is the registry slot it resolved under (e.g. a tier name like 'high'/'low', or the default); together they attribute the message — and any tool calls it carries — to an exact model even across a mid-session vendor/tier switch, where one slot name can map to different models before and after the switch. Both are undefined on any entry that is NOT an LLM response: non-assistant roles (user/tool/system-event) and 'synthetic-user' echoes; assistant interaction/widget entries (empty content carrying an `interaction` — a rendered widget, not a model turn); driver-authored assistant fallbacks (the timeout, repeated-malformed-call, and empty-response apology messages); and messages restored from a session persisted before these fields existed. One partial case: on a genuine model turn whose provider exposes no `getStatus` (or reports no model), `providerName` is still set but `model` alone is undefined. A 'synthetic-user' message is a display-only echo of an interaction outcome (e.g. the answer a widget reported): it renders on the user's side of the chat and `agentName` is the agent that created it, but it is never sent to the LLM — so it has no matching 'turn' and the model learns the outcome only from the corresponding tool result.",
+    "Sub-agent messages appear inline. When a tool delegates to a sub-agent (via `requestSubAgent`), the sub-agent's whole conversation — its own assistant/tool messages, each with their own `content`/`thinking`/`toolCalls`/`toolResult` and per-message `model`/`providerName`/`inputTokens`/`outputTokens`/`cost` — is hoisted into the timeline as ordinary kind:'message' entries, interleaved by timestamp right after the tool call that spawned them (so you read the delegation top-to-bottom). A hoisted entry is marked: `subAgentDepth` is its delegation depth (1 for a sub-agent, 2 for a sub-agent's sub-agent, …), `subAgentOf` is the id of the parent tool call that spawned it (correlates it back even when two sub-agents run in one parent turn), `subAgentName` is the sub-agent's own name, and `agentName` is rewritten to a `\"<parent> › <sub-agent>\"` breadcrumb (composing when nested, e.g. `\"UI Builder › Planner › Grounding\"`). The sub-agent's per-LLM-call snapshots also surface as kind:'turn' entries with an N-M `turnIndex`, and subagent.started/completed (or subagent.failed) events bracket the run. Per-message `cost` on hoisted entries is already part of the session total (it is summed from the un-flattened history), so summing the top-level timeline does NOT double-count.",
     "kind:'turn' — one LLM call. `turnIndex` is a string: a top-level turn is the bare counter ('0', '1', …); a sub-agent's turns are numbered under the parent turn that activated them ('3-1', '3-2', …, and a nested sub-agent contributes '3-2-1', …), and `agentName` names the agent that ran the turn. `systemPrompt` and `toolNames` are what the model saw. A systemPrompt of '<repeated — identical to turn N>' was byte-identical to turn N and de-duplicated; the full prompt is shown whenever it changes (often because a stateful agent advanced), so prompt evolution is visible.",
     "kind:'turn'.`agentSnapshot` — the active agent's own view of its internal state, captured at that turn. An agent opts into this by exposing a `getDebugSnapshot()` that returns JSON-serializable per-state info; stateful/flow agents wire it automatically, so you can watch a flow advance turn-by-turn (e.g. current step, cursor, collected fields, pending changes). Absent for agents that don't expose one.",
     "kind:'event' — a meta/lifecycle event. `type` names it (see below); `detail` carries structured data. `detail.placement` is the emitting UI instance: 'bubble' (collapsed), 'panel' (popped-out), or 'standalone'.",
     "Each 'event' also has an `importance`: 'high' (failures/limits — turn.error, tool.failed, subagent.failed, file.read-failed, suggestions.failed, context.threshold-crossed), 'normal' (session flow — connects, turns, retries, handoffs, agent/provider changes, interactions, sub-agent start/complete), or 'low' (skippable UI/bookkeeping noise — panel.toggled, attachment.added, driver.wired/unwired, context.updated). To skim, ignore importance:'low'; to triage a failure, filter to importance:'high' then read the nearby messages and turns. A 'high' turn.error is often preceded by one or more 'normal' turn.retry events for the same reason — read them together to see how many attempts were made before bailing. 'message' and 'turn' entries carry no importance — they are the substance, always read them.",
     'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), provider.selected (model/provider for the upcoming turns), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver), context.updated/threshold-crossed (token + cost), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
+    'Sub-agent meta events: a sub-agent\'s own turn.retry/turn.error/tool.failed/tool.unresolved events are merged into this same timeline, tagged with `detail.subAgent` — a `"<parent> › <sub-agent>"` breadcrumb that composes when nested (e.g. `"UI Builder › Planner › Grounding"`) — and interleaved by their original timestamps within the subagent.started→completed/failed bracket. These are the per-attempt/per-failure signals that do NOT appear among the sub-agent\'s (hoisted) messages: a malformed/empty attempt that gets retried produces no message, and the stale-vs-hallucinated split and streak counts live only on the event. A sub-agent\'s high-volume, message-derivable events (turn.start/turn.end, provider.selected, context.updated) are intentionally NOT merged — read its hoisted messages for model/tokens/cost and turn-by-turn activity, and the bracketing subagent.* events for the run\'s span.',
     "`meta` holds context captured at export time: agentSummary (full agent configs), context (active model, token usage, session cost), activeDebugSnapshot (the active agent's `getDebugSnapshot()` taken fresh at export — reflects state NOW, which may have advanced beyond the last turn's agentSnapshot), debug (optional host-supplied debug state), host, and the export timestamp.",
     'To debug a failure: find the last turn.error or tool.failed, then read upward for the user message, the turn(s), and the agent/provider/state events that led into it.',
 ];

package/dist/esm/state/debug-event-log.test.js

@@ -0,0 +1,67 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { clearMetaEventRegistry, clearSession, getMetaEvents, mergeMetaEvents, recordMetaEvent, } from './debug-event-log';
+const event = (overrides = {}) => (Object.assign({ index: 0, timestamp: '2026-06-19T16:00:00.000Z', type: 'turn.retry', importance: 'normal' }, overrides));
+const suite = createLogicSuite('debug-event-log merge/clear');
+suite('mergeMetaEvents is a no-op for an empty batch', () => {
+    clearMetaEventRegistry();
+    mergeMetaEvents('k', []);
+    assert.is(getMetaEvents('k').length, 0);
+});
+suite('mergeMetaEvents preserves each event timestamp and re-indexes monotonically', () => {
+    clearMetaEventRegistry();
+    mergeMetaEvents('k', [
+        event({ index: 7, timestamp: '2026-06-19T16:00:01.000Z', detail: { a: 1 } }),
+        event({ index: 99, timestamp: '2026-06-19T16:00:02.000Z', detail: { b: 2 } }),
+    ]);
+    const out = getMetaEvents('k');
+    assert.is(out.length, 2);
+    // original timestamps kept (not re-stamped) ...
+    assert.is(out[0].timestamp, '2026-06-19T16:00:01.000Z');
+    assert.is(out[1].timestamp, '2026-06-19T16:00:02.000Z');
+    // ... indices re-assigned from the target's counter, not carried from source.
+    assert.is(out[0].index, 0);
+    assert.is(out[1].index, 1);
+    assert.equal(out[0].detail, { a: 1 });
+});
+suite('mergeMetaEvents appends after existing events with a continuing index', () => {
+    clearMetaEventRegistry();
+    recordMetaEvent('k', 'turn.start'); // index 0, real timestamp
+    mergeMetaEvents('k', [event({ type: 'turn.error', importance: 'high' })]);
+    const out = getMetaEvents('k');
+    assert.is(out.length, 2);
+    assert.is(out[0].type, 'turn.start');
+    assert.is(out[1].type, 'turn.error');
+    assert.is(out[1].index, 1); // continues the monotonic counter
+});
+suite('mergeMetaEvents into a fresh key creates the bucket', () => {
+    clearMetaEventRegistry();
+    mergeMetaEvents('brand-new', [event()]);
+    assert.is(getMetaEvents('brand-new').length, 1);
+});
+suite('mergeMetaEvents evicts oldest non-high events past the cap but keeps every high', () => {
+    clearMetaEventRegistry();
+    const highStamp = '2026-06-19T16:30:00.000Z';
+    // One `high` failure first, then a flood of `normal` events well past the cap.
+    const batch = [
+        event({ type: 'turn.error', importance: 'high', timestamp: highStamp }),
+    ];
+    for (let i = 0; i < 2000; i += 1) {
+        batch.push(event({ type: 'turn.retry', importance: 'normal' }));
+    }
+    mergeMetaEvents('k', batch);
+    const out = getMetaEvents('k');
+    // Eviction ran (bounded below what we merged) ...
+    assert.ok(out.length < 2001);
+    // ... and the lone high-importance failure was never dropped.
+    assert.is(out.filter((e) => e.importance === 'high').length, 1);
+    assert.ok(out.some((e) => e.timestamp === highStamp));
+});
+suite('clearSession drops one key without touching others', () => {
+    clearMetaEventRegistry();
+    recordMetaEvent('child', 'turn.retry');
+    recordMetaEvent('parent', 'turn.start');
+    clearSession('child');
+    assert.is(getMetaEvents('child').length, 0);
+    assert.is(getMetaEvents('parent').length, 1);
+});
+suite.run();

package/dist/esm/utils/flatten-sub-agent-messages.js

@@ -0,0 +1,49 @@
+/**
+ * Flatten sub-agent conversations into a single top-level message stream for the
+ * debug-log timeline.
+ *
+ * A tool call that delegates to a sub-agent carries the sub-agent's entire
+ * conversation on `toolCall.subAgentTrace`. The live UI reads that nested shape,
+ * but a top-to-bottom timeline reads far better with those messages inline next to
+ * the turn that produced them. This walks the list and, for every tool call with a
+ * `subAgentTrace`, hoists the sub-agent's messages up as their own timeline
+ * entries while **removing** the nested copy from the emitted parent tool call — a
+ * move, not a copy. The data is relocated, never duplicated: the export stays the
+ * same size and a naive `sum(timeline[].cost)` does not double-count (the
+ * canonical `sumCosts` total still reads the un-flattened history).
+ *
+ * Hoisted entries are:
+ * - **breadcrumbed**: `agentName` becomes `"<parent> › <sub-agent>"`, composing for
+ *   nested sub-agents (`"<parent> › <sub> › <subsub>"`); the raw sub-agent name is
+ *   preserved on `subAgentName`.
+ * - **depth-tagged** (`subAgentDepth`) and **correlated** to the spawning tool call
+ *   (`subAgentOf`), so the delegation tree is reconstructable even when two
+ *   sub-agents run within the same parent turn.
+ *
+ * Top-level messages (depth 0) are emitted unchanged apart from the trace strip.
+ * Order is preserved within each list; the caller sorts the whole timeline by
+ * timestamp afterwards, and every sub-agent message carries its own timestamp, so
+ * hoisted entries interleave chronologically between the parent's tool-call and
+ * tool-result messages.
+ *
+ * @internal
+ */
+export function flattenSubAgentMessages(messages, prefix = '', depth = 0, subAgentOf) {
+    return messages.flatMap((m) => {
+        var _a, _b, _c;
+        const breadcrumb = prefix ? `${prefix} › ${(_a = m.agentName) !== null && _a !== void 0 ? _a : '?'}` : m.agentName;
+        const traceCalls = (_c = (_b = m.toolCalls) === null || _b === void 0 ? void 0 : _b.filter((tc) => { var _a; return (_a = tc.subAgentTrace) === null || _a === void 0 ? void 0 : _a.length; })) !== null && _c !== void 0 ? _c : [];
+        const entry = Object.assign(Object.assign(Object.assign({ kind: 'message' }, m), (traceCalls.length > 0 && {
+            toolCalls: m.toolCalls.map((tc) => tc.subAgentTrace ? Object.assign(Object.assign({}, tc), { subAgentTrace: undefined }) : tc),
+        })), (depth > 0 && {
+            agentName: breadcrumb,
+            subAgentName: m.agentName,
+            subAgentDepth: depth,
+            subAgentOf,
+        }));
+        if (traceCalls.length === 0)
+            return [entry];
+        const hoisted = traceCalls.flatMap((tc) => flattenSubAgentMessages(tc.subAgentTrace, breadcrumb !== null && breadcrumb !== void 0 ? breadcrumb : '', depth + 1, tc.id));
+        return [entry, ...hoisted];
+    });
+}

package/dist/esm/utils/flatten-sub-agent-messages.test.js

@@ -0,0 +1,139 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { flattenSubAgentMessages } from './flatten-sub-agent-messages';
+const msg = (overrides = {}) => (Object.assign({ role: 'assistant', content: '' }, overrides));
+/** A parent assistant message whose single tool call delegated to a sub-agent. */
+const delegating = (id, agentName, trace) => msg({
+    agentName,
+    toolCalls: [{ id, name: 'requestSubAgent', args: {}, subAgentTrace: trace }],
+});
+const suite = createLogicSuite('flattenSubAgentMessages');
+suite('returns an empty array for an empty list', () => {
+    assert.equal(flattenSubAgentMessages([]), []);
+});
+suite('emits top-level messages unchanged and tags none as sub-agent', () => {
+    const out = flattenSubAgentMessages([
+        msg({ role: 'user', content: 'hi', agentName: 'UI Builder' }),
+        msg({ content: 'hello', agentName: 'UI Builder' }),
+    ]);
+    assert.is(out.length, 2);
+    assert.is(out[0].kind, 'message');
+    assert.is(out[0].agentName, 'UI Builder');
+    // No depth/marker fields on top-level entries.
+    assert.is(out[0].subAgentDepth, undefined);
+    assert.is(out[0].subAgentName, undefined);
+    assert.is(out[1].subAgentOf, undefined);
+});
+suite('hoists a sub-agent trace to top-level entries after the spawning message', () => {
+    const trace = [
+        msg({
+            agentName: 'UI Architecture Planner',
+            content: '',
+            toolCalls: [{ id: 'g', name: 'grep_source', args: {} }],
+        }),
+        msg({
+            role: 'tool',
+            agentName: 'UI Architecture Planner',
+            toolResult: { toolCallId: 'g', content: 'result' },
+        }),
+    ];
+    const out = flattenSubAgentMessages([
+        delegating('tc1', 'UI Builder', trace),
+        msg({
+            role: 'tool',
+            agentName: 'UI Builder',
+            toolResult: { toolCallId: 'tc1', content: 'plan done' },
+        }),
+    ]);
+    // parent tool-call msg, then 2 hoisted children, then the parent tool-result msg.
+    assert.is(out.length, 4);
+    assert.is(out[0].agentName, 'UI Builder'); // parent unchanged
+    assert.is(out[1].agentName, 'UI Builder › UI Architecture Planner');
+    assert.is(out[2].agentName, 'UI Builder › UI Architecture Planner');
+    assert.is(out[3].agentName, 'UI Builder'); // parent tool-result, back at top level
+});
+suite('marks hoisted entries with depth, raw name, and the spawning tool-call id', () => {
+    const out = flattenSubAgentMessages([
+        delegating('tc1', 'UI Builder', [msg({ agentName: 'UI Architecture Planner', content: 'x' })]),
+    ]);
+    const child = out[1];
+    assert.is(child.subAgentDepth, 1);
+    assert.is(child.subAgentName, 'UI Architecture Planner');
+    assert.is(child.subAgentOf, 'tc1');
+});
+suite('moves the trace out — the emitted parent tool call no longer carries it (no duplication)', () => {
+    const trace = [msg({ agentName: 'Planner', content: 'only once' })];
+    const out = flattenSubAgentMessages([delegating('tc1', 'UI Builder', trace)]);
+    // The trace is stripped from the emitted tool call ...
+    assert.is(out[0].toolCalls[0].subAgentTrace, undefined);
+    // ... and surfaces exactly once, as a hoisted top-level entry.
+    const hoisted = out.filter((e) => e.subAgentDepth === 1);
+    assert.is(hoisted.length, 1);
+    assert.is(hoisted[0].content, 'only once');
+});
+suite('preserves per-message usage fields on hoisted entries', () => {
+    const out = flattenSubAgentMessages([
+        delegating('tc1', 'UI Builder', [
+            msg({
+                agentName: 'Planner',
+                model: 'claude-sonnet-4-6',
+                inputTokens: 100,
+                outputTokens: 20,
+                cost: 0.5,
+            }),
+        ]),
+    ]);
+    const child = out[1];
+    assert.is(child.model, 'claude-sonnet-4-6');
+    assert.is(child.inputTokens, 100);
+    assert.is(child.outputTokens, 20);
+    assert.is(child.cost, 0.5);
+});
+suite('composes the breadcrumb for nested sub-agents', () => {
+    const grandchild = [msg({ agentName: 'Grounding', content: 'deep' })];
+    const childTrace = [delegating('tc2', 'Planner', grandchild)];
+    const out = flattenSubAgentMessages([delegating('tc1', 'UI Builder', childTrace)]);
+    // top: UI Builder | depth1: Planner | depth2: Grounding
+    const depth1 = out.find((e) => e.subAgentDepth === 1);
+    const depth2 = out.find((e) => e.subAgentDepth === 2);
+    assert.is(depth1.agentName, 'UI Builder › Planner');
+    assert.is(depth2.agentName, 'UI Builder › Planner › Grounding');
+    assert.is(depth2.subAgentName, 'Grounding');
+    assert.is(depth2.subAgentOf, 'tc2');
+});
+suite('correlates two sub-agents spawned in the same parent turn', () => {
+    const parent = msg({
+        agentName: 'UI Builder',
+        toolCalls: [
+            {
+                id: 'a',
+                name: 'requestSubAgent',
+                args: {},
+                subAgentTrace: [msg({ agentName: 'Planner', content: 'p' })],
+            },
+            {
+                id: 'b',
+                name: 'requestSubAgent',
+                args: {},
+                subAgentTrace: [msg({ agentName: 'Reviewer', content: 'r' })],
+            },
+        ],
+    });
+    const out = flattenSubAgentMessages([parent]);
+    const planner = out.find((e) => e.subAgentName === 'Planner');
+    const reviewer = out.find((e) => e.subAgentName === 'Reviewer');
+    assert.is(planner.subAgentOf, 'a');
+    assert.is(reviewer.subAgentOf, 'b');
+    assert.is(planner.agentName, 'UI Builder › Planner');
+    assert.is(reviewer.agentName, 'UI Builder › Reviewer');
+});
+suite('falls back gracefully when the spawning message has no agentName', () => {
+    const out = flattenSubAgentMessages([
+        delegating('tc1', undefined, [
+            msg({ agentName: 'Planner', content: 'x' }),
+        ]),
+    ]);
+    // No parent name to prefix → show the sub-agent's own name unbreadcrumbed.
+    assert.is(out[1].agentName, 'Planner');
+    assert.is(out[1].subAgentName, 'Planner');
+});
+suite.run();

package/dist/esm/utils/strip-agent-handlers.js

@@ -0,0 +1,51 @@
+/**
+ * Project an `AgentConfig` down to a JSON-serializable shape for the redux
+ * session store. Drops two kinds of field:
+ *
+ * 1. **Directly function-valued** — the lifecycle/dispatch hooks (`onActivate`,
+ *    `onDeactivate`, `getDebugSnapshot`, `onUnresolvedTool`) and the function
+ *    form of the per-turn resolvers (`systemPrompt`, `toolDefinitions`,
+ *    `displayName`, `provider`, `temperature`, `toolChoice`, `toolHandlers`).
+ * 2. **Object "handler bags" whose *values* are functions** — `toolHandlers` in
+ *    its object form is `{ name: handler }`, so `typeof` is `'object'`, not
+ *    `'function'`. A by-value check on the field alone misses it, leaking a live
+ *    handler into store state and tripping redux's serializability check (the
+ *    regression this guards against — top-level agents tend to use the factory
+ *    function form, but sub-agents commonly declare an object literal).
+ *
+ * `subAgents` are projected recursively. Static forms (string / number / array /
+ * plain data object) pass through unchanged.
+ *
+ * Filtering by value rather than an explicit field list means a new
+ * function-valued field on `AgentConfig` is handled automatically — no denylist
+ * to maintain. The live config on the driver stays the source of truth; the
+ * slice only holds this serializable projection and functions are never read
+ * back from it.
+ *
+ * @internal
+ */
+export function stripAgentHandlers(agent) {
+    var _a;
+    const serializable = {};
+    for (const [key, value] of Object.entries(agent)) {
+        // Projected recursively below.
+        if (key === 'subAgents')
+            continue;
+        // Directly function-valued field.
+        if (typeof value === 'function')
+            continue;
+        // Object/array whose values include a function (e.g. `toolHandlers` in object
+        // form). Drop the whole field — the projection type omits it and a function
+        // must never reach the store.
+        if (value !== null &&
+            typeof value === 'object' &&
+            Object.values(value).some((v) => typeof v === 'function')) {
+            continue;
+        }
+        serializable[key] = value;
+    }
+    if ((_a = agent.subAgents) === null || _a === void 0 ? void 0 : _a.length) {
+        serializable.subAgents = agent.subAgents.map(stripAgentHandlers);
+    }
+    return serializable;
+}

package/dist/esm/utils/strip-agent-handlers.test.js

@@ -0,0 +1,81 @@
+import { __awaiter } from "tslib";
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { stripAgentHandlers } from './strip-agent-handlers';
+const cfg = (overrides) => (Object.assign({ name: 'agent' }, overrides));
+/** Mirrors what redux's serializable-state check does: find any function anywhere. */
+const hasFunctionDeep = (value) => {
+    if (typeof value === 'function')
+        return true;
+    if (Array.isArray(value))
+        return value.some(hasFunctionDeep);
+    if (value !== null && typeof value === 'object') {
+        return Object.values(value).some(hasFunctionDeep);
+    }
+    return false;
+};
+const suite = createLogicSuite('stripAgentHandlers');
+suite('drops object-form toolHandlers (the redux-leak regression)', () => {
+    const stripped = stripAgentHandlers(cfg({ toolHandlers: { vfs_list: () => __awaiter(void 0, void 0, void 0, function* () { return 'x'; }), vfs_read: () => __awaiter(void 0, void 0, void 0, function* () { return 'y'; }) } }));
+    // The whole handler bag is gone — not left behind with live functions inside.
+    assert.not.ok(stripped.toolHandlers);
+    assert.not.ok(hasFunctionDeep(stripped));
+});
+suite('drops factory-function toolHandlers and the lifecycle/dispatch hooks', () => {
+    const stripped = stripAgentHandlers(cfg({
+        toolHandlers: () => ({ t: () => __awaiter(void 0, void 0, void 0, function* () { return 'x'; }) }),
+        onActivate: () => __awaiter(void 0, void 0, void 0, function* () { }),
+        onDeactivate: () => __awaiter(void 0, void 0, void 0, function* () { }),
+        getDebugSnapshot: () => ({}),
+        onUnresolvedTool: () => 'redirect',
+    }));
+    assert.not.ok(stripped.toolHandlers);
+    assert.not.ok(stripped.onActivate);
+    assert.not.ok(stripped.onDeactivate);
+    assert.not.ok(stripped.getDebugSnapshot);
+    assert.not.ok(stripped.onUnresolvedTool);
+});
+suite('drops function-form resolvers but keeps static forms and plain data', () => {
+    const stripped = stripAgentHandlers(cfg({
+        systemPrompt: () => 'dynamic', // function → dropped
+        displayName: 'Static Name', // string → kept
+        temperature: 0.5, // number → kept
+        toolChoice: 'auto', // string → kept
+        toolDefinitions: [{ name: 'x', description: 'd', parameters: {} }], // data array → kept
+        manualSelection: { enabled: true, hint: 'pick me' }, // data object → kept
+    }));
+    assert.not.ok(stripped.systemPrompt);
+    assert.is(stripped.displayName, 'Static Name');
+    assert.is(stripped.temperature, 0.5);
+    assert.is(stripped.toolChoice, 'auto');
+    assert.equal(stripped.toolDefinitions, [{ name: 'x', description: 'd', parameters: {} }]);
+    assert.equal(stripped.manualSelection, { enabled: true, hint: 'pick me' });
+});
+suite('recurses into subAgents, stripping their object-form toolHandlers', () => {
+    const stripped = stripAgentHandlers(cfg({
+        name: 'boss',
+        toolHandlers: () => ({}),
+        subAgents: [
+            cfg({
+                name: 'worker',
+                toolHandlers: { vfs_list: () => __awaiter(void 0, void 0, void 0, function* () { return 'x'; }), vfs_read: () => __awaiter(void 0, void 0, void 0, function* () { return 'y'; }) },
+            }),
+        ],
+    }));
+    const subs = stripped.subAgents;
+    assert.is(subs.length, 1);
+    assert.is(subs[0].name, 'worker');
+    assert.not.ok(subs[0].toolHandlers, 'sub-agent toolHandlers must be stripped (the reported bug)');
+    // Nothing function-valued survives anywhere in the projection.
+    assert.not.ok(hasFunctionDeep(stripped));
+});
+suite('produces a projection with no function at any depth', () => {
+    const stripped = stripAgentHandlers(cfg({
+        name: 'boss',
+        onActivate: () => __awaiter(void 0, void 0, void 0, function* () { }),
+        subAgents: [cfg({ name: 'w', toolHandlers: { t: () => __awaiter(void 0, void 0, void 0, function* () { }) } })],
+    }));
+    assert.not.ok(hasFunctionDeep(stripped));
+    // Round-trips to the expected serializable shape.
+    assert.equal(JSON.parse(JSON.stringify(stripped)), { name: 'boss', subAgents: [{ name: 'w' }] });
+});
+suite.run();

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/index.ts","../src/channel/ai-activity-bus.ts","../src/channel/ai-activity-channel.ts","../src/components/flowing-waves-indicator.ts","../src/components/halo-overlay.ts","../src/components/plasma-orb-indicator.ts","../src/components/waves-indicator.ts","../src/components/activity-halo/activity-halo.ts","../src/components/agent-picker/agent-picker.constants.ts","../src/components/agent-picker/agent-picker.styles.ts","../src/components/agent-picker/agent-picker.template.ts","../src/components/agent-picker/agent-picker.ts","../src/components/agent-picker/index.ts","../src/components/ai-driver/ai-driver.ts","../src/components/ai-driver/index.ts","../src/components/chat-bubble/chat-bubble.styles.ts","../src/components/chat-bubble/chat-bubble.template.ts","../src/components/chat-bubble/chat-bubble.ts","../src/components/chat-bubble/index.ts","../src/components/chat-driver/align-event-globals.ts","../src/components/chat-driver/chat-driver.test.ts","../src/components/chat-driver/chat-driver.ts","../src/components/chat-driver/index.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.styles.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.template.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.test.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.ts","../src/components/chat-interaction-wrapper/index.ts","../src/components/chat-markdown/chat-markdown.ts","../src/components/chat-markdown/index.ts","../src/components/orchestrating-driver/index.ts","../src/components/orchestrating-driver/orchestrating-driver.ts","../src/components/popout-manager/index.ts","../src/components/popout-manager/popout-manager.ts","../src/config/config.ts","../src/config/define-stateful-agent.test.ts","../src/config/define-stateful-agent.ts","../src/config/fallback-agents.ts","../src/config/index.ts","../src/config/validate-providers.test.ts","../src/config/validate-providers.ts","../src/main/index.ts","../src/main/main.styles.ts","../src/main/main.template.ts","../src/main/main.ts","../src/main/main.types.ts","../src/state/ai-assistant-slice.ts","../src/state/debug-event-log.ts","../src/state/driver-registry.ts","../src/state/session-store.ts","../src/styles/ai-colours.ts","../src/styles/index.ts","../src/styles/styles.ts","../src/suggestions/chat-suggestions.ts","../src/tags/index.ts","../src/types/ai-chat-widget.ts","../src/utils/animated-panel-toggle.ts","../src/utils/animation-exclusivity.test.ts","../src/utils/animation-exclusivity.ts","../src/utils/history-transform.ts","../src/utils/index.ts","../src/utils/logger.ts","../src/utils/message-partition.test.ts","../src/utils/message-partition.ts","../src/utils/sum-costs.test.ts","../src/utils/sum-costs.ts","../src/utils/tool-fold.ts"],"version":"5.9.2"}
+{"root":["../src/index.ts","../src/channel/ai-activity-bus.ts","../src/channel/ai-activity-channel.ts","../src/components/flowing-waves-indicator.ts","../src/components/halo-overlay.ts","../src/components/plasma-orb-indicator.ts","../src/components/waves-indicator.ts","../src/components/activity-halo/activity-halo.ts","../src/components/agent-picker/agent-picker.constants.ts","../src/components/agent-picker/agent-picker.styles.ts","../src/components/agent-picker/agent-picker.template.ts","../src/components/agent-picker/agent-picker.ts","../src/components/agent-picker/index.ts","../src/components/ai-driver/ai-driver.ts","../src/components/ai-driver/index.ts","../src/components/chat-bubble/chat-bubble.styles.ts","../src/components/chat-bubble/chat-bubble.template.ts","../src/components/chat-bubble/chat-bubble.ts","../src/components/chat-bubble/index.ts","../src/components/chat-driver/align-event-globals.ts","../src/components/chat-driver/chat-driver.test.ts","../src/components/chat-driver/chat-driver.ts","../src/components/chat-driver/index.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.styles.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.template.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.test.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.ts","../src/components/chat-interaction-wrapper/index.ts","../src/components/chat-markdown/chat-markdown.ts","../src/components/chat-markdown/index.ts","../src/components/orchestrating-driver/index.ts","../src/components/orchestrating-driver/orchestrating-driver.ts","../src/components/popout-manager/index.ts","../src/components/popout-manager/popout-manager.ts","../src/config/config.ts","../src/config/define-stateful-agent.test.ts","../src/config/define-stateful-agent.ts","../src/config/fallback-agents.ts","../src/config/index.ts","../src/config/validate-providers.test.ts","../src/config/validate-providers.ts","../src/main/index.ts","../src/main/main.styles.ts","../src/main/main.template.ts","../src/main/main.ts","../src/main/main.types.ts","../src/state/ai-assistant-slice.ts","../src/state/debug-event-log.test.ts","../src/state/debug-event-log.ts","../src/state/driver-registry.ts","../src/state/session-store.ts","../src/styles/ai-colours.ts","../src/styles/index.ts","../src/styles/styles.ts","../src/suggestions/chat-suggestions.ts","../src/tags/index.ts","../src/types/ai-chat-widget.ts","../src/utils/animated-panel-toggle.ts","../src/utils/animation-exclusivity.test.ts","../src/utils/animation-exclusivity.ts","../src/utils/flatten-sub-agent-messages.test.ts","../src/utils/flatten-sub-agent-messages.ts","../src/utils/history-transform.ts","../src/utils/index.ts","../src/utils/logger.ts","../src/utils/message-partition.test.ts","../src/utils/message-partition.ts","../src/utils/strip-agent-handlers.test.ts","../src/utils/strip-agent-handlers.ts","../src/utils/sum-costs.test.ts","../src/utils/sum-costs.ts","../src/utils/tool-fold.ts"],"version":"5.9.2"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "14.467.1",
+  "version": "14.467.2",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/ai-assistant.d.ts",
@@ -64,24 +64,24 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.467.1",
-    "@genesislcap/genx": "14.467.1",
-    "@genesislcap/rollup-builder": "14.467.1",
-    "@genesislcap/ts-builder": "14.467.1",
-    "@genesislcap/uvu-playwright-builder": "14.467.1",
-    "@genesislcap/vite-builder": "14.467.1",
-    "@genesislcap/webpack-builder": "14.467.1",
+    "@genesislcap/foundation-testing": "14.467.2",
+    "@genesislcap/genx": "14.467.2",
+    "@genesislcap/rollup-builder": "14.467.2",
+    "@genesislcap/ts-builder": "14.467.2",
+    "@genesislcap/uvu-playwright-builder": "14.467.2",
+    "@genesislcap/vite-builder": "14.467.2",
+    "@genesislcap/webpack-builder": "14.467.2",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "14.467.1",
-    "@genesislcap/foundation-logger": "14.467.1",
-    "@genesislcap/foundation-redux": "14.467.1",
-    "@genesislcap/foundation-ui": "14.467.1",
-    "@genesislcap/foundation-utils": "14.467.1",
-    "@genesislcap/rapid-design-system": "14.467.1",
-    "@genesislcap/web-core": "14.467.1",
+    "@genesislcap/foundation-ai": "14.467.2",
+    "@genesislcap/foundation-logger": "14.467.2",
+    "@genesislcap/foundation-redux": "14.467.2",
+    "@genesislcap/foundation-ui": "14.467.2",
+    "@genesislcap/foundation-utils": "14.467.2",
+    "@genesislcap/rapid-design-system": "14.467.2",
+    "@genesislcap/web-core": "14.467.2",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },
@@ -93,5 +93,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2a9820e8efcc82074e74b760b5ec5e216a284d79"
+  "gitHead": "2edbf1311578ebd00440aacdd362b30411428923"
 }