@genesislcap/ai-assistant 14.479.0 → 14.480.0

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

@@ -12,6 +12,18 @@ const VIEWBOX = 120;
 const CENTRE = VIEWBOX / 2;
 /** Horizontal sampling step when tracing each wave path. Lower = smoother. */
 const SAMPLE_STEP = 6;
+/** Milliseconds in one second. */
+const MS_PER_SECOND = 1000;
+/** Baseline frame rate (fps) the wave speeds are tuned against. */
+const BASELINE_FPS = 60;
+/**
+ * Frame duration (ms) at the baseline rate. The paths are driven by elapsed
+ * wall-clock time divided by this — not by the rAF callback count — so they
+ * advance 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;
 const WAVES = [
     {
         colour: AI_COLOUR_AMBER,
@@ -75,10 +87,6 @@ let AiWavesIndicator = AiWavesIndicator_1 = class AiWavesIndicator extends Genes
         super(...arguments);
         /** Diameter of the circular window in px. Default: 56. */
         this.size = WAVES_DEFAULT_SIZE;
-        // A rAF loop drives the wave paths for the same reason `<ai-halo-overlay>`
-        // hand-drives its rotation: a pure-CSS approach can't produce per-frame sine
-        // geometry, and SMIL/`<animate>` can't express the combined travel + slosh.
-        this.frame = 0;
     }
     sizeChanged() {
         this.style.setProperty('--waves-size', `${this.size}px`);
@@ -96,8 +104,10 @@ let AiWavesIndicator = AiWavesIndicator_1 = class AiWavesIndicator extends Genes
             cancelAnimationFrame(this.animFrame);
             this.animFrame = undefined;
         }
+        // Reset the clock so a later reconnect restarts the waves cleanly at frame 0.
+        this.startTime = undefined;
     }
-    tick() {
+    tick(now) {
         var _a, _b;
         // Stop ticking once disconnected (belt-and-braces alongside the cancel in
         // disconnectedCallback) so no frames are scheduled while detached.
@@ -110,11 +120,15 @@ let AiWavesIndicator = AiWavesIndicator_1 = class AiWavesIndicator extends Genes
             if (paths === null || paths === void 0 ? void 0 : paths.length)
                 this.wavePaths = 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;
         (_b = this.wavePaths) === null || _b === void 0 ? void 0 : _b.forEach((path, i) => {
-            path.setAttribute('d', AiWavesIndicator_1.buildWavePath(WAVES[i], this.frame));
+            path.setAttribute('d', AiWavesIndicator_1.buildWavePath(WAVES[i], frame));
         });
-        this.frame += 1;
-        this.animFrame = requestAnimationFrame(() => this.tick());
+        this.animFrame = requestAnimationFrame((t) => this.tick(t));
     }
     /** Trace one wave's polyline `d` attribute for the given frame. */
     static buildWavePath(cfg, frame) {

package/dist/esm/main/main.js

@@ -190,8 +190,20 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
          * to avoid stealing focus from elsewhere on the page.
          */
         this.isEngaged = true;
+        /**
+         * GENC-1410 (Error 3): stable id for this assistant view. Reported to the shared driver so it
+         * can elect a single owner to render (and run) each interaction's widget when more than one view
+         * (e.g. a bubble and a docked panel) is wired to the same driver — so it fires once, not per view.
+         */
+        this.hostId = crypto.randomUUID();
         this._handleGlobalInteraction = (e) => {
+            var _a, _b;
             const next = e.composedPath().includes(this);
+            // GENC-1410: sticky "last active host" — whenever the user interacts inside THIS view, claim
+            // ownership on the shared driver. Unlike `isEngaged` this does NOT clear when the user later
+            // clicks elsewhere in the layout; it only moves when they use a *different* assistant view.
+            if (next)
+                (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.setActiveHost) === null || _b === void 0 ? void 0 : _b.call(_a, this.hostId);
             if (next === this.isEngaged)
                 return;
             this.isEngaged = next;
@@ -368,6 +380,15 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         var _a;
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setShowThinkingSteps(value);
     }
+    /** Current user-facing toggle state for narration (interstitial prose) visibility. */
+    get showNarration() {
+        var _a, _b;
+        return (_b = (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.store.aiAssistant.showNarration) !== null && _b !== void 0 ? _b : false;
+    }
+    set showNarration(value) {
+        var _a;
+        (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setShowNarration(value);
+    }
     /** Current user-facing toggle state for agent switch indicator visibility. */
     get showAgentSwitchIndicator() {
         var _a, _b;
@@ -687,7 +708,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             this.showHalo = 'agent';
         }
     }
-    /** True when there is a pending (unresolved) interaction — disables the popout button. */
+    /** True when there is a pending (unresolved) interaction. */
     get hasActivePendingInteraction() {
         if (!this.busy)
             return false;
@@ -741,6 +762,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         return filterVisibleMessages(listed, {
             showToolCalls: this.showToolCalls,
             showThinkingSteps: this.showThinkingSteps,
+            showNarration: this.showNarration,
             showAgentSwitchIndicator,
         });
     }
@@ -916,11 +938,15 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
      * times — unwires any existing listeners first.
      */
     wireDriver() {
+        var _a;
         const { driver } = this;
         if (!driver)
             return;
         // Idempotent — unwire previous listeners on this component before re-wiring.
         this.unwireDriver();
+        // GENC-1410 (Error 3): announce this view to the (shared) driver so it can elect a single
+        // owner for side-effecting interactions when more than one view is wired to it.
+        (_a = driver.registerHost) === null || _a === void 0 ? void 0 : _a.call(driver, this.hostId);
         const onHistoryUpdated = (e) => {
             this.messages = [...e.detail];
         };
@@ -1002,6 +1028,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         driver.addEventListener('interaction-stop', onInteractionStop);
         driver.addEventListener('provider-changed', onProviderChanged);
         const cleanups = [
+            () => { var _a; return (_a = driver.unregisterHost) === null || _a === void 0 ? void 0 : _a.call(driver, this.hostId); },
             () => driver.removeEventListener('history-updated', onHistoryUpdated),
             () => driver.removeEventListener('sub-agent-history-updated', onSubAgentHistoryUpdated),
             () => driver.removeEventListener('sub-agent-start', onSubAgentStart),
@@ -1071,7 +1098,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.driverCleanup = undefined;
     }
     connectedCallback() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         // Initialise the store reference BEFORE super.connectedCallback() so that
         // the first FAST render has access to the store. The store Proxy calls
         // Observable.track(observableStore, sliceName) whenever a slice is read,
@@ -1087,6 +1114,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             const ui = (_a = this.chatConfig.ui) !== null && _a !== void 0 ? _a : {};
             this.showToolCalls = ui.showToolCalls === true;
             this.showThinkingSteps = ui.showThinkingSteps === true;
+            this.showNarration = ui.showNarration === true;
             this.showAgentSwitchIndicator = ui.showAgentSwitchIndicator === true;
             this.enabledAnimations = resolveExclusiveLoadingStyle((_c = (_b = ui.animations) === null || _b === void 0 ? void 0 : _b.enabled) !== null && _c !== void 0 ? _c : (ui.animations ? [...DEFAULT_ANIMATIONS] : []));
             const defaultAgent = (_d = this.chatConfig.picker) === null || _d === void 0 ? void 0 : _d.defaultAgent;
@@ -1109,9 +1137,15 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                 this._finalizeCostSessionOnPageHide = false;
             });
             const unsubPopin = agenticActivityBus.subscribe('chat-popin', () => {
+                var _a, _b;
                 this.logMeta('driver.wired', { reason: 'popin' });
                 this.wireDriver();
                 this._finalizeCostSessionOnPageHide = true;
+                // GENC-1410: popin makes THIS (bubble) view the visible one. Take interaction ownership on
+                // the shared driver so it elects this view to render widgets — not the now-hidden docked
+                // panel. Ownership transfers as part of the dock lifecycle, deterministically, rather than
+                // being inferred from wherever the user last happened to click.
+                (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.setActiveHost) === null || _b === void 0 ? void 0 : _b.call(_a, this.hostId);
             });
             this.unsubBus = () => {
                 unsubPopout();
@@ -1120,6 +1154,11 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         }
         else if (this.popoutMode === 'collapse') {
             this._finalizeCostSessionOnPageHide = true;
+            // GENC-1410: a collapse-mode view exists only while docked, and it connects (running this
+            // setup) as part of `onDock` — the moment it becomes the visible view. Take interaction
+            // ownership now so the shared driver renders widgets here, not in the hidden bubble. This is
+            // the dock counterpart to the bubble's ownership claim on `chat-popin` above.
+            (_g = (_f = this.driver) === null || _f === void 0 ? void 0 : _f.setActiveHost) === null || _g === void 0 ? void 0 : _g.call(_f, this.hostId);
             const unsubPopout = agenticActivityBus.subscribe('chat-popout', () => {
                 this._finalizeCostSessionOnPageHide = true;
             });
@@ -1134,13 +1173,13 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.syncShowingSplash();
         // Restore loading state if the driver is still executing mid-lifecycle.
         // disconnectedCallback resets state to 'idle', so we must check real driver state here.
-        if ((_f = this.driver) === null || _f === void 0 ? void 0 : _f.isBusy()) {
+        if ((_h = this.driver) === null || _h === void 0 ? void 0 : _h.isBusy()) {
             this.state = 'loading';
             this.startLoadingTimer();
             // Subscribe once so that when the originating send() completes (possibly on a
             // different element instance that has since disconnected), this element cleans up
             // its own timer, syncs the halo, and triggers the post-response suggestion fetch.
-            this._executionCompletionUnsub = (_g = this._sessionRef) === null || _g === void 0 ? void 0 : _g.subscribeKey((s) => s.aiAssistant.state, () => {
+            this._executionCompletionUnsub = (_j = this._sessionRef) === null || _j === void 0 ? void 0 : _j.subscribeKey((s) => s.aiAssistant.state, () => {
                 var _a, _b;
                 if (((_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.store.aiAssistant.state) === 'idle') {
                     this.stopLoadingTimer();
@@ -1163,7 +1202,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         // `provider-changed`. Feature-detected: a no-op for immutable registries.
         // Re-subscribed per connect (docking/popout remounts); balanced in
         // disconnectedCallback.
-        (_h = this.unsubProviderRegistry) === null || _h === void 0 ? void 0 : _h.call(this);
+        (_k = this.unsubProviderRegistry) === null || _k === void 0 ? void 0 : _k.call(this);
         this.unsubProviderRegistry = undefined;
         if (isObservableAIProviderRegistry(this.providerRegistry)) {
             this.unsubProviderRegistry = this.providerRegistry.subscribe(() => {
@@ -1199,7 +1238,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             restoredMessages: this.messages.length,
             driver: driverExisted ? 'reused' : 'created',
             driverKind: this.driver instanceof OrchestratingDriver ? 'orchestrating' : 'chat',
-            driverBusy: (_k = (_j = this.driver) === null || _j === void 0 ? void 0 : _j.isBusy()) !== null && _k !== void 0 ? _k : false,
+            driverBusy: (_m = (_l = this.driver) === null || _l === void 0 ? void 0 : _l.isBusy()) !== null && _m !== void 0 ? _m : false,
         });
     }
     disconnectedCallback() {
@@ -1414,6 +1453,30 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.showLoadingIndicator = false;
     }
     /** Called when the user clicks the popout button. */
+    /**
+     * GENC-1410 (Error 3): claim the right to run a side-effecting interaction's server work for
+     * THIS view, via the shared driver's first-writer-wins latch. Returns `true` when this view may
+     * run it (first/owning claimant, or a re-render of the same view), `false` when another view
+     * already holds it. Fail-open when the driver has no latch. Called by `ai-chat-interaction-wrapper`.
+     */
+    claimSideEffect(interactionId) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.claimSideEffect) === null || _b === void 0 ? void 0 : _b.call(_a, interactionId, this.hostId)) !== null && _c !== void 0 ? _c : true;
+    }
+    /**
+     * GENC-1410 (Error 3): mark THIS view as the interaction owner on the shared driver, so it (not a
+     * sibling view sharing the same driver) is elected to render side-effecting widgets. The bubble
+     * and docked panel normally claim this automatically on the pop-in / dock lifecycle, but that
+     * lifecycle only runs once `popout-mode` is active. A host that establishes a view outside that
+     * lifecycle — e.g. a page that restores a docked assistant from a persisted layout before the
+     * pop-out affordance is enabled — calls this to seize ownership deterministically rather than
+     * leaving it to the last-interaction / first-registered fallback. Idempotent; safe to call on
+     * every layout (re)establish. No-op if the driver was never wired.
+     */
+    claimInteractionOwnership() {
+        var _a, _b;
+        (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.setActiveHost) === null || _b === void 0 ? void 0 : _b.call(_a, this.hostId);
+    }
     handlePopout() {
         if (this.popoutMode === 'expand') {
             this.logMeta('assistant.popout');
@@ -1573,6 +1636,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             !!this.headerTitle ||
             (ui === null || ui === void 0 ? void 0 : ui.showToolCalls) != null ||
             (ui === null || ui === void 0 ? void 0 : ui.showThinkingSteps) != null ||
+            (ui === null || ui === void 0 ? void 0 : ui.showNarration) != null ||
             (ui === null || ui === void 0 ? void 0 : ui.showAgentSwitchIndicator) != null ||
             (ui === null || ui === void 0 ? void 0 : ui.allowDebugDownload) === true ||
             (ui === null || ui === void 0 ? void 0 : ui.animations) != null ||
@@ -1754,6 +1818,9 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     toggleShowThinkingSteps() {
         this.showThinkingSteps = !this.showThinkingSteps;
     }
+    toggleShowNarration() {
+        this.showNarration = !this.showNarration;
+    }
     toggleShowAgentSwitchIndicator() {
         this.showAgentSwitchIndicator = !this.showAgentSwitchIndicator;
     }

package/dist/esm/main/main.styles.js

@@ -273,6 +273,12 @@ const baseStyles = css `
     font-size: 0.95em;
   }
 
+  /* Narration shares the Thinking bubble but is the assistant's commentary (labelled "Working"),
+     not its inner monologue — keep it upright so it reads as action, distinct from italic reasoning. */
+  .message.ai-thinking.narration {
+    font-style: normal;
+  }
+
   .message.ai-function {
     background: linear-gradient(135deg, rgb(15 32 39 / 90%) 0%, rgb(30 58 58 / 80%) 100%);
     color: var(--ai-function-color, #86efac);

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

@@ -76,6 +76,12 @@ const messageType = (m) => {
         // outcome; render it identically to a real user message.
         case m.role === 'synthetic-user':
             return 'user';
+        // Reasoning (chain-of-thought summary) and narration (interstitial prose the model emits
+        // alongside a tool call) both render as the "Thinking" bubble — visually set apart from a real
+        // final agent reply, even though they stay separate categories (own log entry + own toggle:
+        // `showThinkingSteps` vs `showNarration`). `thinking` is the legacy flag for pre-split sessions.
+        case m.category === 'reasoning':
+        case m.category === 'narration':
         case !!m.thinking:
             return 'ai-thinking';
         case !!m.toolCalls:
@@ -93,6 +99,12 @@ const senderLabel = {
     interaction: 'Assistant',
     ai: 'Assistant',
 };
+/**
+ * Sender label for a message. Reasoning and narration share the "Thinking" bubble, so the label is
+ * the only thing that tells them apart: narration reads "Working" (the action it narrates alongside
+ * its tool call), reasoning stays "Thinking". Everything else uses the {@link messageType} map.
+ */
+const senderLabelFor = (m) => m.category === 'narration' ? 'Working' : senderLabel[messageType(m)];
 /**
  * Resolves how the host frames an interaction widget, defaulting to `'label'`
  * (the historical "Assistant" label, no bubble). Callers guard on
@@ -224,7 +236,9 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
     // assistant one.
     (m) => messageType(m) === 'user', userAvatarTemplate)}${when((m) => messageType(m) !== 'user', assistantAvatarTemplate)}
           </div>
-          <div class="message ${(m) => messageType(m)}">
+          <div
+            class="message ${(m) => messageType(m)} ${(m) => classNames(['narration', m.category === 'narration'])}"
+          >
             ${when(
     // A 'bare' interaction owns its full presentation — suppress the
     // host sender label. Every other message keeps it.
@@ -236,7 +250,7 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
             m.agentName &&
             c.parent.showAgentSwitchIndicator
             ? `Tool Call · ${(_a = m.agentLabel) !== null && _a !== void 0 ? _a : m.agentName}`
-            : senderLabel[messageType(m)];
+            : senderLabelFor(m);
     }}
                 </div>
               `)}
@@ -249,6 +263,11 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
                 `)}
               ${when((m) => m.interaction, html `
                   <ai-chat-interaction-wrapper
+                    ${
+    /* GENC-1410: bind ownerHostId BEFORE componentName/interactionId — bindings
+        apply in template order and both trigger renderComponent, so the ownership
+        gate prop must be set by the time the first render runs. */ ''}
+                    :ownerHostId=${(m) => { var _a; return (_a = m.interaction.ownerHostId) !== null && _a !== void 0 ? _a : ''; }}
                     :componentName=${(m) => m.interaction.componentName}
                     :data=${(m) => m.interaction.data}
                     :interactionId=${(m) => m.interaction.interactionId}

package/dist/esm/state/ai-assistant-slice.js

@@ -4,6 +4,7 @@ export const defaultSessionState = {
     state: 'idle',
     showToolCalls: false,
     showThinkingSteps: false,
+    showNarration: false,
     showAgentSwitchIndicator: false,
     enabledAnimations: [],
     suggestionsState: { status: 'idle' },
@@ -39,6 +40,9 @@ export const aiAssistantSlice = createSlice({
         setShowThinkingSteps(state, action) {
             state.showThinkingSteps = action.payload;
         },
+        setShowNarration(state, action) {
+            state.showNarration = action.payload;
+        },
         setShowAgentSwitchIndicator(state, action) {
             state.showAgentSwitchIndicator = action.payload;
         },

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

@@ -35,7 +35,16 @@ export function filterVisibleMessages(messages, toggles) {
         if (m.role === 'tool') {
             return false;
         }
-        // Thinking messages follow their own toggle.
+        // Reasoning (chain-of-thought summary) follows the thinking toggle.
+        if (m.category === 'reasoning') {
+            return toggles.showThinkingSteps;
+        }
+        // Narration (interstitial prose alongside a tool call) follows its own toggle.
+        if (m.category === 'narration') {
+            return toggles.showNarration;
+        }
+        // Legacy: sessions persisted before the reasoning/narration split tagged reasoning-ish
+        // content with `thinking`; keep honouring the flag so their history still hides it.
         if (m.thinking && !toggles.showThinkingSteps) {
             return false;
         }

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

@@ -5,11 +5,13 @@ const interaction = (interactionId, resolved = false) => (Object.assign({ intera
 const ALL_ON = {
     showToolCalls: true,
     showThinkingSteps: true,
+    showNarration: true,
     showAgentSwitchIndicator: true,
 };
 const ALL_OFF = {
     showToolCalls: false,
     showThinkingSteps: false,
+    showNarration: false,
     showAgentSwitchIndicator: false,
 };
 const trailing = createLogicSuite('trailingInteractionRow');

package/package.json

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

package/src/components/ai-driver/ai-driver.ts

@@ -98,4 +98,21 @@ export interface AiDriver extends EventTarget {
    * Optional; the host wires the stop button to it when present.
    */
   cancel?(): void;
+
+  // --- GENC-1410 (Error 3): single-instance execution of interaction widgets ------------------
+  // When several assistant views share one driver, these coordinate which single view renders
+  // (and thus runs) each interaction's widget, so its side effect fires once. Optional — a driver
+  // that never hosts duplicate views can omit them; the host calls with `?.`.
+
+  /** Register an assistant view (host) wired to this driver. */
+  registerHost?(hostId: string): void;
+
+  /** Deregister a host on unwire/disconnect. */
+  unregisterHost?(hostId: string): void;
+
+  /** Record the host whose subtree the user most recently interacted in (owner election signal). */
+  setActiveHost?(hostId: string): void;
+
+  /** First-writer-wins latch: the first host to claim an interaction id runs its side effect. */
+  claimSideEffect?(interactionId: string, hostId: string): boolean;
 }

package/src/components/chat-driver/chat-driver.test.ts

@@ -14,6 +14,8 @@ import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
 import { agenticActivityBus } from '../../channel/ai-activity-bus';
 import type { AgentConfig } from '../../config/config';
 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
@@ -1080,6 +1082,76 @@ subagent(
 
 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',
+  async () => {
+    const config = agent({
+      name: 'Worker',
+      toolDefinitions: () => [def('do_thing')],
+      toolHandlers: () => ({ do_thing: async () => '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);
+
+    await 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) => m.toolCalls?.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)
 //
@@ -1342,6 +1414,77 @@ interactionPresentation('presentation is absent when the option is omitted', asy
 
 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', async () => {
+  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' });
+  await pending;
+});
+
+ownedInteraction(
+  'owner falls back to the first-registered host when none is active yet',
+  async () => {
+    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' });
+    await pending;
+  },
+);
+
+ownedInteraction(
+  'no host registered → no owner (widget renders everywhere, fail-open)',
+  async () => {
+    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' });
+    await pending;
+  },
+);
+
+ownedInteraction(
+  'claimSideEffect is first-writer-wins, and re-entrant for the same host',
+  async () => {
+    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