@genesislcap/ai-assistant 14.479.0 → 14.480.0

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

@@ -1,4 +1,4 @@
-import { __awaiter } from "tslib";
+import { __awaiter, __rest } from "tslib";
 import { isObservableAIProviderRegistry, MalformedFunctionCallError, ResponseTruncatedError, } from '@genesislcap/foundation-ai';
 import { agenticActivityBus } from '../../channel/ai-activity-bus';
 import { resolveChatProvider } from '../../config/validate-providers';
@@ -76,6 +76,13 @@ export class ChatDriver extends EventTarget {
         /** Epoch ms when the current turn loop began — drives the `turn.end` duration. */
         this.turnStartedAt = 0;
         this.pendingInteractions = new Map();
+        // GENC-1410 (Error 3): when several assistant views share this one driver (e.g. a bubble and a
+        // docked panel), each interaction's widget must be rendered live — and thus fire any side
+        // effect — on exactly ONE view. These fields elect that owner and de-dupe execution.
+        /** Assistant host ids currently wired to this driver, in registration (insertion) order. */
+        this.hosts = new Set();
+        /** Interaction id → host id that claimed its side effect (first-writer-wins latch). */
+        this.startedSideEffects = new Map();
         /**
          * Tool-declared condensation policies, keyed by tool-call id. Populated by
          * `condenseWhen` (first-wins per call); read by `applyCondensation` before each
@@ -761,6 +768,53 @@ export class ChatDriver extends EventTarget {
     isBusy() {
         return this.busy;
     }
+    // --- GENC-1410 (Error 3): single-instance execution of side-effecting widgets --------------
+    /** Register an assistant view (host) wired to this shared driver. @internal */
+    registerHost(hostId) {
+        this.hosts.add(hostId);
+    }
+    /** Deregister a host on unwire/disconnect. @internal */
+    unregisterHost(hostId) {
+        this.hosts.delete(hostId);
+    }
+    /**
+     * Record the host whose subtree the user most recently interacted in — the primary signal for
+     * electing which single view renders an interaction's widget. Sticky (unlike focus): it only
+     * moves when the user actually uses a different assistant view, not when they click elsewhere
+     * in the layout. @internal
+     */
+    setActiveHost(hostId) {
+        this.lastActiveHostId = hostId;
+    }
+    /**
+     * First-writer-wins latch guarding a side effect. A host claims before rendering the live
+     * widget: the first host to claim an interaction id gets `true` (run it); a *different* host
+     * gets `false` (render passive, do NOT re-fire). Re-claim by the SAME host returns `true`, so a
+     * benign re-render of the owner keeps its widget. Single-threaded, so check-and-set is race-free
+     * — the backstop that makes duplicate execution impossible even if owner election ever slips. @internal
+     */
+    claimSideEffect(interactionId, hostId) {
+        const existing = this.startedSideEffects.get(interactionId);
+        if (existing === undefined) {
+            this.startedSideEffects.set(interactionId, hostId);
+            return true;
+        }
+        return existing === hostId;
+    }
+    /**
+     * Elect the single host that owns (renders + runs) an interaction's widget: the most-recently-
+     * active host if still connected, else a deterministic default (first registered host — `Set`
+     * preserves insertion order) so exactly one owner is always chosen. Returns `undefined` only when
+     * no host is registered, in which case the interaction renders everywhere (fail-open) not nowhere.
+     */
+    electInteractionOwner() {
+        if (this.lastActiveHostId && this.hosts.has(this.lastActiveHostId)) {
+            return this.lastActiveHostId;
+        }
+        // First registered host (`Set` preserves insertion order); `undefined` when none.
+        const [firstHost] = this.hosts;
+        return firstHost;
+    }
     /**
      * Wire a parent driver as the host for this driver's interactions. When set,
      * `requestInteraction` delegates upward so the widget renders in (and
@@ -803,6 +857,10 @@ export class ChatDriver extends EventTarget {
             const chatInputDuringExecution = options === null || options === void 0 ? void 0 : options.chatInputDuringExecution;
             const timeoutMs = options === null || options === void 0 ? void 0 : options.timeoutMs;
             const presentation = options === null || options === void 0 ? void 0 : options.presentation;
+            // GENC-1410 (Error 3): a widget is rendered live by exactly one host. Elect the owner now
+            // (most-recently-active host, deterministic fallback) and stamp it on the interaction so every
+            // host can compare its own id and render passively when it differs — one server call, not N.
+            const ownerHostId = this.electInteractionOwner();
             return new Promise((resolve, reject) => {
                 this.pendingInteractions.set(interactionId, {
                     resolve,
@@ -839,9 +897,9 @@ export class ChatDriver extends EventTarget {
                 this.appendToHistory({
                     role: 'assistant',
                     content: '',
-                    interaction: Object.assign({ interactionId,
+                    interaction: Object.assign(Object.assign({ interactionId,
                         componentName,
-                        data }, (presentation ? { presentation } : {})),
+                        data }, (presentation ? { presentation } : {})), (ownerHostId ? { ownerHostId } : {})),
                 });
             });
         });
@@ -895,6 +953,8 @@ export class ChatDriver extends EventTarget {
             agenticActivityBus.publish('interaction-resolved', undefined);
             interaction.resolve(result);
             this.pendingInteractions.delete(interactionId);
+            // GENC-1410: release the side-effect claim so a re-request with a fresh id starts clean.
+            this.startedSideEffects.delete(interactionId);
         }
         else {
             logger.warn(`Interaction with ID ${interactionId} not found.`);
@@ -1764,12 +1824,32 @@ export class ChatDriver extends EventTarget {
                     }
                     return { reason: 'done' };
                 }
-                else if (isThinkingStep) {
-                    this.appendToHistory(Object.assign(Object.assign({}, response), { toolCalls: undefined, thinking: true }));
-                    this.appendToHistory(Object.assign(Object.assign({}, response), { content: '' }));
-                }
                 else {
-                    this.appendToHistory(response);
+                    // Split one model response into separate, individually-toggleable messages so each has its
+                    // own visibility toggle and debug-log category:
+                    //   - reasoning (chain-of-thought summary) → category 'reasoning', hidden unless showThinkingSteps
+                    //   - narration (interstitial prose emitted alongside a tool call) → category 'narration',
+                    //     hidden unless showNarration
+                    //   - the answer / tool-call message → always shown; carries this turn's usage.
+                    // Cost invariant (GENC-1410): exactly ONE message carries cost/tokens and is appended LAST, so
+                    // `sumCosts`/`sumTokens` don't double-count and `contextTokens` reads it. Reasoning/narration are
+                    // display-only (usage undefined) and are skipped when building the provider request. `model` /
+                    // `provider` / `providerName` stay on every split message so each is still attributed.
+                    const { reasoning } = response, rest = __rest(response, ["reasoning"]);
+                    const displayOnly = { cost: undefined, inputTokens: undefined, outputTokens: undefined };
+                    if (reasoning) {
+                        this.appendToHistory(Object.assign(Object.assign(Object.assign({}, rest), displayOnly), { content: reasoning, toolCalls: undefined, category: 'reasoning' }));
+                    }
+                    if (isThinkingStep) {
+                        // content + tool call → the content is interstitial narration, not the final answer.
+                        this.appendToHistory(Object.assign(Object.assign(Object.assign({}, rest), displayOnly), { toolCalls: undefined, category: 'narration' }));
+                        this.appendToHistory(Object.assign(Object.assign({}, rest), { content: '' }));
+                    }
+                    else {
+                        // No tool call → `content` is the final answer (always shown), or this is a bare tool-call
+                        // turn with no narration. Either way it carries this turn's usage; append it last.
+                        this.appendToHistory(rest);
+                    }
                 }
                 // Reset retry budgets on any productive (non-empty) response, so the caps mean
                 // "N CONSECUTIVE failures" not "N total per turn".

package/dist/esm/components/chat-driver/chat-driver.test.js

@@ -3,6 +3,8 @@ import { isChatToolCallUnknown } from '@genesislcap/foundation-ai';
 import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
 import { agenticActivityBus } from '../../channel/ai-activity-bus';
 import { clearMetaEventRegistry, getMetaEvents } from '../../state/debug-event-log';
+import { sumCosts } from '../../utils/sum-costs';
+import { sumTokens } from '../../utils/sum-tokens';
 import { createToolFold } from '../../utils/tool-fold';
 // Side-effect import — MUST come before `./chat-driver` so the driver subclasses
 // jsdom's EventTarget rather than Node's native one (see the file). None of the
@@ -773,6 +775,63 @@ subagent('times out (without hanging) when the sub-agent is parked on a user int
 }));
 subagent.run();
 // ---------------------------------------------------------------------------
+// cost / token attribution on the thinking-step split (GENC-1410)
+// ---------------------------------------------------------------------------
+const costAttribution = createLogicSuite('ChatDriver cost attribution (thinking-step split)');
+costAttribution('a text-plus-tool-call response contributes its cost and tokens exactly once', () => __awaiter(void 0, void 0, void 0, function* () {
+    const config = agent({
+        name: 'Worker',
+        toolDefinitions: () => [def('do_thing')],
+        toolHandlers: () => ({ do_thing: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) }),
+    });
+    // A single response that emits reasoning + interstitial narration + a tool call, carrying that
+    // response's usage. The driver splits it into three messages — a `reasoning` bubble, a
+    // `narration` bubble, and the tool-call message — but only ONE may carry the cost/tokens or the
+    // session totals double-count this one response (GENC-1410).
+    const provider = scriptedProvider([
+        {
+            role: 'assistant',
+            content: 'Let me act.',
+            reasoning: 'Let me think.',
+            toolCalls: [{ id: 't1', name: 'do_thing', args: {} }],
+            cost: 0.05,
+            inputTokens: 1000,
+            outputTokens: 50,
+        },
+        // Turn-ending reply (no tool calls, no usage) so the loop terminates cleanly.
+        { role: 'assistant', content: 'Done.' },
+    ]);
+    const driver = makeDriver(config, provider);
+    yield driver.sendMessage('go');
+    const history = driver.getHistory();
+    const reasoning = history.find((m) => m.category === 'reasoning');
+    const narration = history.find((m) => m.category === 'narration');
+    const toolCallMsg = history.find((m) => { var _a; return (_a = m.toolCalls) === null || _a === void 0 ? void 0 : _a.some((c) => c.name === 'do_thing'); });
+    // The one response was split into reasoning + narration bubbles + the tool-call message.
+    assert.ok(reasoning, 'a reasoning bubble is emitted for the chain-of-thought summary');
+    assert.is(reasoning.content, 'Let me think.');
+    assert.ok(narration, 'a narration bubble is emitted for the interstitial prose');
+    assert.is(narration.content, 'Let me act.');
+    assert.ok(toolCallMsg, 'the tool call is on its own message');
+    assert.is(toolCallMsg.content, '');
+    // Only the tool-call message carries the turn's usage; the display bubbles carry none.
+    for (const m of [reasoning, narration]) {
+        assert.is(m.cost, undefined, 'a display bubble must not carry cost');
+        assert.is(m.inputTokens, undefined, 'nor inputTokens');
+        assert.is(m.outputTokens, undefined, 'nor outputTokens');
+    }
+    assert.is(toolCallMsg.cost, 0.05, 'the tool-call message carries the cost');
+    assert.is(toolCallMsg.inputTokens, 1000);
+    assert.is(toolCallMsg.outputTokens, 50);
+    // The reasoning/narration bubbles are UI-only; they must not carry the tool call either.
+    assert.is(reasoning.toolCalls, undefined, 'the reasoning bubble carries no tool call');
+    assert.is(narration.toolCalls, undefined, 'the narration bubble carries no tool call');
+    // The session totals count the one response once, not twice.
+    assert.is(sumCosts(history), 0.05, 'cost is summed once');
+    assert.is(sumTokens(history), 1050, 'tokens are summed once');
+}));
+costAttribution.run();
+// ---------------------------------------------------------------------------
 // per-agent / per-state temperature & tool-call mode (GENC-1321)
 //
 // The driver resolves `temperature` and `toolChoice` the same way it resolves
@@ -972,6 +1031,51 @@ interactionPresentation('presentation is absent when the option is omitted', ()
 }));
 interactionPresentation.run();
 // ---------------------------------------------------------------------------
+// single-instance interaction ownership (GENC-1410 Error 3) — when several views
+// share one driver, each interaction's widget is rendered/run by exactly one host.
+// The driver elects the owner (most-recently-active host, deterministic fallback),
+// stamps `ownerHostId` on every interaction, and de-dupes execution via a
+// first-writer claim.
+// ---------------------------------------------------------------------------
+const ownedInteraction = createLogicSuite('ChatDriver single-instance interaction ownership');
+ownedInteraction('stamps ownerHostId = most-recently-active host on the interaction', () => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
+    driver.registerHost('host-a');
+    driver.registerHost('host-b');
+    driver.setActiveHost('host-b');
+    const pending = driver.requestInteraction('w', {});
+    const interaction = driver.getHistory().at(-1).interaction;
+    assert.is(interaction.ownerHostId, 'host-b', 'owner is the most-recently-active host');
+    driver.resolveInteraction(interaction.interactionId, { status: 'approved' });
+    yield pending;
+}));
+ownedInteraction('owner falls back to the first-registered host when none is active yet', () => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
+    driver.registerHost('host-a');
+    driver.registerHost('host-b');
+    // No setActiveHost — startup, before the user has engaged a view.
+    const pending = driver.requestInteraction('w', {});
+    const interaction = driver.getHistory().at(-1).interaction;
+    assert.is(interaction.ownerHostId, 'host-a', 'deterministic default = first registered');
+    driver.resolveInteraction(interaction.interactionId, { status: 'approved' });
+    yield pending;
+}));
+ownedInteraction('no host registered → no owner (widget renders everywhere, fail-open)', () => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
+    const pending = driver.requestInteraction('w', {});
+    const interaction = driver.getHistory().at(-1).interaction;
+    assert.ok(!('ownerHostId' in interaction), 'no owner stamped when no host is registered');
+    driver.resolveInteraction(interaction.interactionId, { status: 'approved' });
+    yield pending;
+}));
+ownedInteraction('claimSideEffect is first-writer-wins, and re-entrant for the same host', () => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
+    assert.is(driver.claimSideEffect('i1', 'host-a'), true, 'first host claims it');
+    assert.is(driver.claimSideEffect('i1', 'host-b'), false, 'a different host is denied');
+    assert.is(driver.claimSideEffect('i1', 'host-a'), true, 're-claim by the owner (re-render) is fine');
+}));
+ownedInteraction.run();
+// ---------------------------------------------------------------------------
 // interaction activity-bus signals (GENC-1346) — the driver brackets a parked
 // widget interaction with `interaction-requested` / `interaction-resolved`, so
 // turn-aware UI can distinguish "actively computing" from "parked awaiting the

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

@@ -18,6 +18,13 @@ let AiChatInteractionWrapper = class AiChatInteractionWrapper extends GenesisEle
         this.interactionId = '';
         /** The resolved result once the interaction has completed. Forwarded to the rendered component. @internal */
         this.resolved = undefined;
+        /**
+         * GENC-1410 (Error 3): id of the host the driver elected to render (and thus run) this
+         * interaction. When several views share one driver, only the matching host renders the live
+         * widget; others show a passive placeholder so the widget fires once. Empty = no owner elected
+         * (single view, or none registered) → render everywhere (fail-open). @internal
+         */
+        this.ownerHostId = '';
     }
     connectedCallback() {
         super.connectedCallback();
@@ -46,11 +53,19 @@ let AiChatInteractionWrapper = class AiChatInteractionWrapper extends GenesisEle
         this.renderComponent();
     }
     resolvedChanged() {
-        var _a;
+        var _a, _b;
         const element = (_a = this.container) === null || _a === void 0 ? void 0 : _a.firstElementChild;
-        if (element) {
+        // GENC-1410 (Error 3): a non-owner view rendered a passive placeholder for the unresolved
+        // exclusive widget. Now it's resolved (no side effect left to fire), so render the real widget
+        // — the gate below is keyed on `!resolved`, so this instantiates the resolved widget and every
+        // view shows the outcome. The owner already has the live widget: just forward `resolved` to it,
+        // preserving its DOM/state (no re-create).
+        if (element && ((_b = element.tagName) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === this.componentName) {
             element.resolved = this.resolved;
         }
+        else if (this.resolved) {
+            this.renderComponent();
+        }
     }
     /**
      * Watch the rendered widget element for box-size changes. When the widget
@@ -94,17 +109,41 @@ let AiChatInteractionWrapper = class AiChatInteractionWrapper extends GenesisEle
             return;
         }
         try {
+            // Pierce the wrapper's shadow boundary to read state from the assistant host.
+            const root = this.getRootNode();
+            const host = root instanceof ShadowRoot
+                ? root.host
+                : null;
+            // GENC-1410 (Error 3): a widget must run on exactly ONE view. When several views share one
+            // driver, render the live widget only if this host is the elected owner AND wins the
+            // first-writer claim; otherwise show a passive placeholder and do NOT instantiate the widget
+            // (whose connectedCallback would fire a duplicate server call). A single-view app has no owner
+            // (or owns it) so it always renders. Resolved interactions always render (display only, no
+            // side effect) so state survives a pop.
+            if (!this.resolved) {
+                const isOwner = !this.ownerHostId || (host === null || host === void 0 ? void 0 : host.hostId) === this.ownerHostId;
+                // Only the elected owner attempts the claim. A non-owner must NEVER touch the latch: both
+                // views render the same history, so if a non-owner view (e.g. the hidden bubble while the
+                // panel is docked) renders its wrapper first, claiming here would grab the first-writer latch
+                // and the owner's own claim would then return false — leaving BOTH views on the placeholder,
+                // so the widget's side effect never fires (the interaction shows blank and hangs forever).
+                // Gating the claim behind `isOwner` makes the outcome independent of inter-host render order.
+                const claimed = isOwner && ((host === null || host === void 0 ? void 0 : host.claimSideEffect) ? host.claimSideEffect(this.interactionId) : true);
+                if (!claimed) {
+                    const placeholder = document.createElement('div');
+                    placeholder.className = 'interaction-running-elsewhere';
+                    this.container.appendChild(placeholder);
+                    return;
+                }
+            }
             const element = document.createElement(this.componentName);
             // Pass data and resolved state to the component
             if (this.data) {
                 element.data = this.data;
             }
             element.resolved = this.resolved;
-            // Pierce the wrapper's shadow boundary to read engagement from the
-            // assistant host. False if the widget is already resolved — re-renders
+            // Engagement gates autofocus. False if the widget is already resolved — re-renders
             // from history (layout remount, dock/undock) must never steal focus.
-            const root = this.getRootNode();
-            const host = root instanceof ShadowRoot ? root.host : null;
             element.shouldAutoFocus = !this.resolved && !!(host === null || host === void 0 ? void 0 : host.isEngaged);
             // Handle completion from the inner component.
             // Guard against re-emission if the interaction was already resolved
@@ -138,6 +177,9 @@ __decorate([
 __decorate([
     observable
 ], AiChatInteractionWrapper.prototype, "resolved", void 0);
+__decorate([
+    observable
+], AiChatInteractionWrapper.prototype, "ownerHostId", void 0);
 AiChatInteractionWrapper = __decorate([
     customElement({
         name: 'ai-chat-interaction-wrapper',

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

@@ -74,4 +74,66 @@ Suite('forwards resolved in place without rebuilding the widget', (_a) => __awai
     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');
 }));
+/**
+ * GENC-1410 (Error 3): two assistant views (a floating bubble and a docked panel)
+ * share one driver and render the same history, so both mount a wrapper for the
+ * same interaction. Exactly one — the elected owner — must render the live widget
+ * and win the driver's first-writer side-effect latch; the other renders a passive
+ * placeholder. Regression: the claim used to be computed for EVERY host, so if a
+ * non-owner view rendered its wrapper first it grabbed the latch, and the owner's
+ * own claim then returned false — leaving BOTH views on the placeholder so the
+ * widget's side effect never fired (blank + stuck). The claim must be gated behind
+ * ownership, making the outcome independent of inter-host render order.
+ */
+/** First-writer-wins latch, mirroring `ChatDriver.claimSideEffect`. */
+function makeSharedLatch() {
+    const started = new Map();
+    return (interactionId, hostId) => {
+        const existing = started.get(interactionId);
+        if (existing === undefined) {
+            started.set(interactionId, hostId);
+            return true;
+        }
+        return existing === hostId;
+    };
+}
+/**
+ * Mount a wrapper inside a shadow host that exposes `hostId` + a shared claim,
+ * mimicking one `gc-assistant` view. The wrapper reads these across its shadow
+ * boundary via `getRootNode().host`, so a real ShadowRoot host is required.
+ */
+function mountWrapperInHost(hostId, ownerHostId, interactionId, claim) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const hostEl = document.createElement('div');
+        const shadow = hostEl.attachShadow({ mode: 'open' });
+        hostEl.hostId = hostId;
+        hostEl.isEngaged = true;
+        hostEl.claimSideEffect = (id) => claim(id, hostId);
+        const wrapper = document.createElement('ai-chat-interaction-wrapper');
+        shadow.appendChild(wrapper);
+        document.body.appendChild(hostEl);
+        yield DOM.nextUpdate();
+        wrapper.ownerHostId = ownerHostId;
+        wrapper.data = { label: 'q' };
+        wrapper.interactionId = interactionId;
+        wrapper.componentName = FAKE_WIDGET;
+        yield DOM.nextUpdate();
+        return { hostEl, wrapper };
+    });
+}
+Suite('a non-owner host does not poison the side-effect claim when it renders first', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const claim = makeSharedLatch();
+    const ownerId = 'owner-host';
+    const otherId = 'other-host';
+    const interactionId = 'id-x';
+    // The NON-owner (e.g. the hidden bubble) renders FIRST — the race that used to poison the latch.
+    const other = yield mountWrapperInHost(otherId, ownerId, interactionId, claim);
+    // The elected owner renders SECOND.
+    const owner = yield mountWrapperInHost(ownerId, ownerId, interactionId, claim);
+    assert.equal((_a = other.wrapper.container.firstElementChild) === null || _a === void 0 ? void 0 : _a.className, 'interaction-running-elsewhere', 'the non-owner view renders the passive placeholder');
+    assert.equal((_c = (_b = owner.wrapper.container.firstElementChild) === null || _b === void 0 ? void 0 : _b.tagName) === null || _c === void 0 ? void 0 : _c.toLowerCase(), FAKE_WIDGET, 'the owner renders the live widget even though the non-owner rendered first');
+    other.hostEl.remove();
+    owner.hostEl.remove();
+}));
 Suite.run();

package/dist/esm/components/flowing-waves-indicator.js

@@ -20,6 +20,18 @@ const EDGE = 0.16;
 const MORPH_SPEED = 3;
 /** Global multiplier on the harmonic frequencies — raise for narrower peaks. */
 const FREQ_SCALE = 2;
+/** Milliseconds in one second. */
+const MS_PER_SECOND = 1000;
+/** Baseline frame rate (fps) the harmonic speeds are tuned against. */
+const BASELINE_FPS = 60;
+/**
+ * Frame duration (ms) at the baseline rate. The morph is driven by elapsed
+ * wall-clock time divided by this — not by the rAF callback count — so it
+ * advances at a constant real-world rate regardless of the display's refresh
+ * rate or dropped frames. At the baseline rate the resulting frame index
+ * matches the old per-callback counter, preserving the current look.
+ */
+const FRAME_MS = MS_PER_SECOND / BASELINE_FPS;
 /**
  * Half-thickness (viewBox units) each band keeps even between peaks, so the
  * waves emerge from a continuous line rather than leaving gaps. The four bands
@@ -88,13 +100,6 @@ const bandLayersMarkup = BANDS.map((_b, i) => `<svg class="layer band-layer" vie
  * @beta
  */
 let AiFlowingWavesIndicator = AiFlowingWavesIndicator_1 = class AiFlowingWavesIndicator extends GenesisElement {
-    constructor() {
-        // A rAF loop morphs the band shapes: pure CSS can't continuously reshape the
-        // bumps (different sizes appearing at different times), and the per-frame sine
-        // sums are cheap. Same approach as the sine-tracing waves indicator.
-        super(...arguments);
-        this.frame = 0;
-    }
     connectedCallback() {
         super.connectedCallback();
         // Guard against a reconnect starting a second concurrent loop.
@@ -108,8 +113,10 @@ let AiFlowingWavesIndicator = AiFlowingWavesIndicator_1 = class AiFlowingWavesIn
             cancelAnimationFrame(this.animFrame);
             this.animFrame = undefined;
         }
+        // Reset the clock so a later reconnect restarts the morph cleanly at frame 0.
+        this.startTime = undefined;
     }
-    tick() {
+    tick(now) {
         var _a, _c;
         // Stop ticking once disconnected (belt-and-braces alongside the cancel in
         // disconnectedCallback) so no frames are scheduled while detached.
@@ -122,13 +129,17 @@ let AiFlowingWavesIndicator = AiFlowingWavesIndicator_1 = class AiFlowingWavesIn
             if (paths === null || paths === void 0 ? void 0 : paths.length)
                 this.bandPaths = Array.from(paths);
         }
+        // Anchor to the first real rAF timestamp; the initial synchronous call (no
+        // timestamp) renders frame 0. `frame` is then elapsed time in 60fps frames.
+        if (now !== undefined && this.startTime === undefined)
+            this.startTime = now;
+        const frame = now === undefined || this.startTime === undefined ? 0 : (now - this.startTime) / FRAME_MS;
         (_c = this.bandPaths) === null || _c === void 0 ? void 0 : _c.forEach((path, i) => {
             const cfg = BANDS[i];
             if (cfg)
-                path.setAttribute('d', AiFlowingWavesIndicator_1.buildBand(cfg, this.frame));
+                path.setAttribute('d', AiFlowingWavesIndicator_1.buildBand(cfg, frame));
         });
-        this.frame += 1;
-        this.animFrame = requestAnimationFrame(() => this.tick());
+        this.animFrame = requestAnimationFrame((t) => this.tick(t));
     }
     /**
      * Trace one band for the given frame: a baseline-plus-harmonics half-thickness

package/dist/esm/components/halo-overlay.js

@@ -6,6 +6,17 @@ const HALO_DEFAULT_SPEED = 1.5;
 const HALO_DEFAULT_BORDER_SIZE = 3;
 const HALO_DEFAULT_GLOW_OPACITY = 0.35;
 const HALO_DEFAULT_GLOW_SPREAD = 70;
+/** Milliseconds in one second. */
+const MS_PER_SECOND = 1000;
+/** Baseline frame rate (fps) the `speed` (degrees/frame) is calibrated against. */
+const BASELINE_FPS = 60;
+/**
+ * Frame duration (ms) at the baseline rate. Rotation advances by the elapsed
+ * wall-clock time divided by this — not a fixed step per rAF callback — so it
+ * holds a constant real-world speed regardless of the display's refresh rate or
+ * dropped frames.
+ */
+const FRAME_MS = MS_PER_SECOND / BASELINE_FPS;
 /**
  * Animated halo overlay — rotating conic-gradient border with an inward glow.
  *
@@ -52,14 +63,27 @@ let AiHaloOverlay = AiHaloOverlay_1 = class AiHaloOverlay extends GenesisElement
         super.disconnectedCallback();
         if (this.animFrame !== undefined) {
             cancelAnimationFrame(this.animFrame);
+            this.animFrame = undefined;
         }
+        // Reset the clock so a later reconnect doesn't apply one huge time delta.
+        this.lastTime = undefined;
     }
-    tick() {
-        const step = this.direction === 'ccw' ? -this.speed : this.speed;
-        this.angle =
-            (this.angle + step + AiHaloOverlay_1.FULL_ROTATION_DEG) % AiHaloOverlay_1.FULL_ROTATION_DEG;
-        this.style.setProperty('--halo-angle', `${this.angle}deg`);
-        this.animFrame = requestAnimationFrame(() => this.tick());
+    tick(now) {
+        // Advance by elapsed wall-clock time (expressed in 60fps-equivalent frames)
+        // rather than a fixed step per callback, so the rotation runs at a constant
+        // real-world speed regardless of the display's refresh rate or dropped
+        // frames. The first tick just seeds the clock (no delta yet).
+        if (this.lastTime !== undefined && now !== undefined) {
+            const frames = (now - this.lastTime) / FRAME_MS;
+            const step = this.direction === 'ccw' ? -this.speed : this.speed;
+            const raw = this.angle + step * frames;
+            this.angle =
+                ((raw % AiHaloOverlay_1.FULL_ROTATION_DEG) + AiHaloOverlay_1.FULL_ROTATION_DEG) %
+                    AiHaloOverlay_1.FULL_ROTATION_DEG;
+            this.style.setProperty('--halo-angle', `${this.angle}deg`);
+        }
+        this.lastTime = now;
+        this.animFrame = requestAnimationFrame((t) => this.tick(t));
     }
 };
 // TODO: The rAF loop is fine for demos but has two drawbacks vs a pure CSS @property animation:

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

@@ -132,6 +132,20 @@ export class OrchestratingDriver extends EventTarget {
     isBusy() {
         return this.chatDriver.isBusy();
     }
+    // GENC-1410 (Error 3): forward single-instance / side-effect coordination to the inner driver,
+    // which owns the interaction history and pending map.
+    registerHost(hostId) {
+        this.chatDriver.registerHost(hostId);
+    }
+    unregisterHost(hostId) {
+        this.chatDriver.unregisterHost(hostId);
+    }
+    setActiveHost(hostId) {
+        this.chatDriver.setActiveHost(hostId);
+    }
+    claimSideEffect(interactionId, hostId) {
+        return this.chatDriver.claimSideEffect(interactionId, hostId);
+    }
     /** Currently active provider name from the underlying ChatDriver. */
     getActiveProviderName() {
         return this.chatDriver.getActiveProviderName();

package/dist/esm/components/settings-modal/settings-modal.styles.js

@@ -127,6 +127,13 @@ export const settingsModalStyles = css `
     gap: calc(var(--design-unit) * 2px);
   }
 
+  .settings-modal-section-note {
+    margin: calc(var(--design-unit) * -2px) 0 calc(var(--design-unit) * 3px);
+    font-size: 12px;
+    line-height: 1.5;
+    color: var(--neutral-foreground-hint);
+  }
+
   .settings-modal-section-body {
     display: flex;
     flex-direction: column;

package/dist/esm/components/settings-modal/settings-modal.template.js

@@ -116,16 +116,12 @@ const chatBotSettingsTemplate = (switchTag, buttonTag) => html `
   ${when((x) => { var _a; return ((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.showThinkingSteps) != null; }, chatBotToggleRow('Show thinking', "Reveal the assistant's reasoning as it works through your request, surfacing its intermediate thought process before it commits to a response.", switchTag, 'toggle-thinking', (x) => x.showThinkingSteps, (x, c) => {
     x.showThinkingSteps = readSwitchChecked(c.event);
 }))}
-  ${when((x) => { var _a; return ((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.showAgentSwitchIndicator) != null; }, chatBotToggleRow('Enable agents', 'Show in the chat window when tasks are delegated to different agents.', switchTag, 'toggle-agent-switch', (x) => x.showAgentSwitchIndicator, (x, c) => {
+  ${when((x) => { var _a; return ((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.showNarration) != null; }, chatBotToggleRow('Show working', "Show the assistant's running commentary — the short notes it writes alongside its actions as it works, separate from its reasoning and its final answer.", switchTag, 'toggle-narration', (x) => x.showNarration, (x, c) => {
+    x.showNarration = readSwitchChecked(c.event);
+}))}
+  ${when((x) => { var _a; return ((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.showAgentSwitchIndicator) != null; }, chatBotToggleRow('Show delegation', 'Show in the chat window when tasks are delegated to different agents.', switchTag, 'toggle-agent-switch', (x) => x.showAgentSwitchIndicator, (x, c) => {
     x.showAgentSwitchIndicator = readSwitchChecked(c.event);
 }))}
-  ${when((x) => { var _a; return ((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.allowDebugDownload) === true; }, settingsToggleRow('Download agent log', "Export a structured debug timeline of this session's agent activity.", 'download-agent-log', html `
-        <${buttonTag}
-          part="download-button"
-          appearance="outline"
-          @click=${(x) => x.downloadDebugLog()}
-        >Download</${buttonTag}>
-      `))}
   ${when((x) => { var _a, _b; return ((_b = (_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.animations) === null || _b === void 0 ? void 0 : _b.userConfigurable) === true; }, settingsToggleRow('Animations', 'Choose which loading and activity indicators appear while the assistant is working.', 'toggle-animations', animationsPickerTemplate(switchTag), 'column'))}
 `;
 const appSettingsTemplate = (switchTag) => html `
@@ -316,10 +312,24 @@ export const SettingsModalTemplate = (designSystemPrefix) => {
           ${appSettingsTemplate(switchTag)}
         </div>
       </section>
+      ${when((x) => { var _a; return ((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.allowDebugDownload) === true; }, html `
+          <section class="settings-modal-section" part="settings-section-agent-log">
+            <div class="settings-modal-section-body">
+              ${settingsToggleRow('Download agent log', "Export a structured debug timeline of this session's agent activity.", 'download-agent-log', html `
+                  <${buttonTag}
+                    part="download-button"
+                    appearance="outline"
+                    @click=${(x) => x.downloadDebugLog()}
+                  >Download</${buttonTag}>
+                `)}
+            </div>
+          </section>
+        `)}
       <section class="settings-modal-section" part="settings-section-chat">
         <h3 class="settings-modal-section-title">
           <${iconTag} name="comment"></${iconTag}> AI Chat Bot Settings
         </h3>
+        <p class="settings-modal-section-note">These options only control what you see in the chat window and do not control model behaviour.</p>
         <div class="settings-modal-section-body">
           ${chatBotSettingsTemplate(switchTag, buttonTag)}
         </div>