@genesislcap/ai-assistant 15.23.3 → 15.24.0

package/dist/esm/main/composer-menu-controller.js

@@ -0,0 +1,234 @@
+import { DOM } from '@genesislcap/web-core';
+import { AnimatedPanelToggle } from '../utils/animated-panel-toggle';
+/**
+ * Duration of a composer menu's close animation. Must stay in sync with the
+ * `composer-menu-out` keyframe duration in `main.styles.ts` — the toggle strips
+ * the `closing` class on a timer, so a shorter value here unmounts the panel
+ * mid-animation and a longer one leaves it sitting invisible.
+ */
+const AGENT_PICKER_CLOSE_MS = 200;
+const SESSION_MENU_CLOSE_MS = 200;
+/**
+ * Floor for an open menu's height, applied when the assistant is too short to
+ * give it the room it wants. Below this a menu is more frustrating than a
+ * scrollbar is, so it overhangs instead.
+ */
+const COMPOSER_MENU_MIN_HEIGHT = 140;
+/**
+ * Vertical space an open menu must leave free above the button, covering BOTH
+ * the gap the menu sits off the button by (8px, declared in design units in
+ * main.styles.ts) and the breathing room wanted above it. The two are lumped
+ * together because only the second half is a free choice: the first is fixed by
+ * the stylesheet and simply has to be subtracted from the headroom, and a
+ * constant named for only one of them invites someone to "fix" a gap that is
+ * doing exactly what it should.
+ */
+const MENU_HEADROOM_RESERVE = 20;
+/**
+ * The two composer menus — the agent picker and the session (⋮) menu: their
+ * mutually-exclusive open/close animation, their measured placement above the
+ * button that opened them, and the document-level listeners that dismiss them.
+ *
+ * Owns no observable state: both open flags live on the session store so the
+ * bubble and popout instances stay in sync, and reach this controller as
+ * {@link Accessor}s.
+ *
+ * @internal
+ */
+export class ComposerMenuController {
+    constructor(
+    /**
+     * Typed `HTMLElement`, not the assistant: this controller needs the shadow root
+     * and nothing else, and the narrower type is what stops it reaching back into
+     * element API and recreating the god object with extra indirection.
+     */
+    host, deps) {
+        this.host = host;
+        this.deps = deps;
+        this.agentPicker = new AnimatedPanelToggle(host, '.agent-picker-panel', AGENT_PICKER_CLOSE_MS, () => deps.agentPickerOpen.get(), (v) => deps.agentPickerOpen.set(v));
+        this.sessionMenu = new AnimatedPanelToggle(host, '.session-menu-panel', SESSION_MENU_CLOSE_MS, () => deps.sessionMenuOpen.get(), (v) => deps.sessionMenuOpen.set(v));
+    }
+    toggleAgentPicker() {
+        // Mutually exclusive with the session menu — both anchor to the composer bar.
+        if (!this.deps.agentPickerOpen.get() && this.deps.sessionMenuOpen.get()) {
+            this.toggleSessionMenu();
+        }
+        this.deps.logMeta('panel.toggled', {
+            panel: 'agent-picker',
+            open: !this.deps.agentPickerOpen.get(),
+        });
+        this.agentPicker.toggle();
+        // After the render that mounts the panel — it has no box to measure before that.
+        if (this.deps.agentPickerOpen.get()) {
+            void DOM.nextUpdate().then(() => this.position('.agent-picker-panel', '.agent-toggle-button'));
+        }
+    }
+    toggleSessionMenu() {
+        // Mutually exclusive with the agent picker; always reopen showing the menu
+        // (not a leftover Clear-confirm prompt).
+        if (!this.deps.sessionMenuOpen.get() && this.deps.agentPickerOpen.get()) {
+            this.toggleAgentPicker();
+        }
+        this.deps.resetSessionConfirmations();
+        this.deps.logMeta('panel.toggled', {
+            panel: 'session-menu',
+            open: !this.deps.sessionMenuOpen.get(),
+        });
+        this.sessionMenu.toggle();
+        if (this.deps.sessionMenuOpen.get()) {
+            void DOM.nextUpdate().then(() => this.position('.session-menu-panel', '.session-menu-button'));
+        }
+    }
+    /** Close whichever menus are open, with their close animation. */
+    closeAll() {
+        if (this.deps.agentPickerOpen.get())
+            this.toggleAgentPicker();
+        if (this.deps.sessionMenuOpen.get())
+            this.toggleSessionMenu();
+    }
+    /**
+     * Close both menus at once, with no close animation and no `panel.toggled`
+     * meta event — for a caller that is about to replace the view the menu sits in
+     * (Compact swaps the transcript for a progress indicator, Clear wipes it).
+     *
+     * Not {@link ComposerMenuController.closeAll}: animating a panel out over 200ms
+     * while the thing behind it is being replaced is the wrong effect, and routing
+     * through the toggles would log a spurious user-initiated panel toggle into the
+     * debug timeline. This matches what the direct flag assignment on the element did
+     * before — including leaving any in-flight close timer alone, which is safe
+     * because the toggle strips `closing` from the node it captured.
+     */
+    closeImmediate() {
+        if (this.deps.agentPickerOpen.get())
+            this.deps.agentPickerOpen.set(false);
+        if (this.deps.sessionMenuOpen.get())
+            this.deps.sessionMenuOpen.set(false);
+    }
+    /** Re-place whichever menu is open. Cheap enough to run from a resize. */
+    repositionOpen() {
+        if (this.deps.agentPickerOpen.get()) {
+            this.position('.agent-picker-panel', '.agent-toggle-button');
+        }
+        if (this.deps.sessionMenuOpen.get()) {
+            this.position('.session-menu-panel', '.session-menu-button');
+        }
+    }
+    /**
+     * Attach or drop the dismissal listeners to match whether a menu is open.
+     * Called from the open/close setters, so the listeners exist only while there is
+     * something to dismiss.
+     */
+    syncDismissal() {
+        const shouldListen = this.deps.agentPickerOpen.get() || this.deps.sessionMenuOpen.get();
+        if (shouldListen === !!this.dismissPointer)
+            return;
+        if (!shouldListen) {
+            this.teardownDismissal();
+            return;
+        }
+        this.dismissPointer = (e) => {
+            var _a;
+            // The composer owns both the menus and the buttons that open them, so a path
+            // that reaches it is an inside click — including the toggle itself, whose own
+            // handler closes the menu. Closing here too would immediately
+            // reopen-then-close and the menu would never appear.
+            const composer = (_a = this.host.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('.composer');
+            if (composer && e.composedPath().includes(composer))
+                return;
+            this.closeAll();
+        };
+        this.dismissKey = (e) => {
+            if (e.key !== 'Escape')
+                return;
+            this.closeAll();
+            this.deps.focusInput();
+        };
+        this.dismissResize = () => this.repositionOpen();
+        document.addEventListener('pointerdown', this.dismissPointer, true);
+        document.addEventListener('keydown', this.dismissKey, true);
+        window.addEventListener('resize', this.dismissResize);
+    }
+    /**
+     * Finalise in-flight close animations and drop every listener — call from
+     * `disconnectedCallback`.
+     *
+     * **Teardown runs LAST, and the order is load-bearing.** `finalize()` writes the
+     * flag through `setOpen`, which reaches the element setter and therefore
+     * {@link ComposerMenuController.syncDismissal} — so tearing down first let the
+     * sync re-arm the listeners on an element that is going away. Reachable, if
+     * narrowly: a panel's flag stays TRUE for the whole close animation, so
+     * switching from the session menu to the agent picker leaves both flags set for
+     * ~200ms, and a disconnect in that window finalised the closing menu while the
+     * picker was still open — `shouldListen` true, listeners re-attached, nothing
+     * left to remove them (PR #2503 review).
+     */
+    dispose() {
+        this.agentPicker.finalize();
+        this.sessionMenu.finalize();
+        this.teardownDismissal();
+    }
+    teardownDismissal() {
+        if (this.dismissPointer) {
+            document.removeEventListener('pointerdown', this.dismissPointer, true);
+            this.dismissPointer = undefined;
+        }
+        if (this.dismissKey) {
+            document.removeEventListener('keydown', this.dismissKey, true);
+            this.dismissKey = undefined;
+        }
+        if (this.dismissResize) {
+            window.removeEventListener('resize', this.dismissResize);
+            this.dismissResize = undefined;
+        }
+    }
+    /**
+     * Places an open composer menu directly above the control that opened it.
+     *
+     * CSS alone cannot: the menu is a child of `.composer` — which is what lets its
+     * width be capped against the composer rather than against a button — while its
+     * anchor is a button several levels down the bar, and no selector can read a
+     * sibling's offset. So the left edge is measured on open and written as a custom
+     * property.
+     *
+     * Clamped to the composer, so a menu opened from a control near the right edge of
+     * a narrow panel slides back inside instead of overhanging. The animation origin
+     * is written separately and keeps pointing at the button's centre even after such
+     * a shift — the menu still grows out of the thing that opened it, which is the
+     * whole point of anchoring it there.
+     */
+    position(panelSelector, triggerSelector) {
+        const root = this.host.shadowRoot;
+        const composer = root === null || root === void 0 ? void 0 : root.querySelector('.composer');
+        const panel = root === null || root === void 0 ? void 0 : root.querySelector(panelSelector);
+        const trigger = root === null || root === void 0 ? void 0 : root.querySelector(triggerSelector);
+        if (!composer || !panel || !trigger)
+            return;
+        const box = composer.getBoundingClientRect();
+        const anchor = trigger.getBoundingClientRect();
+        // An absolutely-positioned child is placed against its containing block's
+        // PADDING box, while getBoundingClientRect reports the border box — so every
+        // offset below is taken from the padding edge. Skipping this is a 1px drift
+        // that reads as the menu being very slightly out of line with its button.
+        const style = getComputedStyle(composer);
+        const originLeft = box.left + (parseFloat(style.borderLeftWidth) || 0);
+        const originBottom = box.bottom - (parseFloat(style.borderBottomWidth) || 0);
+        // A menu wider than the composer clamps to 0 rather than a negative offset:
+        // Math.min picks the negative headroom, Math.max floors it at the left edge.
+        const left = Math.max(0, Math.min(anchor.left - originLeft, composer.clientWidth - panel.offsetWidth));
+        panel.style.setProperty('--composer-menu-left', `${left}px`);
+        panel.style.setProperty('--composer-menu-origin', `${anchor.left + anchor.width / 2 - originLeft - left}px`);
+        // Sit on the button rather than on top of the whole composer. The gap stays in
+        // CSS so it can be expressed in design units; this is the raw distance from the
+        // padding edge up to the button's top.
+        panel.style.setProperty('--composer-menu-bottom', `${originBottom - anchor.top}px`);
+        // Starting on the button rather than on the composer means less room above, and
+        // the assistant can be short enough that a full-height menu would be clipped by
+        // the wrapper's overflow. Cap it at what is actually available; the menu scrolls
+        // inside whatever it gets.
+        const wrapper = root === null || root === void 0 ? void 0 : root.querySelector('.chat-wrapper');
+        if (wrapper) {
+            const available = anchor.top - wrapper.getBoundingClientRect().top - MENU_HEADROOM_RESERVE;
+            panel.style.setProperty('--composer-menu-max-height', `${Math.max(COMPOSER_MENU_MIN_HEIGHT, available)}px`);
+        }
+    }
+}

package/dist/esm/main/composer-resize-controller.js

@@ -0,0 +1,119 @@
+import { __decorate } from "tslib";
+import { observable } from '@genesislcap/web-core';
+/** Floor for a dragged composer height — below this the control bar clips. */
+const COMPOSER_MIN_HEIGHT_PX = 48;
+/** Ceiling for a dragged composer height, whatever headroom is available. */
+const COMPOSER_MAX_HEIGHT_PX = 400;
+/**
+ * Strip of the message list a resize must leave visible. The composer may claim
+ * the rest of the list's height, but not all of it — a composer filling the panel
+ * with no transcript behind it reads as a broken layout rather than a big input.
+ */
+const COMPOSER_MIN_MESSAGES_PX = 80;
+/**
+ * Drag-to-resize for the composer: owns the chosen height and the transient
+ * geometry of one drag gesture.
+ *
+ * @internal
+ */
+export class ComposerResizeController {
+    constructor(deps) {
+        this.deps = deps;
+        /**
+         * Explicit composer height in px once the user has dragged; `null` keeps the
+         * default auto-grow behaviour.
+         *
+         * Observable because {@link ComposerResizeController.heightStyle} is bound in
+         * the template — see the sibling scratch fields for why the rest are not.
+         */
+        this.heightPx = null;
+        /**
+         * Pointer Y and height captured at the start of a drag.
+         *
+         * Deliberately NOT observable, and the same goes for the two bounds below.
+         * These are rewritten on every `pointermove`, and no binding reads them, so
+         * marking them would fire a notification per mouse-move for values nothing
+         * displays — while `heightPx`, which does drive the render, fires exactly one.
+         */
+        this.startY = 0;
+        this.startHeight = 0;
+        /** Natural (un-dragged) height, measured on the first drag — the floor for shrinking. */
+        this.naturalHeight = 0;
+        /** Upper bound for the current drag, capped to the headroom above the composer. */
+        this.maxHeight = COMPOSER_MAX_HEIGHT_PX;
+    }
+    /** Whether the composer shows a drag handle. On by default; hosts opt out via config. */
+    get resizable() {
+        return this.deps.enabled();
+    }
+    /**
+     * Inline style for the composer: writes the chosen height into the
+     * `--composer-height` custom property (read by `.chat-input` and its control in
+     * `main.styles.ts`). Empty until the user drags, or when resizing is disabled,
+     * so the CSS default applies.
+     *
+     * `heightPx` is read into a local BEFORE the branch, and that is load-bearing.
+     * Written as `this.resizable && this.heightPx != null ? …`, the `&&`
+     * short-circuits past `heightPx` whenever resizing is off — so on a host that
+     * mounts with `resizableInput: false`, FAST never records a dependency on it.
+     * The template's binding for this getter (`style=${(x) => x.composerHeightStyle}`)
+     * carries no `:`/`&&`/`||`, so FAST classifies it non-volatile and collects
+     * dependencies exactly once per bind; the missing dependency is therefore never
+     * picked up, and a later `resizableInput: true` gives a handle that drags —
+     * `heightPx` updates — while the composer never visibly moves.
+     *
+     * Reading it unconditionally makes the dependency honest and costs nothing.
+     * `@volatile` would also fix it, by re-collecting on every evaluation, but it pays
+     * a full unsubscribe/resubscribe cycle each time to express something that is
+     * simply true: this getter always depends on both.
+     */
+    get heightStyle() {
+        const px = this.heightPx;
+        return this.resizable && px != null ? `--composer-height: ${px}px` : '';
+    }
+    /**
+     * Begin a drag. Captures the pointer so move/up keep firing on the handle even
+     * when the cursor leaves its 7px band.
+     */
+    onStart(e) {
+        var _a, _b, _c, _d, _e;
+        const measured = (_b = (_a = this.deps.inputEl()) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect().height) !== null && _b !== void 0 ? _b : COMPOSER_MIN_HEIGHT_PX;
+        // First drag (no explicit height yet) measures the natural height — the floor
+        // for shrinking, so the box never goes below where it started.
+        if (this.heightPx == null)
+            this.naturalHeight = measured;
+        this.startY = e.clientY;
+        this.startHeight = (_c = this.heightPx) !== null && _c !== void 0 ? _c : measured;
+        // Cap growth to the headroom currently above the composer: the message list
+        // can yield all but a visible strip of its height. The pool (composer +
+        // messages) is fixed for the duration of one drag, so measuring once here is
+        // correct throughout the gesture.
+        const messagesHeight = (_e = (_d = this.deps.messagesEl()) === null || _d === void 0 ? void 0 : _d.getBoundingClientRect().height) !== null && _e !== void 0 ? _e : COMPOSER_MAX_HEIGHT_PX;
+        this.maxHeight = Math.min(COMPOSER_MAX_HEIGHT_PX, this.startHeight + Math.max(0, messagesHeight - COMPOSER_MIN_MESSAGES_PX));
+        e.currentTarget.setPointerCapture(e.pointerId);
+    }
+    /**
+     * Resize while dragging. Dragging up (clientY decreases) grows the composer; the
+     * result is clamped between the natural height and the available headroom. No-op
+     * unless a drag is active (the handle holds pointer capture), so plain
+     * hover-moves are ignored.
+     */
+    onMove(e) {
+        const handle = e.currentTarget;
+        if (!handle.hasPointerCapture(e.pointerId))
+            return;
+        const min = Math.max(COMPOSER_MIN_HEIGHT_PX, Math.round(this.naturalHeight));
+        const max = Math.max(min, Math.round(this.maxHeight));
+        const next = this.startHeight + (this.startY - e.clientY);
+        this.heightPx = Math.max(min, Math.min(max, Math.round(next)));
+    }
+    /** End a drag and release the pointer capture. */
+    onEnd(e) {
+        const handle = e.currentTarget;
+        if (handle.hasPointerCapture(e.pointerId))
+            handle.releasePointerCapture(e.pointerId);
+    }
+}
+__decorate([
+    observable
+], ComposerResizeController.prototype, "heightPx", void 0);

package/dist/esm/main/context-gate-controller.js

@@ -0,0 +1,289 @@
+import { __decorate } from "tslib";
+import { volatile } from '@genesislcap/web-core';
+import { CONTEXT_ABORT_MARGIN_TOKENS, resolveContextBudget, } from '../utils/resolve-context-budget';
+/**
+ * The context gate: how close the conversation is to the model's window, what
+ * compacting would reclaim, and the copy that states both (GENC-1567).
+ *
+ * Owns **no state at all** — every member derives from the callbacks above. That
+ * is what makes it the safest of these extractions: there is no field to forget
+ * to mark `@observable`, so the observability trap in `docs/code-health.md` §11.4
+ * cannot bite here.
+ *
+ * @internal
+ */
+export class ContextGateController {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** Window, warn/block thresholds and compaction sizing for the active model. */
+    get budget() {
+        // Resolved ONCE. The reserve re-reads live routing state on every access, so
+        // two reads can land on different winners and pair one agent's
+        // `warnAheadTokens` with another's `tokens` — the exact pairing
+        // `ContextReserveResolution` warns against (reviewer catch on #2504). It also
+        // stops the orchestrator walking every specialist plus the fallback twice per
+        // evaluation.
+        const reserve = this.deps.contextReserve();
+        return resolveContextBudget({
+            chatConfig: this.deps.chatConfig(),
+            contextLimit: this.deps.contextLimit(),
+            agentReserveTokens: reserve === null || reserve === void 0 ? void 0 : reserve.tokens,
+            agentWarnAheadTokens: reserve === null || reserve === void 0 ? void 0 : reserve.warnAheadTokens,
+        });
+    }
+    /**
+     * What compacting right now would reclaim, or `null` when it would not be worth
+     * it. Sized against {@link ContextGateController.budget}, so the plan aims at
+     * this model's window rather than a fixed default.
+     *
+     * Reads `messages` to stay reactive as the conversation grows: the driver's
+     * history is not a tracked observable, so every consumer keys its re-evaluation
+     * off the Redux mirror.
+     *
+     * Deliberately NOT memoized on `messages` identity: it runs against the driver's
+     * history, which can move without the mirror moving (a mid-turn `condenseWhen`
+     * rewrite), so an identity key would risk serving a plan for a transcript the
+     * driver no longer has.
+     */
+    get plan() {
+        if (this.deps.messages().length === 0)
+            return null;
+        const budget = this.budget;
+        return this.deps.compactionPlanFor({
+            preambleTokens: this.deps.preambleTokens(),
+            tailTokenBudget: budget.tailTokenBudget,
+            minReclaimTokens: budget.minReclaimTokens,
+        });
+    }
+    /**
+     * Guard policy pushed to the driver, or `undefined` when the host has switched
+     * the gate off — so `enabled: false` really does mean no local blocking of any
+     * kind, UI or mid-loop.
+     *
+     * A MARGIN, not a threshold: the driver resolves the window of the provider each
+     * call actually goes to. The fallback window rides along because the driver
+     * cannot learn it any other way — without it, a host that knows its window while
+     * its provider does not report one had `fallbackContextLimit` protecting the
+     * composer and nothing else.
+     */
+    get guardPolicy() {
+        var _a;
+        if (!this.budget.enabled)
+            return undefined;
+        return {
+            marginTokens: CONTEXT_ABORT_MARGIN_TOKENS,
+            fallbackLimit: (_a = this.deps.chatConfig().context) === null || _a === void 0 ? void 0 : _a.fallbackContextLimit,
+        };
+    }
+    /**
+     * How close this conversation is to the model's context window.
+     *
+     * **Derived, never latched** — the opposite of the budget wall. A wall stays set
+     * because nothing the user does fixes it; this clears itself the moment the
+     * conversation shrinks, which is precisely what the user is being asked to do.
+     *
+     * **A flow in progress is never blocked, only warned.** Machine state lives
+     * outside the transcript, so a stateful flow is not desynced by compaction — but
+     * the summary can still drop detail the flow's own prompt leans on, and blocking
+     * mid-journey would strand the user between a flow they cannot finish and a
+     * compaction that is a poor idea right there.
+     */
+    get gate() {
+        var _a;
+        const budget = this.budget;
+        if (!budget.enabled)
+            return 'ok';
+        // The figure from the last moment nothing was running, not the live one — see
+        // `gateContextTokens` for why the gauge and the gate differ here.
+        const tokens = (_a = this.deps.gateContextTokens()) !== null && _a !== void 0 ? _a : this.deps.contextTokens();
+        if (tokens == null || budget.blockAt == null || budget.warnAt == null)
+            return 'ok';
+        if (tokens >= budget.blockAt) {
+            return this.deps.flowOwnerAgentName() !== null ? 'warn' : 'blocked';
+        }
+        return tokens >= budget.warnAt ? 'warn' : 'ok';
+    }
+    /**
+     * WHY the composer is blocked, when it is (GENC-1582). `undefined` unless
+     * {@link ContextGateController.gate} is `'blocked'`.
+     *
+     * - `'transcript'` — the conversation has grown into the reserve.
+     * - `'model'` — the reserve meets or exceeds the whole window, so `blockAt` is 0
+     *   and EVERY message is refused, including the first of an empty chat.
+     *
+     * Keyed off `blockAt === 0`, deliberately NOT off whether a compaction plan
+     * exists. A null plan has two unrelated causes — nothing left worth summarizing,
+     * versus a window that cannot host the agent at all — and only the second is a
+     * statement about the configuration rather than the transcript.
+     *
+     * **This drives behaviour, not copy.** It reads as though it should also pick the
+     * wording, and GENC-1582 had it do so: the `'model'` branch told the user to
+     * switch to a model with a larger context window, or pick a different agent.
+     * Removed, because the assistant offers no way to do either — the model follows
+     * from the host's provider registry and each agent's `provider` field, and the
+     * only user-facing lever is the agent picker, which is triple-gated
+     * (`agentPicker` enabled, two or more agents, at least one with
+     * `manualSelection.enabled`) and commonly absent. Copy that names a control the
+     * user does not have is worse than copy that names a remedy which merely turns
+     * out to be insufficient, and `contextGateReason` is not host-overridable, so
+     * nobody downstream could correct it either. Both causes now read the GENC-1567
+     * sentence.
+     *
+     * What it still decides is `sessionMenuForcedByContext`: the transcript cause
+     * forces the session menu open so a user told to compact can reach Compact, and
+     * the model cause deliberately does not, because there Compact and Clear are
+     * both futile and a menu of dead actions helps nobody.
+     *
+     * The block itself is correct in both cases and must stay: an agent that
+     * measurably cannot complete a turn in this window would otherwise start one and
+     * die mid-loop on a provider context error, with partial writes and no clean
+     * exit. Refusing up front is the better failure.
+     */
+    get blockCause() {
+        if (this.gate !== 'blocked')
+            return undefined;
+        return this.budget.blockAt === 0 ? 'model' : 'transcript';
+    }
+    /**
+     * What the composer notice says about the gate.
+     *
+     * The copy is a function of whether compaction can actually clear it, which is
+     * why it reads {@link ContextGateController.plan} rather than assuming. Telling
+     * someone to compact when the projection says it would not free enough — a tail
+     * that is one indivisible tool result, say — sends them into a summarizer call
+     * that leaves them exactly where they were.
+     */
+    get gateReason() {
+        const level = this.gate;
+        const canHelp = this.plan != null;
+        if (level === 'blocked') {
+            // Name the agent whose headroom is binding when routing is automatic
+            // (GENC-1582). The reserve is then the hungriest agent the turn could land
+            // on, so the composer can close while there is plenty of room for the short
+            // question the user was about to type — and a message that only said "not
+            // enough room for more work" would read as a bug rather than a reason.
+            const reserve = this.deps.contextReserve();
+            const cause = (reserve === null || reserve === void 0 ? void 0 : reserve.basis) === 'reachable-max'
+                ? `There is not enough room in the model context to start another task — ${reserve.agentName} needs the most of any I could pick up next.`
+                : 'There is not enough room in the model context for more work.';
+            const remedy = canHelp
+                ? 'Click the error pill and compact the context to continue working.'
+                : 'Compacting the context will not free enough room, click the error pill to clear and start a new conversation.';
+            return `${cause} ${remedy}`;
+        }
+        if (this.deps.flowOwnerAgentName() !== null) {
+            return 'This conversation is nearly full. The task in progress will finish, but compact before starting another.';
+        }
+        return canHelp
+            ? 'This conversation is getting long. Compact it to free up room.'
+            : 'This conversation is getting long and is close to the limit.';
+    }
+    /**
+     * Short label the session-menu pill wears while the gate is active — the primary
+     * visible signal, in place of a banner.
+     *
+     * It states the CONDITION only; the remedy lives in the placeholder once the
+     * composer is actually blocked, which is the moment the user needs to be told
+     * what to do rather than merely warned.
+     */
+    get gateLabel() {
+        switch (this.gate) {
+            case 'blocked':
+                return 'At context limit';
+            case 'warn':
+                return 'Approaching context limit';
+            default:
+                return '';
+        }
+    }
+    /** Tooltip and hint for the Compact row — why it is or is not available. */
+    get compactHint() {
+        if (this.plan)
+            return `Summarize older messages to free up context`;
+        return this.deps.messages().length === 0
+            ? 'Nothing to compact yet'
+            : 'There is nothing left to summarize here — the recent messages are too large to shrink further';
+    }
+    /**
+     * Whether the menu's "Compact" action would do anything. Delegates to the
+     * driver's plan so the gate uses the exact same history `compact()` acts on,
+     * judged against the same budget — one source of truth for both whether a cut is
+     * legal and whether it reclaims enough.
+     */
+    get compactable() {
+        return this.plan != null;
+    }
+    /**
+     * Whether the composer notice has anything to show — a budget wall or the gate.
+     * One region for both, so the live region stays single and registered.
+     */
+    get noticeVisible() {
+        return this.deps.bannerVisible() || this.gate !== 'ok';
+    }
+    /**
+     * Text for that region. A budget wall outranks the gate: it is the condition the
+     * user cannot clear, so it must not be hidden behind advice about compacting that
+     * would not restore sending anyway.
+     */
+    get noticeText() {
+        if (this.deps.bannerVisible())
+            return this.deps.effectiveBlockedReason();
+        return this.gate === 'ok' ? '' : this.gateReason;
+    }
+    /**
+     * Whether the notice region should be announced but not drawn.
+     *
+     * The gate shows itself visually through the pill's label, the composer outline
+     * and the placeholder — a strip of prose on top would be a fourth statement of
+     * the same thing. But dropping the region outright would be an accessibility
+     * regression: a `role="status"` region announces MUTATIONS to a region already
+     * being observed, and it is the only announcement available here, because the
+     * composer flips to `disabled` at the same moment and a disabled control is out
+     * of the tab order — so neither the placeholder nor an `aria-label` on it is ever
+     * voiced.
+     *
+     * So the region stays mounted, keeps its text and keeps announcing; only the
+     * visual treatment is withheld. A budget wall still draws its banner, because
+     * that condition has no other visible expression.
+     */
+    get noticeSrOnly() {
+        return !this.deps.bannerVisible() && this.gate !== 'ok';
+    }
+}
+__decorate([
+    volatile
+], ContextGateController.prototype, "budget", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "plan", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "guardPolicy", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "gate", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "blockCause", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "gateReason", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "gateLabel", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "compactHint", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "compactable", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "noticeVisible", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "noticeText", null);
+__decorate([
+    volatile
+], ContextGateController.prototype, "noticeSrOnly", null);