@genesislcap/ai-assistant 15.60.0 → 15.62.0

package/dist/esm/main/main.js

@@ -27,9 +27,12 @@ import { showNotificationDialog } from '@genesislcap/foundation-notifications';
 import { avoidTreeShaking } from '@genesislcap/foundation-utils';
 import { customElement, DOM, html, GenesisElement, observable, volatile, attr, } from '@genesislcap/web-core';
 import DOMPurify from 'dompurify';
+import { AutopilotDriver, autopilotOf, } from '../autopilot/autopilot-driver';
 import { agenticActivityBus } from '../channel/ai-activity-bus';
+import { setAutopilotNeedsUser } from '../channel/autopilot-needs-user';
 import { AiActivityHalo } from '../components/activity-halo/activity-halo';
 import { AgentPicker } from '../components/agent-picker/agent-picker';
+import { DEFAULT_ORCHESTRATION_DESCRIPTION, DEFAULT_ORCHESTRATION_LABEL, DEFAULT_ORCHESTRATION_MENU_LABEL, } from '../components/agent-picker/agent-picker.constants';
 import { AiChatBubble } from '../components/chat-bubble/chat-bubble';
 import { ChatDriver } from '../components/chat-driver/chat-driver';
 import { AiChatInteractionWrapper } from '../components/chat-interaction-wrapper/chat-interaction-wrapper';
@@ -44,6 +47,7 @@ import { AiWavesIndicator } from '../components/waves-indicator';
 import { AssistantAppSettingsProvider, } from '../provider/assistant-app-settings';
 import { recordMetaEvent, getMetaEvents, clearSession as clearMetaSession, DEBUG_LOG_README, } from '../state/debug-event-log';
 import { getOrCreateDriver, getDriver, getDriverAgentsKey, deleteDriver, } from '../state/driver-registry';
+import { getInteractionRegistration } from '../state/interaction-registry';
 import { buildTimelineEntries } from '../state/persistence/build-timeline-entries';
 import { assembleDebugLog, withFreshMetaSnapshot } from '../state/persistence/diagnostics';
 import { deleteDiagnosticsCursorsFor, resetDiagnosticsCursorsFor, } from '../state/persistence/diagnostics-cursors';
@@ -487,6 +491,8 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         // one session (bubble + popped-out panel) and must share cursors, or they'd
         // double-append the stream.
         this.showHalo = 'no';
+        /** Who holds the trailing pending interaction: `'user'` unless a claimant took it. @internal */
+        this.activeHeldBy = 'user';
         // ── Session lifecycle menu (GENC-1351 §5.5) ─────────────────────────────────
         /** Two-step confirm for the destructive Clear action; reset whenever the menu toggles. */
         this.confirmingClear = false;
@@ -1191,7 +1197,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     /**
      * Name of the agent the user has pinned via the agent picker. `null` means
-     * automatic routing (Auto). Persisted on the session store, so it survives
+     * orchestration: the assistant routes each message. Persisted on the session store, so it survives
      * pop-in/pop-out but resets on page refresh.
      *
      * Only changes on explicit user action (picker click or host's `setAgent`).
@@ -1610,10 +1616,10 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             this.showHalo = 'no';
             return;
         }
-        const last = this.messages[this.messages.length - 1];
         // Hide only while a pending interaction blocks on the user; a resolved
-        // interaction means the assistant is computing again (keep the halo).
-        if ((last === null || last === void 0 ? void 0 : last.interaction) && !last.interaction.resolved) {
+        // interaction means the assistant is computing again (keep the halo), and so
+        // does one a claimant such as the autopilot holds (GENC-1660 §4.10).
+        if (this.waitingOnUser) {
             this.showHalo = 'no';
         }
         else if (this.showHalo !== 'orchestrating') {
@@ -1627,6 +1633,229 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         const last = this.messages[this.messages.length - 1];
         return !!(last === null || last === void 0 ? void 0 : last.interaction) && !last.interaction.resolved;
     }
+    /**
+     * True when the turn is parked on the person: a pending interaction they hold. One a claimant
+     * holds (the autopilot deciding it) is the assistant still working, so the halo and the loading
+     * indicator stay on (GENC-1660 §4.10).
+     */
+    get waitingOnUser() {
+        return this.hasActivePendingInteraction && this.activeHeldBy === 'user';
+    }
+    /** The autopilot behind the slim bar and the banner, if there is one. */
+    get autopilotHost() {
+        var _a;
+        return (_a = this.autopilotHostOverride) !== null && _a !== void 0 ? _a : autopilotOf(this.driver);
+    }
+    /** Whether the autopilot is available for the current flow, running or paused. @internal */
+    get autopilotAvailable() {
+        return !!this.autopilotState && this.autopilotState.mode !== 'unavailable';
+    }
+    /** Running and not waiting on an answer, so its control pauses it; otherwise it resumes. @internal */
+    get autopilotCanPause() {
+        var _a;
+        return ((_a = this.autopilotState) === null || _a === void 0 ? void 0 : _a.mode) === 'running' && !this.autopilotSelfPaused;
+    }
+    /**
+     * What clicking the toggle does, at the head of its tooltip. While it waits on a question it
+     * handed back, Resume is not a plain resume: it takes that question back and decides it, with no
+     * way to hand it back again. @internal
+     */
+    get autopilotToggleAction() {
+        const copy = this.autopilotCopy;
+        if (this.autopilotCanPause)
+            return copy === null || copy === void 0 ? void 0 : copy.pauseLabel;
+        return this.autopilotSelfPaused ? copy === null || copy === void 0 ? void 0 : copy.resumeDecideLabel : copy === null || copy === void 0 ? void 0 : copy.resumeLabel;
+    }
+    /**
+     * The toggle's tooltip: what clicking does now, then what the autopilot does. The action is here
+     * and not in its accessible name: the toggle is a toggle (`aria-pressed`), so its name stays
+     * `toggleLabel` and its state is announced once, by the pressed state. @internal
+     */
+    get autopilotToggleTitle() {
+        const copy = this.autopilotCopy;
+        if (!copy)
+            return undefined;
+        return `${this.autopilotToggleAction}: ${copy.description}`;
+    }
+    /** Waiting on one answer it handed back. @internal */
+    get autopilotSelfPaused() {
+        var _a, _b;
+        return ((_b = (_a = this.autopilotState) === null || _a === void 0 ? void 0 : _a.pause) === null || _b === void 0 ? void 0 : _b.scope) === 'this-interaction';
+    }
+    /**
+     * The slim bar takes the composer's place while something is happening and the autopilot runs or
+     * waits on one answer, and otherwise wherever the agent's own rules would hide the composer. Running
+     * but idle — stopped at a wall such as the budget, or at the end of a turn it had nothing to
+     * answer for — shows what those rules show, normally the composer, with the Autopilot pill on among
+     * its pills. It never forces the composer open. A host that hides the built-in composer
+     * (`chatConfig.ui.hideComposer`) has no pills to put it among, so there the slim bar stays up
+     * whenever the autopilot is available, running or paused, idle or not: the person can always see
+     * that it is on, and pause or resume it. @internal
+     */
+    get slimBarVisible() {
+        const state = this.autopilotState;
+        if (!state || state.mode === 'unavailable')
+            return false;
+        if (this.composerHiddenByConfig)
+            return true;
+        if ((state.mode === 'running' || this.autopilotSelfPaused) && state.working)
+            return true;
+        return this.busy && this.effectiveChatInputDuringExecution === 'hidden';
+    }
+    /**
+     * What the autopilot's status region announces (GENC-1660 §4.10): the hand-back, with its reason,
+     * while the autopilot waits on an answer; otherwise the slim bar's status while that shows;
+     * otherwise nothing. The region stays mounted and only this text changes, so each change is
+     * announced. @internal
+     */
+    get autopilotAnnouncement() {
+        var _a, _b;
+        const state = this.autopilotState;
+        if (!state || state.mode === 'unavailable')
+            return '';
+        if (this.autopilotSelfPaused) {
+            return [(_a = this.autopilotCopy) === null || _a === void 0 ? void 0 : _a.handBackLead, (_b = state.pause) === null || _b === void 0 ? void 0 : _b.reason].filter(Boolean).join(' ');
+        }
+        return this.slimBarVisible ? state.status : '';
+    }
+    /**
+     * The Autopilot pill among the composer's pills: available, with the composer shown — paused, or
+     * running with nothing happening. Where the host hides the composer, it is in the slim bar
+     * instead (see `slimBarVisible`). @internal
+     */
+    get composerAutopilotVisible() {
+        return this.autopilotAvailable && !this.slimBarVisible;
+    }
+    autopilotHostOverrideChanged() {
+        if (this.$fastController.isConnected)
+            this.wireAutopilot();
+    }
+    /** Follow the autopilot host's state, publishing the "needs you" signal for the bubble. */
+    wireAutopilot() {
+        var _a, _b;
+        (_a = this.autopilotCleanup) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.autopilotCleanup = undefined;
+        const host = this.autopilotHost;
+        const sessionKey = (_b = this.getStateKey()) !== null && _b !== void 0 ? _b : '';
+        const read = () => {
+            this.autopilotState = host === null || host === void 0 ? void 0 : host.state;
+            this.autopilotCopy = host === null || host === void 0 ? void 0 : host.copy;
+            setAutopilotNeedsUser(sessionKey, !!(host === null || host === void 0 ? void 0 : host.state.needsUser));
+        };
+        read();
+        if (!host)
+            return;
+        const unsubscribeHost = host.subscribe(read);
+        // Opened from the badge: bring what waits on the person into view.
+        const unsubscribeShow = agenticActivityBus.subscribe('autopilot-show-waiting', (detail) => {
+            if ((detail === null || detail === void 0 ? void 0 : detail.sessionKey) && detail.sessionKey !== sessionKey)
+                return;
+            this.showWaiting();
+        });
+        this.autopilotCleanup = () => {
+            unsubscribeHost();
+            unsubscribeShow();
+        };
+    }
+    /**
+     * Scroll to the pending interaction that waits on the person, and pulse it, so opening the chat
+     * from the badge lands on it rather than wherever the transcript was left.
+     */
+    showWaiting() {
+        const id = this.heldInteractionId;
+        if (!id)
+            return;
+        this._userScrolledAway = false;
+        this.scrollToBottom();
+        this.attentionInteractionId = id;
+        clearTimeout(this.attentionTimer);
+        this.attentionTimer = setTimeout(() => {
+            this.attentionInteractionId = undefined;
+        }, FoundationAiAssistant_1.ATTENTION_MS);
+    }
+    /**
+     * Follow who holds the trailing pending interaction. A claimant changes it on its context, which
+     * notifies, so the view re-reads it on every notification rather than once (GENC-1660 §4.3).
+     */
+    syncActiveHold() {
+        var _a;
+        const row = this.activeInteractionRow[0];
+        const pending = (row === null || row === void 0 ? void 0 : row.interaction) && !row.interaction.resolved ? row.interaction.interactionId : undefined;
+        if (pending !== this.heldInteractionId) {
+            (_a = this.heldCleanup) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.heldCleanup = undefined;
+            this.heldInteractionId = pending;
+            const ctx = pending ? this.getInteractionContext(pending) : undefined;
+            if (ctx)
+                this.heldCleanup = ctx.subscribe(() => this.readActiveHold());
+        }
+        this.readActiveHold();
+    }
+    readActiveHold() {
+        var _a;
+        const id = this.heldInteractionId;
+        const next = (id && ((_a = this.getInteractionContext(id)) === null || _a === void 0 ? void 0 : _a.heldBy)) || 'user';
+        if (next === this.activeHeldBy)
+            return;
+        this.activeHeldBy = next;
+        if (this.busy)
+            this.syncLoadingIndicator();
+        this.syncShowHalo();
+    }
+    /**
+     * Whether a pending interaction's bubble is drawn at all. A widget registered with
+     * `whileAutopilot: 'hidden'` asks for no chrome while a claimant holds it: the view renders
+     * nothing, so an empty bubble would be left behind. @internal
+     */
+    isHiddenWhileHeld(m) {
+        var _a;
+        const interaction = m.interaction;
+        if (!interaction || interaction.resolved)
+            return false;
+        if (interaction.interactionId !== this.heldInteractionId || this.activeHeldBy === 'user') {
+            return false;
+        }
+        return ((_a = getInteractionRegistration(interaction.componentName)) === null || _a === void 0 ? void 0 : _a.whileAutopilot) === 'hidden';
+    }
+    /** The hand-back banner's reason, when this interaction is the one the autopilot handed back. @internal */
+    handBackReasonFor(m) {
+        var _a, _b;
+        const pause = (_a = this.autopilotState) === null || _a === void 0 ? void 0 : _a.pause;
+        if (!m.interaction || m.interaction.resolved)
+            return undefined;
+        if ((pause === null || pause === void 0 ? void 0 : pause.scope) !== 'this-interaction' ||
+            pause.interactionId !== m.interaction.interactionId) {
+            return undefined;
+        }
+        return (_b = pause.reason) !== null && _b !== void 0 ? _b : '';
+    }
+    /** Whether to mark a message as done in autopilot mode. @internal */
+    showsDelegateMark(m) {
+        var _a, _b, _c;
+        if (((_b = (_a = this.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.delegatedMessages) === null || _b === void 0 ? void 0 : _b.marker) === 'none')
+            return false;
+        if (m.delegate)
+            return true;
+        const answeredBy = (_c = m.interaction) === null || _c === void 0 ? void 0 : _c.answeredBy;
+        return !!answeredBy && answeredBy !== 'user';
+    }
+    /** The autopilot mark's tooltip. @internal */
+    get delegateMarkLabel() {
+        var _a, _b;
+        return (_b = (_a = this.autopilotCopy) === null || _a === void 0 ? void 0 : _a.markLabel) !== null && _b !== void 0 ? _b : 'Done in autopilot mode';
+    }
+    handleAutopilotPause() {
+        var _a;
+        (_a = this.autopilotHost) === null || _a === void 0 ? void 0 : _a.pause();
+    }
+    handleAutopilotResume() {
+        var _a;
+        (_a = this.autopilotHost) === null || _a === void 0 ? void 0 : _a.resume();
+    }
+    handleKeepPaused(interactionId) {
+        var _a;
+        (_a = this.autopilotHost) === null || _a === void 0 ? void 0 : _a.keepPaused(interactionId);
+    }
     showHaloChanged() {
         var _a;
         if (!((_a = this.enabledAnimations) === null || _a === void 0 ? void 0 : _a.includes('halo')))
@@ -1789,7 +2018,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         }
     }
     createDriver() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this.warnUnreachableStatefulAgents();
         const agent = (_a = this.chatConfig.agent) !== null && _a !== void 0 ? _a : {};
         const { agents } = this;
@@ -1807,7 +2036,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                 // this via `agent-changed` once installAgent fires on first sendMessage.
                 this.activeAgent = agents[0];
             }
-            return new OrchestratingDriver(this.providerRegistry, agents, {
+            const orchestrator = new OrchestratingDriver(this.providerRegistry, agents, {
                 sessionKey: (_b = this.getStateKey()) !== null && _b !== void 0 ? _b : '',
                 maxHandoffs: agent.maxHandoffs,
                 classifierHistoryLength: agent.classifierHistoryLength,
@@ -1819,12 +2048,22 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                 budgetExhaustedMessage: this.transcriptBudgetExhaustedMessage,
                 aiServiceErrorMessages: this.aiServiceErrorMessages,
             });
+            // The autopilot is installed outermost, and only when some agent declares one (GENC-1660).
+            // The element keeps reading it as an `AutopilotHost`; nothing about it travels through
+            // `AiDriver`.
+            if (!agents.some((a) => a.autopilot))
+                return orchestrator;
+            return new AutopilotDriver(orchestrator, {
+                agents,
+                providerRegistry: this.providerRegistry,
+                sessionKey: (_c = this.getStateKey()) !== null && _c !== void 0 ? _c : '',
+            });
         }
         return new ChatDriver(this.providerRegistry, {
             maxToolIterations: agent.maxToolIterations,
             maxFoldOperations: agent.maxFoldOperations,
             maxTurnSnapshots: agent.maxTurnSnapshots,
-            sessionKey: (_c = this.getStateKey()) !== null && _c !== void 0 ? _c : '',
+            sessionKey: (_d = this.getStateKey()) !== null && _d !== void 0 ? _d : '',
             activityBus: agenticActivityBus,
             budgetExhaustedMessage: this.transcriptBudgetExhaustedMessage,
             aiServiceErrorMessages: this.aiServiceErrorMessages,
@@ -1877,6 +2116,9 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             (_b = this.persister()) === null || _b === void 0 ? void 0 : _b.scheduleDiagnostics();
         };
         driver.addEventListener('external-cost-recorded', onExternalCostRecorded);
+        // A long action's finished step changes no message, so autosave would miss it (GENC-1660).
+        const onCheckpointSaved = () => { var _a; return (_a = this.persister()) === null || _a === void 0 ? void 0 : _a.scheduleSave(); };
+        driver.addEventListener('checkpoint-saved', onCheckpointSaved);
         // Re-seed the rendered list from the driver's current history. `wireDriver`
         // runs on (re)connect, popin, and when adopting a sibling's driver
         // (GENC-1388); in those cases `messages` would otherwise stay stale until the
@@ -1940,6 +2182,14 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                 (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.removeInputOverride({ id: interactionId });
             }
         };
+        // An interaction answered by any route — including a controller's `ctx.resolve`, which never
+        // reaches `handleInteractionCompleted` — means the turn is about to compute again (GENC-1660).
+        // Not on a timeout or a stop, which carry no `answeredBy`: the turn may be ending.
+        const onInteractionSettled = (e) => {
+            var _a;
+            if ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.answeredBy)
+                this.startLoadingTimer();
+        };
         const onProviderChanged = (e) => {
             const { name } = e.detail;
             this.activeProviderName = name;
@@ -1952,15 +2202,18 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         driver.addEventListener('sub-agent-stop', onSubAgentStop);
         driver.addEventListener('interaction-start', onInteractionStart);
         driver.addEventListener('interaction-stop', onInteractionStop);
+        driver.addEventListener('interaction-settled', onInteractionSettled);
         driver.addEventListener('provider-changed', onProviderChanged);
         const cleanups = [
             () => driver.removeEventListener('history-updated', onHistoryUpdated),
             () => driver.removeEventListener('external-cost-recorded', onExternalCostRecorded),
+            () => driver.removeEventListener('checkpoint-saved', onCheckpointSaved),
             () => driver.removeEventListener('sub-agent-history-updated', onSubAgentHistoryUpdated),
             () => driver.removeEventListener('sub-agent-start', onSubAgentStart),
             () => driver.removeEventListener('sub-agent-stop', onSubAgentStop),
             () => driver.removeEventListener('interaction-start', onInteractionStart),
             () => driver.removeEventListener('interaction-stop', onInteractionStop),
+            () => driver.removeEventListener('interaction-settled', onInteractionSettled),
             () => driver.removeEventListener('provider-changed', onProviderChanged),
         ];
         // Wired on the driver this element holds, whatever it is, rather than on an orchestrator found
@@ -2036,15 +2289,22 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             for (const fn of cleanups)
                 fn();
         };
+        this.wireAutopilot();
+        this.syncActiveHold();
     }
     /**
      * Removes event listeners attached by `wireDriver`. Does not destroy
      * the driver or remove it from the registry.
      */
     unwireDriver() {
-        var _a;
+        var _a, _b, _c;
         (_a = this.driverCleanup) === null || _a === void 0 ? void 0 : _a.call(this);
         this.driverCleanup = undefined;
+        (_b = this.autopilotCleanup) === null || _b === void 0 ? void 0 : _b.call(this);
+        this.autopilotCleanup = undefined;
+        (_c = this.heldCleanup) === null || _c === void 0 ? void 0 : _c.call(this);
+        this.heldCleanup = undefined;
+        this.heldInteractionId = undefined;
     }
     /**
      * Tear down the session's currently-wired driver (GENC-1351): unwire this view, drop
@@ -2054,8 +2314,11 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
      * `this.driver`, so the instance is still readable here for disposal.
      */
     teardownDriver(key) {
+        var _a;
         const old = this.driver;
         this.unwireDriver();
+        // Its autopilot goes with it, so nothing waits on the person any more (GENC-1660).
+        setAutopilotNeedsUser((_a = key !== null && key !== void 0 ? key : this.getStateKey()) !== null && _a !== void 0 ? _a : '', false);
         if (key)
             deleteDriver(key);
         if (old && 'dispose' in old && typeof old.dispose === 'function') {
@@ -2505,6 +2768,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         // individual step gets a fresh window before the spinner appears.
         // If the last message is a blocking interaction, stop the timer — the AI is
         // waiting for the user, not computing.
+        this.syncActiveHold();
         if (this.busy)
             this.syncLoadingIndicator();
         this.syncShowHalo();
@@ -2639,7 +2903,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
      * resume (e.g. while it works out the next planning question after the user answers a widget).
      */
     syncLoadingIndicator() {
-        if (this.hasActivePendingInteraction)
+        if (this.waitingOnUser)
             this.stopLoadingTimer();
         else
             this.startLoadingTimer();
@@ -2655,6 +2919,17 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             agenticActivityBus.publish('chat-popin', undefined);
         }
     }
+    /**
+     * The key this assistant's session is published under (on the activity bus, in the debug log,
+     * in storage): the wired session's once one is active, else the one its attributes imply. Not
+     * always the `session-key` attribute, which can run ahead of a deferred switch and is absent when
+     * the key is derived from `id` and the header title. `undefined` when it has no identity.
+     *
+     * @beta
+     */
+    get stateKey() {
+        return this.getStateKey();
+    }
     /** Returns a cache key for this instance, or undefined if the component has no identity. */
     getStateKey() {
         var _a;
@@ -3459,7 +3734,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                 ? `${this.pinnedAgentName} — ${this.pinnedAgentHint}`
                 : this.pinnedAgentName;
         }
-        return 'Attempts to route messages to the correct available agent. Click to manually pin an agent.';
+        return `${this.orchestrationMenuLabel}: ${this.orchestrationDescription} Click to pin an agent instead.`;
     }
     /**
      * Tint applied to the pin icon when an agent is pinned. Picked from the
@@ -3479,14 +3754,32 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         return pinColourAt((_c = (_b = this.agents) === null || _b === void 0 ? void 0 : _b.findIndex((a) => a.name === this.pinnedAgentName)) !== null && _c !== void 0 ? _c : -1);
     }
     /**
-     * Label beside the composer's agent glyph: `AUTO` while the orchestrator is
-     * routing, otherwise the pinned agent's name. The name is NOT shortened here —
+     * Label beside the composer's agent glyph: the orchestration label (`Orchestration` unless the
+     * host renames it) while the orchestrator is routing, otherwise the pinned agent's name. The name is NOT shortened here —
      * the button truncates with an ellipsis in CSS, so the full name stays
      * available to a screen reader and to the `title` tooltip.
      */
     get agentButtonLabel() {
         var _a;
-        return (_a = this.pinnedAgentName) !== null && _a !== void 0 ? _a : 'AUTO';
+        return (_a = this.pinnedAgentName) !== null && _a !== void 0 ? _a : this.orchestrationLabel;
+    }
+    /**
+     * The picker's name for orchestration, from `chatConfig.picker.orchestrationLabel`. Not "Auto":
+     * other tools use that for picking a model tier, and here it is the agent that is chosen.
+     */
+    get orchestrationLabel() {
+        var _a;
+        return ((_a = this.chatConfig.picker) === null || _a === void 0 ? void 0 : _a.orchestrationLabel) || DEFAULT_ORCHESTRATION_LABEL;
+    }
+    /** The same choice's name in the picker menu, from `chatConfig.picker.orchestrationMenuLabel`. */
+    get orchestrationMenuLabel() {
+        var _a;
+        return ((_a = this.chatConfig.picker) === null || _a === void 0 ? void 0 : _a.orchestrationMenuLabel) || DEFAULT_ORCHESTRATION_MENU_LABEL;
+    }
+    /** What orchestration does, from `chatConfig.picker.orchestrationDescription`. */
+    get orchestrationDescription() {
+        var _a;
+        return ((_a = this.chatConfig.picker) === null || _a === void 0 ? void 0 : _a.orchestrationDescription) || DEFAULT_ORCHESTRATION_DESCRIPTION;
     }
     /**
      * Placeholder shown in the chat input. Substitutes the pinned agent's name
@@ -4141,12 +4434,15 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
      * finishes first). Guarded so a second click is a no-op.
      */
     handleStopClick() {
-        var _a, _b;
+        var _a, _b, _c, _d;
         // Only valid mid-turn; once `cancelling`, a second click is a no-op.
         if (this.state !== 'loading')
             return;
         this.state = 'cancelling';
-        (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.cancel) === null || _b === void 0 ? void 0 : _b.call(_a);
+        // Stop also pauses the autopilot, so the slim bar does not read "running" over a stopped turn.
+        if (((_a = this.autopilotState) === null || _a === void 0 ? void 0 : _a.mode) === 'running')
+            (_b = this.autopilotHost) === null || _b === void 0 ? void 0 : _b.pause();
+        (_d = (_c = this.driver) === null || _c === void 0 ? void 0 : _c.cancel) === null || _d === void 0 ? void 0 : _d.call(_c);
     }
     handleSuggestionClick(suggestion) {
         // Belt-and-braces with the template gate that hides the chips while blocked:
@@ -4463,6 +4759,8 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
 FoundationAiAssistant.SCROLL_BOTTOM_THRESHOLD_PX = 50;
 /** Context-usage percentage that fires the one-shot `context.threshold-crossed` event. */
 FoundationAiAssistant.CONTEXT_USAGE_WARN_PERCENT = 80;
+/** How long a pointed-out interaction pulses for. */
+FoundationAiAssistant.ATTENTION_MS = 2400;
 FoundationAiAssistant.DEFAULT_LOADING_DELAY_S = 0;
 FoundationAiAssistant.DEFAULT_SUGGESTION_COUNT = 3;
 FoundationAiAssistant.MS_PER_SECOND = 1000;
@@ -4577,6 +4875,27 @@ __decorate([
 __decorate([
     observable
 ], FoundationAiAssistant.prototype, "showHalo", void 0);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "autopilotHostOverride", void 0);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "autopilotState", void 0);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "autopilotCopy", void 0);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "attentionInteractionId", void 0);
+__decorate([
+    observable
+], FoundationAiAssistant.prototype, "activeHeldBy", void 0);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "slimBarVisible", null);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "autopilotAnnouncement", null);
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "visibleMessages", null);