@genesislcap/ai-assistant 14.451.1-alpha-3c3e1d3.0 → 14.451.2

package/dist/esm/components/chat-interaction-wrapper/chat-interaction-wrapper.js

@@ -32,6 +32,19 @@ let AiChatInteractionWrapper = class AiChatInteractionWrapper extends GenesisEle
     componentNameChanged() {
         this.renderComponent();
     }
+    /**
+     * Re-render the hosted widget when the interaction identity changes. This
+     * ensures widgets don't go stale with them being rendered with `recycle: true`
+     * when messages are dynamically filtered, showing/hiding thinking/tool calls
+     *
+     * `interactionId` is a per-interaction UUID, so it changes exactly when the
+     * hosted interaction does. Property bindings apply in template order
+     * (componentName, data, interactionId), so `data` is already rebound by the
+     * time this fires and the fresh widget is built with the correct data.
+     */
+    interactionIdChanged() {
+        this.renderComponent();
+    }
     resolvedChanged() {
         var _a;
         const element = (_a = this.container) === null || _a === void 0 ? void 0 : _a.firstElementChild;
@@ -74,9 +87,9 @@ let AiChatInteractionWrapper = class AiChatInteractionWrapper extends GenesisEle
         this._resizeObserver = undefined;
         this.container.replaceChildren();
         if (!customElements.get(this.componentName)) {
-            logger.warn(`Interactive component "\${this.componentName}" is not registered in the customElements registry.`);
+            logger.warn(`Interactive component "${this.componentName}" is not registered in the customElements registry.`);
             const errorDiv = document.createElement('div');
-            errorDiv.textContent = `Error: Component "\${this.componentName}" is not available in this application.`;
+            errorDiv.textContent = `Error: Component "${this.componentName}" is not available in this application.`;
             this.container.appendChild(errorDiv);
             return;
         }
@@ -108,7 +121,7 @@ let AiChatInteractionWrapper = class AiChatInteractionWrapper extends GenesisEle
         catch (e) {
             logger.error(`Failed to create interactive component: \${this.componentName}`, e);
             const errorDiv = document.createElement('div');
-            errorDiv.textContent = `Error: Could not load component \${this.componentName}`;
+            errorDiv.textContent = `Error: Could not load component ${this.componentName}`;
             this.container.appendChild(errorDiv);
         }
     }

package/dist/esm/components/chat-interaction-wrapper/chat-interaction-wrapper.test.js

@@ -0,0 +1,77 @@
+import { __awaiter } from "tslib";
+import { assert, createComponentSuite } from '@genesislcap/foundation-testing';
+import { DOM } from '@genesislcap/web-core';
+import { AiChatInteractionWrapper } from './chat-interaction-wrapper';
+// Hold a reference so the custom-element registration isn't tree-shaken.
+AiChatInteractionWrapper;
+/**
+ * Minimal stand-in for a real interaction widget. The wrapper instantiates the
+ * element named by `componentName` and assigns `data`/`resolved` onto it; the
+ * tests read those back to verify which interaction the rendered widget belongs
+ * to.
+ */
+const FAKE_WIDGET = 'test-interaction-widget';
+if (!customElements.get(FAKE_WIDGET)) {
+    customElements.define(FAKE_WIDGET, class extends HTMLElement {
+    });
+}
+/**
+ * Renders a first interaction into a freshly-mounted wrapper.
+ *
+ * `componentName` is assigned last on purpose. The suite hands us an
+ * already-connected element, so the only render trigger left is
+ * `componentNameChanged`; setting it last means that render sees `data` and
+ * `interactionId` already in place — reproducing production, where the initial
+ * widget renders in `connectedCallback` with every bound property present. This
+ * keeps the *first* render correct on both the patched and unpatched code so
+ * that the id-change rebind is the only behaviour each test isolates.
+ */
+function renderFirstInteraction(element) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield DOM.nextUpdate();
+        element.data = { label: 'interaction-a' };
+        element.interactionId = 'id-a';
+        element.componentName = FAKE_WIDGET;
+        yield DOM.nextUpdate();
+    });
+}
+const Suite = createComponentSuite('AiChatInteractionWrapper', 'ai-chat-interaction-wrapper');
+/**
+ * Regression for the cog-menu toggle misalignment: FAST's `repeat` reconciles
+ * the message list by array index (it has no key function), so toggling "Tool
+ * calls"/"Thinking" re-filters the visible messages and rebinds an existing
+ * row's wrapper to a *different* interaction. When both interactions use the
+ * same component, `componentNameChanged` doesn't fire — so the wrapper must
+ * re-render on `interactionId` change, or the previous interaction's widget
+ * stays mounted under the new message.
+ */
+Suite('re-renders the hosted widget when interactionId changes with the same componentName', (_a) => __awaiter(void 0, [_a], void 0, function* ({ element }) {
+    yield renderFirstInteraction(element);
+    const firstWidget = element.container.firstElementChild;
+    assert.ok(firstWidget, 'a widget is rendered for the first interaction');
+    assert.equal(firstWidget.data, { label: 'interaction-a' });
+    // Rebind the reused wrapper to a different interaction that happens to use
+    // the same component — `data` then `interactionId`, mirroring the template's
+    // property-binding order. `componentName` is unchanged, so the only thing
+    // that can drive a re-render is the interactionId hook.
+    element.data = { label: 'interaction-b' };
+    element.interactionId = 'id-b';
+    yield DOM.nextUpdate();
+    const secondWidget = element.container.firstElementChild;
+    assert.is.not(secondWidget, firstWidget, 'the stale widget is replaced, not left mounted');
+    assert.equal(secondWidget.data, { label: 'interaction-b' }, 'the rendered widget reflects the new interaction, not the stale one');
+}));
+/**
+ * Resolving an interaction in place (the user answers it) must forward the
+ * result without tearing down and rebuilding the widget — only a genuine change
+ * of interaction identity should rebuild.
+ */
+Suite('forwards resolved in place without rebuilding the widget', (_a) => __awaiter(void 0, [_a], void 0, function* ({ element }) {
+    yield renderFirstInteraction(element);
+    const widget = element.container.firstElementChild;
+    element.resolved = { status: 'approved' };
+    yield DOM.nextUpdate();
+    assert.is(element.container.firstElementChild, widget, 'resolving in place must not rebuild the widget');
+    assert.equal(widget.resolved, { status: 'approved' }, 'resolved is forwarded to the widget');
+}));
+Suite.run();

package/dist/esm/components/orchestrating-driver/orchestrating-driver.js

@@ -222,7 +222,7 @@ export class OrchestratingDriver extends EventTarget {
                 }
                 handoffs += 1;
                 if (handoffs > this.maxHandoffs) {
-                    this.appendInlineMessage(`I wasn't able to fully complete your request — the task required more hand-offs between specialists than allowed (max: ${this.maxHandoffs}). Please try breaking your request into smaller steps.`);
+                    this.appendInlineMessage(`I wasn't able to fully complete your request — the task required more hand-offs between specialists than allowed. Please try breaking your request into smaller steps.`);
                     break;
                 }
                 handoffSummary = result.summary;

package/dist/esm/main/main.js

@@ -41,6 +41,7 @@ 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 { logger } from '../utils/logger';
+import { filterVisibleMessages, trailingInteractionRow } from '../utils/message-partition';
 import { sumCosts } from '../utils/sum-costs';
 import { expandToolTree } from '../utils/tool-fold';
 import { styles } from './main.styles';
@@ -504,9 +505,13 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         return [];
     }
     /**
-     * Messages filtered by the current toggle state.
-     * Tool-related messages (those with toolCalls or toolResult) are hidden when
-     * `showToolCalls` is false.
+     * Messages rendered in the scrolling list, filtered by the current toggle
+     * state. Tool-related messages (those with toolCalls or toolResult) are hidden
+     * when `showToolCalls` is false.
+     *
+     * Excludes the trailing interaction (see `activeInteractionRow`), which is
+     * rendered in a separate pinned slot so toggling the message filters never
+     * re-creates a live interaction widget.
      *
      * Marked `@volatile` because the filter branches conditionally access
      * `showToolCalls`, `showThinkingSteps`, and `showAgentSwitchIndicator`
@@ -519,28 +524,23 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         const showAgentSwitchIndicator = ((_a = this.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.showAgentSwitchIndicator) != null
             ? this.showAgentSwitchIndicator
             : this.showToolCalls;
-        return this.messages.filter((m) => {
-            var _a, _b, _c;
-            // Agent switch indicators are shown when the toggle is on (or showToolCalls implies it)
-            if (m.role === 'system-event') {
-                return showAgentSwitchIndicator;
-            }
-            // Never show tool messages to the user
-            if (m.role === 'tool') {
-                return false;
-            }
-            // Filter thinking messages based on toggle
-            if (m.thinking && !this.showThinkingSteps) {
-                return false;
-            }
-            // Filter out empty assistant messages that might have slipped through
-            if (m.role === 'assistant' && !((_a = m.content) === null || _a === void 0 ? void 0 : _a.trim()) && !((_b = m.toolCalls) === null || _b === void 0 ? void 0 : _b.length) && !m.interaction) {
-                return false;
-            }
-            const isToolRelated = !!(((_c = m.toolCalls) === null || _c === void 0 ? void 0 : _c.length) || m.toolResult);
-            return !isToolRelated || this.showToolCalls;
+        const { messages } = this;
+        const listed = trailingInteractionRow(messages).length ? messages.slice(0, -1) : messages;
+        return filterVisibleMessages(listed, {
+            showToolCalls: this.showToolCalls,
+            showThinkingSteps: this.showThinkingSteps,
+            showAgentSwitchIndicator,
         });
     }
+    /**
+     * The trailing interaction, rendered in a pinned slot below the scrolling
+     * list rather than inside it. Reads only `messages` (never the toggle state),
+     * so a cog-menu toggle leaves this binding — and the live widget's DOM —
+     * untouched. See `trailingInteractionRow` for the rationale.
+     */
+    get activeInteractionRow() {
+        return trailingInteractionRow(this.messages);
+    }
     agentsChanged() {
         var _a, _b, _c;
         // Guard: driver doesn't exist yet during connectedCallback — createDriver/wireDriver handle that.

package/dist/esm/main/main.template.js

@@ -432,6 +432,7 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
 
       <div class="messages" part="messages" ${ref('messagesEl')}>
         ${repeat((x) => x.visibleMessages, messageRowTemplate)}
+        ${repeat((x) => x.activeInteractionRow, messageRowTemplate)}
         ${when((x) => x.liveSubAgentTrace.length > 0 && x.showToolCalls, liveSubAgentTraceTemplate)}
         ${when((x) => {
         var _a;

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

@@ -16,8 +16,10 @@
  *   there's no reason to pay immutable-reducer cost or flood the Redux DevTools
  *   action log with debug noise.
  *
- * Surfaced under `getDebugLog().meta.events`. Ring-buffered so a long-lived
- * session can't grow the timeline unbounded.
+ * Surfaced in `getDebugLog().timeline`, merged chronologically with messages and
+ * turn snapshots. Ring-buffered — the oldest non-`high` events are evicted first
+ * while `high`-importance failure events are retained — so a long-lived session
+ * stays bounded in normal use without ever dropping a failure signal.
  *
  * @internal
  */
@@ -45,6 +47,7 @@ export const META_EVENT_IMPORTANCE = {
     'state.changed': 'normal',
     'turn.start': 'normal',
     'turn.end': 'normal',
+    'turn.retry': 'normal',
     'agent.handoff': 'normal',
     'agent.pinned': 'normal',
     'agent.unpinned': 'normal',
@@ -57,13 +60,20 @@ export const META_EVENT_IMPORTANCE = {
     'panel.toggled': 'low',
     'attachment.added': 'low',
 };
-/** Default ring-buffer cap. ~5× the turn-snapshot cap — entries are cheap. */
-const DEFAULT_MAX_META_EVENTS = 200;
+/**
+ * Soft ring-buffer cap. Once exceeded, the oldest *non-`high`* event is evicted;
+ * `high`-importance events (failures and hard limits) are never dropped — they're
+ * the whole reason the log exists. So a buffer dominated by `high` events is
+ * allowed to float above this cap rather than lose a failure signal; in normal
+ * use the frequent `low`/`normal` events keep it near the cap. Entries are cheap.
+ */
+const DEFAULT_MAX_META_EVENTS = 400;
 const registry = new Map();
 /**
- * Append a meta event to the timeline for `key`. Evicts the oldest entry once
- * the buffer exceeds {@link DEFAULT_MAX_META_EVENTS}. An empty `key` is bucketed
- * under `''`, matching how drivers/stores handle an absent session identity, so
+ * Append a meta event to the timeline for `key`. Once the buffer exceeds
+ * {@link DEFAULT_MAX_META_EVENTS}, evicts the oldest *non-`high`* event;
+ * `high`-importance events are never evicted. An empty `key` is bucketed under
+ * `''`, matching how drivers/stores handle an absent session identity, so
  * callers never need to guard.
  */
 export function recordMetaEvent(key, type, detail) {
@@ -81,9 +91,34 @@ export function recordMetaEvent(key, type, detail) {
     });
     buffer.next += 1;
     if (buffer.events.length > DEFAULT_MAX_META_EVENTS) {
-        buffer.events.shift();
+        // Drop the oldest event that isn't `high` importance. `high` events
+        // (failures/limits) are retained even past the cap — losing a failure
+        // signal is worse than briefly exceeding the buffer size. If every retained
+        // event is `high` (all-failures session), nothing is evicted and the buffer
+        // grows; in practice frequent `low`/`normal` events keep it bounded.
+        const evictAt = buffer.events.findIndex((e) => e.importance !== 'high');
+        if (evictAt !== -1) {
+            buffer.events.splice(evictAt, 1);
+        }
     }
 }
+/**
+ * Record a turn-ending failure (`turn.error`, importance `high`). The `reason`
+ * is typed so the high-importance triage surface stays consistent; pass any
+ * diagnostic specifics (attempt counts, offending tool names, etc.) in `detail`.
+ */
+export function recordTurnError(key, reason, detail) {
+    recordMetaEvent(key, 'turn.error', Object.assign({ reason }, detail));
+}
+/**
+ * Record a recoverable retry *within* a turn (`turn.retry`, importance `normal`)
+ * — e.g. one malformed/empty attempt that will be retried, as distinct from the
+ * final attempt that bails out as a `turn.error`. Include `attempt`/`maxAttempts`
+ * in `detail` so the timeline shows which try this was.
+ */
+export function recordTurnRetry(key, reason, detail) {
+    recordMetaEvent(key, 'turn.retry', Object.assign({ reason }, detail));
+}
 /** Returns the meta-event timeline for `key`, or an empty array if none recorded. */
 export function getMetaEvents(key) {
     var _a, _b;
@@ -102,8 +137,8 @@ export const DEBUG_LOG_README = [
     "kind:'turn' — one LLM call. `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, file.read-failed, suggestions.failed, context.threshold-crossed), 'normal' (session flow — connects, turns, handoffs, agent/provider changes, interactions), 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. '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.error (a turn failed or hit a guardrail — see detail.reason), tool.failed (a tool threw), 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), context.updated/threshold-crossed (token + cost), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
+    "Each 'event' also has an `importance`: 'high' (failures/limits — turn.error, tool.failed, file.read-failed, suggestions.failed, context.threshold-crossed), 'normal' (session flow — connects, turns, retries, handoffs, agent/provider changes, interactions), 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), 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, finishMessage, unknownTools + availableTools, iterations + limit, or name + message for exceptions), tool.failed (a tool threw), 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), context.updated/threshold-crossed (token + cost), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
     "`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/utils/message-partition.js

@@ -0,0 +1,49 @@
+/**
+ * The trailing interaction to render in a pinned slot, separate from the
+ * filtered list. Empty unless the most recent message carries an interaction.
+ *
+ * Pinning the trailing interaction keeps its widget out of the list's
+ * reconciliation: FAST's `repeat` has no key function and reconciles by array
+ * index, so re-filtering the list (a cog-menu toggle) would otherwise rebind an
+ * existing row to a different message and re-create the live widget — discarding
+ * any in-progress input. The slot's binding reads only `messages` and returns
+ * the same message object across toggles, so the widget's DOM is preserved.
+ *
+ * It is the *trailing* message (resolved or not), not "unresolved only", so that
+ * answering an interaction leaves it in the slot — `resolved` is forwarded in
+ * place with no re-render. It rejoins the list naturally once a newer message
+ * arrives and it is no longer last.
+ */
+export function trailingInteractionRow(messages) {
+    const last = messages[messages.length - 1];
+    return (last === null || last === void 0 ? void 0 : last.interaction) ? [last] : [];
+}
+/**
+ * Filters messages for the scrolling list per the current cog-menu toggles.
+ *
+ * The trailing interaction (see `trailingInteractionRow`) must be removed
+ * before calling, as it is rendered separately.
+ */
+export function filterVisibleMessages(messages, toggles) {
+    return messages.filter((m) => {
+        var _a, _b, _c;
+        // Agent switch indicators show when their toggle is on (or showToolCalls implies it).
+        if (m.role === 'system-event') {
+            return toggles.showAgentSwitchIndicator;
+        }
+        // Tool result messages are never shown to the user.
+        if (m.role === 'tool') {
+            return false;
+        }
+        // Thinking messages follow their own toggle.
+        if (m.thinking && !toggles.showThinkingSteps) {
+            return false;
+        }
+        // Drop empty assistant messages that slipped through.
+        if (m.role === 'assistant' && !((_a = m.content) === null || _a === void 0 ? void 0 : _a.trim()) && !((_b = m.toolCalls) === null || _b === void 0 ? void 0 : _b.length) && !m.interaction) {
+            return false;
+        }
+        const isToolRelated = !!(((_c = m.toolCalls) === null || _c === void 0 ? void 0 : _c.length) || m.toolResult);
+        return !isToolRelated || toggles.showToolCalls;
+    });
+}

package/dist/esm/utils/message-partition.test.js

@@ -0,0 +1,69 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { filterVisibleMessages, trailingInteractionRow, } from './message-partition';
+const msg = (overrides = {}) => (Object.assign({ role: 'assistant', content: '' }, overrides));
+const interaction = (interactionId, resolved = false) => (Object.assign({ interactionId, componentName: 'test-widget', data: {} }, (resolved ? { resolved: { status: 'approved' } } : {})));
+const ALL_ON = {
+    showToolCalls: true,
+    showThinkingSteps: true,
+    showAgentSwitchIndicator: true,
+};
+const ALL_OFF = {
+    showToolCalls: false,
+    showThinkingSteps: false,
+    showAgentSwitchIndicator: false,
+};
+const trailing = createLogicSuite('trailingInteractionRow');
+trailing('is empty when there are no messages', () => {
+    assert.equal(trailingInteractionRow([]), []);
+});
+trailing('is empty when the last message has no interaction', () => {
+    assert.equal(trailingInteractionRow([msg({ content: 'hi' })]), []);
+});
+trailing('returns the last message when it carries an interaction (pending)', () => {
+    const pending = msg({ interaction: interaction('id-a') });
+    assert.equal(trailingInteractionRow([msg({ content: 'q' }), pending]), [pending]);
+});
+trailing('still returns the trailing interaction once it is resolved', () => {
+    // Keeps it in the pinned slot so resolving forwards in place without a rebuild.
+    const resolved = msg({ interaction: interaction('id-a', true) });
+    assert.equal(trailingInteractionRow([resolved]), [resolved]);
+});
+trailing('returns nothing once a newer non-interaction message arrives', () => {
+    // The interaction is no longer last, so it rejoins the scrolling list.
+    const earlier = msg({ interaction: interaction('id-a', true) });
+    assert.equal(trailingInteractionRow([earlier, msg({ content: 'next' })]), []);
+});
+trailing('returns the same message reference (lets FAST short-circuit rebind)', () => {
+    const pending = msg({ interaction: interaction('id-a') });
+    assert.is(trailingInteractionRow([pending])[0], pending);
+});
+const filter = createLogicSuite('filterVisibleMessages');
+filter('hides tool result messages regardless of toggles', () => {
+    const msgs = [msg({ role: 'tool', toolResult: { toolCallId: 't1', content: 'r' } })];
+    assert.equal(filterVisibleMessages(msgs, ALL_ON), []);
+});
+filter('hides tool-call messages when showToolCalls is off, shows them when on', () => {
+    const toolCall = msg({ toolCalls: [{ id: 't1', name: 'do', args: {} }] });
+    assert.equal(filterVisibleMessages([toolCall], ALL_OFF), []);
+    assert.equal(filterVisibleMessages([toolCall], ALL_ON), [toolCall]);
+});
+filter('hides thinking messages when showThinkingSteps is off', () => {
+    const thinking = msg({ thinking: true, content: 'hmm' });
+    assert.equal(filterVisibleMessages([thinking], ALL_OFF), []);
+    assert.equal(filterVisibleMessages([thinking], ALL_ON), [thinking]);
+});
+filter('hides system-event rows unless the agent-switch toggle is on', () => {
+    const event = msg({ role: 'system-event', content: 'switched' });
+    assert.equal(filterVisibleMessages([event], ALL_OFF), []);
+    assert.equal(filterVisibleMessages([event], ALL_ON), [event]);
+});
+filter('drops empty assistant messages', () => {
+    assert.equal(filterVisibleMessages([msg({ content: '   ' })], ALL_ON), []);
+});
+filter('keeps user and non-empty assistant messages with everything off', () => {
+    const user = msg({ role: 'user', content: 'hello' });
+    const reply = msg({ content: 'hi there' });
+    assert.equal(filterVisibleMessages([user, reply], ALL_OFF), [user, reply]);
+});
+trailing.run();
+filter.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/halo-overlay.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/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.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.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/history-transform.ts","../src/utils/index.ts","../src/utils/logger.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/halo-overlay.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/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.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/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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "14.451.1-alpha-3c3e1d3.0",
+  "version": "14.451.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.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/genx": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/rollup-builder": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/ts-builder": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/uvu-playwright-builder": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/vite-builder": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/webpack-builder": "14.451.1-alpha-3c3e1d3.0",
+    "@genesislcap/foundation-testing": "14.451.2",
+    "@genesislcap/genx": "14.451.2",
+    "@genesislcap/rollup-builder": "14.451.2",
+    "@genesislcap/ts-builder": "14.451.2",
+    "@genesislcap/uvu-playwright-builder": "14.451.2",
+    "@genesislcap/vite-builder": "14.451.2",
+    "@genesislcap/webpack-builder": "14.451.2",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/foundation-logger": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/foundation-redux": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/foundation-ui": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/foundation-utils": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/rapid-design-system": "14.451.1-alpha-3c3e1d3.0",
-    "@genesislcap/web-core": "14.451.1-alpha-3c3e1d3.0",
+    "@genesislcap/foundation-ai": "14.451.2",
+    "@genesislcap/foundation-logger": "14.451.2",
+    "@genesislcap/foundation-redux": "14.451.2",
+    "@genesislcap/foundation-ui": "14.451.2",
+    "@genesislcap/foundation-utils": "14.451.2",
+    "@genesislcap/rapid-design-system": "14.451.2",
+    "@genesislcap/web-core": "14.451.2",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },
@@ -93,5 +93,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "71f52da6801da778a24804715814985bf09b074c"
+  "gitHead": "44a0946f3ff1f184fd6fd8f877108b0dbaf2d9e0"
 }