@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/dist/esm/components/chat-interaction-wrapper/chat-interaction-wrapper.test.js

@@ -1,104 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createComponentSuite } from '@genesislcap/foundation-testing';
-import { DOM } from '@genesislcap/web-core';
-import { AiChatInteractionWrapper } from './chat-interaction-wrapper';
-// Hold a reference so the custom-element registration isn't tree-shaken.
-AiChatInteractionWrapper;
-/**
- * Minimal stand-in for a real interaction widget. The wrapper instantiates the
- * element named by `componentName` and assigns `interactionId`/`interaction` onto
- * it (GENC-1390); the tests read `interaction` back to verify which interaction the
- * rendered widget belongs to and its pending/resolved state.
- */
-const FAKE_WIDGET = 'test-interaction-widget';
-if (!customElements.get(FAKE_WIDGET)) {
-    customElements.define(FAKE_WIDGET, class extends HTMLElement {
-    });
-}
-/**
- * Renders a first interaction into a freshly-mounted wrapper.
- *
- * `componentName` is assigned last on purpose. The suite hands us an
- * already-connected element, so the only render trigger left is
- * `componentNameChanged`; setting it last means that render sees `data` and
- * `interactionId` already in place — reproducing production, where the initial
- * widget renders in `connectedCallback` with every bound property present. This
- * keeps the *first* render correct on both the patched and unpatched code so
- * that the id-change rebind is the only behaviour each test isolates.
- */
-function renderFirstInteraction(element) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield DOM.nextUpdate();
-        element.data = { label: 'interaction-a' };
-        element.interactionId = 'id-a';
-        element.componentName = FAKE_WIDGET;
-        yield DOM.nextUpdate();
-    });
-}
-const Suite = createComponentSuite('AiChatInteractionWrapper', 'ai-chat-interaction-wrapper');
-/**
- * Regression for the cog-menu toggle misalignment: FAST's `repeat` reconciles
- * the message list by array index (it has no key function), so toggling "Tool
- * calls"/"Thinking" re-filters the visible messages and rebinds an existing
- * row's wrapper to a *different* interaction. When both interactions use the
- * same component, `componentNameChanged` doesn't fire — so the wrapper must
- * re-render on `interactionId` change, or the previous interaction's widget
- * stays mounted under the new message.
- */
-Suite('re-renders the hosted widget when interactionId changes with the same componentName', (_a) => __awaiter(void 0, [_a], void 0, function* ({ element }) {
-    var _b, _c;
-    yield renderFirstInteraction(element);
-    const firstWidget = element.container.firstElementChild;
-    assert.ok(firstWidget, 'a widget is rendered for the first interaction');
-    assert.equal((_b = firstWidget.interaction) === null || _b === void 0 ? void 0 : _b.data, { label: 'interaction-a' });
-    // Rebind the reused wrapper to a different interaction that happens to use
-    // the same component — `data` then `interactionId`, mirroring the template's
-    // property-binding order. `componentName` is unchanged, so the only thing
-    // that can drive a re-render is the interactionId hook.
-    element.data = { label: 'interaction-b' };
-    element.interactionId = 'id-b';
-    yield DOM.nextUpdate();
-    const secondWidget = element.container.firstElementChild;
-    assert.is.not(secondWidget, firstWidget, 'the stale widget is replaced, not left mounted');
-    assert.equal((_c = secondWidget.interaction) === null || _c === void 0 ? void 0 : _c.data, { label: 'interaction-b' }, 'the rendered widget reflects the new interaction, not the stale one');
-}));
-/**
- * Resolving an interaction in place (the user answers it) must forward the
- * result without tearing down and rebuilding the widget — only a genuine change
- * of interaction identity should rebuild.
- */
-Suite('forwards resolved in place without rebuilding the widget', (_a) => __awaiter(void 0, [_a], void 0, function* ({ element }) {
-    var _b, _c, _d;
-    yield renderFirstInteraction(element);
-    const widget = element.container.firstElementChild;
-    assert.is((_b = widget.interaction) === null || _b === void 0 ? void 0 : _b.status, 'pending', 'the widget starts pending');
-    element.resolved = { status: 'approved' };
-    yield DOM.nextUpdate();
-    assert.is(element.container.firstElementChild, widget, 'resolving in place must not rebuild the widget');
-    assert.is((_c = widget.interaction) === null || _c === void 0 ? void 0 : _c.status, 'resolved', 'the widget transitions to resolved in place');
-    assert.equal(((_d = widget.interaction) === null || _d === void 0 ? void 0 : _d.status) === 'resolved' ? widget.interaction.result : undefined, { status: 'approved' }, 'the resolved result is forwarded to the widget');
-}));
-/**
- * When no live `InteractionContext` exists for the interaction — it has resolved and the driver
- * dropped it (the `resolved` binding can lag a render behind during a layout rebuild), or the widget
- * is rendered outside the normal host flow (as here: no host on the root) — the wrapper must hand the
- * widget an INERT context whose `once` refuses, never a live throwaway. A live throwaway re-ran the
- * widget's open-once side effect on the remount following a resolve, re-opening a just-closed side
- * panel and looping the layout rebuild (GENC-1390).
- */
-Suite('falls back to an inert context (once refuses) when there is no live context', (_a) => __awaiter(void 0, [_a], void 0, function* ({ element }) {
-    var _b, _c;
-    yield renderFirstInteraction(element);
-    const widget = element.container.firstElementChild;
-    assert.is((_b = widget.interaction) === null || _b === void 0 ? void 0 : _b.status, 'pending', 'the widget is pending');
-    const ctx = ((_c = widget.interaction) === null || _c === void 0 ? void 0 : _c.status) === 'pending' ? widget.interaction.interactionContext : undefined;
-    assert.ok(ctx, 'a context is still provided so the widget does not crash on a missing one');
-    let ran = 0;
-    const result = ctx.once('open-review-panel', () => {
-        ran += 1;
-        return 'opened';
-    });
-    assert.is(ran, 0, 'the inert fallback context must not run a once factory');
-    assert.is(result, null, 'once returns null on the inert fallback context');
-}));
-Suite.run();

package/dist/esm/components/orchestrating-driver/orchestrating-driver.budget.test.js

@@ -1,312 +0,0 @@
-import { __awaiter } from "tslib";
-import { BudgetExhaustedError } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { AgenticActivityBus } from '../../channel/ai-activity-bus';
-// Side-effect import — MUST precede `./orchestrating-driver` so the driver
-// subclasses jsdom's EventTarget (CustomEvent dispatch then works in node).
-import '../chat-driver/align-event-globals';
-import { OrchestratingDriver } from './orchestrating-driver';
-// GENC-1464 — the orchestrated turn's OUTCOME.
-//
-// `createDriver` returns an `OrchestratingDriver` for every agents-configured
-// host, and its `sendMessage` used to end with a hardcoded `return { reason:
-// 'done' }`. That made every typed failure unreachable for those hosts —
-// including `'budget-exhausted'`, which the assistant element latches its blocked
-// state off. A 402 therefore produced an apology over a still-enabled composer
-// for exactly the configurations this workstream exists to fix.
-//
-// The classifier compounds it: `classify()` is a SECOND retry ladder stacked on
-// the transport's, so an untyped catch re-issued the 402 `classifierRetries + 1`
-// times and then ran a fallback turn into the same wall.
-const makeRegistry = (provider) => ({
-    get: () => provider,
-    default: () => provider,
-    defaultName: () => 'test',
-    names: () => ['test'],
-    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
-    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-});
-const agent = (overrides) => (Object.assign({ description: 'test agent' }, overrides));
-/** A provider that ends every turn immediately with a plain-text reply (no tools). */
-const okProvider = () => ({
-    chat: () => __awaiter(void 0, void 0, void 0, function* () { return ({ role: 'assistant', content: 'ok' }); }),
-});
-/** A provider that counts calls and always refuses for budget. */
-const walledProvider = (vendorLabel = 'Anthropic') => {
-    let n = 0;
-    return {
-        calls: () => n,
-        provider: {
-            chat: () => __awaiter(void 0, void 0, void 0, function* () {
-                n += 1;
-                throw new BudgetExhaustedError(vendorLabel, 25, 25.4);
-            }),
-        },
-    };
-};
-const failureReasonOf = (r) => r.reason === 'done' ? r.failureReason : undefined;
-const Suite = createLogicSuite('orchestrating-driver budget wall');
-// ── 1. The showstopper: a walled AGENT turn must reach the caller ───────────
-Suite('a budget wall on the agent turn surfaces as the orchestrated result', () => __awaiter(void 0, void 0, void 0, function* () {
-    // ONE specialist and no fallback, so `classify` short-circuits without calling
-    // the provider — the wall is hit by the AGENT turn, inside a real tool loop.
-    // Against the old hardcoded return this deep-equal fails.
-    const { provider } = walledProvider();
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'Solo' })], {
-        sessionKey: 'budget-1',
-    });
-    const result = yield driver.sendMessage('go');
-    assert.equal(result, {
-        reason: 'done',
-        failureReason: 'budget-exhausted',
-        budget: { budgetUsd: 25, spentUsd: 25.4, vendorLabel: 'Anthropic', vendor: 'anthropic' },
-    });
-}));
-Suite("the vendor is the refusing transport's, not a hardcoded default", () => __awaiter(void 0, void 0, void 0, function* () {
-    // The label rides the contract; `vendor` is its normalised key. Without a
-    // second vendor exercised here, a constant would pass every other assertion in
-    // this file — and per-vendor blocking would wall the wrong vendor forever.
-    const { provider } = walledProvider('Gemini');
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'Solo' })], {
-        sessionKey: 'budget-gemini',
-    });
-    const result = yield driver.sendMessage('go');
-    assert.equal(result.reason === 'done' ? result.budget : undefined, {
-        budgetUsd: 25,
-        spentUsd: 25.4,
-        vendorLabel: 'Gemini',
-        vendor: 'gemini',
-    });
-}));
-Suite('an unrecognised vendor label carries no typed vendor at all', () => __awaiter(void 0, void 0, void 0, function* () {
-    // Attribution degrades to "unattributable" rather than to a wrong vendor —
-    // which makes the element fall back to its vendor-agnostic block. Safe.
-    const { provider } = walledProvider('Acme AI');
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'Solo' })], {
-        sessionKey: 'budget-unknown-vendor',
-    });
-    const result = yield driver.sendMessage('go');
-    assert.equal(result.reason === 'done' ? result.budget : undefined, {
-        budgetUsd: 25,
-        spentUsd: 25.4,
-        vendorLabel: 'Acme AI',
-    });
-}));
-Suite('the wall also reaches the tool-loop-end bus detail through the orchestrator', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const bus = new AgenticActivityBus();
-    const seen = [];
-    const stop = bus.subscribe('tool-loop-end', (d) => seen.push(d));
-    const { provider } = walledProvider();
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'Solo' })], {
-        sessionKey: 'budget-2',
-        activityBus: bus,
-    });
-    yield driver.sendMessage('go');
-    assert.is(seen.length, 1, 'exactly one tool-loop-end for the one agent turn');
-    assert.is((_a = seen[0]) === null || _a === void 0 ? void 0 : _a.failureReason, 'budget-exhausted');
-    stop();
-    bus.close();
-}));
-Suite('the bus detail carries the proxy figures, not just the failure reason', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    // The element latches off THIS event for an in-loop wall — the publish sits in
-    // sendMessage's `finally`, so it lands before the return-value seam and the
-    // idempotent latch makes the later one a no-op. If the figures rode only the
-    // return value they would be unreachable in the common case and the banner would
-    // show the generic copy in exactly the path they were added for.
-    const bus = new AgenticActivityBus();
-    const seen = [];
-    const stop = bus.subscribe('tool-loop-end', (d) => seen.push(d));
-    const { provider } = walledProvider();
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'Solo' })], {
-        sessionKey: 'budget-figures',
-        activityBus: bus,
-    });
-    const result = yield driver.sendMessage('go');
-    assert.equal((_a = seen[0]) === null || _a === void 0 ? void 0 : _a.budget, { budgetUsd: 25, spentUsd: 25.4, vendorLabel: 'Anthropic', vendor: 'anthropic' }, 'the event carries the same figures as the return value');
-    assert.is((_b = seen[0]) === null || _b === void 0 ? void 0 : _b.vendor, 'anthropic', 'and the top-level vendor agrees with the refusing transport, not with a stale last-resolved provider');
-    assert.equal(result.reason === 'done' ? result.budget : undefined, (_c = seen[0]) === null || _c === void 0 ? void 0 : _c.budget, 'event and return value agree — neither is the sole carrier');
-    stop();
-    bus.close();
-}));
-Suite('a clean turn publishes no budget key at all', () => __awaiter(void 0, void 0, void 0, function* () {
-    const bus = new AgenticActivityBus();
-    const seen = [];
-    const stop = bus.subscribe('tool-loop-end', (d) => seen.push(d));
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () { return ({ role: 'assistant', content: 'ok' }); }),
-    };
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'Solo' })], {
-        sessionKey: 'budget-clean',
-        activityBus: bus,
-    });
-    yield driver.sendMessage('go');
-    assert.ok(seen.every((d) => d === undefined || !('budget' in d)), 'no budget key on a non-budget turn — the historical detail shape is unchanged');
-    stop();
-    bus.close();
-}));
-// ── 2. No regression on the happy / handoff paths ───────────────────────────
-Suite('a clean turn still returns the bare legacy shape', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = new OrchestratingDriver(makeRegistry(okProvider()), [agent({ name: 'Solo' })], {
-        sessionKey: 'budget-3',
-    });
-    const result = yield driver.sendMessage('go');
-    assert.equal(result, { reason: 'done' }, 'no failureReason on a clean turn');
-}));
-Suite('a handoff-capped turn never leaks agent-handoff to the caller', () => __awaiter(void 0, void 0, void 0, function* () {
-    // `'agent-handoff'` is an internal routing protocol. The two breaks that hold a
-    // non-'done' inner result both carry it, so the collapse rule in `sendMessage`
-    // is what keeps "report the turn that ended the loop" from changing the
-    // discriminant a host matches on.
-    let n = 0;
-    const nextId = () => {
-        n += 1;
-        return n;
-    };
-    const handoffProvider = {
-        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            // The classifier call carries the routing tool; answer it with index 0.
-            if ((_a = options === null || options === void 0 ? void 0 : options.tools) === null || _a === void 0 ? void 0 : _a.some((t) => t.name === 'select_agent')) {
-                return {
-                    role: 'assistant',
-                    content: '',
-                    toolCalls: [{ id: `c-${nextId()}`, name: 'select_agent', args: { agent_index: 0 } }],
-                };
-            }
-            // Every agent turn asks to hand off, so the handoff cap is what ends it.
-            return {
-                role: 'assistant',
-                content: '',
-                toolCalls: [
-                    {
-                        id: `h-${nextId()}`,
-                        name: 'request_continuation',
-                        args: { summary: 's', remaining_task: 'more' },
-                    },
-                ],
-            };
-        }),
-    };
-    const driver = new OrchestratingDriver(makeRegistry(handoffProvider), [agent({ name: 'A' }), agent({ name: 'B' })], { sessionKey: 'budget-4', maxHandoffs: 1 });
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason, 'done', 'the internal handoff protocol never escapes');
-}));
-Suite('a wall on a post-handoff classify does not duplicate the user message', () => __awaiter(void 0, void 0, void 0, function* () {
-    // `classify()` runs at TWO seams. Before the first agent turn the user's
-    // message is unappended (only the optimistic `history-updated` echo exists),
-    // so the wall-catch must append it. At the END of a handoff iteration
-    // `chatDriver.sendMessage` has already appended it — passing it again
-    // produced ['user','assistant','tool','user','assistant'] with 'go' twice,
-    // persisting into the snapshot and into the history sent to the model once
-    // the budget was raised. The single-specialist narrowness guard below cannot
-    // catch this: with one specialist, classify short-circuits and the handoff
-    // seam never runs.
-    let n = 0;
-    const provider = {
-        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            n += 1;
-            if ((_a = options === null || options === void 0 ? void 0 : options.tools) === null || _a === void 0 ? void 0 : _a.some((t) => t.name === 'select_agent')) {
-                // First classify routes; the post-handoff classify hits the wall.
-                if (n > 2)
-                    throw new BudgetExhaustedError('Anthropic', 25, 25.4);
-                return {
-                    role: 'assistant',
-                    content: '',
-                    toolCalls: [{ id: `c-${n}`, name: 'select_agent', args: { agent_index: 0 } }],
-                };
-            }
-            // The agent turn asks to hand off, forcing the second classify.
-            return {
-                role: 'assistant',
-                content: '',
-                toolCalls: [
-                    {
-                        id: `h-${n}`,
-                        name: 'request_continuation',
-                        args: { summary: 's', remaining_task: 'more' },
-                    },
-                ],
-            };
-        }),
-    };
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'A' }), agent({ name: 'B' })], { sessionKey: 'budget-4b' });
-    const result = yield driver.sendMessage('go');
-    assert.is(failureReasonOf(result), 'budget-exhausted');
-    const history = driver.getRawHistory();
-    const userMessages = history.filter((m) => m.role === 'user' && m.content === 'go');
-    assert.is(userMessages.length, 1, "the user's message appears exactly once");
-}));
-// ── 3. The classifier's own retry ladder ───────────────────────────────────
-Suite('a wall during classification costs exactly one provider call', () => __awaiter(void 0, void 0, void 0, function* () {
-    // TWO specialists and no fallback, so `classify` really runs. Before the narrow
-    // rethrow this was FOUR calls: `classifierRetries + 1` classifier attempts, then
-    // a doomed agent turn.
-    const { calls, provider } = walledProvider();
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'A' }), agent({ name: 'B' })], { sessionKey: 'budget-5' });
-    const result = yield driver.sendMessage('go');
-    assert.is(calls(), 1, 'no ladder clears a budget wall — do not climb it');
-    assert.is(failureReasonOf(result), 'budget-exhausted');
-}));
-Suite('a classify-time wall lands on the transcript, without a routing apology', () => __awaiter(void 0, void 0, void 0, function* () {
-    // The old ordering emitted "I'm not sure how to help with that…" from the
-    // no-fallback exit and THEN routed anyway, so the user read a routing excuse
-    // the classifier never earned, immediately above the real error.
-    const { provider } = walledProvider();
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'A' }), agent({ name: 'B' })], { sessionKey: 'budget-6' });
-    yield driver.sendMessage('go');
-    const history = driver.getRawHistory();
-    const text = history.map((m) => m.content).join('\n');
-    assert.ok(text.includes('AI usage limit'), 'the real reason is what the user reads');
-    assert.not.ok(text.includes("I'm not sure how to help with that"));
-    // The user's own message must survive. `runOrchestratedTurn` dispatches it
-    // optimistically and leaves the real append to `chatDriver.sendMessage`, which
-    // a classify-time wall never reaches — so the driver's history held only the
-    // assistant bubble and the next render dropped what the user had typed.
-    assert.equal(history.map((m) => m.role), ['user', 'assistant'], 'the question stays above the answer');
-    assert.is(history[0].content, 'go');
-}));
-Suite('an in-loop wall does not double-append the user message', () => __awaiter(void 0, void 0, void 0, function* () {
-    // Narrowness guard for the append above: `reportBudgetExhausted` also serves
-    // the in-loop path, where `sendMessage` has ALREADY appended the user message.
-    // Only the classify seam passes one, so this path must be unchanged. ONE
-    // specialist and no fallback, so `classify` short-circuits and the wall is hit
-    // inside a real tool loop.
-    const { provider } = walledProvider();
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'Solo' })], {
-        sessionKey: 'budget-6b',
-    });
-    yield driver.sendMessage('go');
-    const history = driver.getRawHistory();
-    assert.is(history.filter((m) => m.role === 'user').length, 1, 'one user message, not two');
-}));
-Suite('a wall during classification never starts the fallback turn', () => __awaiter(void 0, void 0, void 0, function* () {
-    const { calls, provider } = walledProvider();
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'A' }), agent({ name: 'B' }), agent({ name: 'Catch-all', fallback: true })], { sessionKey: 'budget-7' });
-    const result = yield driver.sendMessage('go');
-    assert.is(calls(), 1, 'the fallback agent is not run into the same wall');
-    assert.is(failureReasonOf(result), 'budget-exhausted');
-}));
-Suite('a plain classifier failure still retries and falls back (narrowness guard)', () => __awaiter(void 0, void 0, void 0, function* () {
-    // Proves the rethrow did not make every classify failure terminal: only the
-    // budget wall short-circuits, because only the budget wall is unclearable.
-    let classifierCalls = 0;
-    const provider = {
-        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            if ((_a = options === null || options === void 0 ? void 0 : options.tools) === null || _a === void 0 ? void 0 : _a.some((t) => t.name === 'select_agent')) {
-                classifierCalls += 1;
-                throw new Error('classifier is having a moment');
-            }
-            return { role: 'assistant', content: 'fallback handled it' };
-        }),
-    };
-    const driver = new OrchestratingDriver(makeRegistry(provider), [agent({ name: 'A' }), agent({ name: 'B' }), agent({ name: 'Catch-all', fallback: true })], { sessionKey: 'budget-8' });
-    const result = yield driver.sendMessage('go');
-    assert.is(classifierCalls, 3, 'classifierRetries (2) + the first attempt');
-    assert.is(result.reason, 'done');
-    assert.is(failureReasonOf(result), undefined, 'the fallback turn succeeded');
-}));
-Suite.run();

package/dist/esm/components/orchestrating-driver/orchestrating-driver.cost.test.js

@@ -1,76 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-// Side-effect import — MUST precede `./orchestrating-driver` so the driver
-// subclasses jsdom's EventTarget (CustomEvent dispatch then works in node).
-import '../chat-driver/align-event-globals';
-import { OrchestratingDriver } from './orchestrating-driver';
-// GENC-1508 — `recordExternalCost` is OPTIONAL on `AiDriver`, so a missing delegation here
-// is not a compile error: the host's `driver?.recordExternalCost?.(…)` simply evaluates to
-// undefined and every post-resolve charge from every widget disappears — silently, and only
-// in orchestrated setups. That is the same invisible-when-broken failure the method exists to
-// fix, so the delegation gets a test rather than trust.
-const makeRegistry = (provider) => ({
-    get: () => provider,
-    default: () => provider,
-    defaultName: () => 'test',
-    names: () => ['test'],
-    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
-    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-});
-const noToolProvider = () => ({
-    chat: (_history, _userMessage, _options) => __awaiter(void 0, void 0, void 0, function* () { return ({ role: 'assistant', content: 'ok' }); }),
-});
-const agent = (overrides) => (Object.assign({ description: 'test agent' }, overrides));
-const makeDriver = () => new OrchestratingDriver(makeRegistry(noToolProvider()), [agent({ name: 'Genesis Assistant' })], {
-    sessionKey: 'k',
-});
-/** The orchestrator does not expose `requestInteraction`, so the interaction is ARRANGED on the
- *  wrapped driver. Every assertion below goes through the orchestrator's own public surface. */
-const wrapped = (driver) => driver.chatDriver;
-const Suite = createLogicSuite('orchestrating-driver external cost');
-Suite('post-resolve spend delegates to the wrapped driver', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver();
-    const inner = wrapped(driver);
-    const pending = inner.requestInteraction('planning-question', { question: 'Pick one' });
-    const id = driver.getRawHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id, { status: 'approved', costUsd: 0.5 });
-    yield pending;
-    assert.is(driver.recordExternalCost(id, 0.25), true);
-    const msg = driver.getRawHistory().find((m) => { var _a; return ((_a = m.interaction) === null || _a === void 0 ? void 0 : _a.interactionId) === id; });
-    assert.is(msg === null || msg === void 0 ? void 0 : msg.externalCostUsd, 0.75);
-}));
-Suite('an unknown interaction is reported as unrecorded, not thrown', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver();
-    assert.is(driver.recordExternalCost('never-existed', 0.25), false);
-}));
-Suite('the announcement reaches the HOST, which only ever holds this wrapper', () => __awaiter(void 0, void 0, void 0, function* () {
-    // The delegation test above passes with the forward missing: the money still lands on the
-    // message. What breaks is quieter — `createDriver` hands the host an OrchestratingDriver for any
-    // non-empty `agents`, so an event the inner driver raises and the constructor's forward list
-    // omits is one the host never sees. The totals then never refresh and the save is never
-    // scheduled, and because this flow's interaction is the last thing in the session, "stale until
-    // the next history change" means permanently. Asserted on the WRAPPER for that reason.
-    const driver = makeDriver();
-    const inner = wrapped(driver);
-    const pending = inner.requestInteraction('planning-question', { question: 'Pick one' });
-    const id = driver.getRawHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id, { status: 'approved' });
-    yield pending;
-    let seen = 0;
-    let detail;
-    driver.addEventListener('external-cost-recorded', (e) => {
-        seen += 1;
-        detail = e.detail;
-    });
-    // …and never on `history-updated`, which would rebuild the reporting widget.
-    let historyUpdated = 0;
-    driver.addEventListener('history-updated', () => {
-        historyUpdated += 1;
-    });
-    driver.recordExternalCost(id, 0.25);
-    assert.is(seen, 1);
-    assert.is(detail === null || detail === void 0 ? void 0 : detail.costUsd, 0.25);
-    assert.is(detail === null || detail === void 0 ? void 0 : detail.interactionId, id);
-    assert.is(historyUpdated, 0);
-}));
-Suite.run();

package/dist/esm/components/orchestrating-driver/orchestrating-driver.pin.test.js

@@ -1,61 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-// Side-effect import — MUST precede `./orchestrating-driver` so the driver
-// subclasses jsdom's EventTarget (CustomEvent dispatch then works in node).
-import '../chat-driver/align-event-globals';
-import { OrchestratingDriver } from './orchestrating-driver';
-// GENC-1351 — a set routing pin must be honoured on the next turn. This is the
-// invariant that broke on restore (found via the §5.8 diagnostics log): the pin
-// was hydrated into the store but never pushed to the driver, so the first
-// post-restore message fell through to the classifier and re-routed away from the
-// pinned agent. `Guided Booking` here is `excludeFromClassifier`, so the classifier
-// can NEVER pick it — a turn landing on it proves the pin (not classification)
-// routed it. The element-side fix (restore → `driver.setPinnedAgent`) is what makes
-// the pin reach the driver; this locks the driver half of the contract.
-const makeRegistry = (provider) => ({
-    get: () => provider,
-    default: () => provider,
-    defaultName: () => 'test',
-    names: () => ['test'],
-    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
-    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-});
-/** A provider that ends every turn immediately with a plain-text reply (no tools). */
-const noToolProvider = () => ({
-    chat: (_history, _userMessage, _options) => __awaiter(void 0, void 0, void 0, function* () { return ({ role: 'assistant', content: 'ok' }); }),
-});
-const agent = (overrides) => (Object.assign({ description: 'test agent' }, overrides));
-const makeDriver = () => new OrchestratingDriver(makeRegistry(noToolProvider()), [
-    agent({ name: 'Genesis Assistant' }), // classifier-eligible specialist
-    agent({ name: 'Guided Booking', excludeFromClassifier: true }), // pin-only
-], { sessionKey: 'k' });
-const Suite = createLogicSuite('orchestrating-driver-pin');
-Suite('a set pin routes the next turn to the pinned agent (bypassing the classifier)', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const driver = makeDriver();
-    driver.setPinnedAgent('Guided Booking');
-    yield driver.sendMessage('hi');
-    assert.is((_a = driver.getActiveAgent()) === null || _a === void 0 ? void 0 : _a.name, 'Guided Booking', 'pinned agent ran; it is excludeFromClassifier, so only the pin could have routed it');
-}));
-Suite('the pin is sticky across turns', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const driver = makeDriver();
-    driver.setPinnedAgent('Guided Booking');
-    yield driver.sendMessage('one');
-    yield driver.sendMessage('two');
-    assert.is((_a = driver.getActiveAgent()) === null || _a === void 0 ? void 0 : _a.name, 'Guided Booking', 'still pinned on the second turn');
-}));
-// GENC-1351 — the flow-owner lock is the *unpinned* routing path. A classifier-routed
-// stateful flow (flow-owned but never user-pinned) must resume on restore without
-// re-classifying: the persister re-applies BOTH `setPinnedAgent` and `setFlowOwner` on
-// restore, and `resolvePinnedAgent` reads `flowOwnerAgentName ?? pinnedAgentName`. Here
-// `Guided Booking` is `excludeFromClassifier` AND left unpinned, so a turn landing on it
-// proves the flow-owner lock (not the pin, not classification) routed it.
-Suite('a set flow-owner lock routes the next turn to that agent (bypassing the classifier)', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const driver = makeDriver();
-    driver.setFlowOwner('Guided Booking'); // flow-owned but NOT pinned
-    yield driver.sendMessage('hi');
-    assert.is((_a = driver.getActiveAgent()) === null || _a === void 0 ? void 0 : _a.name, 'Guided Booking', 'flow-owner routed it; it is excludeFromClassifier and unpinned, so only the flow-owner lock could have');
-}));
-Suite.run();

package/dist/esm/components/settings-modal/settings-modal.styles.test.js

@@ -1,80 +0,0 @@
-var _a;
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { settingsModalStyles } from './settings-modal.styles';
-// GENC-1464 budget meter — the styling invariants a reviewer would otherwise
-// have to catch by eye, following main.styles.test.ts (see there for why CSS
-// gets asserted from the generated text at all, and for the scoping lesson:
-// these assertions are about the BUDGET rules only, not a global style policy).
-//
-//   1. Design-system tokens are consumed UNFALLBACKED — the #2411/#2436 review
-//      rule. Every token the meter reads ships a DS default, so a
-//      `var(--token, fallback)` is dead code at best and a silently-broken
-//      token name at worst.
-//   2. The meter's row anatomy is SHARED with the context indicator via grouped
-//      selectors, not copied. The two indicators are siblings by design;
-//      copied declarations would let them drift apart one edit at a time, which
-//      is exactly what the grouping was chosen to make impossible.
-const suite = createLogicSuite('settings-modal.styles budget-meter rules');
-/**
- * The generated stylesheet text, flattened recursively — `css` composes nested
- * `ElementStyles`, and a shallow read can return almost nothing, making every
- * negative assertion below pass vacuously. The first test guards that.
- */
-const flatten = (value) => {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.map(flatten).join('\n');
-    const nested = value === null || value === void 0 ? void 0 : value.styles;
-    return nested ? flatten(nested) : '';
-};
-/**
- * Comments stripped before matching: the assertions below are about
- * DECLARATIONS, and the sheet's own prose legitimately mentions the very
- * pattern (`var(--x, y)`) the negative assertion hunts for.
- */
-const cssText = flatten(settingsModalStyles).replace(/\/\*[\s\S]*?\*\//g, '');
-/** Every declaration block whose selector mentions `.settings-budget-`, joined. */
-const budgetRules = ((_a = cssText.match(/[^{}]*\.settings-budget-[^{}]*\{[^}]*\}/g)) !== null && _a !== void 0 ? _a : []).join('\n');
-suite('the budget rules were extracted as text (guards the assertions below)', () => {
-    assert.ok(cssText.includes('.settings-budget-usage'), 'the meter container rule is in the sheet');
-    assert.ok(budgetRules.length > 0, 'the extraction found the budget rules');
-});
-suite('the meter consumes design-system tokens without dead fallbacks', () => {
-    // One structural probe rather than a per-token list: ANY `var(--x,` inside a
-    // budget rule is a fallback, and the meter reads only tokens that ship DS
-    // defaults (--design-unit, --neutral-foreground-*), so there is no legitimate
-    // fallback for this scope. Scoped to the budget rules on purpose — see
-    // main.styles.test.ts for why a whole-sheet grep is the wrong test.
-    assert.not.ok(/var\(--[a-z-]+\s*,/.test(budgetRules), 'no var(--token, fallback) in the meter');
-    assert.ok(budgetRules.includes('var(--design-unit)'), 'and it does consume tokens');
-});
-suite('every meter row sits on one shared rhythm', () => {
-    // The 4/2/2 fix. `.settings-modal-section-body` gaps at 4 units and the
-    // budget meter at 2, so an unwrapped context indicator sat 4 units above the
-    // FIRST vendor row while the vendor rows sat 2 apart — three visually
-    // identical meter rows, unevenly spaced. Both meters now live in
-    // `.settings-usage-meters`, which must carry the SAME gap as the meter it
-    // wraps: asserted as ONE grouped rule, so the two cannot drift to different
-    // rhythms. (settings-modal.template.test.ts pins the other half — that the
-    // wrapper is conditional, so a host with no meters pays no stray gap for it.)
-    const shared = /\.settings-usage-meters\s*,\s*\.settings-budget-usage\s*\{([^}]*)\}/.exec(cssText);
-    assert.ok(shared, '.settings-usage-meters is grouped with .settings-budget-usage');
-    assert.ok(shared[1].includes('flex-direction: column'), 'the shared container is a column');
-    assert.ok(shared[1].includes('gap: calc(var(--design-unit) * 2px)'), 'gapped at the meter rhythm (2 units), not the section body 4');
-});
-suite("the meter shares the context indicator's row anatomy by grouped selector", () => {
-    // The invariant is the SHARING, not the shape: each budget class must sit in
-    // the same selector list as its context sibling, so restyling one restyles
-    // both and the two indicators cannot drift apart.
-    const sharedPairs = [
-        ['.settings-context-header', '.settings-budget-header'],
-        ['.settings-context-label', '.settings-budget-label'],
-        ['.settings-context-tokens', '.settings-budget-figures'],
-    ];
-    for (const [contextClass, budgetClass] of sharedPairs) {
-        const grouped = new RegExp(`${contextClass.replace(/\./g, '\\.')}\\s*,\\s*${budgetClass.replace(/\./g, '\\.')}\\s*\\{`);
-        assert.ok(grouped.test(cssText), `${budgetClass} is grouped with ${contextClass}`);
-    }
-});
-suite.run();