@genesislcap/ai-assistant 15.85.1 → 15.86.1

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

@@ -2,6 +2,7 @@ import { __decorate } from "tslib";
 import { attr, customElement, GenesisElement, html, observable } from '@genesislcap/web-core';
 import { agenticActivityBus } from '../../channel/ai-activity-bus';
 import { autopilotNeedsUser } from '../../channel/autopilot-needs-user';
+import { AiAssistantEvent } from '../../main/main.types';
 import { styles } from './chat-bubble.styles';
 import { AiChatBubbleTemplate } from './chat-bubble.template';
 /**
@@ -325,12 +326,10 @@ let AiChatBubble = class AiChatBubble extends GenesisElement {
             this.removeCloseButton();
             return;
         }
-        if (this.injectedCloseBtn) {
-            if (this.injectedCloseBtn.parentElement === assistant)
-                return;
-            this.removeCloseButton();
-        }
-        this.injectCloseButton(assistant);
+        if (this.closableAssistant === assistant)
+            return;
+        this.removeCloseButton();
+        this.showCloseButton(assistant);
     }
     findAssistant(nodes) {
         var _a, _b, _c, _d;
@@ -345,24 +344,22 @@ let AiChatBubble = class AiChatBubble extends GenesisElement {
         }
         return null;
     }
-    injectCloseButton(assistant) {
-        const prefix = this.designSystemPrefix;
-        const btn = document.createElement(`${prefix}-button`);
-        btn.setAttribute('slot', 'header-actions-extra');
-        btn.setAttribute('appearance', 'stealth');
-        btn.setAttribute('title', 'Close');
-        const icon = document.createElement(`${prefix}-icon`);
-        icon.setAttribute('name', 'times');
-        btn.appendChild(icon);
-        btn.addEventListener('click', this.onCloseBtnClick);
-        assistant.appendChild(btn);
-        this.injectedCloseBtn = btn;
+    /**
+     * The Close button is the assistant's own, rendered in its header beside the cog. It used to be
+     * a design-system button injected into the assistant's light DOM, where the assistant's styles
+     * could reach its host but not the padded control inside it, so it sat narrower than the cog
+     * and off its centre line, and every host carried a shim to square it up.
+     */
+    showCloseButton(assistant) {
+        assistant.toggleAttribute('closable', true);
+        assistant.addEventListener(AiAssistantEvent.CloseRequested, this.onCloseBtnClick);
+        this.closableAssistant = assistant;
     }
     removeCloseButton() {
         var _a, _b;
-        (_a = this.injectedCloseBtn) === null || _a === void 0 ? void 0 : _a.removeEventListener('click', this.onCloseBtnClick);
-        (_b = this.injectedCloseBtn) === null || _b === void 0 ? void 0 : _b.remove();
-        this.injectedCloseBtn = undefined;
+        (_a = this.closableAssistant) === null || _a === void 0 ? void 0 : _a.removeEventListener(AiAssistantEvent.CloseRequested, this.onCloseBtnClick);
+        (_b = this.closableAssistant) === null || _b === void 0 ? void 0 : _b.removeAttribute('closable');
+        this.closableAssistant = undefined;
     }
     onBubbleMouseDown(e) {
         e.preventDefault();

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

@@ -23,15 +23,24 @@ const styles = css `
     padding-left: calc(var(--design-unit, 4) * 5px);
   }
 
+  /*
+   * Code paints a surface of its own, so it names the foreground that goes with it rather than
+   * inheriting the bubble's. A layer and neutral-foreground-rest are the pair the design system
+   * keeps in contrast; neutral-fill-rest is not paired with anything, and a theme that keeps it
+   * light in dark mode (corporate-light does, as its button fill) put dark mode's light text on
+   * a near-white chip. Inherited, it was also the on-accent colour inside the user's bubble.
+   */
   code {
-    background-color: var(--neutral-fill-rest);
+    background-color: var(--neutral-layer-1);
+    color: var(--neutral-foreground-rest);
     padding: 2px 4px;
     border-radius: calc(var(--design-unit, 4) * 0.5px);
     font-family: monospace;
   }
 
   pre {
-    background-color: var(--neutral-fill-rest);
+    background-color: var(--neutral-layer-1);
+    color: var(--neutral-foreground-rest);
     padding: calc(var(--design-unit, 4) * 2px);
     border-radius: calc(var(--design-unit, 4) * 1px);
     overflow-x: auto;
@@ -48,6 +57,13 @@ const styles = css `
     color: inherit;
   }
 
+  /* The browser's own link blue fails on a dark bubble. The user's bubble resets this to its
+     on-accent colour (main.styles), where an accent link would vanish into the accent fill. */
+  a {
+    color: var(--accent-foreground-rest);
+    text-decoration: underline;
+  }
+
   table {
     display: block;
     overflow-x: auto;

package/dist/esm/genesis/write-review/write-review.js

@@ -79,6 +79,37 @@ const PARKED = {
  * @beta
  */
 let GenesisWriteReview = class GenesisWriteReview extends GenesisElement {
+    connectedCallback() {
+        super.connectedCallback();
+        // jsdom has no ResizeObserver: there the review stays a table, which is what it renders first.
+        if (typeof ResizeObserver === 'undefined')
+            return;
+        this.resizeObserver = new ResizeObserver(() => this.fitLayout());
+        this.resizeObserver.observe(this);
+    }
+    disconnectedCallback() {
+        var _a;
+        super.disconnectedCallback();
+        (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        this.resizeObserver = undefined;
+    }
+    /**
+     * Stacks the rows when the table is wider than the review, and goes back to the table once the
+     * review is as wide as the table was. While stacked there is no table to measure, so the width it
+     * had is kept from the last time it was one.
+     */
+    fitLayout() {
+        var _a;
+        const scroller = (_a = this.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('.scroller');
+        const table = scroller === null || scroller === void 0 ? void 0 : scroller.querySelector('table');
+        if (!scroller || !table)
+            return;
+        if (!this.stacked)
+            this.tableWidth = table.offsetWidth;
+        const stacked = this.tableWidth > scroller.clientWidth;
+        if (stacked !== this.stacked)
+            this.stacked = stacked;
+    }
     constructor() {
         super();
         /** Set by the interaction wrapper on every (re)mount. */
@@ -91,6 +122,20 @@ let GenesisWriteReview = class GenesisWriteReview extends GenesisElement {
         this.changeText = '';
         /** What the live region says: the outcome once the review has resolved. See `sayOutcome`. */
         this.announcement = '';
+        /**
+         * True when the table would not fit the width it has, and each row is laid out as its fields
+         * stacked label beside value instead.
+         *
+         * @remarks
+         * The table scrolls sideways rather than clip (see the styles), but in a chat bubble that left
+         * three of a trade's nine columns on screen, and the changing ones were behind the scrollbar.
+         * Measured rather than a fixed breakpoint, because whether a table fits depends on how many
+         * columns it has and how long their values are: a two-field insert fits a bubble a nine-field
+         * modify does not.
+         */
+        this.stacked = false;
+        /** The table's width when last laid out as a table: what the review needs to stop stacking. */
+        this.tableWidth = 0;
         /**
          * Set when this element sends its answer. The host marks the review resolved after that, and
          * until it did, a second click sent a second answer — a Deny straight after a Write included.
@@ -508,6 +553,9 @@ __decorate([
 __decorate([
     observable
 ], GenesisWriteReview.prototype, "announcement", void 0);
+__decorate([
+    observable
+], GenesisWriteReview.prototype, "stacked", void 0);
 __decorate([
     observable
 ], GenesisWriteReview.prototype, "answered", void 0);

package/dist/esm/genesis/write-review/write-review.styles.js

@@ -72,6 +72,70 @@ export const WriteReviewStyles = css `
     max-width: 40ch;
   }
 
+  /*
+   * Stacked: the table did not fit (see GenesisWriteReview.stacked), so each row becomes a block
+   * and each field a line of its own, its label beside its value, and nothing is off to the side.
+   * The headings go, as every value now carries its own; the select-all box stays, labelled.
+   */
+  .stacked table,
+  .stacked tbody,
+  .stacked tr,
+  .stacked td {
+    display: block;
+  }
+
+  .stacked thead tr {
+    display: flex;
+  }
+
+  .stacked thead th:not(.select) {
+    display: none;
+  }
+
+  .stacked thead th.select {
+    border-bottom: none;
+    font-weight: 400;
+  }
+
+  /* Without its column of row boxes beneath it, a lone box at the top says nothing on sight. Its
+     spoken name is its aria-label, so the words here are for the eye only (the empty alt). */
+  .stacked thead th.select::after {
+    content: 'Select all' / '';
+    margin-inline-start: calc(var(--design-unit, 4) * 1.5px);
+    vertical-align: middle;
+  }
+
+  .stacked tbody tr {
+    padding-block: calc(var(--design-unit, 4) * 1px);
+    border-top: calc(var(--stroke-width, 1) * 1px) solid var(--neutral-stroke-rest);
+  }
+
+  .stacked td {
+    border-bottom: none;
+  }
+
+  .stacked td[data-label] {
+    display: grid;
+    grid-template-columns: minmax(0, 2fr) minmax(0, 3fr);
+    gap: calc(var(--design-unit, 4) * 2px);
+    white-space: normal;
+    overflow-wrap: anywhere;
+  }
+
+  .stacked td[data-label]::before {
+    content: attr(data-label);
+    font-weight: 600;
+  }
+
+  /* No column to bound any more: a long value takes the line's width like any other, and wraps
+     within it like any other. */
+  .stacked td.long {
+    min-width: 0;
+    max-width: none;
+    white-space: normal;
+    overflow-wrap: anywhere;
+  }
+
   /*
    * The two marks this table carries — "this field is changing" and "this field decides which
    * record disappears" — were weight, colour and a strike-through only. None of that reaches
@@ -197,7 +261,7 @@ export const WriteReviewStyles = css `
     white-space: nowrap;
   }
 
-  td.select rapid-checkbox,
+  .select rapid-checkbox,
   td.select .mark {
     vertical-align: middle;
   }
@@ -223,8 +287,10 @@ export const WriteReviewStyles = css `
     white-space: normal;
   }
 
+  /* Wraps, so in a narrow bubble the last button drops to a new line rather than off the edge. */
   .actions {
     display: flex;
+    flex-wrap: wrap;
     gap: calc(var(--design-unit, 4) * 2px);
     margin-top: calc(var(--design-unit, 4) * 2px);
   }

package/dist/esm/genesis/write-review/write-review.template.js

@@ -79,34 +79,46 @@ const valueOrBlank = (pick) => html `
       </span>
     `)}
 `;
-/** A cell shows what the field becomes, and — when it is changing — what it is now. */
+/**
+ * A cell shows what the field becomes, and — when it is changing — what it is now.
+ *
+ * @remarks
+ * The cell carries its column's label, and its content sits in one wrapper, for the stacked
+ * layout: there the headings are gone and each cell is a label beside its value (see
+ * `GenesisWriteReview.stacked`), and the wrapper keeps the − and + lines together in the value's
+ * column rather than letting each take a grid cell of its own.
+ */
 const cell = html `
   <td
+    role="cell"
+    data-label="${(x) => x.label}"
     class="${(x) => [x.changed ? 'changed' : '', x.identifying ? 'identifying' : '', x.long ? 'long' : '']
     .join(' ')
     .trim()}"
     title="${(x) => { var _a; return x.identifying ? `This field identifies ${(_a = x.identifies) !== null && _a !== void 0 ? _a : 'the row being removed'}` : ''; }}"
   >
-    ${when((x) => x.identifying, html `
-        <span class="sr-only">identifies this row:</span>
-      `)}
-    ${when((x) => x.changed && x.previousDisplay !== undefined, html `
-        <span class="sr-only">was</span>
-        <span class="was">${mark('−')}${valueOrBlank((x) => x.previousDisplay)}</span>
-        <span class="sr-only">now</span>
-        <span class="now">${mark('+')}${valueOrBlank((x) => x.display)}</span>
-      `)}
-    ${when((x) => !!x.input, html `
-        <span class="input-mark">input:</span>
-      `)}
-    ${when((x) => !(x.changed && x.previousDisplay !== undefined), html `
-        ${(x) => x.display}
-      `)}
+    <div class="value">
+      ${when((x) => x.identifying, html `
+          <span class="sr-only">identifies this row:</span>
+        `)}
+      ${when((x) => x.changed && x.previousDisplay !== undefined, html `
+          <span class="sr-only">was</span>
+          <span class="was">${mark('−')}${valueOrBlank((x) => x.previousDisplay)}</span>
+          <span class="sr-only">now</span>
+          <span class="now">${mark('+')}${valueOrBlank((x) => x.display)}</span>
+        `)}
+      ${when((x) => !!x.input, html `
+          <span class="input-mark">input:</span>
+        `)}
+      ${when((x) => !(x.changed && x.previousDisplay !== undefined), html `
+          ${(x) => x.display}
+        `)}
+    </div>
   </td>
 `;
 const row = html `
-  <tr class="${(x, c) => rowClass(x, c.parent)}">
-    <td class="select">
+  <tr role="row" class="${(x, c) => rowClass(x, c.parent)}">
+    <td role="cell" class="select">
       <rapid-checkbox
         aria-label="Select ${(x) => x.label}"
         aria-describedby="${(x) => { var _a; return (((_a = x.problems) === null || _a === void 0 ? void 0 : _a.length) ? `problems-${x.index}` : ''); }}"
@@ -130,9 +142,9 @@ const row = html `
     ${repeat((x) => x.cells, cell)}
   </tr>
   ${when((x) => { var _a; return !!((_a = x.problems) === null || _a === void 0 ? void 0 : _a.length); }, html `
-      <tr class="refused">
-        <td></td>
-        <td class="problems" colspan="99" id="problems-${(x) => String(x.index)}">
+      <tr role="row" class="refused">
+        <td role="cell"></td>
+        <td role="cell" class="problems" colspan="99" id="problems-${(x) => String(x.index)}">
           ${(x) => { var _a; return (_a = x.problems) === null || _a === void 0 ? void 0 : _a.join('; '); }}
         </td>
       </tr>
@@ -157,8 +169,13 @@ export const WriteReviewTemplate = html `
       ${when((x) => !!x.customCodeLine, html `
           <p class="custom-code" id="${CUSTOM_CODE_LINE_ID}">${(x) => x.customCodeLine}</p>
         `)}
-      <div class="scroller">
+      ${
+/* The table's roles are stated, not left to the tags: the stacked layout sets display: block
+   on its parts, and a browser then drops their table semantics, so a screen reader would
+   hear a run of values with no row or column to put them in. */ ''}
+      <div class="scroller ${(x) => (x.stacked ? 'stacked' : '')}">
         <table
+          role="table"
           aria-label="${(x) => x.tableLabel}"
           aria-describedby="${(x) => x.customCodeLine
     ? CUSTOM_CODE_LINE_ID
@@ -166,9 +183,9 @@ export const WriteReviewTemplate = html `
         ? ROW_ACTION_LINES_ID
         : undefined}"
         >
-          <thead>
-            <tr>
-              <th>
+          <thead role="rowgroup">
+            <tr role="row">
+              <th role="columnheader" class="select">
                 <rapid-checkbox
                   aria-label="Select all rows"
                   :checked="${(x) => x.allSelected}"
@@ -177,11 +194,11 @@ export const WriteReviewTemplate = html `
                 ></rapid-checkbox>
               </th>
               ${repeat((x) => { var _a, _b; return (_b = (_a = x.model) === null || _a === void 0 ? void 0 : _a.columns) !== null && _b !== void 0 ? _b : []; }, html `
-                  <th>${(c) => c.label}</th>
+                  <th role="columnheader">${(c) => c.label}</th>
                 `)}
             </tr>
           </thead>
-          <tbody>${repeat((x) => { var _a, _b; return (_b = (_a = x.model) === null || _a === void 0 ? void 0 : _a.rows) !== null && _b !== void 0 ? _b : []; }, row)}</tbody>
+          <tbody role="rowgroup">${repeat((x) => { var _a, _b; return (_b = (_a = x.model) === null || _a === void 0 ? void 0 : _a.rows) !== null && _b !== void 0 ? _b : []; }, row)}</tbody>
         </table>
       </div>
       <div class="actions">

package/dist/esm/main/main.js

@@ -203,6 +203,7 @@ avoidTreeShaking(AiChatMarkdown, AiChatInteractionWrapper, AiHaloOverlay, AiWave
  * {@link FoundationAiAssistant.finalizeCostSession} to flush early; it is idempotent.
  *
  * @fires chat-header-mousedown - Fired when the user presses the chat header in `popout-mode="expand"` (for drag-to-popout hosts). Bubbles and composed. detail: `ChatHeaderMouseDownDetail`
+ * @fires close-requested - Fired when the user presses the header's Close button, which shows while `closable` is set (the chat bubble sets it while the assistant is in its dialog). Bubbles and composed.
  * @fires session-cleared - Fired after the session is wiped (the lifecycle menu's Clear). The payload is captured before teardown so the host can clean up any external state the active agent was working on. Bubbles and composed. detail: `SessionClearedDetail`
  * @fires handoff-started - Fired when an agent's `handOff` takes effect and its target becomes active. Bubbles and composed. detail: `HandOffFrame`
  * @fires handoff-returned - Fired when a hand-off ends and its caller is active again; `detail.outcome` says how it ended. Bubbles and composed. detail: `HandOffFrame`
@@ -324,6 +325,11 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         /** Sanitized `userIcon`, or the default person mark; bound into the template. @internal */
         this.userIconSafe = userIconSvg;
         this.placeholder = 'Message assistant...';
+        /**
+         * Shows a Close button in the header, which fires `close-requested` and leaves the closing to
+         * whatever holds the assistant. The chat bubble sets it while the assistant is in its dialog.
+         */
+        this.closable = false;
         this.chatConfig = {};
         /**
          * Optional session persistence (GENC-1351). Off by default — set `enabled`
@@ -4918,6 +4924,10 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             return;
         agenticActivityBus.publish('agent-attention', { sessionKey, kind: 'turn-ended' });
     }
+    /** Called when the user clicks the header's Close button. */
+    handleClose() {
+        this.dispatchEvent(new CustomEvent(AiAssistantEvent.CloseRequested, { bubbles: true, composed: true }));
+    }
     onChatHeaderMouseDown(e) {
         if (this.popoutMode === 'collapse')
             return;
@@ -5060,6 +5070,9 @@ __decorate([
 __decorate([
     attr({ attribute: 'popout-mode' })
 ], FoundationAiAssistant.prototype, "popoutMode", void 0);
+__decorate([
+    attr({ mode: 'boolean' })
+], FoundationAiAssistant.prototype, "closable", void 0);
 __decorate([
     observable
 ], FoundationAiAssistant.prototype, "agents", void 0);

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

@@ -70,9 +70,45 @@ const baseStyles = css `
     margin-left: auto;
   }
 
+  /* Square, as wide as the control is tall, with the glyph on both centre lines. The
+     design-system control pads its sides and aligns its content to the baseline, and the icon
+     sits inline on a text line, so each button came out as wide as its glyph plus that padding
+     (the X narrower than the cog) and a little above centre, more so with a tall-ascender font.
+     An app's ::part() rules still win. */
+  .close-button,
   .settings-button,
   .popout-button {
     font-size: 1.2em;
+    min-width: 0;
+  }
+
+  .close-button::part(control),
+  .settings-button::part(control),
+  .popout-button::part(control) {
+    flex-grow: 0;
+    width: auto;
+    aspect-ratio: 1;
+    min-width: 0;
+    padding: 0;
+    align-items: center;
+    justify-content: center;
+  }
+
+  .close-button::part(content),
+  .settings-button::part(content),
+  .popout-button::part(content) {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    line-height: 1;
+  }
+
+  /* The glyph's own wrapper, so the icon font's baseline nudge (vertical-align: -0.125em) has no
+     line to act on. */
+  .close-button > ::part(i-icon),
+  .settings-button > ::part(i-icon),
+  .popout-button > ::part(i-icon) {
+    display: flex;
   }
 
   ::slotted([slot='header-actions-extra']) {
@@ -327,6 +363,12 @@ const baseStyles = css `
     box-shadow: 0 2px 8px color-mix(in srgb, var(--accent-fill-rest) 35%, transparent);
   }
 
+  /* On the accent fill an accent-coloured link disappears; it takes the bubble's own colour and
+     keeps its underline. */
+  .message.user ai-chat-markdown::part(md-link) {
+    color: inherit;
+  }
+
   .message.ai {
     background: linear-gradient(135deg, var(--neutral-layer-3) 0%, var(--neutral-layer-4) 100%);
     color: var(--neutral-foreground-rest);

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

@@ -1038,7 +1038,7 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
                 <span class="chat-title" part="chat-title">${(x) => x.headerTitle}</span>
               `)}
             ${
-    /* The two buttons below re-publish the design-system button's inner parts (control,
+    /* The buttons below re-publish the design-system button's inner parts (control,
        content) into THIS component's part namespace via exportparts.
 
        Without it they are unreachable by an embedding app: ::part() crosses exactly one
@@ -1056,6 +1056,16 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
        parts are exported, and so control does not collide across buttons. */ ''}
             <div class="header-actions" part="header-actions">
               <slot name="header-actions-extra"></slot>
+              ${when((x) => x.closable, html `
+                  <${buttonTag}
+                    class="close-button"
+                    part="close-button"
+                    exportparts="control: close-button-control, content: close-button-content"
+                    appearance="stealth"
+                    title="Close"
+                    @click=${(x) => x.handleClose()}
+                  ><${iconTag} name="times"></${iconTag}></${buttonTag}>
+                `)}
               ${when((x) => !!x.popoutMode, html `
                   <${buttonTag}
                     class="popout-button"

package/dist/esm/main/main.types.js

@@ -30,6 +30,8 @@ export const AiAssistantEvent = {
     HandOffReturned: 'handoff-returned',
     /** A hand-off ended with no hand-back. `detail`: `HandOffFrame`, with `outcome`. */
     HandOffUnwound: 'handoff-unwound',
+    /** The header's Close button pressed, shown while `closable` is set. No `detail`. */
+    CloseRequested: 'close-requested',
 };
 /**
  * Registry of all available animations with their display metadata.

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

@@ -95,6 +95,8 @@ export const META_EVENT_IMPORTANCE = {
     'autopilot.handed-back': 'normal',
     'autopilot.paused': 'normal',
     'autopilot.resumed': 'normal',
+    // The mode went with the task across a hand-off or its hand-back, rather than ending with the flow.
+    'autopilot.carried': 'normal',
     // The wrapper itself failed: the journey stops being automatic without anyone choosing that.
     'autopilot.error': 'high',
     // A written answer counted against the step's limit; reaching it withdraws `reply`.
@@ -262,7 +264,7 @@ export const DEBUG_LOG_README = [
     "kind:'turn'.`agentSnapshot` — the active agent's own view of its internal state, captured at that turn. An agent opts into this by exposing a `getDebugSnapshot()` that returns JSON-serializable per-state info; stateful/flow agents wire it automatically, so you can watch a flow advance turn-by-turn (e.g. current step, cursor, collected fields, pending changes). Absent for agents that don't expose one.",
     "kind:'event' — a meta/lifecycle event. `type` names it (see below); `detail` carries structured data. `detail.placement` is the emitting UI instance: 'bubble' (collapsed), 'panel' (popped-out), or 'standalone'.",
     "Each 'event' also has an `importance`: 'high' (failures/limits — turn.error, tool.failed, subagent.failed, file.read-failed, suggestions.failed, context.threshold-crossed), 'normal' (session flow — connects, turns, retries, handoffs, agent/provider changes, interactions, sub-agent start/complete), or 'low' (skippable UI/bookkeeping noise — panel.toggled, attachment.added, driver.wired/unwired, context.updated, context.condensed). To skim, ignore importance:'low'; to triage a failure, filter to importance:'high' then read the nearby messages and turns. A 'high' turn.error is often preceded by one or more 'normal' turn.retry events for the same reason — read them together to see how many attempts were made before bailing. 'message' and 'turn' entries carry no importance — they are the substance, always read them.",
-    'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations/response-truncated/refusal/budget-exhausted/provider-refused/context-exhausted/ai-service-error, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, for response-truncated the model + maxTokens + outputTokens + tools, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, for budget-exhausted the budgetUsd + spentUsd figures reported by the proxy plus the resolved vendor, for provider-refused the kind (spend|auth) plus the upstream status and error type — the vendor refusing the ACCOUNT rather than us refusing to spend, so the remedy is a top-up or a key rotation rather than a raised cap, and the kind is the only place that distinction survives because the user-facing copy is deliberately cause-free, for context-exhausted the estimated contextTokens against the guard that stopped the turn plus the iterations reached — the driver ending a runaway tool loop at the edge of the context window rather than issuing a request the provider would reject, so the transcript survives intact and can still be compacted, for ai-service-error the code (one of AI_SERVICE_ERROR_CODES, e.g. NO_API_KEY) and the status the AI service answered with — its own text goes to the browser console only, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout/response_truncated/refusal/budget_exhausted/provider_refused/context_exhausted/ai_service_error; budget_exhausted and provider_refused are terminal for the PARENT turn too, and so is ai_service_error when the refusal is about the service rather than the request and came from the vendor the parent calls — the parent stops rather than calling the model again into the same wall; after context_exhausted the parent goes on, but its own next call is likely to stop on the same guard), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), routing.decided (ONE PER ROUTING DECISION — see its own paragraph below), provider.selected (the resolved provider for the upcoming turns — detail.provider is the registry SLOT/tier name, detail.model the concrete model behind it and detail.vendor its vendor; emitted only when the slot CHANGES, so read the per-turn `model` for the model of any given call rather than assuming the nearest event still applies), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver; detail.ownerPath names the agents that actually asked, outermost first, the last being the one whose tool requested it, and detail.heldBy says who held it when it opened: user, or the id of the interceptor that claimed it, such as autopilot; on interaction.resolved, detail.answeredBy is who answered — the claimant id when it settled through its own hold, user for any other answer (a click counts as the person even on a widget a claimant held) — absent when it closed unanswered (a timeout or a stop), and absent too when it settled by itself other than through the hold of a claimant — a widget registered resolvesItself (one that does its work and settles on its own, asking the person nothing, such as a generation run), or one outcome its controller said settled itself (ctx.resolve with resolvedItself, such as a generation phase that failed outright before its review gate ever asked anything) — which then carries detail.resolvedItself: true instead, as the interaction message does — nobody answered it, and the platform cannot tell it finishing from the person interrupting it (a Skip), so only the result of the widget itself can say which; the same value is stamped on the interaction message as answeredBy and on the result the asking tool handler receives (absent there in the same cases), and when it is not user the tool result that interaction returned carries a decidedOnUsersBehalf record, so the model was told the choice was not made by the person; detail.edits, present only when non-zero, counts the editing actions a claimant ran on the widget before it was settled, whoever settled it, and those edits are stamped on the interaction message as edits, each with by, action, choice and args when it had some, in the order they ran, while a decidedOnUsersBehalf record carries their choice texts as edits, and when the person settled it after such edits the tool result carries an editedOnUsersBehalf record instead — the framing and those choice texts — so the model knows the widget was changed on the user behalf before the user answered, and that the user then confirmed it by finishing it), interaction.held (a claimant moved a pending interaction to the person or back to itself — detail.heldBy is the new holder, detail.claimant the interceptor; detail.late: true is an interceptor that declined it when it opened claiming it afterwards, such as the autopilot resumed while it was open; a widget held by anything but user was not answered by the person), interaction.claim-refused (a claim on a userOnly interaction, which stays with the person — detail.claimant + reason), autopilot.* (the autopilot, a decorator that answers interactions on behalf of the user — autopilot.claimed / autopilot.declined say whether it took each interaction and, for a decline, detail.reason: paused, other-flow, no-autopilot, unavailable, userOnly, policy or no-controller; one declined as paused that is still open when the person resumes the autopilot is looked at again, and the autopilot.claimed or autopilot.declined recorded for it then carries detail.onResume: true (a decline then can also be claimed-elsewhere, another interceptor having claimed it first); a restored mode looks at nothing; autopilot.decision-sent is what it was sent (detail.chars; detail.nothingEnabled: true when every action on the widget was unavailable — a gate whose controller said it was asking, such as a failed build the autopilot may not cancel — so it could only hand it back, which it may then do even after the person asked it to decide it itself; a widget whose controller says it is working (ctx.setWorking) is never sent a decision until it says it is asking, even when an action is enabled or the person resumes the autopilot); autopilot.acted is what it did (detail.action, detail.note, detail.finished); autopilot.handed-back is a decision it gave to the person (detail.reason and detail.trigger: model, no-decision or error); autopilot.paused / autopilot.resumed are mode changes (detail.scope, detail.trigger, detail.decideYourself when the person resumed during a hand-back; detail.trigger is restored when the mode came back with the session after a reload, applied once its flow re-activated, which starts nothing by itself); autopilot.error is the wrapper itself failing; autopilot.refinement counts a refining action against its step — a written answer (reply) or a widget action declared refines, such as a regenerate with instructions, counted together (detail.action, detail.stepKey, detail.count, detail.limitReached, after which every refining action is withdrawn for that step: not listed, and refused; the decision and every relisting of its actions say how many are left at the step, as a line Refinements left at this step: N, wherever the widget has a refining action); autopilot.handback-presented is the turn-level hand-back, shown when a working turn ended needing the person with no widget to hand over (detail.why: max-iterations, context-exhausted, failure or question; detail.options; detail.choice once answered); autopilot.catch-up is the autopilot being given the whole visible transcript at once (detail.why: first, for its first decision in a flow or after a reload; size, when its own history passed its budget and was rebuilt short — detail.ownChars; or compacted, when a compaction removed the last message it had seen, so it reads the summary and everything since, short; in each, what it had sent on the user behalf is included and labelled as its own, since its own history does not hold it); autopilot.cost-dropped is autopilot spend that no message carries, so it is NOT in the session total (detail.costUsd and detail.why: handed-back, aborted or stale for a written question it answered that no reply was sent for — stale when a pause, a resume, a new turn or the end of its flow came before the answer landed, which then went nowhere — or no-recorder when the driver had no way to book a decision to its interaction); a hand-back trigger can also be budget (the decision passed its spend cap), watchdog (its work went quiet: no ready surface and no heartbeat, or its own decision stalled with no model call landing, which stops that decision) or detached (the autopilot was removed while it held the interaction, which went to the person with no reason shown). To debug one autopilot decision, follow its interactionId: interaction.requested (heldBy), autopilot.claimed, autopilot.decision-sent, autopilot.acted or autopilot.handed-back, interaction.invoked, interaction.resolved (answeredBy), then the next turn of the working agent), interaction.invoked (a claimant ran one of the actions the widget itself exposes, through its hold, the same code the button runs — detail.claimant, detail.action (an option id, select or reply) and detail.finished, whether that settled the interaction, and when it did not, the run is recorded as an edit; the choice and narration it recorded reach the result of the tool that asked as decidedOnUsersBehalf), interaction.step (a long action run as named steps through runSteps, which survive a reload — detail.step and detail.outcome: started, done, skipped when the step was already done before a reload, or resumed when it started before a reload and runs again with what it saved part-way, such as a job id it re-attaches to), interaction.checkpoint (the checkpoints a conversation keeps for its long actions: the one in flight, and each one a reload cut, held apart until a request of its own widget type takes it over, so a resumed flow that opens other long widgets first, which save their own, loses nothing — detail.action: resumed when a reload cut the work and a request of the same widget type that the registration sameWork agrees is the same work took it over, refused when sameWork said a new request is different work (detail.saved is the identity it kept; detail.kept: true, since it stays for a later request of that type, and is offered to every one until one agrees) or when runSteps found the handed-over checkpoint malformed and started fresh (detail.reason, detail.saved), or cleared when its flow ended, once per checkpoint, with detail.cut: true for one a reload cut that nothing took over), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
+    'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations/response-truncated/refusal/budget-exhausted/provider-refused/context-exhausted/ai-service-error, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, for response-truncated the model + maxTokens + outputTokens + tools, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, for budget-exhausted the budgetUsd + spentUsd figures reported by the proxy plus the resolved vendor, for provider-refused the kind (spend|auth) plus the upstream status and error type — the vendor refusing the ACCOUNT rather than us refusing to spend, so the remedy is a top-up or a key rotation rather than a raised cap, and the kind is the only place that distinction survives because the user-facing copy is deliberately cause-free, for context-exhausted the estimated contextTokens against the guard that stopped the turn plus the iterations reached — the driver ending a runaway tool loop at the edge of the context window rather than issuing a request the provider would reject, so the transcript survives intact and can still be compacted, for ai-service-error the code (one of AI_SERVICE_ERROR_CODES, e.g. NO_API_KEY) and the status the AI service answered with — its own text goes to the browser console only, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout/response_truncated/refusal/budget_exhausted/provider_refused/context_exhausted/ai_service_error; budget_exhausted and provider_refused are terminal for the PARENT turn too, and so is ai_service_error when the refusal is about the service rather than the request and came from the vendor the parent calls — the parent stops rather than calling the model again into the same wall; after context_exhausted the parent goes on, but its own next call is likely to stop on the same guard), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), routing.decided (ONE PER ROUTING DECISION — see its own paragraph below), provider.selected (the resolved provider for the upcoming turns — detail.provider is the registry SLOT/tier name, detail.model the concrete model behind it and detail.vendor its vendor; emitted only when the slot CHANGES, so read the per-turn `model` for the model of any given call rather than assuming the nearest event still applies), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver; detail.ownerPath names the agents that actually asked, outermost first, the last being the one whose tool requested it, and detail.heldBy says who held it when it opened: user, or the id of the interceptor that claimed it, such as autopilot; on interaction.resolved, detail.answeredBy is who answered — the claimant id when it settled through its own hold, user for any other answer (a click counts as the person even on a widget a claimant held) — absent when it closed unanswered (a timeout or a stop), and absent too when it settled by itself other than through the hold of a claimant — a widget registered resolvesItself (one that does its work and settles on its own, asking the person nothing, such as a generation run), or one outcome its controller said settled itself (ctx.resolve with resolvedItself, such as a generation phase that failed outright before its review gate ever asked anything) — which then carries detail.resolvedItself: true instead, as the interaction message does — nobody answered it, and the platform cannot tell it finishing from the person interrupting it (a Skip), so only the result of the widget itself can say which; the same value is stamped on the interaction message as answeredBy and on the result the asking tool handler receives (absent there in the same cases), and when it is not user the tool result that interaction returned carries a decidedOnUsersBehalf record, so the model was told the choice was not made by the person; detail.edits, present only when non-zero, counts the editing actions a claimant ran on the widget before it was settled, whoever settled it, and those edits are stamped on the interaction message as edits, each with by, action, choice and args when it had some, in the order they ran, while a decidedOnUsersBehalf record carries their choice texts as edits, and when the person settled it after such edits the tool result carries an editedOnUsersBehalf record instead — the framing and those choice texts — so the model knows the widget was changed on the user behalf before the user answered, and that the user then confirmed it by finishing it), interaction.held (a claimant moved a pending interaction to the person or back to itself — detail.heldBy is the new holder, detail.claimant the interceptor; detail.late: true is an interceptor that declined it when it opened claiming it afterwards, such as the autopilot resumed while it was open; a widget held by anything but user was not answered by the person), interaction.claim-refused (a claim on a userOnly interaction, which stays with the person — detail.claimant + reason), autopilot.* (the autopilot, a decorator that answers interactions on behalf of the user — autopilot.claimed / autopilot.declined say whether it took each interaction and, for a decline, detail.reason: paused, other-flow, no-autopilot, unavailable, userOnly, policy or no-controller; one declined as paused that is still open when the person resumes the autopilot is looked at again, and the autopilot.claimed or autopilot.declined recorded for it then carries detail.onResume: true (a decline then can also be claimed-elsewhere, another interceptor having claimed it first); a restored mode looks at nothing; autopilot.decision-sent is what it was sent (detail.chars; detail.nothingEnabled: true when every action on the widget was unavailable — a gate whose controller said it was asking, such as a failed build the autopilot may not cancel — so it could only hand it back, which it may then do even after the person asked it to decide it itself; a widget whose controller says it is working (ctx.setWorking) is never sent a decision until it says it is asking, even when an action is enabled or the person resumes the autopilot); autopilot.acted is what it did (detail.action, detail.note, detail.finished); autopilot.handed-back is a decision it gave to the person (detail.reason and detail.trigger: model, no-decision or error); autopilot.paused / autopilot.resumed are mode changes (detail.scope, detail.trigger, detail.decideYourself when the person resumed during a hand-back; detail.trigger is restored when the mode came back with the session after a reload, applied once its flow re-activated, which starts nothing by itself); autopilot.carried is the mode, running or paused, going with the task to the agent that took it over, rather than ending with the flow as on any other change of flow owner: to the target of a hand-off, or back to its caller on the hand-back (detail.from, detail.to, detail.mode); a pause the person chose goes with it, and Stop and Clear still end it; a mode restored for the target of a hand-off applies to its caller when the reload hands back; autopilot.error is the wrapper itself failing; autopilot.refinement counts a refining action against its step — a written answer (reply) or a widget action declared refines, such as a regenerate with instructions, counted together (detail.action, detail.stepKey, detail.count, detail.limitReached, after which every refining action is withdrawn for that step: not listed, and refused; the decision and every relisting of its actions say how many are left at the step, as a line Refinements left at this step: N, wherever the widget has a refining action); autopilot.handback-presented is the turn-level hand-back, shown when a working turn ended needing the person with no widget to hand over (detail.why: max-iterations, context-exhausted, failure or question; detail.options; detail.choice once answered); autopilot.catch-up is the autopilot being given the whole visible transcript at once (detail.why: first, for its first decision in a flow or after a reload; size, when its own history passed its budget and was rebuilt short — detail.ownChars; or compacted, when a compaction removed the last message it had seen, so it reads the summary and everything since, short; in each, what it had sent on the user behalf is included and labelled as its own, since its own history does not hold it); autopilot.cost-dropped is autopilot spend that no message carries, so it is NOT in the session total (detail.costUsd and detail.why: handed-back, aborted or stale for a written question it answered that no reply was sent for — stale when a pause, a resume, a new turn or the end of its flow came before the answer landed, which then went nowhere — or no-recorder when the driver had no way to book a decision to its interaction); a hand-back trigger can also be budget (the decision passed its spend cap), watchdog (its work went quiet: no ready surface and no heartbeat, or its own decision stalled with no model call landing, which stops that decision) or detached (the autopilot was removed while it held the interaction, which went to the person with no reason shown). To debug one autopilot decision, follow its interactionId: interaction.requested (heldBy), autopilot.claimed, autopilot.decision-sent, autopilot.acted or autopilot.handed-back, interaction.invoked, interaction.resolved (answeredBy), then the next turn of the working agent), interaction.invoked (a claimant ran one of the actions the widget itself exposes, through its hold, the same code the button runs — detail.claimant, detail.action (an option id, select or reply) and detail.finished, whether that settled the interaction, and when it did not, the run is recorded as an edit; the choice and narration it recorded reach the result of the tool that asked as decidedOnUsersBehalf), interaction.step (a long action run as named steps through runSteps, which survive a reload — detail.step and detail.outcome: started, done, skipped when the step was already done before a reload, or resumed when it started before a reload and runs again with what it saved part-way, such as a job id it re-attaches to), interaction.checkpoint (the checkpoints a conversation keeps for its long actions: the one in flight, and each one a reload cut, held apart until a request of its own widget type takes it over, so a resumed flow that opens other long widgets first, which save their own, loses nothing — detail.action: resumed when a reload cut the work and a request of the same widget type that the registration sameWork agrees is the same work took it over, refused when sameWork said a new request is different work (detail.saved is the identity it kept; detail.kept: true, since it stays for a later request of that type, and is offered to every one until one agrees) or when runSteps found the handed-over checkpoint malformed and started fresh (detail.reason, detail.saved), or cleared when its flow ended, once per checkpoint, with detail.cut: true for one a reload cut that nothing took over), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
     'Sub-agent meta events: a sub-agent\'s own turn.retry/turn.error/tool.failed/tool.unresolved events are merged into this same timeline, tagged with `detail.subAgent` — a `"<parent> › <sub-agent>"` breadcrumb that composes when nested (e.g. `"UI Builder › Planner › Grounding"`) — and interleaved by their original timestamps within the subagent.started→completed/failed bracket. These are the per-attempt/per-failure signals that do NOT appear among the sub-agent\'s (hoisted) messages: a malformed/empty attempt that gets retried produces no message, and the stale-vs-hallucinated split and streak counts live only on the event. A sub-agent\'s high-volume, message-derivable events (turn.start/turn.end, provider.selected, context.updated) are intentionally NOT merged — read its hoisted messages for model/tokens/cost and turn-by-turn activity, and the bracketing subagent.* events for the run\'s span.',
     "`meta` holds context captured at export time: agentSummary (full agent configs), context (active model, contextTokens/contextLimit/contextUsagePercent for the last call, and the session totals — sessionCostUsd, sessionTokensConsumed, and the four-bucket sessionUsage lifted to the top of this log), 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.",
     'Note the two different scopes in `meta.context`: `contextTokens` is the prompt size of the LAST call (against `contextLimit`, the model context window), while `sessionUsage`/`sessionTokensConsumed` are cumulative BILLED throughput. Every turn resends the conversation, so the cumulative figure counts each turn’s prompt again in the next turn’s and is expected to dwarf the context size — that is not double-counting.',

package/dist/react.cjs

@@ -53,12 +53,14 @@ const AiWavesIndicator = React.forwardRef(function AiWavesIndicator(props, ref)
 });
 
 const FoundationAiAssistant = React.forwardRef(function FoundationAiAssistant(props, ref) {
-  const { onBudgetRefreshRequested, onChatHeaderMousedown, onSessionCleared, onHandoffStarted, onHandoffReturned, onHandoffUnwound, children, ...rest } = props;
+  const { onBudgetRefreshRequested, onChatHeaderMousedown, onCloseRequested, onSessionCleared, onHandoffStarted, onHandoffReturned, onHandoffUnwound, children, ...rest } = props;
   const _innerRef = React.useRef(null);
   const _onBudgetRefreshRequestedRef = React.useRef(onBudgetRefreshRequested);
   _onBudgetRefreshRequestedRef.current = onBudgetRefreshRequested;
   const _onChatHeaderMousedownRef = React.useRef(onChatHeaderMousedown);
   _onChatHeaderMousedownRef.current = onChatHeaderMousedown;
+  const _onCloseRequestedRef = React.useRef(onCloseRequested);
+  _onCloseRequestedRef.current = onCloseRequested;
   const _onSessionClearedRef = React.useRef(onSessionCleared);
   _onSessionClearedRef.current = onSessionCleared;
   const _onHandoffStartedRef = React.useRef(onHandoffStarted);
@@ -74,6 +76,8 @@ const FoundationAiAssistant = React.forwardRef(function FoundationAiAssistant(pr
     el.addEventListener('budget-refresh-requested', _onBudgetRefreshRequestedFn);
     const _onChatHeaderMousedownFn = (e) => _onChatHeaderMousedownRef.current?.(e);
     el.addEventListener('chat-header-mousedown', _onChatHeaderMousedownFn);
+    const _onCloseRequestedFn = (e) => _onCloseRequestedRef.current?.(e);
+    el.addEventListener('close-requested', _onCloseRequestedFn);
     const _onSessionClearedFn = (e) => _onSessionClearedRef.current?.(e);
     el.addEventListener('session-cleared', _onSessionClearedFn);
     const _onHandoffStartedFn = (e) => _onHandoffStartedRef.current?.(e);
@@ -85,6 +89,7 @@ const FoundationAiAssistant = React.forwardRef(function FoundationAiAssistant(pr
     return () => {
       el.removeEventListener('budget-refresh-requested', _onBudgetRefreshRequestedFn);
       el.removeEventListener('chat-header-mousedown', _onChatHeaderMousedownFn);
+      el.removeEventListener('close-requested', _onCloseRequestedFn);
       el.removeEventListener('session-cleared', _onSessionClearedFn);
       el.removeEventListener('handoff-started', _onHandoffStartedFn);
       el.removeEventListener('handoff-returned', _onHandoffReturnedFn);