@genesislcap/ai-assistant 15.61.0 → 15.63.0

package/dist/esm/autopilot/decision-message.js

@@ -0,0 +1,206 @@
+import { getInteractionRegistration } from '../state/interaction-registry';
+import { filterVisibleMessages } from '../utils/message-partition';
+/** How long a fallback dump of a widget's data may run, in characters. */
+const FALLBACK_DATA_CHARS = 2000;
+/**
+ * A widget as text: what the person saw (GENC-1660 §4.7). From its registration's `asText` when it
+ * has one; otherwise its name and a size-limited dump of its data — ugly, never wrong, and a nudge
+ * to register one.
+ */
+export function widgetAsText(componentName, data, result) {
+    var _a, _b;
+    const asText = (_a = getInteractionRegistration(componentName)) === null || _a === void 0 ? void 0 : _a.asText;
+    if (asText) {
+        try {
+            return asText(data, result);
+        }
+        catch (_c) {
+            // Fall through to the dump: a broken text form must not hide the decision.
+        }
+    }
+    const dump = (_b = JSON.stringify(data)) !== null && _b !== void 0 ? _b : '';
+    return `[${componentName}] ${dump.length > FALLBACK_DATA_CHARS ? `${dump.slice(0, FALLBACK_DATA_CHARS)}…` : dump}`;
+}
+/**
+ * List a surface's actions for the model (GENC-1660 §4.2). Options are numbered from 1, so they are
+ * chosen by number rather than by retyping a label; platform-owned actions keep their names. An
+ * unavailable action is listed, and marked, so the model knows it exists but cannot take it.
+ */
+export function renderActions(actions, options = {}) {
+    var _a;
+    const numbering = [];
+    const lines = [];
+    for (const action of actions) {
+        // Past the refinement limit, `reply` is not offered at all: not listed, not runnable.
+        if (options.withholdReply && action.args === 'text')
+            continue;
+        const unavailable = action.enabled ? '' : ' (not available right now)';
+        if (action.description !== undefined) {
+            // A full-form action: named, described, and finishing or not.
+            const call = action.args === 'fields' ? `${action.name}({fields})` : `${action.name}()`;
+            const settles = action.finishes ? 'settles it' : 'does not settle it';
+            lines.push(`  ${call} — ${action.description} (${settles})${unavailable}`);
+            if (action.argsSchema)
+                lines.push(`    fields schema: ${JSON.stringify(action.argsSchema)}`);
+        }
+        else if (action.args === 'options') {
+            lines.push(`  select({options}) — choose several, by number or label${unavailable}`);
+        }
+        else if (action.args === 'text') {
+            lines.push(`  reply({text}) — answer in your own words${unavailable}`);
+        }
+        else {
+            numbering.push(action.name);
+            lines.push(`  [${numbering.length}] "${(_a = action.label) !== null && _a !== void 0 ? _a : action.name}"${unavailable}`);
+        }
+    }
+    const allSettle = actions.every((a) => a.description === undefined);
+    return {
+        text: `${allSettle ? 'Actions (each settles it)' : 'Actions'}:\n${lines.join('\n')}`,
+        numbering,
+    };
+}
+/** The current decision as one message for the autopilot (GENC-1660 §4.2). */
+export function renderDecision(opts) {
+    var _a, _b;
+    const { surface } = opts;
+    const facts = surface.facts();
+    const actions = renderActions(surface.actions(), { withholdReply: opts.withholdReply });
+    // A full-form surface describes itself, lists its views, and shows its default view up front, to
+    // save a round trip.
+    let full = [];
+    if (surface.describe) {
+        let preview = '';
+        try {
+            preview = JSON.stringify((_a = surface.read) === null || _a === void 0 ? void 0 : _a.call(surface));
+        }
+        catch (_c) {
+            preview = '';
+        }
+        full = [
+            surface.describe(),
+            ...(((_b = surface.views) === null || _b === void 0 ? void 0 : _b.length) ? [`Views (widget_read): ${surface.views.join(', ')}`] : []),
+            ...(preview ? [`Now: ${preview}`] : []),
+        ];
+    }
+    const parts = [
+        `<interaction id="${opts.interactionId}" widget="${opts.componentName}">`,
+        widgetAsText(opts.componentName, opts.data),
+        ...full,
+        ...(Object.keys(facts).length ? [`Facts: ${JSON.stringify(facts)}`] : []),
+        ...(surface.prompt ? [`Guidance: ${surface.prompt}`] : []),
+        actions.text,
+        ...(opts.decideYourself
+            ? [
+                'The user handed this one back to you and asked you to use your best judgement: decide it yourself. hand_back is not available.',
+            ]
+            : []),
+        '</interaction>',
+    ];
+    return { text: parts.join('\n'), numbering: actions.numbering };
+}
+/**
+ * A written question the working agent ended its turn on, as one message for the autopilot
+ * (GENC-1660 §4.2): answer it in the user's place, or hand it back.
+ */
+export function renderQuestion(question, opts = {}) {
+    return [
+        '<question>',
+        'The assistant asked the user this, and is waiting for their answer:',
+        question,
+        "Actions:\n  reply({text}) — answer it in the user's place, with widget_act",
+        ...(opts.decideYourself
+            ? ['The user asked you to use your best judgement: hand_back is not available.']
+            : []),
+        '</question>',
+    ].join('\n');
+}
+/**
+ * What the person sees with the chat's default settings: no reasoning, no narration, no tool calls.
+ * The autopilot sees the same, whatever toggles this user has switched on, so runs are repeatable
+ * (§4.7, §4.11).
+ */
+const DEFAULT_VISIBILITY = {
+    showToolCalls: false,
+    showThinkingSteps: false,
+    showNarration: false,
+    showAgentSwitchIndicator: false,
+    showRestoreNotices: false,
+};
+/**
+ * Who answered a resolved widget, as the autopilot is told. Nobody, only when it timed out: the
+ * record of who answered is newer than some saved sessions, so a widget without one that did not
+ * time out was answered by the person. `claimant` is this autopilot; any other claimant answered on
+ * the user's behalf.
+ */
+const answeredPhrase = (resolved, answeredBy, claimant) => {
+    if ((resolved === null || resolved === void 0 ? void 0 : resolved.status) === 'timeout') {
+        return 'answered by nobody';
+    }
+    if (answeredBy === claimant)
+        return 'answered by you';
+    if (answeredBy === undefined || answeredBy === 'user')
+        return 'answered by the user';
+    return "answered on the user's behalf";
+};
+/** Recent entries a short-form transcript keeps verbatim. */
+const SHORT_FORM_RECENT = 20;
+/**
+ * What the person could see in `messages`, as lines, for the autopilot's `<since-last>` block
+ * (GENC-1660 §4.7). Built with the renderer's own visibility function at the default settings, so
+ * what the autopilot is told and what the person sees cannot drift: verbatim user messages and
+ * visible assistant output (driver notices included — hidden from the model is not hidden from the
+ * person); interactions by their text form and who answered. Never the working agent's hidden prose,
+ * tool calls or results: the autopilot checks proposals against its grounding, not against the
+ * argument that produced them.
+ *
+ * `claimant` is this autopilot's id. Its own messages — what it said to the person, and what it
+ * sent on the user's behalf — are left out while its own history holds them; `includeOwn` puts them
+ * in, labelled as its own, for when it does not (a first decision, a reload, a rebuild, or a
+ * compaction that removed what it last saw). `short` keeps the last entries verbatim and reduces
+ * older answered widgets to their first line — the form a catch-up after a long flow uses.
+ */
+export function visibleTranscript(messages, opts) {
+    const visible = filterVisibleMessages([...messages], DEFAULT_VISIBILITY);
+    const olderThan = opts.short ? visible.length - SHORT_FORM_RECENT : -1;
+    const lines = [];
+    visible.forEach((m, i) => {
+        var _a, _b, _c, _d, _e, _f;
+        if (m.interaction) {
+            const { interactionId, componentName, data, resolved, answeredBy } = m.interaction;
+            if (interactionId === opts.skipInteractionId || !resolved)
+                return;
+            const answered = answeredPhrase(resolved, answeredBy, opts.claimant);
+            const text = widgetAsText(componentName, data, resolved);
+            lines.push(`[${componentName}, ${answered}] ${i < olderThan ? text.split('\n')[0] : text}`);
+            return;
+        }
+        if (m.role === 'compacted-summary') {
+            lines.push(`[Earlier, summarised] ${(_a = m.content) !== null && _a !== void 0 ? _a : ''}`);
+            // The user's own words from the summarised part, which a summary must not paraphrase.
+            for (const u of (_c = (_b = m.compaction) === null || _b === void 0 ? void 0 : _b.preservedUserMessages) !== null && _c !== void 0 ? _c : []) {
+                lines.push(u.delegate === opts.claimant && opts.includeOwn
+                    ? `You (on the user's behalf, earlier): ${u.content}`
+                    : u.delegate
+                        ? `User (on their behalf, earlier): ${u.content}`
+                        : `User (earlier): ${u.content}`);
+            }
+            return;
+        }
+        if (m.delegate === opts.claimant) {
+            if (!opts.includeOwn || !((_d = m.content) === null || _d === void 0 ? void 0 : _d.trim()))
+                return;
+            lines.push(m.role === 'assistant'
+                ? `You (to the user): ${m.content}`
+                : `You (on the user's behalf): ${m.content}`);
+            return;
+        }
+        if ((m.role === 'user' || m.role === 'synthetic-user') && ((_e = m.content) === null || _e === void 0 ? void 0 : _e.trim())) {
+            lines.push(m.delegate ? `User (on their behalf): ${m.content}` : `User: ${m.content}`);
+            return;
+        }
+        if (m.role === 'assistant' && ((_f = m.content) === null || _f === void 0 ? void 0 : _f.trim()))
+            lines.push(`Assistant: ${m.content}`);
+    });
+    return lines;
+}

package/dist/esm/autopilot/hand-back/hand-back.controller.js

@@ -0,0 +1,47 @@
+/**
+ * The tag of the turn-level hand-back widget (GENC-1660 §4.10): what the autopilot shows when a
+ * working turn ends needing the person, and there is no widget to hand over.
+ *
+ * @beta
+ */
+export const AUTOPILOT_HAND_BACK = 'ai-autopilot-hand-back';
+/**
+ * The hand-back's controller. DOM-free: it exposes the choices as a decision (so the visible
+ * transcript and the debug log describe it like any widget) and resolves through `ctx.resolve`. The
+ * hand-back is always `userOnly`, so nothing but the person ever answers it.
+ */
+export class HandBackController {
+    constructor(data, ctx) {
+        this.data = data;
+        this.ctx = ctx;
+        ctx.exposeDecision({
+            options: data.options.map((o) => ({ id: o.id, label: o.label })),
+            freeText: data.freeText,
+            choose: (answer) => this.choose(answer),
+        });
+    }
+    /** The person's choice, from the view's buttons or its text box. */
+    choose(answer) {
+        const payload = answer.kind === 'text'
+            ? { choice: 'reply', text: answer.text }
+            : {
+                choice: (answer.kind === 'option'
+                    ? answer.option
+                    : answer.options[0]),
+            };
+        this.ctx.resolve({ status: 'approved', payload });
+    }
+}
+/** The hand-back as text: what the person saw, and what they chose. */
+export function handBackAsText(data, result) {
+    var _a, _b;
+    const d = data;
+    const lines = [d.message, ...(d.question ? [`Question: ${d.question}`] : [])];
+    lines.push(`Options: ${d.options.map((o) => o.label).join(' | ')}`);
+    const payload = result === null || result === void 0 ? void 0 : result.payload;
+    if (payload) {
+        const label = (_b = (_a = d.options.find((o) => o.id === payload.choice)) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : payload.choice;
+        lines.push(`Answer: ${payload.choice === 'reply' ? payload.text : label}`);
+    }
+    return lines.join('\n');
+}

package/dist/esm/autopilot/hand-back/hand-back.js

@@ -0,0 +1,129 @@
+import { __decorate } from "tslib";
+import { css, customElement, GenesisElement, html, observable, repeat, when, } from '@genesislcap/web-core';
+import { AUTOPILOT_HAND_BACK, } from './hand-back.controller';
+const template = html `
+  <p class="message">${(x) => { var _a; return (_a = x.data) === null || _a === void 0 ? void 0 : _a.message; }}</p>
+  ${when((x) => { var _a; return !!((_a = x.data) === null || _a === void 0 ? void 0 : _a.question); }, html `
+      <p class="question">${(x) => { var _a; return (_a = x.data) === null || _a === void 0 ? void 0 : _a.question; }}</p>
+    `)}
+  ${when((x) => x.answer !== undefined, html `
+      <p class="answer">✓ ${(x) => x.answer}</p>
+    `)}
+  ${when((x) => x.answer === undefined, html `
+      ${when((x) => { var _a; return !!((_a = x.data) === null || _a === void 0 ? void 0 : _a.freeText); }, html `
+          <textarea
+            class="reply"
+            rows="2"
+            :value="${(x) => x.draft}"
+            @input="${(x, c) => {
+    x.draft = c.event.target.value;
+    return true;
+}}"
+          ></textarea>
+          <rapid-button
+            appearance="accent"
+            ?disabled="${(x) => !x.draft.trim()}"
+            @click="${(x) => {
+    x.reply();
+    return true;
+}}"
+          >
+            ${(x) => { var _a; return (_a = x.data) === null || _a === void 0 ? void 0 : _a.sendLabel; }}
+          </rapid-button>
+        `)}
+      <div class="options">
+        ${repeat((x) => { var _a, _b; return (_b = (_a = x.data) === null || _a === void 0 ? void 0 : _a.options) !== null && _b !== void 0 ? _b : []; }, html `
+            <rapid-button
+              @click="${(o, c) => {
+    c.parent.choose(o.id);
+    return true;
+}}"
+            >
+              ${(o) => o.label}
+            </rapid-button>
+          `)}
+      </div>
+    `)}
+`;
+const styles = css `
+  :host {
+    display: block;
+    font: inherit;
+  }
+  .message,
+  .question,
+  .answer {
+    margin: 0 0 calc(var(--design-unit) * 2px);
+  }
+  .question {
+    font-style: italic;
+  }
+  .reply {
+    width: 100%;
+    box-sizing: border-box;
+    font: inherit;
+    margin-bottom: calc(var(--design-unit) * 2px);
+  }
+  .options {
+    display: flex;
+    flex-wrap: wrap;
+    gap: calc(var(--design-unit) * 2px);
+    margin-top: calc(var(--design-unit) * 2px);
+  }
+`;
+/**
+ * The turn-level hand-back's view (GENC-1660 §4.10): the message, the working agent's question if
+ * there was one, and the choices. It only renders: choosing calls the controller, which resolves.
+ * Always the person's to answer (`userOnly`), so it never hides itself.
+ *
+ * @beta
+ */
+let AutopilotHandBack = class AutopilotHandBack extends GenesisElement {
+    constructor() {
+        super(...arguments);
+        this.interactionId = '';
+        this.draft = '';
+    }
+    get data() {
+        var _a;
+        return (_a = this.interaction) === null || _a === void 0 ? void 0 : _a.data;
+    }
+    /** What was chosen, once resolved. */
+    get answer() {
+        var _a, _b, _c, _d, _e;
+        if (((_a = this.interaction) === null || _a === void 0 ? void 0 : _a.status) !== 'resolved')
+            return undefined;
+        const payload = this.interaction.result.payload;
+        if (!payload)
+            return '';
+        if (payload.choice === 'reply')
+            return (_b = payload.text) !== null && _b !== void 0 ? _b : '';
+        return (_e = (_d = (_c = this.data) === null || _c === void 0 ? void 0 : _c.options.find((o) => o.id === payload.choice)) === null || _d === void 0 ? void 0 : _d.label) !== null && _e !== void 0 ? _e : payload.choice;
+    }
+    get controller() {
+        var _a;
+        return ((_a = this.interaction) === null || _a === void 0 ? void 0 : _a.status) === 'pending'
+            ? this.interaction.interactionContext.controller
+            : undefined;
+    }
+    choose(option) {
+        var _a;
+        (_a = this.controller) === null || _a === void 0 ? void 0 : _a.choose({ kind: 'option', option });
+    }
+    reply() {
+        var _a;
+        const text = this.draft.trim();
+        if (text)
+            (_a = this.controller) === null || _a === void 0 ? void 0 : _a.choose({ kind: 'text', text });
+    }
+};
+__decorate([
+    observable
+], AutopilotHandBack.prototype, "interaction", void 0);
+__decorate([
+    observable
+], AutopilotHandBack.prototype, "draft", void 0);
+AutopilotHandBack = __decorate([
+    customElement({ name: AUTOPILOT_HAND_BACK, template, styles })
+], AutopilotHandBack);
+export { AutopilotHandBack };

package/dist/esm/autopilot/index.js

@@ -0,0 +1,4 @@
+export { AUTOPILOT_CLAIMANT, AutopilotDriver, } from './autopilot-driver';
+export { AUTOPILOT_HAND_BACK, } from './hand-back/hand-back.controller';
+// The view: importing the package defines the element, so the host can render the hand-back.
+export { AutopilotHandBack } from './hand-back/hand-back';

package/dist/esm/channel/ai-activity-bus.js

@@ -41,6 +41,7 @@ export class AgenticActivityBus {
      * browser environment; elsewhere the bus stays purely in-process.
      */
     ensureChannel() {
+        var _a, _b;
         if (this.channelInitialised)
             return;
         this.channelInitialised = true;
@@ -48,6 +49,12 @@ export class AgenticActivityBus {
         if (this.crossTabEvents.size === 0 || !this.channelNameFactory || !inBrowser)
             return;
         this.channel = new BroadcastChannel(this.channelNameFactory());
+        // Node's BroadcastChannel (which jsdom test runs get, since they also have a `window`) is an
+        // open handle that keeps the process alive, and tests that touched the bus hung after their last
+        // assertion, again and again, unless they remembered to `close()` it. Unref it so a channel can
+        // never hold the process open: it still delivers while anything else keeps the process running.
+        // Browsers have no `unref` (a tab never "exits"), so there this does nothing.
+        (_b = (_a = this.channel).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
         this.channel.onmessage = (ev) => {
             var _a;
             const { type, detail } = ((_a = ev.data) !== null && _a !== void 0 ? _a : {});

package/dist/esm/channel/autopilot-needs-user.js

@@ -0,0 +1,26 @@
+import { agenticActivityBus } from './ai-activity-bus';
+/**
+ * Which sessions have something waiting on the person while their autopilot is available
+ * (GENC-1660 §4.10), kept as well as announced: the collapsed assistant can mount after the change
+ * was published — a popin, or a host adding the bubble late — and an event alone would leave its
+ * badge wrong until the next change. Keyed by session, so two assistants on one page each badge
+ * only their own.
+ */
+const waiting = new Set();
+/** Set it for one session, announcing `autopilot-needs-user` when it changes. */
+export function setAutopilotNeedsUser(sessionKey, needsUser) {
+    if (waiting.has(sessionKey) === needsUser)
+        return;
+    if (needsUser)
+        waiting.add(sessionKey);
+    else
+        waiting.delete(sessionKey);
+    agenticActivityBus.publish('autopilot-needs-user', { sessionKey, needsUser });
+}
+/**
+ * Whether a session has something waiting on the person — or, without a key (a bubble that cannot
+ * tell which assistant it holds), whether any session has.
+ */
+export function autopilotNeedsUser(sessionKey) {
+    return sessionKey === undefined ? waiting.size > 0 : waiting.has(sessionKey);
+}

package/dist/esm/components/agent-picker/agent-picker.constants.js

@@ -1,2 +1,12 @@
 /** Sentinel value representing "Auto" where a menu row needs a string value. */
 export const AGENT_PICKER_AUTO_VALUE = '__auto__';
+/**
+ * The picker's default name for orchestration: the assistant routes each message to the agent it
+ * suits, as opposed to a pinned agent. Not "Auto", which other tools use for picking a model tier;
+ * "Orchestration" says that several agents stand behind it.
+ */
+export const DEFAULT_ORCHESTRATION_LABEL = 'Orchestration';
+/** The same choice as the picker menu's first row. The same word by default; separate so a host can say more there. */
+export const DEFAULT_ORCHESTRATION_MENU_LABEL = 'Orchestration';
+/** What orchestration does, as the menu row's hint and the pill's tooltip. */
+export const DEFAULT_ORCHESTRATION_DESCRIPTION = 'Each message goes to the specialist it suits.';

package/dist/esm/components/agent-picker/agent-picker.js

@@ -1,7 +1,7 @@
 import { __decorate } from "tslib";
 import { customElement, GenesisElement, observable, volatile } from '@genesislcap/web-core';
 import { pinColourAt } from '../../styles/ai-colours';
-import { AGENT_PICKER_AUTO_VALUE } from './agent-picker.constants';
+import { AGENT_PICKER_AUTO_VALUE, DEFAULT_ORCHESTRATION_DESCRIPTION, DEFAULT_ORCHESTRATION_MENU_LABEL, } from './agent-picker.constants';
 import { styles } from './agent-picker.styles';
 import { AgentPickerTemplate } from './agent-picker.template';
 export { AGENT_PICKER_AUTO_VALUE };
@@ -39,6 +39,10 @@ let AgentPicker = class AgentPicker extends GenesisElement {
         this.pinnedAgentName = null;
         /** When true, rows show a neutral dot instead of the per-agent brand tint. */
         this.disablePinColours = false;
+        /** The orchestration row's name, from `chatConfig.picker.orchestrationMenuLabel` (resolved by the host). */
+        this.orchestrationLabel = DEFAULT_ORCHESTRATION_MENU_LABEL;
+        /** The orchestration row's hint, from `chatConfig.picker.orchestrationDescription` (resolved by the host). */
+        this.orchestrationDescription = DEFAULT_ORCHESTRATION_DESCRIPTION;
     }
     /** Top-level agents that opted in to manual selection. */
     get selectableAgents() {
@@ -103,6 +107,12 @@ __decorate([
 __decorate([
     observable
 ], AgentPicker.prototype, "disablePinColours", void 0);
+__decorate([
+    observable
+], AgentPicker.prototype, "orchestrationLabel", void 0);
+__decorate([
+    observable
+], AgentPicker.prototype, "orchestrationDescription", void 0);
 __decorate([
     volatile
 ], AgentPicker.prototype, "selectableAgents", null);

package/dist/esm/components/agent-picker/agent-picker.template.js

@@ -1,6 +1,4 @@
 import { html, repeat } from '@genesislcap/web-core';
-const AUTO_LABEL = 'Auto';
-const AUTO_HINT = 'Let the assistant route each message to the right agent.';
 /**
  * One selectable row. `menuitemradio` rather than `menuitem` because the choice
  * is single-select and sticky — a screen reader should announce which agent is
@@ -41,8 +39,8 @@ export const AgentPickerTemplate = () => html `
     >
       <span class="menu-item-mark" aria-hidden="true"></span>
       <span class="menu-item-body">
-        <span class="menu-item-name">${() => AUTO_LABEL}</span>
-        <span class="menu-item-hint">${() => AUTO_HINT}</span>
+        <span class="menu-item-name">${(x) => x.orchestrationLabel}</span>
+        <span class="menu-item-hint">${(x) => x.orchestrationDescription}</span>
       </span>
     </button>
     <div class="menu-separator" role="separator"></div>

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

@@ -11,8 +11,10 @@ export const AI_DRIVER_EVENT_TYPES = Object.keys({
     'sub-agent-stop': true,
     'interaction-start': true,
     'interaction-stop': true,
+    'interaction-settled': true,
     'provider-changed': true,
     'external-cost-recorded': true,
+    'checkpoint-saved': true,
     'agent-changed': true,
     'agent-released': true,
     'flow-owner-changed': true,

package/dist/esm/components/ai-driver/base-driver-decorator.js

@@ -119,6 +119,14 @@ export class BaseDriverDecorator extends EventTarget {
         var _a, _b, _c;
         return (_c = (_b = (_a = this.inner).getFlowOwner) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : null;
     }
+    getInteractionCheckpoint() {
+        var _a, _b;
+        return (_b = (_a = this.inner).getInteractionCheckpoint) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    restoreInteractionCheckpoint(saved) {
+        var _a, _b;
+        (_b = (_a = this.inner).restoreInteractionCheckpoint) === null || _b === void 0 ? void 0 : _b.call(_a, saved);
+    }
     /**
      * Forwarded, so an interceptor installed on any layer lands on the driver that opens the
      * interactions. A decorator that answers interactions installs its own on `this.inner`.

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

@@ -1,6 +1,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 { styles } from './chat-bubble.styles';
 import { AiChatBubbleTemplate } from './chat-bubble.template';
 /**
@@ -60,6 +61,12 @@ let AiChatBubble = class AiChatBubble extends GenesisElement {
         super(...arguments);
         this.title = 'AI Assistant';
         this.designSystemPrefix = 'rapid';
+        /**
+         * What the "needs you" badge on the orb says — its tooltip, and what a screen reader announces
+         * when it appears (GENC-1660 §4.10). The bubble cannot read the autopilot's own wording, so a host
+         * that renames or localises the autopilot sets this too.
+         */
+        this.needsInputLabel = 'The assistant needs your input';
         /** @internal */
         this.dialogContent = [];
         /** @internal */
@@ -80,6 +87,11 @@ let AiChatBubble = class AiChatBubble extends GenesisElement {
         this.dialogOpen = false;
         /** Whether the bubble orb is currently hovered. @internal */
         this.hovered = false;
+        /**
+         * Whether the autopilot waits on the person (GENC-1660 §4.10): a hand-back the closed chat would
+         * otherwise hide. Shown as a badge on the orb; opening the chat shows what it waits on. @internal
+         */
+        this.needsUser = false;
         this.dragging = false;
         this.dragTarget = null;
         this.startMouseX = 0;
@@ -153,6 +165,7 @@ let AiChatBubble = class AiChatBubble extends GenesisElement {
                             this.dialogLeft = Math.max(VIEWPORT_EDGE_MARGIN, this.bubbleLeft - DIALOG_BUBBLE_HORIZONTAL_OFFSET);
                             this.dialogTop = Math.max(VIEWPORT_EDGE_MARGIN, this.bubbleTop - DIALOG_OPEN_TOP_OFFSET);
                             this.dialogOpen = true;
+                            this.showWaitingIfBadged();
                         }
                     }
                 }
@@ -182,9 +195,12 @@ let AiChatBubble = class AiChatBubble extends GenesisElement {
             this.hidden = false;
             this.dialogOpen = true;
         });
+        this.refreshNeedsUser();
+        const unsubNeedsUser = agenticActivityBus.subscribe('autopilot-needs-user', () => this.refreshNeedsUser());
         this.unsubBus = () => {
             unsubPopout();
             unsubPopin();
+            unsubNeedsUser();
         };
         // Measure tooltip width once after first render. The bubble is visible on connect
         // (dialogOpen starts false), so the element is in the DOM by the time rAF fires.
@@ -266,7 +282,30 @@ let AiChatBubble = class AiChatBubble extends GenesisElement {
             this.resizeObserver = undefined;
         }
     }
+    /**
+     * The session of the assistant this bubble holds, when it can tell: the key the assistant
+     * publishes under, read from the assistant in the bubble's light DOM — whether or not the dialog
+     * (and with it the slot) is rendered, since the badge shows while it is not.
+     */
+    assistantSessionKey() {
+        var _a;
+        const assistant = this.findAssistant([...this.children]);
+        return (_a = assistant === null || assistant === void 0 ? void 0 : assistant.stateKey) !== null && _a !== void 0 ? _a : undefined;
+    }
+    /** Opened from the badge: take the person to what is waiting on them (GENC-1660). */
+    showWaitingIfBadged() {
+        if (!this.needsUser)
+            return;
+        agenticActivityBus.publish('autopilot-show-waiting', {
+            sessionKey: this.assistantSessionKey(),
+        });
+    }
+    /** Badge only for this bubble's own assistant (GENC-1660). */
+    refreshNeedsUser() {
+        this.needsUser = autopilotNeedsUser(this.assistantSessionKey());
+    }
     dialogContentChanged(_, next) {
+        this.refreshNeedsUser();
         const assistant = this.findAssistant(next);
         if (!assistant) {
             this.removeCloseButton();
@@ -415,6 +454,9 @@ __decorate([
 __decorate([
     attr({ attribute: 'design-system-prefix' })
 ], AiChatBubble.prototype, "designSystemPrefix", void 0);
+__decorate([
+    attr({ attribute: 'needs-input-label' })
+], AiChatBubble.prototype, "needsInputLabel", void 0);
 __decorate([
     observable
 ], AiChatBubble.prototype, "dialogContent", void 0);
@@ -445,6 +487,9 @@ __decorate([
 __decorate([
     observable
 ], AiChatBubble.prototype, "hovered", void 0);
+__decorate([
+    observable
+], AiChatBubble.prototype, "needsUser", void 0);
 AiChatBubble = __decorate([
     customElement({
         name: 'foundation-ai-chat-bubble',

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

@@ -99,6 +99,32 @@ export const styles = css `
     translate: 0 0;
   }
 
+  /* The autopilot waits on the person (GENC-1660): a dot on the orb, which opening the chat answers. */
+  .needs-you-badge {
+    position: absolute;
+    top: 2px;
+    right: 2px;
+    width: 14px;
+    height: 14px;
+    border: 2px solid var(--neutral-layer-1, #fff);
+    border-radius: 50%;
+    background: var(--accent-fill-rest, rgb(0 120 255));
+    pointer-events: none;
+  }
+
+  /* The badge's live region: out of paint and flow, kept in the accessibility tree. */
+  .visually-hidden {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    margin: -1px;
+    padding: 0;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border: 0;
+  }
+
   .pulse-ring {
     position: absolute;
     width: 62px;