@genesislcap/ai-assistant 14.479.0 → 14.480.0

package/src/main/main.template.ts

@@ -89,6 +89,12 @@ const messageType = (m: ChatMessage): string => {
     // 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:
@@ -108,6 +114,14 @@ const senderLabel: Record<string, string> = {
   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: ChatMessage): string =>
+  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
@@ -293,7 +307,10 @@ ${(tc) => (tc.foldPath?.length ? `${tc.foldPath.join(' › ')} › ` : '')}<stro
               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.
@@ -305,7 +322,7 @@ ${(tc) => (tc.foldPath?.length ? `${tc.foldPath.join(' › ')} › ` : '')}<stro
                     m.agentName &&
                     (c.parent as FoundationAiAssistant).showAgentSwitchIndicator
                       ? `Tool Call · ${m.agentLabel ?? m.agentName}`
-                      : senderLabel[messageType(m)]}
+                      : senderLabelFor(m)}
                 </div>
               `,
             )}
@@ -326,6 +343,12 @@ ${(tc) => (tc.foldPath?.length ? `${tc.foldPath.join(' › ')} › ` : '')}<stro
                 (m) => m.interaction,
                 html<ChatMessage, FoundationAiAssistant>`
                   <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) => m.interaction!.ownerHostId ?? ''}
                     :componentName=${(m) => m.interaction!.componentName}
                     :data=${(m) => m.interaction!.data}
                     :interactionId=${(m) => m.interaction!.interactionId}

package/src/main/main.ts

@@ -409,6 +409,14 @@ export class FoundationAiAssistant extends GenesisElement {
     this._sessionRef?.actions.aiAssistant.setShowThinkingSteps(value);
   }
 
+  /** Current user-facing toggle state for narration (interstitial prose) visibility. */
+  get showNarration(): boolean {
+    return this._sessionRef?.store.aiAssistant.showNarration ?? false;
+  }
+  set showNarration(value: boolean) {
+    this._sessionRef?.actions.aiAssistant.setShowNarration(value);
+  }
+
   /** Current user-facing toggle state for agent switch indicator visibility. */
   get showAgentSwitchIndicator(): boolean {
     return this._sessionRef?.store.aiAssistant.showAgentSwitchIndicator ?? false;
@@ -786,8 +794,18 @@ export class FoundationAiAssistant extends GenesisElement {
    * to avoid stealing focus from elsewhere on the page.
    */
   @observable isEngaged: boolean = 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.
+   */
+  private readonly hostId = crypto.randomUUID();
   private _handleGlobalInteraction = (e: Event) => {
     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) this.driver?.setActiveHost?.(this.hostId);
     if (next === this.isEngaged) return;
     this.isEngaged = next;
   };
@@ -837,7 +855,7 @@ export class FoundationAiAssistant extends GenesisElement {
     }
   }
 
-  /** True when there is a pending (unresolved) interaction — disables the popout button. */
+  /** True when there is a pending (unresolved) interaction. */
   get hasActivePendingInteraction(): boolean {
     if (!this.busy) return false;
     const last = this.messages[this.messages.length - 1];
@@ -892,6 +910,7 @@ export class FoundationAiAssistant extends GenesisElement {
     return filterVisibleMessages(listed, {
       showToolCalls: this.showToolCalls,
       showThinkingSteps: this.showThinkingSteps,
+      showNarration: this.showNarration,
       showAgentSwitchIndicator,
     });
   }
@@ -1082,6 +1101,10 @@ export class FoundationAiAssistant extends GenesisElement {
     // 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.
+    driver.registerHost?.(this.hostId);
+
     const onHistoryUpdated = (e: Event) => {
       this.messages = [...(e as CustomEvent<ChatMessage[]>).detail];
     };
@@ -1166,6 +1189,7 @@ export class FoundationAiAssistant extends GenesisElement {
     driver.addEventListener('provider-changed', onProviderChanged);
 
     const cleanups: (() => void)[] = [
+      () => driver.unregisterHost?.(this.hostId),
       () => driver.removeEventListener('history-updated', onHistoryUpdated),
       () => driver.removeEventListener('sub-agent-history-updated', onSubAgentHistoryUpdated),
       () => driver.removeEventListener('sub-agent-start', onSubAgentStart),
@@ -1257,6 +1281,7 @@ export class FoundationAiAssistant extends GenesisElement {
       const ui = this.chatConfig.ui ?? {};
       this.showToolCalls = ui.showToolCalls === true;
       this.showThinkingSteps = ui.showThinkingSteps === true;
+      this.showNarration = ui.showNarration === true;
       this.showAgentSwitchIndicator = ui.showAgentSwitchIndicator === true;
       this.enabledAnimations = resolveExclusiveLoadingStyle(
         (ui.animations?.enabled as AiAssistantAnimation[]) ??
@@ -1288,6 +1313,11 @@ export class FoundationAiAssistant extends GenesisElement {
         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.
+        this.driver?.setActiveHost?.(this.hostId);
       });
       this.unsubBus = () => {
         unsubPopout();
@@ -1295,6 +1325,11 @@ export class FoundationAiAssistant extends GenesisElement {
       };
     } 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.
+      this.driver?.setActiveHost?.(this.hostId);
       const unsubPopout = agenticActivityBus.subscribe('chat-popout', () => {
         this._finalizeCostSessionOnPageHide = true;
       });
@@ -1595,6 +1630,30 @@ export class FoundationAiAssistant extends GenesisElement {
   }
 
   /** 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: string): boolean {
+    return this.driver?.claimSideEffect?.(interactionId, this.hostId) ?? 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(): void {
+    this.driver?.setActiveHost?.(this.hostId);
+  }
+
   handlePopout(): void {
     if (this.popoutMode === 'expand') {
       this.logMeta('assistant.popout');
@@ -1787,6 +1846,7 @@ export class FoundationAiAssistant extends GenesisElement {
       !!this.headerTitle ||
       ui?.showToolCalls != null ||
       ui?.showThinkingSteps != null ||
+      ui?.showNarration != null ||
       ui?.showAgentSwitchIndicator != null ||
       ui?.allowDebugDownload === true ||
       ui?.animations != null ||
@@ -1985,6 +2045,10 @@ export class FoundationAiAssistant extends GenesisElement {
     this.showThinkingSteps = !this.showThinkingSteps;
   }
 
+  toggleShowNarration() {
+    this.showNarration = !this.showNarration;
+  }
+
   toggleShowAgentSwitchIndicator() {
     this.showAgentSwitchIndicator = !this.showAgentSwitchIndicator;
   }

package/src/state/ai-assistant-slice.ts

@@ -34,6 +34,7 @@ export interface AiAssistantSessionState {
   state: AiAssistantState;
   showToolCalls: boolean;
   showThinkingSteps: boolean;
+  showNarration: boolean;
   showAgentSwitchIndicator: boolean;
   enabledAnimations: AiAssistantAnimation[];
   suggestionsState: SuggestionsState;
@@ -100,6 +101,7 @@ export const defaultSessionState: AiAssistantSessionState = {
   state: 'idle',
   showToolCalls: false,
   showThinkingSteps: false,
+  showNarration: false,
   showAgentSwitchIndicator: false,
   enabledAnimations: [],
   suggestionsState: { status: 'idle' },
@@ -136,6 +138,9 @@ export const aiAssistantSlice = createSlice({
     setShowThinkingSteps(state, action: PayloadAction<boolean>) {
       state.showThinkingSteps = action.payload;
     },
+    setShowNarration(state, action: PayloadAction<boolean>) {
+      state.showNarration = action.payload;
+    },
     setShowAgentSwitchIndicator(state, action: PayloadAction<boolean>) {
       state.showAgentSwitchIndicator = action.payload;
     },

package/src/utils/message-partition.test.ts

@@ -22,11 +22,13 @@ const interaction = (interactionId: string, resolved = false): ChatInteraction =
 const ALL_ON: MessageFilterState = {
   showToolCalls: true,
   showThinkingSteps: true,
+  showNarration: true,
   showAgentSwitchIndicator: true,
 };
 const ALL_OFF: MessageFilterState = {
   showToolCalls: false,
   showThinkingSteps: false,
+  showNarration: false,
   showAgentSwitchIndicator: false,
 };
 

package/src/utils/message-partition.ts

@@ -9,6 +9,7 @@ import type { ChatMessage } from '@genesislcap/foundation-ai';
 export interface MessageFilterState {
   showToolCalls: boolean;
   showThinkingSteps: boolean;
+  showNarration: boolean;
   showAgentSwitchIndicator: boolean;
 }
 
@@ -52,7 +53,16 @@ export function filterVisibleMessages(
     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;
     }