@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/dist/esm/components/chat-driver/chat-driver.test.js

@@ -1,2770 +0,0 @@
-import { __awaiter } from "tslib";
-import { BudgetExhaustedError, DEFAULT_PROVIDER_REFUSED_MESSAGE, ProviderRefusedError, DEFAULT_BUDGET_EXHAUSTED_MESSAGE, isChatToolCallUnknown, MalformedFunctionCallError, ResponseTruncatedError, } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { AgenticActivityBus } from '../../channel/ai-activity-bus';
-import { clearMetaEventRegistry, getMetaEvents } from '../../state/debug-event-log';
-import { sumCosts } from '../../utils/sum-costs';
-import { sumTokens } from '../../utils/sum-tokens';
-import { createToolFold } from '../../utils/tool-fold';
-// Side-effect import — MUST come before `./chat-driver` so the driver subclasses
-// jsdom's EventTarget rather than Node's native one (see the file). None of the
-// imports above pull in the driver, so its realm is still set before evaluation.
-import './align-event-globals';
-import { ChatDriver } from './chat-driver';
-const scriptedProvider = (responses) => {
-    const queue = [...responses];
-    const advertisedPerCall = [];
-    const toolChoicePerCall = [];
-    const temperaturePerCall = [];
-    const cachePolicyPerCall = [];
-    const tailContextPerCall = [];
-    const systemPromptPerCall = [];
-    const historyPerCall = [];
-    return {
-        advertisedPerCall,
-        toolChoicePerCall,
-        temperaturePerCall,
-        cachePolicyPerCall,
-        tailContextPerCall,
-        systemPromptPerCall,
-        historyPerCall,
-        chat: (history, _userMessage, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a, _b;
-            advertisedPerCall.push(((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name));
-            toolChoicePerCall.push(options === null || options === void 0 ? void 0 : options.toolChoice);
-            temperaturePerCall.push(options === null || options === void 0 ? void 0 : options.temperature);
-            cachePolicyPerCall.push(options === null || options === void 0 ? void 0 : options.cachePolicy);
-            tailContextPerCall.push(options === null || options === void 0 ? void 0 : options.tailContext);
-            systemPromptPerCall.push(options === null || options === void 0 ? void 0 : options.systemPrompt);
-            // Snapshot the slice (condensation produces fresh objects per call and never
-            // mutates stored history, so a shallow array copy is a stable per-call view).
-            historyPerCall.push([...history]);
-            // Once the script is exhausted, end the turn with a plain text reply.
-            return (_b = queue.shift()) !== null && _b !== void 0 ? _b : { role: 'assistant', content: 'done' };
-        }),
-    };
-};
-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 def = (name) => ({
-    name,
-    description: `${name} tool`,
-    parameters: { type: 'object', properties: {} },
-});
-/** An assistant turn that calls a single tool. `content` is empty so the driver
- * does not treat it as a thinking step (which would split it into two messages). */
-const callsTool = (name, id) => ({
-    role: 'assistant',
-    content: '',
-    toolCalls: [{ id, name, args: {} }],
-});
-const agent = (overrides) => (Object.assign({ description: 'test agent' }, overrides));
-const makeDriver = (config, provider, sessionKey = '', activityBus) => {
-    const driver = new ChatDriver(makeRegistry(provider), {
-        maxToolIterations: 50,
-        maxFoldOperations: 5,
-        sessionKey,
-        activityBus,
-    });
-    driver.applyAgent(config);
-    return driver;
-};
-/** All tool calls across the whole conversation, flattened. */
-const allToolCalls = (driver) => driver.getHistory().flatMap((m) => { var _a; return (_a = m.toolCalls) !== null && _a !== void 0 ? _a : []; });
-/** Tool-result message contents, in order. */
-const toolResultContents = (driver) => driver
-    .getHistory()
-    .filter((m) => m.role === 'tool' && m.toolResult)
-    .map((m) => m.toolResult.content);
-/** `tool.unresolved` meta-event details recorded for a session (download-log surface). */
-const unresolvedEvents = (sessionKey) => getMetaEvents(sessionKey)
-    .filter((e) => e.type === 'tool.unresolved')
-    .map((e) => { var _a; return (_a = e.detail) !== null && _a !== void 0 ? _a : {}; });
-// ---------------------------------------------------------------------------
-// stale tool detection — stateful agent advances past a tool's state
-// ---------------------------------------------------------------------------
-const stale = createLogicSuite('ChatDriver stale-tool detection');
-stale('guides the model when it calls a tool that an earlier state exposed', () => __awaiter(void 0, void 0, void 0, function* () {
-    // State A exposes tool_a; calling it advances to state B, which exposes only
-    // tool_b. A factory-form agent narrows the tool set per turn, mirroring how
-    // `defineStatefulAgent` works.
-    let state = 'A';
-    const config = agent({
-        name: 'Stateful',
-        toolDefinitions: () => (state === 'A' ? [def('tool_a')] : [def('tool_b')]),
-        toolHandlers: () => state === 'A'
-            ? {
-                tool_a: () => __awaiter(void 0, void 0, void 0, function* () {
-                    state = 'B';
-                    return 'advanced to B';
-                }),
-            }
-            : { tool_b: () => __awaiter(void 0, void 0, void 0, function* () { return 'b done'; }) },
-    });
-    const provider = scriptedProvider([
-        callsTool('tool_a', 't1'), // real — advances A -> B
-        callsTool('tool_a', 't2'), // stale — tool_a no longer in state B
-        callsTool('tool_b', 't3'), // real — valid in state B
-    ]);
-    const sessionKey = 'stale-meta-test';
-    const driver = makeDriver(config, provider, sessionKey);
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason, 'done');
-    // The per-state narrowing actually happened: tool_a advertised first, tool_b later.
-    assert.equal(provider.advertisedPerCall[0], ['tool_a']);
-    assert.ok(provider.advertisedPerCall.some((tools) => tools.includes('tool_b') && !tools.includes('tool_a')), 'a later turn should advertise tool_b without tool_a');
-    // The retried tool_a got stale guidance — not "Unknown tool".
-    const staleGuidance = toolResultContents(driver).find((c) => c.includes('was available earlier but is not part of the current step'));
-    assert.ok(staleGuidance, 'a previously-available tool should receive stale guidance');
-    assert.not.ok(toolResultContents(driver).some((c) => c.startsWith('Unknown tool:')), 'a previously-available tool must not be reported as a hallucination');
-    // The retried call is flagged unknown + stale for the UI.
-    const retried = allToolCalls(driver).filter((tc) => tc.name === 'tool_a' && isChatToolCallUnknown(tc));
-    assert.is(retried.length, 1, 'exactly one tool_a call should be flagged unknown');
-    assert.ok(isChatToolCallUnknown(retried[0]) && retried[0].stale === true, 'and marked stale');
-    // The occurrence is recorded to the meta-event log for the download log.
-    assert.ok(unresolvedEvents(sessionKey).some((d) => d.kind === 'stale' && d.tool === 'tool_a'), 'a stale tool.unresolved meta event should be recorded');
-}));
-stale('reports a never-seen tool as a hallucinated unknown tool', () => __awaiter(void 0, void 0, void 0, function* () {
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('real_tool')],
-        toolHandlers: { real_tool: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const provider = scriptedProvider([callsTool('made_up', 'm1')]);
-    const sessionKey = 'hallucination-meta-test';
-    const driver = makeDriver(config, provider, sessionKey);
-    yield driver.sendMessage('go');
-    assert.ok(toolResultContents(driver).includes('Unknown tool: made_up'), 'a tool never advertised should be reported as unknown');
-    const call = allToolCalls(driver).find((tc) => tc.name === 'made_up');
-    assert.ok(call && isChatToolCallUnknown(call), 'the call should be flagged unknown');
-    assert.not.ok(call.stale, 'a hallucinated tool must NOT be flagged stale');
-    assert.ok(unresolvedEvents(sessionKey).some((d) => d.kind === 'unknown' && d.tool === 'made_up'), 'an unknown tool.unresolved meta event should be recorded');
-}));
-stale('points the model at the close tool when an exclusive fold hides a base tool', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const fold = createToolFold({
-        name: 'my_fold',
-        tools: [def('inner_tool')],
-        handlers: { inner_tool: () => __awaiter(void 0, void 0, void 0, function* () { return 'inner done'; }) },
-        // exclusive defaults to true — opening it removes base_tool from the set.
-    });
-    const config = agent({
-        name: 'Folded',
-        toolDefinitions: [def('base_tool'), fold.definition],
-        toolHandlers: Object.assign({ base_tool: () => __awaiter(void 0, void 0, void 0, function* () { return 'base done'; }) }, fold.handler),
-    });
-    const provider = scriptedProvider([
-        callsTool('my_fold', 'f1'), // open the exclusive fold — base_tool now hidden
-        callsTool('base_tool', 'b1'), // hidden behind the open fold
-    ]);
-    const sessionKey = 'fold-meta-test';
-    const driver = makeDriver(config, provider, sessionKey);
-    yield driver.sendMessage('go');
-    // Target the base_tool result specifically — the fold-open result also
-    // mentions my_fold, so match on the tool call id rather than substring.
-    const guidance = (_b = (_a = driver
-        .getHistory()
-        .find((m) => { var _a; return m.role === 'tool' && ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 'b1'; })) === null || _a === void 0 ? void 0 : _a.toolResult) === null || _b === void 0 ? void 0 : _b.content;
-    assert.ok(guidance, 'calling a fold-hidden tool should produce guidance');
-    assert.match(guidance, /not available while the "my_fold" fold is open/);
-    assert.match(guidance, /close_my_fold/);
-    const hidden = allToolCalls(driver).find((tc) => tc.name === 'base_tool' && isChatToolCallUnknown(tc));
-    assert.ok(hidden && isChatToolCallUnknown(hidden) && hidden.stale === true, 'the hidden call is stale');
-    assert.ok(unresolvedEvents(sessionKey).some((d) => d.kind === 'fold-hidden' && d.tool === 'base_tool' && d.fold === 'my_fold'), 'a fold-hidden tool.unresolved meta event should be recorded');
-}));
-stale('splits stale vs hallucinated tools on the unknown-tool-limit error', () => __awaiter(void 0, void 0, void 0, function* () {
-    const sessionKey = 'stale-limit-test';
-    clearMetaEventRegistry();
-    let state = 'A';
-    const config = agent({
-        name: 'Stateful',
-        toolDefinitions: () => (state === 'A' ? [def('tool_a')] : [def('tool_b')]),
-        toolHandlers: () => state === 'A'
-            ? {
-                tool_a: () => __awaiter(void 0, void 0, void 0, function* () {
-                    state = 'B';
-                    return 'advanced to B';
-                }),
-            }
-            : { tool_b: () => __awaiter(void 0, void 0, void 0, function* () { return 'b done'; }) },
-    });
-    // One real call to advance to B, then 10 consecutive stale calls — the 10th
-    // trips the stale ceiling (MAX_STALE_TOOL_CALLS, 2x the hallucination limit) and ends the turn.
-    const provider = scriptedProvider([
-        callsTool('tool_a', 'real'),
-        ...Array.from({ length: 10 }, (_unused, i) => callsTool('tool_a', `stale-${i}`)),
-    ]);
-    const driver = makeDriver(config, provider, sessionKey);
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason, 'done');
-    const limitError = getMetaEvents(sessionKey).find((e) => { var _a; return e.type === 'turn.error' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.reason) === 'unknown-tool-limit'; });
-    assert.ok(limitError, 'hitting the limit should record an unknown-tool-limit turn.error');
-    const detail = limitError.detail;
-    assert.equal(detail.staleTools, ['tool_a'], 'tool_a should be classified as stale');
-    assert.equal(detail.hallucinatedTools, [], 'nothing was hallucinated');
-    // Every stale attempt — not just the final limit error — is in the download log.
-    assert.is(unresolvedEvents(sessionKey).filter((d) => d.kind === 'stale').length, 10, 'each stale attempt should be recorded as its own tool.unresolved event');
-    // The user-facing turn ends with the apology, not a crash.
-    const last = driver.getHistory().at(-1);
-    assert.ok((last === null || last === void 0 ? void 0 : last.role) === 'assistant' && last.content.startsWith("I'm sorry"));
-}));
-stale.run();
-// ---------------------------------------------------------------------------
-// onUnresolvedTool hook — an agent can redirect an unresolved tool call
-// ---------------------------------------------------------------------------
-const hook = createLogicSuite('ChatDriver onUnresolvedTool hook');
-hook('replaces the default for a hallucinated tool when the hook returns a string', () => __awaiter(void 0, void 0, void 0, function* () {
-    const config = agent({
-        name: 'Hooked',
-        toolDefinitions: [def('real_tool')],
-        toolHandlers: { real_tool: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-        onUnresolvedTool: ({ toolName, kind, availableTools }) => `redirect: ${toolName} is ${kind}; use ${availableTools.join(', ')}`,
-    });
-    const provider = scriptedProvider([callsTool('made_up', 'm1')]);
-    const driver = makeDriver(config, provider);
-    yield driver.sendMessage('go');
-    assert.ok(toolResultContents(driver).includes('redirect: made_up is unknown; use real_tool'), 'the hook string should replace the default Unknown tool message');
-    assert.not.ok(toolResultContents(driver).some((c) => c.startsWith('Unknown tool:')), 'the default unknown-tool message must not appear');
-}));
-hook('replaces the default for a stale tool when the hook returns a string', () => __awaiter(void 0, void 0, void 0, function* () {
-    let state = 'A';
-    const config = agent({
-        name: 'HookedStateful',
-        toolDefinitions: () => (state === 'A' ? [def('tool_a')] : [def('tool_b')]),
-        toolHandlers: () => state === 'A'
-            ? {
-                tool_a: () => __awaiter(void 0, void 0, void 0, function* () {
-                    state = 'B';
-                    return 'advanced to B';
-                }),
-            }
-            : { tool_b: () => __awaiter(void 0, void 0, void 0, function* () { return 'b done'; }) },
-        onUnresolvedTool: ({ toolName, kind }) => `redirect: ${toolName}/${kind}`,
-    });
-    const provider = scriptedProvider([
-        callsTool('tool_a', 't1'), // real — advances A -> B
-        callsTool('tool_a', 't2'), // stale — tool_a no longer in state B
-        callsTool('tool_b', 't3'), // real — valid in state B
-    ]);
-    const driver = makeDriver(config, provider);
-    yield driver.sendMessage('go');
-    assert.ok(toolResultContents(driver).includes('redirect: tool_a/stale'), 'the hook string should replace the default stale message');
-    assert.not.ok(toolResultContents(driver).some((c) => c.includes('was available earlier but is not part of the current step')), 'the default stale message must not appear');
-}));
-hook('falls back to the default when the hook returns undefined', () => __awaiter(void 0, void 0, void 0, function* () {
-    const config = agent({
-        name: 'HookUndefined',
-        toolDefinitions: [def('real_tool')],
-        toolHandlers: { real_tool: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-        onUnresolvedTool: () => undefined,
-    });
-    const provider = scriptedProvider([callsTool('made_up', 'm1')]);
-    const driver = makeDriver(config, provider);
-    yield driver.sendMessage('go');
-    assert.ok(toolResultContents(driver).includes('Unknown tool: made_up'), 'an undefined hook result should fall back to the default message');
-}));
-hook('falls back to the default when the hook returns a whitespace-only string', () => __awaiter(void 0, void 0, void 0, function* () {
-    const config = agent({
-        name: 'HookEmpty',
-        toolDefinitions: [def('real_tool')],
-        toolHandlers: { real_tool: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-        onUnresolvedTool: () => '   ',
-    });
-    const provider = scriptedProvider([callsTool('made_up', 'm1')]);
-    const driver = makeDriver(config, provider);
-    yield driver.sendMessage('go');
-    assert.ok(toolResultContents(driver).includes('Unknown tool: made_up'), 'a whitespace-only hook result should fall back to the default message');
-}));
-hook('falls back to the default when the hook throws', () => __awaiter(void 0, void 0, void 0, function* () {
-    const config = agent({
-        name: 'HookThrows',
-        toolDefinitions: [def('real_tool')],
-        toolHandlers: { real_tool: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-        onUnresolvedTool: () => {
-            throw new Error('boom');
-        },
-    });
-    const provider = scriptedProvider([callsTool('made_up', 'm1')]);
-    const driver = makeDriver(config, provider);
-    yield driver.sendMessage('go');
-    assert.ok(toolResultContents(driver).includes('Unknown tool: made_up'), 'a throwing hook should fall back to the default message');
-}));
-hook.run();
-// ---------------------------------------------------------------------------
-// timeout handling — a transport `TimeoutError` surfaces a distinct message
-// ---------------------------------------------------------------------------
-const timeout = createLogicSuite('ChatDriver timeout handling');
-/** A provider whose `chat` rejects with the `TimeoutError` the transports tag
- * a request timeout with (see gemini/anthropic `post`). */
-const timesOutProvider = () => ({
-    chat: () => __awaiter(void 0, void 0, void 0, function* () {
-        throw new DOMException('Gemini request timed out', 'TimeoutError');
-    }),
-});
-timeout('surfaces a timeout-specific message instead of the generic failure', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    clearMetaEventRegistry();
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const sessionKey = 'timeout-test';
-    const driver = makeDriver(config, timesOutProvider(), sessionKey);
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason, 'done');
-    // The turn ends with the timeout message, NOT the generic "something went wrong".
-    const last = driver.getHistory().at(-1);
-    assert.ok((last === null || last === void 0 ? void 0 : last.role) === 'assistant', 'turn ends with an assistant message');
-    assert.ok(last.content.includes('timed out'), 'message names the timeout');
-    assert.not.ok(last.content.includes('something went wrong'), 'must not fall through to the generic catch');
-    // Recorded distinctly in the debug log: a turn.error tagged TimeoutError,
-    // not swallowed silently.
-    const err = getMetaEvents(sessionKey).find((e) => e.type === 'turn.error');
-    assert.ok(err, 'a turn.error should be recorded');
-    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.reason, 'exception');
-    assert.is((_b = err.detail) === null || _b === void 0 ? void 0 : _b.name, 'TimeoutError');
-}));
-timeout.run();
-// ---------------------------------------------------------------------------
-// cancellation — dispose() aborts the in-flight provider call (lifecycle signal)
-// ---------------------------------------------------------------------------
-const cancel = createLogicSuite('ChatDriver cancellation');
-cancel('threads a non-aborted signal into the provider call by default', () => __awaiter(void 0, void 0, void 0, function* () {
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const capture = {};
-    const provider = {
-        chat: (_h, _m, options) => __awaiter(void 0, void 0, void 0, function* () {
-            capture.signal = options === null || options === void 0 ? void 0 : options.signal;
-            return { role: 'assistant', content: 'hi' };
-        }),
-    };
-    const driver = makeDriver(config, provider, 'signal-plumb');
-    yield driver.sendMessage('go');
-    assert.ok(capture.signal, 'provider received an options.signal');
-    assert.not.ok(capture.signal.aborted, 'and it is not aborted on a normal turn');
-}));
-cancel('dispose() aborts the in-flight request and stops quietly', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    clearMetaEventRegistry();
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    // A provider that hangs until its signal aborts, then rejects with the
-    // signal's reason — mirroring how the transport surfaces an aborted fetch.
-    const capture = {};
-    const provider = {
-        chat: (_h, _m, options) => {
-            const signal = options === null || options === void 0 ? void 0 : options.signal;
-            capture.signal = signal;
-            return new Promise((_resolve, reject) => {
-                if (!signal)
-                    return;
-                if (signal.aborted) {
-                    reject(signal.reason);
-                    return;
-                }
-                signal.addEventListener('abort', () => reject(signal.reason), { once: true });
-            });
-        },
-    };
-    const driver = makeDriver(config, provider, 'cancel-test');
-    const pending = driver.sendMessage('go');
-    driver.dispose();
-    const result = yield pending;
-    assert.is(result.reason, 'done');
-    assert.ok((_a = capture.signal) === null || _a === void 0 ? void 0 : _a.aborted, 'the provider signal aborted on dispose');
-    assert.is(capture.signal.reason.name, 'AbortError');
-    // Quiet: no assistant message appended (would otherwise pollute cached history).
-    const assistantMsgs = driver.getHistory().filter((m) => m.role === 'assistant');
-    assert.is(assistantMsgs.length, 0, 'no message appended on a disposal abort');
-    assert.not.ok(driver.getHistory().some((m) => { var _a; return (_a = m.content) === null || _a === void 0 ? void 0 : _a.includes('something went wrong'); }), 'must not surface the generic failure');
-}));
-cancel('cancel() stops the turn with a "Stopped." marker and leaves the driver usable', () => __awaiter(void 0, void 0, void 0, function* () {
-    clearMetaEventRegistry();
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    let call = 0;
-    const provider = {
-        chat: (_h, _m, options) => {
-            call += 1;
-            if (call === 1) {
-                // First turn hangs until its signal aborts (the user cancel). Must also
-                // handle the already-aborted case: cancel can land before chat runs
-                // (during the provider-resolution await), so the signal may arrive
-                // aborted — mirror how real fetch rejects immediately in that case.
-                const signal = options.signal;
-                return new Promise((_resolve, reject) => {
-                    if (signal.aborted) {
-                        reject(signal.reason);
-                        return;
-                    }
-                    signal.addEventListener('abort', () => reject(signal.reason), { once: true });
-                });
-            }
-            // Second turn resolves normally — proves the driver wasn't bricked.
-            return Promise.resolve({ role: 'assistant', content: 'second response' });
-        },
-    };
-    const driver = makeDriver(config, provider, 'cancel-stop');
-    const pending = driver.sendMessage('go');
-    driver.cancel();
-    const result = yield pending;
-    assert.is(result.reason, 'done');
-    // Subtle 'Stopped.' marker (system-event, not a generic failure).
-    const last = driver.getHistory().at(-1);
-    assert.is(last === null || last === void 0 ? void 0 : last.role, 'system-event');
-    assert.is(last === null || last === void 0 ? void 0 : last.content, 'Stopped.');
-    // The driver is still usable for the next message.
-    const second = yield driver.sendMessage('again');
-    assert.is(second.reason, 'done');
-    assert.ok(driver.getHistory().some((m) => m.content === 'second response'), 'a fresh turn runs after a cancel');
-}));
-cancel('a tool already running finishes, then the loop stops at the boundary', () => __awaiter(void 0, void 0, void 0, function* () {
-    let toolFinished = false;
-    let secondChatCalled = false;
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('slow')],
-        toolHandlers: {
-            slow: () => __awaiter(void 0, void 0, void 0, function* () {
-                // Cancel mid-tool: the tool must still run to completion.
-                driver.cancel();
-                yield Promise.resolve();
-                toolFinished = true;
-                return 'tool done';
-            }),
-        },
-    });
-    let call = 0;
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            call += 1;
-            if (call === 1) {
-                return {
-                    role: 'assistant',
-                    content: '',
-                    toolCalls: [{ id: 't1', name: 'slow', args: {} }],
-                };
-            }
-            secondChatCalled = true;
-            return { role: 'assistant', content: 'should not be reached' };
-        }),
-    };
-    const driver = makeDriver(config, provider, 'cancel-tool');
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason, 'done');
-    assert.ok(toolFinished, 'the in-flight tool ran to completion (tools are atomic)');
-    assert.not.ok(secondChatCalled, 'no further LLM call is made after cancel');
-    const last = driver.getHistory().at(-1);
-    assert.is(last === null || last === void 0 ? void 0 : last.role, 'system-event');
-    assert.is(last === null || last === void 0 ? void 0 : last.content, 'Stopped.');
-}));
-cancel('cancel() is a no-op when no turn is running', () => {
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, scriptedProvider([]), 'cancel-idle');
-    driver.cancel(); // must not throw or append anything while idle
-    assert.is(driver.getHistory().length, 0);
-});
-cancel.run();
-// ---------------------------------------------------------------------------
-// sub-agents — forced tool use + typed completion/failure union (GENC-1312)
-//
-// A child sub-agent driver shares the parent's provider registry, so one
-// scripted queue drives both: script the parent's delegating turn, then the
-// worker's turn(s), in order.
-// ---------------------------------------------------------------------------
-const subagent = createLogicSuite('ChatDriver sub-agents');
-/** A sub-agent named `worker` that finishes by calling `completeSubAgent`. */
-const completingWorker = (result) => agent({
-    name: 'worker',
-    toolDefinitions: [def('finish')],
-    toolHandlers: {
-        finish: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            (_a = ctx.completeSubAgent) === null || _a === void 0 ? void 0 : _a.call(ctx, result);
-            return 'finished';
-        }),
-    },
-});
-/** A parent that delegates to `worker` and reports the outcome via `capture`. */
-const delegatingParent = (sub, capture) => agent({
-    name: 'boss',
-    subAgents: [sub],
-    toolDefinitions: [def('delegate')],
-    toolHandlers: {
-        delegate: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-            const outcome = yield ctx.requestSubAgent('worker', { task: 'do it' });
-            capture(outcome);
-            return outcome.ok ? 'sub-agent completed' : `sub-agent failed: ${outcome.reason}`;
-        }),
-    },
-});
-subagent('resolves { ok: true, result } when the sub-agent calls completeSubAgent', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d, _e;
-    const sessionKey = 'subagent-success-events';
-    clearMetaEventRegistry();
-    let outcome;
-    const parent = delegatingParent(completingWorker({ value: 42 }), (o) => {
-        outcome = o;
-    });
-    const provider = scriptedProvider([
-        callsTool('delegate', 'd1'), // parent delegates to the worker
-        callsTool('finish', 'f1'), //   worker completes
-    ]);
-    const driver = makeDriver(parent, provider, sessionKey);
-    yield driver.sendMessage('go');
-    assert.equal(outcome, { ok: true, result: { value: 42 } });
-    // The delegation is bracketed on the parent timeline by started + completed
-    // (no subagent.failed), mirroring turn.start/turn.end.
-    const subEvents = getMetaEvents(sessionKey).filter((e) => e.type.startsWith('subagent.'));
-    assert.equal(subEvents.map((e) => e.type), ['subagent.started', 'subagent.completed']);
-    assert.is((_a = subEvents[0].detail) === null || _a === void 0 ? void 0 : _a.agent, 'worker');
-    assert.is((_b = subEvents[1].detail) === null || _b === void 0 ? void 0 : _b.agent, 'worker');
-    // The sub-agent trace lives on the tool CALL (read by the UI trace panel and
-    // sumCosts) and is NOT duplicated onto the tool RESULT.
-    const callMsg = driver.getHistory().find((m) => { var _a; return (_a = m.toolCalls) === null || _a === void 0 ? void 0 : _a.some((c) => c.name === 'delegate'); });
-    const delegateCall = (_c = callMsg === null || callMsg === void 0 ? void 0 : callMsg.toolCalls) === null || _c === void 0 ? void 0 : _c.find((c) => c.name === 'delegate');
-    assert.ok((_d = delegateCall === null || delegateCall === void 0 ? void 0 : delegateCall.subAgentTrace) === null || _d === void 0 ? void 0 : _d.length, 'the tool call carries the sub-agent trace');
-    const resultMsg = driver.getHistory().find((m) => m.role === 'tool' && !!m.toolResult);
-    assert.not.ok((_e = resultMsg === null || resultMsg === void 0 ? void 0 : resultMsg.toolResult) === null || _e === void 0 ? void 0 : _e.subAgentTrace, 'the tool result must not duplicate the trace');
-}));
-subagent('forces tool use on the sub-agent turn but not the parent turn', () => __awaiter(void 0, void 0, void 0, function* () {
-    const parent = delegatingParent(completingWorker({ done: true }), () => { });
-    const provider = scriptedProvider([callsTool('delegate', 'd1'), callsTool('finish', 'f1')]);
-    yield makeDriver(parent, provider).sendMessage('go');
-    // Call 0 is the parent's turn (may-call); call 1 is the worker's turn (must-call).
-    assert.is(provider.toolChoicePerCall[0], undefined, 'parent turn is not forced');
-    assert.is(provider.toolChoicePerCall[1], 'required', 'sub-agent turn forces a tool call');
-    assert.ok(provider.advertisedPerCall[1].includes('finish'), 'the worker advertised its completion tool');
-}));
-subagent('resolves { ok: false, reason } and records telemetry when the sub-agent never completes', () => __awaiter(void 0, void 0, void 0, function* () {
-    const sessionKey = 'subagent-unknown-tool-test';
-    clearMetaEventRegistry();
-    let outcome;
-    const worker = agent({
-        name: 'worker',
-        toolDefinitions: [def('real')],
-        toolHandlers: { real: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const parent = delegatingParent(worker, (o) => {
-        outcome = o;
-    });
-    // The worker repeatedly calls a tool it was never given, tripping the
-    // unknown-tool limit (DEFAULT_MAX_UNKNOWN_TOOL_CALLS = 5) without completing.
-    const provider = scriptedProvider([
-        callsTool('delegate', 'd1'),
-        ...Array.from({ length: 5 }, (_unused, i) => callsTool('made_up', `u${i}`)),
-    ]);
-    yield makeDriver(parent, provider, sessionKey).sendMessage('go');
-    assert.equal(outcome, { ok: false, reason: 'unknown_tool_limit' });
-    // The failure surfaces as a high-importance `subagent.failed` meta event,
-    // recorded under the PARENT driver's session so it lands on the user-visible
-    // debug-log timeline — not orphaned in the child's own session bucket.
-    assert.ok(getMetaEvents(sessionKey).some((e) => {
-        var _a, _b;
-        return e.type === 'subagent.failed' &&
-            ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.agent) === 'worker' &&
-            ((_b = e.detail) === null || _b === void 0 ? void 0 : _b.reason) === 'unknown_tool_limit';
-    }), 'a subagent.failed meta event should be recorded under the parent session');
-    assert.not.ok(getMetaEvents('').some((e) => e.type === 'subagent.failed'), 'the failure must not be orphaned in the child default session bucket');
-}));
-subagent("folds the sub-agent's high-value meta events into the parent session, breadcrumbed", () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const sessionKey = 'subagent-meta-harvest-test';
-    clearMetaEventRegistry();
-    const worker = agent({
-        name: 'worker',
-        toolDefinitions: [def('real')],
-        toolHandlers: { real: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const parent = delegatingParent(worker, () => { });
-    // The worker trips the unknown-tool limit — emitting tool.unresolved + a
-    // turn.error under its own transient session, which the parent harvests.
-    const provider = scriptedProvider([
-        callsTool('delegate', 'd1'),
-        ...Array.from({ length: 5 }, (_unused, i) => callsTool('made_up', `u${i}`)),
-    ]);
-    yield makeDriver(parent, provider, sessionKey).sendMessage('go');
-    const events = getMetaEvents(sessionKey);
-    // The sub-agent's turn.error is folded onto the parent timeline, breadcrumbed.
-    const harvestedError = events.find((e) => { var _a; return e.type === 'turn.error' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.subAgent) === 'boss › worker'; });
-    assert.ok(harvestedError, "the sub-agent's turn.error is folded in, breadcrumbed");
-    assert.is((_a = harvestedError.detail) === null || _a === void 0 ? void 0 : _a.reason, 'unknown-tool-limit');
-    // ... as are its per-attempt tool.unresolved signals.
-    assert.ok(events.some((e) => { var _a; return e.type === 'tool.unresolved' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.subAgent) === 'boss › worker'; }), "the sub-agent's tool.unresolved events are folded in too");
-    // High-volume, message-derivable events are NOT merged.
-    assert.not.ok(events.some((e) => { var _a; return e.type === 'turn.start' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.subAgent) === 'boss › worker'; }), 'turn.start is intentionally excluded from the harvest');
-    // The child's transient bucket is cleared, never polluting the empty-key sink.
-    assert.is(getMetaEvents('').length, 0);
-}));
-subagent('defaults to { ok: false, reason: "max_iterations" } when the sub-agent ends without completing', () => __awaiter(void 0, void 0, void 0, function* () {
-    const sessionKey = 'subagent-default-fail-test';
-    clearMetaEventRegistry();
-    let outcome;
-    const worker = agent({
-        name: 'worker',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const parent = delegatingParent(worker, (o) => {
-        outcome = o;
-    });
-    // No script for the worker turn → it returns a plain-text reply and ends
-    // without ever calling a completion tool (the child records no explicit
-    // failure reason).
-    const provider = scriptedProvider([callsTool('delegate', 'd1')]);
-    yield makeDriver(parent, provider, sessionKey).sendMessage('go');
-    assert.equal(outcome, { ok: false, reason: 'max_iterations' });
-    // Even the defensive default is reported to the parent session — this is the
-    // only telemetry path when the child recorded no explicit failure.
-    assert.ok(getMetaEvents(sessionKey).some((e) => { var _a; return e.type === 'subagent.failed' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.reason) === 'max_iterations'; }), 'the default failure should still record a subagent.failed meta event');
-}));
-subagent("forwards the sub-agent's turns onto the parent timeline, numbered under the activating turn", () => __awaiter(void 0, void 0, void 0, function* () {
-    const parent = delegatingParent(completingWorker({ done: true }), () => { });
-    const provider = scriptedProvider([callsTool('delegate', 'd1'), callsTool('finish', 'f1')]);
-    const driver = makeDriver(parent, provider);
-    yield driver.sendMessage('go');
-    const snaps = driver.getTurnSnapshots();
-    // Parent turn 0 activated the sub-agent, so the worker's single turn is "0-1".
-    const childSnap = snaps.find((s) => s.turnIndex === '0-1');
-    assert.ok(childSnap, 'the sub-agent\'s turn should be forwarded as "0-1"');
-    assert.is(childSnap.agentName, 'worker', 'the forwarded snapshot keeps the sub-agent name');
-    assert.ok(childSnap.toolNames.includes('finish'), 'and records the tools the sub-agent saw');
-    // The parent's own turns stay numeric.
-    assert.ok(snaps.some((s) => s.turnIndex === '0'), 'the activating parent turn is present as a bare string counter');
-}));
-subagent('resolves { ok: false, reason: "timeout" } and aborts the run when the sub-agent exceeds timeoutMs', () => __awaiter(void 0, void 0, void 0, function* () {
-    const sessionKey = 'subagent-timeout-test';
-    clearMetaEventRegistry();
-    let outcome;
-    // The worker would complete if allowed to run — but its turn hangs (below),
-    // so the parent's timeout fires first.
-    const worker = agent({
-        name: 'worker',
-        toolDefinitions: [def('finish')],
-        toolHandlers: {
-            finish: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                var _a;
-                (_a = ctx.completeSubAgent) === null || _a === void 0 ? void 0 : _a.call(ctx, { ok: true });
-                return 'finished';
-            }),
-        },
-    });
-    const parent = agent({
-        name: 'boss',
-        subAgents: [worker],
-        toolDefinitions: [def('delegate')],
-        toolHandlers: {
-            delegate: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                const o = yield ctx.requestSubAgent('worker', { task: 'do it', timeoutMs: 20 });
-                outcome = o;
-                return o.ok ? 'sub-agent completed' : `sub-agent failed: ${o.reason}`;
-            }),
-        },
-    });
-    // Call 0: parent delegates. Call 1: the worker's turn hangs until its signal
-    // aborts (the timeout-driven dispose). Call 2: the parent wraps up.
-    let call = 0;
-    const provider = {
-        chat: (_h, _m, options) => {
-            const n = call;
-            call += 1;
-            if (n === 0)
-                return Promise.resolve(callsTool('delegate', 'd1'));
-            if (n === 1) {
-                return new Promise((_resolve, reject) => {
-                    const signal = options === null || options === void 0 ? void 0 : options.signal;
-                    if (!signal)
-                        return;
-                    if (signal.aborted) {
-                        reject(signal.reason);
-                        return;
-                    }
-                    signal.addEventListener('abort', () => reject(signal.reason), { once: true });
-                });
-            }
-            return Promise.resolve({ role: 'assistant', content: 'done' });
-        },
-    };
-    yield makeDriver(parent, provider, sessionKey).sendMessage('go');
-    assert.equal(outcome, { ok: false, reason: 'timeout' });
-    // Recorded under the parent session, like every other sub-agent failure.
-    assert.ok(getMetaEvents(sessionKey).some((e) => { var _a; return e.type === 'subagent.failed' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.reason) === 'timeout'; }), 'a subagent.failed meta event with reason "timeout" should be recorded');
-}));
-subagent('times out (without hanging) when the sub-agent is parked on a user interaction', () => __awaiter(void 0, void 0, void 0, function* () {
-    const sessionKey = 'subagent-interaction-timeout';
-    clearMetaEventRegistry();
-    let outcome;
-    // The worker asks a question and waits; the user never answers. The parent's
-    // timeout must cancel that interaction and unblock the worker — if it didn't,
-    // `await runPromise` inside invokeSubAgent would hang here forever (the worker
-    // is parked on a promise only the parent can settle), and this test would
-    // never resolve.
-    const worker = agent({
-        name: 'worker',
-        toolDefinitions: [def('ask')],
-        toolHandlers: {
-            ask: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                const r = yield ctx.requestInteraction('q', {}); // parks on the parent
-                return { answered: r };
-            }),
-        },
-    });
-    const parent = agent({
-        name: 'boss',
-        subAgents: [worker],
-        toolDefinitions: [def('delegate')],
-        toolHandlers: {
-            delegate: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                const o = yield ctx.requestSubAgent('worker', { task: 'ask', timeoutMs: 20 });
-                outcome = o;
-                return o.ok ? 'ok' : `failed: ${o.reason}`;
-            }),
-        },
-    });
-    // call 0: parent delegates. call 1: worker asks (parks on the interaction).
-    // Later calls: the disposed worker's turn sees an aborted signal and rejects;
-    // the parent's resuming turn (not aborted) ends with text.
-    let call = 0;
-    const provider = {
-        chat: (_h, _m, options) => {
-            const n = call;
-            call += 1;
-            if (n === 0)
-                return Promise.resolve(callsTool('delegate', 'd1'));
-            if (n === 1)
-                return Promise.resolve(callsTool('ask', 'a1'));
-            const signal = options === null || options === void 0 ? void 0 : options.signal;
-            if (signal === null || signal === void 0 ? void 0 : signal.aborted)
-                return Promise.reject(signal.reason);
-            return Promise.resolve({ role: 'assistant', content: 'done' });
-        },
-    };
-    yield makeDriver(parent, provider, sessionKey).sendMessage('go');
-    assert.equal(outcome, { ok: false, reason: 'timeout' });
-    assert.ok(getMetaEvents(sessionKey).some((e) => { var _a; return e.type === 'subagent.failed' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.reason) === 'timeout'; }), 'subagent.failed (timeout) should be recorded — proving it neither hung nor skipped logging');
-}));
-subagent('fails the sub-agent with reason "timeout" (no apology text) on a transport TimeoutError', () => __awaiter(void 0, void 0, void 0, function* () {
-    const sessionKey = 'subagent-transport-timeout-test';
-    clearMetaEventRegistry();
-    let outcome;
-    const worker = agent({
-        name: 'worker',
-        toolDefinitions: [def('finish')],
-        toolHandlers: {
-            finish: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                var _a;
-                (_a = ctx.completeSubAgent) === null || _a === void 0 ? void 0 : _a.call(ctx, { ok: true });
-                return 'finished';
-            }),
-        },
-    });
-    const parent = delegatingParent(worker, (o) => {
-        outcome = o;
-    });
-    // Call 0: parent delegates. Call 1: the worker's request times out at the
-    // transport (tagged TimeoutError). Call 2: the parent wraps up.
-    let call = 0;
-    const provider = {
-        chat: () => {
-            const n = call;
-            call += 1;
-            if (n === 0)
-                return Promise.resolve(callsTool('delegate', 'd1'));
-            if (n === 1) {
-                return Promise.reject(new DOMException('Anthropic request timed out', 'TimeoutError'));
-            }
-            return Promise.resolve({ role: 'assistant', content: 'done' });
-        },
-    };
-    const driver = makeDriver(parent, provider, sessionKey);
-    yield driver.sendMessage('go');
-    // The parent gets a typed timeout — not the wrong max_iterations default it
-    // used to see when the child answered with the user-facing apology instead.
-    assert.equal(outcome, { ok: false, reason: 'timeout' });
-    assert.ok(getMetaEvents(sessionKey).some((e) => {
-        var _a, _b;
-        return e.type === 'subagent.failed' &&
-            ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.agent) === 'worker' &&
-            ((_b = e.detail) === null || _b === void 0 ? void 0 : _b.reason) === 'timeout';
-    }), 'a subagent.failed meta event with reason "timeout" should be recorded');
-    // The child must not speak to the user.
-    assert.not.ok(driver.getHistory().some((m) => { var _a; return (_a = m.content) === null || _a === void 0 ? void 0 : _a.includes('The request timed out'); }), 'the sub-agent must not append the user-facing timeout apology');
-}));
-subagent.run();
-// ---------------------------------------------------------------------------
-// cost / token attribution on the thinking-step split (GENC-1410)
-// ---------------------------------------------------------------------------
-const costAttribution = createLogicSuite('ChatDriver cost attribution (thinking-step split)');
-costAttribution('a text-plus-tool-call response contributes its cost and tokens exactly once', () => __awaiter(void 0, void 0, void 0, function* () {
-    const config = agent({
-        name: 'Worker',
-        toolDefinitions: () => [def('do_thing')],
-        toolHandlers: () => ({ do_thing: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) }),
-    });
-    // A single response that emits reasoning + interstitial narration + a tool call, carrying that
-    // response's usage. The driver splits it into three messages — a `reasoning` bubble, a
-    // `narration` bubble, and the tool-call message — but only ONE may carry the cost/tokens or the
-    // session totals double-count this one response (GENC-1410).
-    const provider = scriptedProvider([
-        {
-            role: 'assistant',
-            content: 'Let me act.',
-            reasoning: 'Let me think.',
-            toolCalls: [{ id: 't1', name: 'do_thing', args: {} }],
-            cost: 0.05,
-            inputTokens: 1000,
-            outputTokens: 50,
-        },
-        // Turn-ending reply (no tool calls, no usage) so the loop terminates cleanly.
-        { role: 'assistant', content: 'Done.' },
-    ]);
-    const driver = makeDriver(config, provider);
-    yield driver.sendMessage('go');
-    const history = driver.getHistory();
-    const reasoning = history.find((m) => m.category === 'reasoning');
-    const narration = history.find((m) => m.category === 'narration');
-    const toolCallMsg = history.find((m) => { var _a; return (_a = m.toolCalls) === null || _a === void 0 ? void 0 : _a.some((c) => c.name === 'do_thing'); });
-    // The one response was split into reasoning + narration bubbles + the tool-call message.
-    assert.ok(reasoning, 'a reasoning bubble is emitted for the chain-of-thought summary');
-    assert.is(reasoning.content, 'Let me think.');
-    assert.ok(narration, 'a narration bubble is emitted for the interstitial prose');
-    assert.is(narration.content, 'Let me act.');
-    assert.ok(toolCallMsg, 'the tool call is on its own message');
-    assert.is(toolCallMsg.content, '');
-    // Only the tool-call message carries the turn's usage; the display bubbles carry none.
-    for (const m of [reasoning, narration]) {
-        assert.is(m.cost, undefined, 'a display bubble must not carry cost');
-        assert.is(m.inputTokens, undefined, 'nor inputTokens');
-        assert.is(m.outputTokens, undefined, 'nor outputTokens');
-    }
-    assert.is(toolCallMsg.cost, 0.05, 'the tool-call message carries the cost');
-    assert.is(toolCallMsg.inputTokens, 1000);
-    assert.is(toolCallMsg.outputTokens, 50);
-    // The reasoning/narration bubbles are UI-only; they must not carry the tool call either.
-    assert.is(reasoning.toolCalls, undefined, 'the reasoning bubble carries no tool call');
-    assert.is(narration.toolCalls, undefined, 'the narration bubble carries no tool call');
-    // The session totals count the one response once, not twice.
-    assert.is(sumCosts(history), 0.05, 'cost is summed once');
-    assert.is(sumTokens(history), 1050, 'tokens are summed once');
-}));
-costAttribution.run();
-// ---------------------------------------------------------------------------
-// per-agent / per-state temperature & tool-call mode (GENC-1321)
-//
-// The driver resolves `temperature` and `toolChoice` the same way it resolves
-// `provider`: a static value, or a function of the turn context (which carries
-// the live state for stateful agents). These tests assert both forms reach the
-// provider call, and that the per-turn (function) form re-resolves each call.
-// ---------------------------------------------------------------------------
-const settings = createLogicSuite('ChatDriver temperature & toolChoice');
-settings('passes a static agent temperature and tool-call mode to the provider', () => __awaiter(void 0, void 0, void 0, function* () {
-    const provider = scriptedProvider([]);
-    const driver = makeDriver(agent({
-        name: 'a',
-        temperature: 0.3,
-        toolChoice: 'none',
-        cachePolicy: { scope: 'prompt' },
-        tailContext: 'STATE',
-    }), provider);
-    yield driver.sendMessage('hi');
-    assert.is(provider.temperaturePerCall[0], 0.3);
-    assert.equal(provider.toolChoicePerCall[0], 'none');
-    assert.equal(provider.cachePolicyPerCall[0], { scope: 'prompt' });
-    // The driver frames the raw tail content in a <system-reminder> marker.
-    assert.is(provider.tailContextPerCall[0], '<system-reminder>\nSTATE\n</system-reminder>');
-    // ...and surfaced in the per-turn debug snapshot (the effective values sent).
-    const snap = driver.getTurnSnapshots()[0];
-    assert.is(snap.temperature, 0.3);
-    assert.equal(snap.toolChoice, 'none');
-    // The framed tail is captured on the snapshot too — it is never stored in
-    // history, so the snapshot is the only record of what the model actually saw.
-    assert.is(snap.tailContext, '<system-reminder>\nSTATE\n</system-reminder>');
-}));
-settings('re-resolves the function form per turn (carrying turn context)', () => __awaiter(void 0, void 0, void 0, function* () {
-    const provider = scriptedProvider([callsTool('tool_a', 't1')]);
-    const config = agent({
-        name: 'b',
-        toolDefinitions: [def('tool_a')],
-        toolHandlers: { tool_a: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-        // turnIndex: 0 on the first LLM call, > 0 on subsequent tool-loop iterations.
-        temperature: (ctx) => (ctx.turnIndex === 0 ? 0.1 : 0.9),
-        toolChoice: (ctx) => (ctx.turnIndex === 0 ? { tool: 'tool_a' } : 'auto'),
-        cachePolicy: (ctx) => (ctx.turnIndex === 0 ? { scope: 'history' } : { scope: 'tools' }),
-    });
-    yield makeDriver(config, provider).sendMessage('go');
-    // First call forces the named tool at a low temperature...
-    assert.is(provider.temperaturePerCall[0], 0.1);
-    assert.equal(provider.toolChoicePerCall[0], { tool: 'tool_a' });
-    assert.equal(provider.cachePolicyPerCall[0], { scope: 'history' });
-    // ...the follow-up call (after the tool result) sees the other branch.
-    assert.is(provider.temperaturePerCall[1], 0.9);
-    assert.equal(provider.toolChoicePerCall[1], 'auto');
-    assert.equal(provider.cachePolicyPerCall[1], { scope: 'tools' });
-}));
-settings('leaves temperature and toolChoice unset when the agent does not configure them', () => __awaiter(void 0, void 0, void 0, function* () {
-    const provider = scriptedProvider([]);
-    yield makeDriver(agent({ name: 'c' }), provider).sendMessage('hi');
-    assert.is(provider.temperaturePerCall[0], undefined);
-    assert.is(provider.toolChoicePerCall[0], undefined);
-    assert.is(provider.cachePolicyPerCall[0], undefined);
-    assert.is(provider.tailContextPerCall[0], undefined);
-}));
-// GENC-1380 A3b: the framework's malformed/empty retry nudge is routed to the framed tail (so the
-// system prompt stays byte-stable for caching), not appended to the system string.
-settings('routes the empty-response retry nudge into the framed tail, not the system prompt', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    // First call returns empty → the driver retries; the second exhausts the queue and ends the turn.
-    const provider = scriptedProvider([{ role: 'assistant', content: '' }]);
-    const driver = makeDriver(agent({ name: 'r', systemPrompt: 'BASE' }), provider);
-    yield driver.sendMessage('go');
-    // The retry call (index 1) carries the nudge in the framed tail...
-    assert.ok((_a = provider.tailContextPerCall[1]) === null || _a === void 0 ? void 0 : _a.startsWith('<system-reminder>'), 'tail is framed');
-    assert.ok((_b = provider.tailContextPerCall[1]) === null || _b === void 0 ? void 0 : _b.includes('You must respond'), 'retry nudge is in the tail');
-    // ...and the system prompt stays the bare agent prompt on both calls (nudge moved, not copied).
-    assert.is(provider.systemPromptPerCall[0], 'BASE');
-    assert.is(provider.systemPromptPerCall[1], 'BASE');
-    // Regression guard (debug-log reconstruction): the tail is never stored in
-    // history, so the per-turn snapshot must capture it — otherwise the retry
-    // nudge the model actually received would be invisible in the export. The
-    // snapshot's (systemPrompt + tailContext) must equal what the provider saw.
-    const retrySnap = driver.getTurnSnapshots()[1];
-    assert.is(retrySnap.systemPrompt, provider.systemPromptPerCall[1]);
-    assert.is(retrySnap.tailContext, provider.tailContextPerCall[1]);
-    assert.ok((_c = retrySnap.tailContext) === null || _c === void 0 ? void 0 : _c.includes('You must respond'), 'nudge reconstructable');
-    // The first (non-retry) call had no framework suffix and no agent tail → empty.
-    assert.is(driver.getTurnSnapshots()[0].tailContext, undefined);
-}));
-settings.run();
-// ---------------------------------------------------------------------------
-// empty-response diagnostics (GENC-1321)
-//
-// The transport surfaces a provider diagnostic (Gemini: finishReason,
-// thoughtsTokens, parts, blockReason) on the message; the driver must fold it
-// into the empty-response meta events so the debug-log timeline shows *why* a
-// turn came back blank — not just that it did.
-// ---------------------------------------------------------------------------
-const emptyDiag = createLogicSuite('ChatDriver empty-response diagnostics');
-emptyDiag('folds the provider responseMeta into the empty-response meta events', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d;
-    clearMetaEventRegistry();
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            return ({
-                role: 'assistant',
-                content: '',
-                responseMeta: {
-                    finishReason: 'STOP',
-                    thoughtsTokens: 999,
-                    parts: { functionCall: 0, thought: 0, text: 0 },
-                },
-            });
-        }),
-    };
-    const sessionKey = 'empty-diag';
-    yield makeDriver(agent({ name: 'Static' }), provider, sessionKey).sendMessage('go');
-    // Both the in-turn retries and the final bail carry the diagnostic.
-    const retry = getMetaEvents(sessionKey).find((e) => { var _a; return e.type === 'turn.retry' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.reason) === 'empty-response'; });
-    assert.ok(retry, 'an empty-response turn.retry should be recorded');
-    assert.is((_a = retry.detail) === null || _a === void 0 ? void 0 : _a.finishReason, 'STOP');
-    assert.is((_b = retry.detail) === null || _b === void 0 ? void 0 : _b.thoughtsTokens, 999);
-    const err = getMetaEvents(sessionKey).find((e) => { var _a; return e.type === 'turn.error' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.reason) === 'empty-response'; });
-    assert.ok(err, 'an empty-response turn.error should be recorded after retries');
-    assert.is((_c = err.detail) === null || _c === void 0 ? void 0 : _c.finishReason, 'STOP');
-    assert.is((_d = err.detail) === null || _d === void 0 ? void 0 : _d.thoughtsTokens, 999);
-}));
-emptyDiag.run();
-// ---------------------------------------------------------------------------
-// synthetic-user echo — a resolved interaction can optionally surface its
-// outcome on the user's side of the chat (GENC-1330). The widget opts in by
-// returning `userMessage`; the driver appends it as a display-only
-// `'synthetic-user'` message that transports never serialize.
-// ---------------------------------------------------------------------------
-const syntheticUser = createLogicSuite('ChatDriver synthetic-user interaction echo');
-syntheticUser('resolveInteraction with userMessage appends a synthetic-user message', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const pending = driver.requestInteraction('planning-question', { question: 'Pick one' });
-    const interactionMsg = driver.getHistory().at(-1);
-    const id = interactionMsg.interaction.interactionId;
-    driver.resolveInteraction(id, {
-        status: 'approved',
-        payload: { answer: 'Option A' },
-        userMessage: 'Option A',
-    });
-    yield pending;
-    const history = driver.getHistory();
-    const synthetic = history.filter((m) => m.role === 'synthetic-user');
-    assert.is(synthetic.length, 1);
-    assert.is(synthetic[0].content, 'Option A');
-    // The original interaction message is still present and now marked resolved
-    // (the existing resolved-widget mechanism is untouched).
-    const resolved = history.find((m) => { var _a; return ((_a = m.interaction) === null || _a === void 0 ? void 0 : _a.interactionId) === id; });
-    assert.ok((_a = resolved === null || resolved === void 0 ? void 0 : resolved.interaction) === null || _a === void 0 ? void 0 : _a.resolved);
-    // Chronology: the user-side echo follows the (resolved) interaction.
-    const idxInteraction = history.findIndex((m) => { var _a; return ((_a = m.interaction) === null || _a === void 0 ? void 0 : _a.interactionId) === id; });
-    const idxSynthetic = history.findIndex((m) => m.role === 'synthetic-user');
-    assert.ok(idxSynthetic > idxInteraction);
-    // It is attributed to the agent that created it — same stamping as any other
-    // appended message — so the debug log can say which agent produced it.
-    assert.is(synthetic[0].agentName, resolved === null || resolved === void 0 ? void 0 : resolved.agentName);
-}));
-syntheticUser('omitted or whitespace-only userMessage appends no synthetic-user message', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    // Omitted entirely — the previous behaviour.
-    const first = driver.requestInteraction('w', {});
-    const firstId = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(firstId, { status: 'approved' });
-    yield first;
-    // Whitespace-only — treated as absent, never appended.
-    const second = driver.requestInteraction('w', {});
-    const secondId = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(secondId, { status: 'approved', userMessage: '   ' });
-    yield second;
-    assert.is(driver.getHistory().filter((m) => m.role === 'synthetic-user').length, 0);
-}));
-syntheticUser.run();
-// ---------------------------------------------------------------------------
-// interaction presentation — the per-call `presentation` option is stamped
-// onto the appended interaction so the renderer can frame the widget, and is
-// absent (the historical default) when the option is omitted.
-// ---------------------------------------------------------------------------
-const interactionPresentation = createLogicSuite('ChatDriver interaction presentation');
-interactionPresentation('presentation option is stamped onto the appended interaction', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const pending = driver.requestInteraction('w', {}, { presentation: 'bubble' });
-    const interaction = driver.getHistory().at(-1).interaction;
-    assert.is(interaction.presentation, 'bubble');
-    // Clean up the pending interaction so it does not dangle.
-    driver.resolveInteraction(interaction.interactionId, { status: 'approved' });
-    yield pending;
-}));
-interactionPresentation('presentation is absent when the option is omitted', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const pending = driver.requestInteraction('w', {});
-    const interaction = driver.getHistory().at(-1).interaction;
-    assert.ok(!('presentation' in interaction));
-    driver.resolveInteraction(interaction.interactionId, { status: 'approved' });
-    yield pending;
-}));
-interactionPresentation.run();
-// ---------------------------------------------------------------------------
-// external diagnostics harvest (GENC-1461) — a widget may return an out-of-band
-// engine's collated debug log on `InteractionResult.diagnostics` (e.g. a
-// server-side ChatDriver's). Those entries carry the SOURCE engine's own 0-based
-// index space, which would collide with this host's forward-capture cursors and
-// be dropped: the persister dedups `turn` entries by `turnIndex` and `event`
-// entries by an `index` high-water mark. So the driver decomposes the harvest by
-// kind — events fold into the session's meta-event registry (re-indexed onto the
-// host's monotonic counter), turns are re-keyed into a per-batch namespace, and
-// messages pass through unchanged (the persister already keys those by content).
-// ---------------------------------------------------------------------------
-const externalDiagnostics = createLogicSuite('ChatDriver external diagnostics harvest');
-/** A `diagnostics` payload as a headless engine would collate it — one of each kind,
- * all carrying that engine's own 0-based indices (`turnIndex: '0'`, event `index: 0`). */
-const harvestPayload = (marker) => [
-    { kind: 'message', timestamp: '2026-07-23T10:00:00.000Z', role: 'assistant', content: marker },
-    { kind: 'turn', timestamp: '2026-07-23T10:00:01.000Z', turnIndex: '0', systemPrompt: 'sys' },
-    {
-        kind: 'event',
-        index: 0,
-        timestamp: '2026-07-23T10:00:02.000Z',
-        type: 'turn.error',
-        importance: 'high',
-        detail: { marker },
-    },
-];
-externalDiagnostics('routes harvested events to the meta-event registry (re-indexed) and keeps turns + messages', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    clearMetaEventRegistry();
-    const sessionKey = 'external-diag-harvest';
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]), sessionKey);
-    // Requesting the interaction records a host `interaction.requested` meta-event, so the
-    // registry's index counter is already advanced when the harvested event is merged — exactly
-    // the condition that made the foreign 0-based `index` lose the persister's high-water race.
-    const pending = driver.requestInteraction('w', {});
-    const { interactionId } = driver.getHistory().at(-1).interaction;
-    const requestedIndex = getMetaEvents(sessionKey).find((e) => e.type === 'interaction.requested').index;
-    driver.resolveInteraction(interactionId, {
-        status: 'approved',
-        diagnostics: harvestPayload('m1'),
-    });
-    yield pending;
-    // The event left the external buffer and landed in the registry, re-indexed ABOVE the host's
-    // prior event (so it beats the persister's `index <= lastEventIndex` high-water), timestamp kept.
-    const external = driver.getExternalDiagnostics();
-    assert.is(external.filter((e) => e.kind === 'event').length, 0, 'events do not stay in the buffer');
-    const merged = getMetaEvents(sessionKey).find((e) => { var _a; return ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.marker) === 'm1'; });
-    assert.ok(merged, 'the harvested event is folded into the session registry');
-    assert.ok(merged.index > requestedIndex, 're-indexed onto the host counter, above prior events');
-    assert.is(merged.timestamp, '2026-07-23T10:00:02.000Z', 'original timestamp preserved for ordering');
-    // The turn is kept in the buffer but re-keyed out of the host's bare-integer turn-key space,
-    // and the message passes through untouched.
-    const turn = external.find((e) => e.kind === 'turn');
-    assert.ok(turn, 'the harvested turn is kept in the external buffer');
-    assert.is(turn.turnIndex, 'server-generation.1:0', 'turnIndex namespaced per batch');
-    const message = external.find((e) => e.kind === 'message');
-    assert.ok(message, 'the harvested message is kept in the external buffer');
-    assert.is(message.content, 'm1', 'message passes through unchanged');
-    // A single manifest event records the fold's provenance — the fragile boundary this feature
-    // guards is now observable: a dropped generation shows up as a zero/absent manifest.
-    const manifest = getMetaEvents(sessionKey).find((e) => e.type === 'external-diagnostics.folded');
-    assert.ok(manifest, 'a manifest meta-event is recorded for the fold');
-    assert.is((_a = manifest.detail) === null || _a === void 0 ? void 0 : _a.interactionId, interactionId);
-    assert.equal((_b = manifest.detail) === null || _b === void 0 ? void 0 : _b.counts, { turn: 1, event: 1, message: 1 });
-}));
-externalDiagnostics('namespaces each batch so distinct server generations cannot collide on turnIndex', () => __awaiter(void 0, void 0, void 0, function* () {
-    clearMetaEventRegistry();
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]), 'external-diag-batches');
-    const first = driver.requestInteraction('w', {});
-    const firstId = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(firstId, { status: 'approved', diagnostics: harvestPayload('a') });
-    yield first;
-    const second = driver.requestInteraction('w', {});
-    const secondId = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(secondId, { status: 'approved', diagnostics: harvestPayload('b') });
-    yield second;
-    // Both harvests carried `turnIndex: '0'`; the per-batch namespace keeps them distinct, so the
-    // persister's `emittedTurnKeys` can't fold the second generation's turn into the first.
-    const turnKeys = driver
-        .getExternalDiagnostics()
-        .filter((e) => e.kind === 'turn')
-        .map((e) => e.turnIndex);
-    assert.equal(turnKeys, ['server-generation.1:0', 'server-generation.2:0']);
-}));
-externalDiagnostics('keys turns by local position so several server runs in one harvest do not collide', () => __awaiter(void 0, void 0, void 0, function* () {
-    clearMetaEventRegistry();
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]), 'external-diag-multirun');
-    // One interaction carrying two independent server runs (e.g. a consolidator's consolidator-code
-    // run and its table-code run) — each numbers its own turns from 0, so the harvest has two
-    // `turnIndex: '0'` entries. Keying by source index would collapse them; local position keeps
-    // both, so the persister's per-turnIndex dedup drops neither.
-    const pending = driver.requestInteraction('w', {});
-    const { interactionId } = driver.getHistory().at(-1).interaction;
-    driver.resolveInteraction(interactionId, {
-        status: 'approved',
-        diagnostics: [
-            {
-                kind: 'turn',
-                timestamp: '2026-07-23T10:00:00.000Z',
-                turnIndex: '0',
-                systemPrompt: 'run1',
-            },
-            {
-                kind: 'turn',
-                timestamp: '2026-07-23T10:00:01.000Z',
-                turnIndex: '1',
-                systemPrompt: 'run1',
-            },
-            {
-                kind: 'turn',
-                timestamp: '2026-07-23T10:00:02.000Z',
-                turnIndex: '0',
-                systemPrompt: 'run2',
-            },
-        ],
-    });
-    yield pending;
-    const turnKeys = driver
-        .getExternalDiagnostics()
-        .filter((e) => e.kind === 'turn')
-        .map((e) => e.turnIndex);
-    assert.equal(turnKeys, [
-        'server-generation.1:0',
-        'server-generation.1:1',
-        'server-generation.1:2',
-    ]);
-    // All distinct — no key repeats despite the repeated source `turnIndex: '0'`.
-    assert.is(new Set(turnKeys).size, 3, 'every harvested turn gets a distinct key');
-}));
-externalDiagnostics('tolerates malformed entries and does not fold or miscount non-standard kinds', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    clearMetaEventRegistry();
-    const sessionKey = 'external-diag-malformed';
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]), sessionKey);
-    const pending = driver.requestInteraction('w', {});
-    const { interactionId } = driver.getHistory().at(-1).interaction;
-    // The harvest is untrusted `unknown[]`: primitives/null and an object without a string `kind`
-    // must be skipped (not throw), and a `meta-snapshot` (host-owned, never emitted by a sibling)
-    // must be dropped rather than folded or miscounted as a message.
-    driver.resolveInteraction(interactionId, {
-        status: 'approved',
-        diagnostics: [
-            null,
-            'oops',
-            42,
-            { timestamp: '2026-07-23T10:00:00.000Z' }, // no kind
-            {
-                kind: 'message',
-                timestamp: '2026-07-23T10:00:01.000Z',
-                role: 'assistant',
-                content: 'real',
-            },
-            { kind: 'meta-snapshot', timestamp: '2026-07-23T10:00:02.000Z', meta: { host: 'foreign' } },
-        ],
-    });
-    yield pending;
-    // Only the one real message survives the buffer; the meta-snapshot is not folded.
-    const external = driver.getExternalDiagnostics();
-    assert.equal(external.map((e) => e.kind), ['message']);
-    assert.is(external[0].content, 'real');
-    // Manifest counts only the three real kinds — the meta-snapshot is not miscounted as a message.
-    const manifest = getMetaEvents(sessionKey).find((e) => e.type === 'external-diagnostics.folded');
-    assert.equal((_a = manifest.detail) === null || _a === void 0 ? void 0 : _a.counts, { turn: 0, event: 0, message: 1 });
-}));
-externalDiagnostics.run();
-// ---------------------------------------------------------------------------
-// interaction context lifecycle (GENC-1390) — the driver creates a live
-// InteractionContext on requestInteraction and disposes+drops it on resolve, so
-// widget state survives element remounts but never outlives the interaction.
-// ---------------------------------------------------------------------------
-const interactionContextLifecycle = createLogicSuite('ChatDriver interaction context');
-interactionContextLifecycle('creates a context on request and returns it by id', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const pending = driver.requestInteraction('w', {});
-    const { interactionId } = driver.getHistory().at(-1).interaction;
-    const ctx = driver.getInteractionContext(interactionId);
-    assert.ok(ctx, 'a context exists for the pending interaction');
-    assert.is(ctx.interactionId, interactionId);
-    // Same instance on a second lookup — this stable identity is what survives remounts.
-    assert.is(driver.getInteractionContext(interactionId), ctx, 'the context is a stable instance');
-    driver.resolveInteraction(interactionId, { status: 'approved' });
-    yield pending;
-}));
-interactionContextLifecycle('disposes and drops the context on resolve', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const pending = driver.requestInteraction('w', {});
-    const { interactionId } = driver.getHistory().at(-1).interaction;
-    let disposed = false;
-    driver.getInteractionContext(interactionId).onDispose(() => {
-        disposed = true;
-    });
-    driver.resolveInteraction(interactionId, { status: 'approved' });
-    yield pending;
-    assert.ok(disposed, 'onDispose fired on resolve');
-    assert.is(driver.getInteractionContext(interactionId), undefined, 'the context is dropped after resolve');
-}));
-interactionContextLifecycle.run();
-// ---------------------------------------------------------------------------
-// interaction activity-bus signals (GENC-1346) — the driver brackets a parked
-// widget interaction with `interaction-requested` / `interaction-resolved`, so
-// turn-aware UI can distinguish "actively computing" from "parked awaiting the
-// user". No tool-loop event fires at a park boundary, so these are the signal.
-// ---------------------------------------------------------------------------
-const interactionBus = createLogicSuite('ChatDriver interaction activity-bus signals');
-// These two tests need to observe what the driver publishes, so they inject a local
-// in-memory bus (no `crossTabEvents` → no BroadcastChannel is ever opened, nothing to close)
-// rather than the shared singleton. Every other suite lets the driver default to the no-op bus.
-interactionBus('brackets a park with interaction-requested then -resolved', () => __awaiter(void 0, void 0, void 0, function* () {
-    const events = [];
-    const bus = new AgenticActivityBus();
-    const unsubs = [
-        bus.subscribe('interaction-requested', () => events.push('requested')),
-        bus.subscribe('interaction-resolved', () => events.push('resolved')),
-    ];
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]), '', bus);
-    const pending = driver.requestInteraction('w', {});
-    assert.equal(events, ['requested'], 'parking fires interaction-requested');
-    const id = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id, { status: 'approved' });
-    yield pending;
-    assert.equal(events, ['requested', 'resolved'], 'resolving fires interaction-resolved');
-    unsubs.forEach((u) => u());
-    driver.dispose();
-}));
-interactionBus('a timed-out interaction still fires interaction-resolved', () => __awaiter(void 0, void 0, void 0, function* () {
-    const events = [];
-    const bus = new AgenticActivityBus();
-    const unsub = bus.subscribe('interaction-resolved', () => events.push('resolved'));
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]), '', bus);
-    // Never resolved by a user — the timeout path runs the same teardown, so it
-    // must signal the bus too (else the button would stay enabled after a timeout).
-    const pending = driver.requestInteraction('w', {}, { timeoutMs: 1 });
-    yield pending;
-    assert.equal(events, ['resolved'], 'the timeout resolution path also signals the bus');
-    unsub();
-    driver.dispose();
-}));
-interactionBus.run();
-// ---------------------------------------------------------------------------
-// interaction timeout — requestInteraction({ timeoutMs }) resolves with a
-// status:'timeout' result (never rejects) and closes the widget read-only.
-// ---------------------------------------------------------------------------
-const interactionTimeout = createLogicSuite('ChatDriver interaction timeout');
-interactionTimeout('resolves with status "timeout" when the user does not respond in time', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const result = (yield driver.requestInteraction('planning-question', { question: 'Pick one' }, { timeoutMs: 10 }));
-    assert.is(result.status, 'timeout');
-    // The widget message is stamped resolved (renders read-only) with the timeout.
-    const msg = driver.getHistory().find((m) => m.interaction);
-    assert.ok((_a = msg === null || msg === void 0 ? void 0 : msg.interaction) === null || _a === void 0 ? void 0 : _a.resolved);
-    assert.is(msg.interaction.resolved.status, 'timeout');
-}));
-interactionTimeout('a user response before the deadline wins and cancels the timeout', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    // A long timeout that must NOT fire because we resolve immediately.
-    const pending = driver.requestInteraction('planning-question', { question: 'Pick one' }, { timeoutMs: 10000 });
-    const id = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id, { status: 'approved', payload: { answer: 'A' } });
-    const result = yield pending;
-    assert.is(result.status, 'approved');
-    assert.is((_a = result.payload) === null || _a === void 0 ? void 0 : _a.answer, 'A');
-}));
-interactionTimeout.run();
-// ---------------------------------------------------------------------------
-// interaction external cost — a widget may report its own (non-LLM) cost via
-// InteractionResult.costUsd; the driver folds it onto the message as
-// externalCostUsd so the host's sumCosts recompute includes it.
-// ---------------------------------------------------------------------------
-const interactionCost = createLogicSuite('ChatDriver interaction external cost');
-interactionCost('folds a widget-reported costUsd onto the message as externalCostUsd', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const pending = driver.requestInteraction('planning-question', { question: 'Pick one' });
-    const id = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id, { status: 'approved', payload: { answer: 'A' }, costUsd: 0.05 });
-    yield pending;
-    const msg = driver.getHistory().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.05);
-}));
-interactionCost('leaves externalCostUsd unset for a missing, zero, or negative costUsd', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    // Omitted entirely.
-    const p1 = driver.requestInteraction('w', {});
-    const id1 = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id1, { status: 'approved' });
-    yield p1;
-    // Zero and negative are both ignored (only a positive, finite amount counts).
-    const p2 = driver.requestInteraction('w', {});
-    const id2 = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id2, { status: 'approved', costUsd: 0 });
-    yield p2;
-    const p3 = driver.requestInteraction('w', {});
-    const id3 = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id3, { status: 'approved', costUsd: -1 });
-    yield p3;
-    assert.not.ok(driver.getHistory().some((m) => m.externalCostUsd != null));
-}));
-interactionCost.run();
-/**
- * A single-name (`'high'`) observable registry. `get`/`default` always return
- * the current provider, so swapping it mid-session models a same-name vendor
- * switch (the tier name stays `'high'`, the provider underneath changes).
- */
-const makeObservableRegistry = (initial) => {
-    let current = initial;
-    const listeners = new Set();
-    return {
-        get: () => current,
-        default: () => current,
-        defaultName: () => 'high',
-        names: () => ['high'],
-        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
-        listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-        subscribe(listener) {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        swap(provider) {
-            current = provider;
-            for (const l of Array.from(listeners))
-                l();
-        },
-        listenerCount: () => listeners.size,
-    };
-};
-const makeDriverWithRegistry = (config, registry) => {
-    const driver = new ChatDriver(registry, { maxToolIterations: 50, maxFoldOperations: 5 });
-    driver.applyAgent(config);
-    return driver;
-};
-const observable = createLogicSuite('ChatDriver observable provider registry');
-observable('a registry change clears the resolved-provider cache so the next turn uses the new provider', () => __awaiter(void 0, void 0, void 0, function* () {
-    const providerA = scriptedProvider([{ role: 'assistant', content: 'A' }]);
-    const providerB = scriptedProvider([{ role: 'assistant', content: 'B' }]);
-    const registry = makeObservableRegistry(providerA);
-    // A static provider name means lookups go through `resolvedProviderCache` —
-    // the cache that must self-invalidate on a registry change.
-    const driver = makeDriverWithRegistry(agent({ name: 'tiered', provider: 'high' }), registry);
-    yield driver.sendMessage('first');
-    assert.is(providerA.advertisedPerCall.length, 1, 'turn 1 resolves the original provider');
-    assert.is(providerB.advertisedPerCall.length, 0);
-    registry.swap(providerB); // notify → cache cleared
-    yield driver.sendMessage('second');
-    assert.is(providerB.advertisedPerCall.length, 1, 'turn 2 resolves the swapped-in provider');
-    assert.is(providerA.advertisedPerCall.length, 1, 'the stale provider is not reused');
-    driver.dispose();
-}));
-observable('re-emits provider-changed on a same-name swap', () => __awaiter(void 0, void 0, void 0, function* () {
-    const providerA = scriptedProvider([{ role: 'assistant', content: 'A' }]);
-    const providerB = scriptedProvider([{ role: 'assistant', content: 'B' }]);
-    const registry = makeObservableRegistry(providerA);
-    const driver = makeDriverWithRegistry(agent({ name: 'tiered', provider: 'high' }), registry);
-    const names = [];
-    driver.addEventListener('provider-changed', (e) => {
-        names.push(e.detail.name);
-    });
-    yield driver.sendMessage('first');
-    registry.swap(providerB);
-    yield driver.sendMessage('second');
-    // The resolved name ('high') never changes, but the swap resets the
-    // last-dispatched name so the cog can refresh — two events, not one.
-    assert.equal(names, ['high', 'high']);
-    driver.dispose();
-}));
-observable('a non-observable registry is a no-op — turn runs, dispose does not throw', () => __awaiter(void 0, void 0, void 0, function* () {
-    const provider = scriptedProvider([{ role: 'assistant', content: 'hi' }]);
-    const driver = makeDriverWithRegistry(agent({ name: 'plain' }), makeRegistry(provider));
-    yield driver.sendMessage('go');
-    assert.is(provider.advertisedPerCall.length, 1);
-    driver.dispose(); // no subscription was wired — must still be safe
-}));
-observable('a child sub-agent driver unsubscribes on completion — no listener leak', () => __awaiter(void 0, void 0, void 0, function* () {
-    const provider = scriptedProvider([callsTool('delegate', 'd1'), callsTool('finish', 'f1')]);
-    const registry = makeObservableRegistry(provider);
-    const parent = delegatingParent(completingWorker({ ok: true }), () => { });
-    const driver = makeDriverWithRegistry(parent, registry);
-    assert.is(registry.listenerCount(), 1, 'the parent driver subscribed on construction');
-    yield driver.sendMessage('go');
-    // The child subscribed during the run; if it didn't clean up on its (normal)
-    // completion the registry would now hold two listeners.
-    assert.is(registry.listenerCount(), 1, 'the completed child unsubscribed');
-    driver.dispose();
-    assert.is(registry.listenerCount(), 0, 'the parent unsubscribed on dispose');
-}));
-observable.run();
-// ---------------------------------------------------------------------------
-// per-message model attribution (GENC-1346)
-//
-// Each model-produced assistant message carries `model` (the concrete model id
-// the active provider's getStatus reports) and `providerName` (the registry slot
-// it resolved under), so the exported debug log shows which model produced each
-// message — and, since tool calls ride on the assistant message, each tool call.
-// ---------------------------------------------------------------------------
-/** A provider that replays scripted replies and reports `model` via getStatus
- *  (omitted entirely when `model` is undefined, to model a provider with no
- *  status). */
-const modelProvider = (model, responses) => {
-    const queue = [...responses];
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = queue.shift()) !== null && _a !== void 0 ? _a : { role: 'assistant', content: 'done' }; }),
-    };
-    if (model !== undefined) {
-        provider.getStatus = () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model }); });
-    }
-    return provider;
-};
-const modelAttr = createLogicSuite('ChatDriver per-message model attribution');
-modelAttr('stamps the resolved model and registry name onto an assistant reply', () => __awaiter(void 0, void 0, void 0, function* () {
-    const provider = modelProvider('gemini-2.5-flash-lite', [
-        { role: 'assistant', content: 'hi there' },
-    ]);
-    const driver = makeDriver(agent({ name: 'plain' }), provider);
-    yield driver.sendMessage('hello');
-    const reply = driver.getHistory().find((m) => m.role === 'assistant');
-    assert.ok(reply, 'assistant reply present');
-    assert.is(reply.model, 'gemini-2.5-flash-lite', 'model id read from provider getStatus');
-    assert.is(reply.provider, 'gemini', 'vendor id read from provider getStatus');
-    // makeRegistry registers a single provider under the name 'test'.
-    assert.is(reply.providerName, 'test', 'registry slot the turn resolved under');
-    driver.dispose();
-}));
-modelAttr('attributes a tool-calling assistant message (and so its tool calls) to the model', () => __awaiter(void 0, void 0, void 0, function* () {
-    const provider = modelProvider('claude-haiku-4-5-20251001', [
-        callsTool('noop', 't1'),
-        { role: 'assistant', content: 'finished' },
-    ]);
-    const config = agent({
-        name: 'withTool',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, provider);
-    yield driver.sendMessage('go');
-    const toolCallMsg = driver.getHistory().find((m) => { var _a, _b; return ((_b = (_a = m.toolCalls) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0; });
-    assert.ok(toolCallMsg, 'an assistant message with tool calls is present');
-    assert.is(toolCallMsg.model, 'claude-haiku-4-5-20251001');
-    assert.is(toolCallMsg.provider, 'gemini');
-    assert.is(toolCallMsg.providerName, 'test');
-    driver.dispose();
-}));
-modelAttr('picks up a model swapped behind a stable name', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    const before = modelProvider('gemini-2.5-flash-lite', [{ role: 'assistant', content: 'A' }]);
-    const after = modelProvider('gemini-2.5-pro', [{ role: 'assistant', content: 'B' }]);
-    const registry = makeObservableRegistry(before);
-    const driver = makeDriverWithRegistry(agent({ name: 'tiered', provider: 'high' }), registry);
-    yield driver.sendMessage('first');
-    registry.swap(after); // notify → model cache cleared, next turn re-resolves
-    yield driver.sendMessage('second');
-    const replies = driver.getHistory().filter((m) => m.role === 'assistant');
-    assert.is((_a = replies.at(-2)) === null || _a === void 0 ? void 0 : _a.model, 'gemini-2.5-flash-lite', 'first turn keeps the original model');
-    assert.is((_b = replies.at(-1)) === null || _b === void 0 ? void 0 : _b.model, 'gemini-2.5-pro', 'after the swap the new model is stamped');
-    // The tier name ('high') never changed across the swap — only the model behind it.
-    assert.is((_c = replies.at(-1)) === null || _c === void 0 ? void 0 : _c.providerName, 'high');
-    driver.dispose();
-}));
-modelAttr('omits the model key entirely when the provider reports no status', () => __awaiter(void 0, void 0, void 0, function* () {
-    const provider = modelProvider(undefined, [{ role: 'assistant', content: 'no status here' }]);
-    const driver = makeDriver(agent({ name: 'plain' }), provider);
-    yield driver.sendMessage('hi');
-    const reply = driver.getHistory().find((m) => m.role === 'assistant');
-    assert.ok(reply, 'assistant reply present');
-    // No getStatus → no model. The key is left off, not set to undefined, so the
-    // exported log carries no dead `model` line for this message.
-    assert.not.ok('model' in reply, 'model key is absent, not present-as-undefined');
-    assert.is(reply.providerName, 'test', 'provider name is still recorded');
-    driver.dispose();
-}));
-modelAttr.run();
-// ---------------------------------------------------------------------------
-// condenseWhen — tool-declared context condensation (wiring through the loop)
-// ---------------------------------------------------------------------------
-const condense = createLogicSuite('ChatDriver condenseWhen');
-const bigBody = 'A'.repeat(2000);
-/** An assistant turn calling `read` with a path arg (so `by: args.path` resolves). */
-const readsPath = (id, path) => ({
-    role: 'assistant',
-    content: '',
-    toolCalls: [{ id, name: 'read', args: { path } }],
-});
-condense('collapses a superseded result in the model slice but keeps stored history full', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const sessionKey = 'condense-supersede';
-    clearMetaEventRegistry();
-    const provider = scriptedProvider([
-        readsPath('r1', 'A'),
-        readsPath('r2', 'A'), // re-read of the same path supersedes r1
-    ]);
-    const config = agent({
-        name: 'reader',
-        systemPrompt: 'read files',
-        toolDefinitions: [def('read')],
-        toolHandlers: {
-            read: (args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                ctx.condenseWhen({
-                    on: { kind: 'superseded', by: String(args.path) },
-                    response: 'pointer',
-                });
-                return bigBody;
-            }),
-        },
-    });
-    const driver = makeDriver(config, provider, sessionKey);
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason, 'done');
-    // The 3rd provider call (index 2) ran after both reads: r1 is superseded, r2 is latest.
-    const slice = provider.historyPerCall[2];
-    const r1 = slice.find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 'r1'; });
-    const r2 = slice.find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 'r2'; });
-    assert.match(r1.toolResult.content, /re-call to restore/, 'earlier read collapsed for the model');
-    assert.is(r2.toolResult.content, bigBody, 'latest read still full');
-    // Stored history is untouched — both reads remain full for the UI / debug export.
-    assert.is(toolResultContents(driver).filter((c) => c === bigBody).length, 2, 'stored history retains both full reads');
-    // One context.condensed meta-event, for r1's response, recorded once.
-    const events = getMetaEvents(sessionKey).filter((e) => e.type === 'context.condensed');
-    assert.is(events.length, 1, 'the full→stub transition is reported exactly once');
-    assert.is((_a = events[0].detail) === null || _a === void 0 ? void 0 : _a.toolCallId, 'r1');
-    assert.is((_b = events[0].detail) === null || _b === void 0 ? void 0 : _b.target, 'response');
-}));
-condense('first-wins: a second condenseWhen for the same tool call is ignored', () => __awaiter(void 0, void 0, void 0, function* () {
-    const sessionKey = 'condense-first-wins';
-    clearMetaEventRegistry();
-    const provider = scriptedProvider([readsPath('r1', 'A'), readsPath('r2', 'A')]);
-    const config = agent({
-        name: 'reader',
-        systemPrompt: 'read files',
-        toolDefinitions: [def('read')],
-        toolHandlers: {
-            read: (args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                // First declaration wins; the second (a different mode) is dropped.
-                ctx.condenseWhen({
-                    on: { kind: 'superseded', by: String(args.path) },
-                    response: 'pointer',
-                });
-                ctx.condenseWhen({
-                    on: { kind: 'superseded', by: String(args.path) },
-                    response: { replaceWith: 'SECOND' },
-                });
-                return bigBody;
-            }),
-        },
-    });
-    const driver = makeDriver(config, provider, sessionKey);
-    yield driver.sendMessage('go');
-    const collapsed = provider.historyPerCall[2].find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 'r1'; });
-    assert.match(collapsed.toolResult.content, /re-call to restore/, 'the first (pointer) policy applied');
-    assert.is.not(collapsed.toolResult.content, 'SECOND', 'the later policy was ignored');
-}));
-condense('age clock is monotonic across turns — collapses on a later, separate turn', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // Regression guard for the per-turn-reset bug: the age clock is the local loop
-    // counter that resets every `sendMessage`, so an `age` payload from turn 1
-    // would never collapse across short turns. The driver now uses a monotonic
-    // model-call counter, so it does.
-    const sessionKey = 'condense-age-cross-turn';
-    clearMetaEventRegistry();
-    const provider = scriptedProvider([
-        { role: 'assistant', content: '', toolCalls: [{ id: 'n1', name: 'notes', args: {} }] }, // turn 1, call 1
-        { role: 'assistant', content: 'noted' }, // turn 1, call 2 — model sees n1 once (full), turn ends
-        { role: 'assistant', content: 'ok' }, // turn 2, call 1 — a short follow-up, no tools
-    ]);
-    const config = agent({
-        name: 'note-taker',
-        systemPrompt: 'take notes',
-        toolDefinitions: [def('notes')],
-        toolHandlers: {
-            notes: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                ctx.condenseWhen({ on: { kind: 'age', turns: 1 }, response: 'pointer' });
-                return bigBody;
-            }),
-        },
-    });
-    const driver = makeDriver(config, provider, sessionKey);
-    yield driver.sendMessage('first'); // turn 1
-    yield driver.sendMessage('second'); // turn 2 — a separate, short sendMessage
-    // Turn 1's consume call (provider call #1) saw n1 in full — its one allowed look.
-    const turn1Consume = provider.historyPerCall[1].find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 'n1'; });
-    assert.is(turn1Consume.toolResult.content, bigBody, 'full on its one allowed turn');
-    // Turn 2's first call (#2) is a SEPARATE sendMessage — the local loop counter has
-    // reset to 0, but the monotonic clock kept counting, so n1 is now collapsed.
-    // Under the old per-turn counter it would still be full here.
-    const turn2 = provider.historyPerCall[2].find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 'n1'; });
-    assert.match(turn2.toolResult.content, /re-call to restore/, 'collapsed on the next turn');
-    assert.ok(toolResultContents(driver).includes(bigBody), 'stored history retains the full note');
-    const events = getMetaEvents(sessionKey).filter((e) => e.type === 'context.condensed');
-    assert.is(events.length, 1);
-    assert.is((_a = events[0].detail) === null || _a === void 0 ? void 0 : _a.trigger, 'age:1');
-}));
-condense('turnEnd: full during its request, collapsed on the next user turn', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const sessionKey = 'condense-turn-end';
-    clearMetaEventRegistry();
-    const provider = scriptedProvider([
-        { role: 'assistant', content: '', toolCalls: [{ id: 'n1', name: 'notes', args: {} }] }, // turn 1, call 1
-        { role: 'assistant', content: 'noted' }, // turn 1, call 2 — n1 still full this turn
-        { role: 'assistant', content: 'ok' }, // turn 2 — a separate request
-    ]);
-    const config = agent({
-        name: 'note-taker',
-        systemPrompt: 'take notes',
-        toolDefinitions: [def('notes')],
-        toolHandlers: {
-            notes: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                ctx.condenseWhen({ on: { kind: 'turnEnd' }, response: 'pointer' });
-                return bigBody;
-            }),
-        },
-    });
-    const driver = makeDriver(config, provider, sessionKey);
-    yield driver.sendMessage('first'); // turn 1
-    yield driver.sendMessage('second'); // turn 2
-    const inTurn1 = provider.historyPerCall[1].find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 'n1'; });
-    assert.is(inTurn1.toolResult.content, bigBody, 'full for the rest of the request it served');
-    const inTurn2 = provider.historyPerCall[2].find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 'n1'; });
-    assert.match(inTurn2.toolResult.content, /re-call to restore/, 'collapsed once the turn ended');
-    const events = getMetaEvents(sessionKey).filter((e) => e.type === 'context.condensed');
-    assert.is(events.length, 1);
-    assert.is((_a = events[0].detail) === null || _a === void 0 ? void 0 : _a.trigger, 'turnEnd');
-}));
-condense('agentEnd: collapses once the agent releases (flow complete)', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const sessionKey = 'condense-agent-end';
-    clearMetaEventRegistry();
-    const provider = scriptedProvider([
-        { role: 'assistant', content: '', toolCalls: [{ id: 's1', name: 'load', args: {} }] }, // call 1
-        { role: 'assistant', content: '', toolCalls: [{ id: 'f1', name: 'finish', args: {} }] }, // call 2 — releases
-        { role: 'assistant', content: 'wrapped up' }, // call 3 — flow done
-    ]);
-    const config = agent({
-        name: 'wizard',
-        systemPrompt: 'a flow',
-        toolDefinitions: [def('load'), def('finish')],
-        toolHandlers: {
-            load: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                ctx.condenseWhen({ on: { kind: 'agentEnd' }, response: 'pointer' });
-                return bigBody;
-            }),
-            finish: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                ctx.releaseAgent();
-                return 'flow complete';
-            }),
-        },
-    });
-    const driver = makeDriver(config, provider, sessionKey);
-    yield driver.sendMessage('run the flow');
-    // call #2 (index 1) ran before `finish` released — schema still full.
-    const beforeRelease = provider.historyPerCall[1].find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 's1'; });
-    assert.is(beforeRelease.toolResult.content, bigBody, 'full while the flow is active');
-    // call #3 (index 2) ran after release — schema collapsed.
-    const afterRelease = provider.historyPerCall[2].find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 's1'; });
-    assert.match(afterRelease.toolResult.content, /re-call to restore/, 'collapsed once released');
-    const events = getMetaEvents(sessionKey).filter((e) => e.type === 'context.condensed');
-    assert.is(events.length, 1);
-    assert.is((_a = events[0].detail) === null || _a === void 0 ? void 0 : _a.trigger, 'agentEnd');
-}));
-condense('phaseEnd: collapses at endPhase() while the agent keeps running', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const sessionKey = 'condense-phase-end';
-    clearMetaEventRegistry();
-    const provider = scriptedProvider([
-        { role: 'assistant', content: '', toolCalls: [{ id: 's1', name: 'load', args: {} }] }, // call 1
-        { role: 'assistant', content: '', toolCalls: [{ id: 'a1', name: 'advance', args: {} }] }, // call 2 — ends the phase
-        { role: 'assistant', content: 'continuing' }, // call 3 — agent still active, just answers
-    ]);
-    const config = agent({
-        name: 'journey',
-        systemPrompt: 'a multi-phase flow',
-        toolDefinitions: [def('load'), def('advance')],
-        toolHandlers: {
-            load: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                ctx.condenseWhen({ on: { kind: 'phaseEnd' }, response: 'pointer' });
-                return bigBody;
-            }),
-            advance: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                var _a;
-                // Declares a phase boundary WITHOUT ending the agent (no releaseAgent).
-                (_a = ctx.endPhase) === null || _a === void 0 ? void 0 : _a.call(ctx);
-                return 'next phase';
-            }),
-        },
-    });
-    const driver = makeDriver(config, provider, sessionKey);
-    const result = yield driver.sendMessage('run the flow');
-    // The agent never released — the turn ends normally on the text response.
-    assert.is(result.reason, 'done');
-    // call #2 (index 1) ran before `advance` ended the phase — result still full.
-    const beforePhaseEnd = provider.historyPerCall[1].find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 's1'; });
-    assert.is(beforePhaseEnd.toolResult.content, bigBody, 'full while the phase is current');
-    // call #3 (index 2) ran after endPhase() — collapsed. The activation never ended
-    // (no release/swap), so this collapse can ONLY be the phase boundary, not the
-    // agentEnd backstop.
-    const afterPhaseEnd = provider.historyPerCall[2].find((m) => { var _a; return ((_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.toolCallId) === 's1'; });
-    assert.match(afterPhaseEnd.toolResult.content, /re-call to restore/, 'collapsed at phase end');
-    assert.match(afterPhaseEnd.toolResult.content, /phase ended/);
-    const events = getMetaEvents(sessionKey).filter((e) => e.type === 'context.condensed');
-    assert.is(events.length, 1);
-    assert.is((_a = events[0].detail) === null || _a === void 0 ? void 0 : _a.trigger, 'phaseEnd');
-}));
-condense.run();
-// ---------------------------------------------------------------------------
-// turn-outcome surfacing (PTC-0) — the typed failure reason must reach BOTH
-// the loop-boundary result (`ChatDriverResult.failureReason`) and the
-// `tool-loop-end` activity-bus event detail. Historically every exit flattened
-// to `{ reason: 'done' }` and the bus detail was `undefined`; these lock the
-// two seams together, one per `TurnFailureReason`, plus a happy-path compat
-// check that the legacy shape is byte-unchanged.
-// ---------------------------------------------------------------------------
-const outcome = createLogicSuite('ChatDriver turn-outcome surfacing');
-// This branch routes activity events to an INJECTED bus (default NOOP), not the module
-// singleton, so these tests inject a local bus and observe the same seam the driver publishes to.
-const outcomeBus = new AgenticActivityBus();
-outcome.after(() => {
-    outcomeBus.close();
-});
-/**
- * Subscribe to `tool-loop-end` and expose the most recent detail seen. `fired()` reports
- * whether the event was seen at all — distinct from `detail()`, which is `undefined` both
- * when no event fired and when a clean turn fired with the historical `undefined` detail.
- */
-const captureLoopEnd = () => {
-    let last;
-    let seen = false;
-    const stop = outcomeBus.subscribe('tool-loop-end', (d) => {
-        last = d;
-        seen = true;
-    });
-    return { detail: () => (seen ? last : undefined), fired: () => seen, stop };
-};
-/** A ChatDriver with an explicit (small) tool-iteration cap. */
-const makeCappedDriver = (config, provider, maxIterations, sessionKey = '') => {
-    const driver = new ChatDriver(makeRegistry(provider), {
-        maxToolIterations: maxIterations,
-        maxFoldOperations: 5,
-        sessionKey,
-        activityBus: outcomeBus,
-    });
-    driver.applyAgent(config);
-    return driver;
-};
-/**
- * Assert that a turn driven by `provider` surfaces `expected` at BOTH seams.
- * `driverFor` lets the max-iterations case swap in a low cap.
- */
-const assertSurfacesReason = (label_1, provider_1, expected_1, ...args_1) => __awaiter(void 0, [label_1, provider_1, expected_1, ...args_1], void 0, function* (label, provider, expected, driverFor = (c, p, k) => makeDriver(c, p, k, outcomeBus)) {
-    var _a;
-    clearMetaEventRegistry();
-    const sessionKey = `outcome-${label}`;
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = driverFor(config, provider, sessionKey);
-    const cap = captureLoopEnd();
-    const result = yield driver.sendMessage('go');
-    // Seam 1 — the loop-boundary result. Discriminant stays 'done' (compat).
-    assert.is(result.reason, 'done', `[${label}] discriminant stays 'done'`);
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, expected, `[${label}] result.failureReason surfaces the typed reason`);
-    // Seam 2 — the activity-bus tool-loop-end detail.
-    assert.ok(cap.detail(), `[${label}] a tool-loop-end event fired`);
-    assert.is(cap.detail().failureReason, expected, `[${label}] the bus detail carries the same reason`);
-    // Consistency: the debug-log turn.error records the same taxonomy.
-    const err = getMetaEvents(sessionKey).find((e) => e.type === 'turn.error');
-    assert.ok(err, `[${label}] a turn.error is recorded`);
-    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.reason, expected, `[${label}] the debug-log reason matches`);
-    cap.stop();
-});
-/** A provider that returns a MALFORMED_FUNCTION_CALL on every call. */
-const malformedProvider = () => ({
-    chat: () => __awaiter(void 0, void 0, void 0, function* () {
-        throw new MalformedFunctionCallError('bad call');
-    }),
-});
-/** A provider that returns an empty response on every call. */
-const emptyProvider = () => ({
-    chat: () => __awaiter(void 0, void 0, void 0, function* () { return ({ role: 'assistant', content: '' }); }),
-});
-/** A provider that throws a ResponseTruncatedError (deterministic, no retry). */
-const truncatedProvider = () => ({
-    chat: () => __awaiter(void 0, void 0, void 0, function* () {
-        throw new ResponseTruncatedError('test-model', 1024, 1024, ['noop']);
-    }),
-});
-/** A provider refused for budget (deterministic, terminal — must not retry). */
-const budgetExhaustedProvider = () => ({
-    chat: () => __awaiter(void 0, void 0, void 0, function* () {
-        throw new BudgetExhaustedError('Anthropic', 25, 25.4, 'AI budget exhausted');
-    }),
-});
-/** A provider the vendor refused outright (GENC-1506 — terminal, must not retry). */
-const providerRefusedProvider = (kind = 'spend') => ({
-    chat: () => __awaiter(void 0, void 0, void 0, function* () {
-        // Both fixtures are the real captured shapes (2026-08-18), matched to their kind — an `auth`
-        // fixture carrying a credit-balance message would read as a classification bug to the next person.
-        throw kind === 'auth'
-            ? new ProviderRefusedError('Anthropic', 'auth', 401, 'authentication_error', 'API key is invalid.')
-            : new ProviderRefusedError('Anthropic', 'spend', 400, 'invalid_request_error', 'Your credit balance is too low to access the Anthropic API.');
-    }),
-});
-/** A provider that throws a generic error (the sendMessage catch-all → 'exception'). */
-const throwingProvider = () => ({
-    chat: () => __awaiter(void 0, void 0, void 0, function* () {
-        throw new Error('boom');
-    }),
-});
-/** A provider that never stops calling a valid tool (drives the iteration cap). */
-const neverStopsProvider = () => {
-    let n = 0;
-    return {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            const id = `noop-${n}`;
-            n += 1;
-            return { role: 'assistant', content: '', toolCalls: [{ id, name: 'noop', args: {} }] };
-        }),
-    };
-};
-/** A provider that keeps calling a tool with no handler (hallucinated → limit). */
-const hallucinatedProvider = () => scriptedProvider(Array.from({ length: 6 }, (_u, i) => callsTool('ghost', `ghost-${i}`)));
-/** A provider that refuses: empty content + finishReason 'refusal' (deterministic, must not retry). */
-const refusalProvider = () => ({
-    chat: () => __awaiter(void 0, void 0, void 0, function* () {
-        return ({
-            role: 'assistant',
-            content: '',
-            responseMeta: { finishReason: 'refusal' },
-        });
-    }),
-});
-outcome('malformed-function-call surfaces at both seams', () => __awaiter(void 0, void 0, void 0, function* () {
-    yield assertSurfacesReason('malformed', malformedProvider(), 'malformed-function-call');
-}));
-outcome('empty-response surfaces at both seams', () => __awaiter(void 0, void 0, void 0, function* () {
-    yield assertSurfacesReason('empty', emptyProvider(), 'empty-response');
-}));
-outcome('response-truncated surfaces at both seams', () => __awaiter(void 0, void 0, void 0, function* () {
-    yield assertSurfacesReason('truncated', truncatedProvider(), 'response-truncated');
-}));
-outcome('exception surfaces at both seams', () => __awaiter(void 0, void 0, void 0, function* () {
-    yield assertSurfacesReason('exception', throwingProvider(), 'exception');
-}));
-outcome('unknown-tool-limit surfaces at both seams', () => __awaiter(void 0, void 0, void 0, function* () {
-    yield assertSurfacesReason('unknown-tool', hallucinatedProvider(), 'unknown-tool-limit');
-}));
-outcome('max-iterations surfaces at both seams', () => __awaiter(void 0, void 0, void 0, function* () {
-    yield assertSurfacesReason('max-iter', neverStopsProvider(), 'max-iterations', (c, p, k) => makeCappedDriver(c, p, 2, k));
-}));
-// A refusal reaching 'refusal' (not 'empty-response') at both seams proves the short-circuit fired —
-// otherwise the empty content would retry to exhaustion and surface as 'empty-response'.
-outcome('refusal surfaces at both seams', () => __awaiter(void 0, void 0, void 0, function* () {
-    yield assertSurfacesReason('refusal', refusalProvider(), 'refusal');
-}));
-outcome('a refusal is deterministic — surfaced without any empty-response retry', () => __awaiter(void 0, void 0, void 0, function* () {
-    clearMetaEventRegistry();
-    let calls = 0;
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            calls += 1;
-            return { role: 'assistant', content: '', responseMeta: { finishReason: 'refusal' } };
-        }),
-    };
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, provider, 'outcome-refusal-once', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'refusal', 'refusal surfaces as the typed failure reason');
-    assert.is(calls, 1, 'a refusal is not retried — exactly one model call');
-}));
-outcome('a clean turn leaves the legacy shape byte-unchanged (no failureReason)', () => __awaiter(void 0, void 0, void 0, function* () {
-    clearMetaEventRegistry();
-    const config = agent({ name: 'Static' });
-    // Plain-text reply ends the turn cleanly on the first call.
-    const driver = makeDriver(config, scriptedProvider([{ role: 'assistant', content: 'hi' }]), 'outcome-ok', outcomeBus);
-    const cap = captureLoopEnd();
-    const result = yield driver.sendMessage('go');
-    // The result is exactly `{ reason: 'done' }` — no `failureReason` key added.
-    assert.equal(result, { reason: 'done' }, 'happy-path result is the historical shape');
-    assert.not.ok('failureReason' in result, 'no failureReason key is present on a clean turn');
-    // The bus event still fires, and its detail is the historical `undefined` — a clean
-    // turn emits no detail object at all (byte-shape compat), not `{ failureReason: undefined }`.
-    assert.ok(cap.fired(), 'a tool-loop-end event fired');
-    assert.is(cap.detail(), undefined, 'a clean turn emits the historical undefined detail');
-    // And no turn.error was recorded.
-    assert.not.ok(getMetaEvents('outcome-ok').some((e) => e.type === 'turn.error'), 'a clean turn records no turn.error');
-    cap.stop();
-}));
-// ── Budget exhaustion (GENC-1464) ──────────────────────────────────────────────
-outcome('provider-refused surfaces at both seams', () => __awaiter(void 0, void 0, void 0, function* () {
-    yield assertSurfacesReason('provider-refused', providerRefusedProvider(), 'provider-refused');
-}));
-outcome('a provider refusal is terminal — no retry, cause-free copy, kind in the log', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    // GENC-1506. The measured bug this pins: the refusal used to arrive as an untyped transport error,
-    // get re-issued MAX_SETUP_TRANSPORT_RETRIES times against a wall that cannot move, and then surface
-    // as "something went wrong on my end" — wrong twice over, since nothing went wrong on our end and
-    // trying again cannot help.
-    clearMetaEventRegistry();
-    let calls = 0;
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            calls += 1;
-            throw new ProviderRefusedError('Anthropic', 'spend', 400, 'invalid_request_error', 'credit too low');
-        }),
-        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'anthropic', model: 'test-model' }); }),
-    };
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, provider, 'outcome-provider-refused', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    assert.is(calls, 1, 'a provider refusal is not retried — exactly one model call');
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'provider-refused', 'the turn ends with the provider-refused failure reason');
-    // The kind reaches the CALLER, which is what lets ai-service's Sentry alert say whether an operator
-    // must top up an account or rotate a key. It is the only place that distinction survives, because
-    // the user-facing sentence is deliberately cause-free.
-    const refused = result.reason === 'done' ? result.providerRefused : undefined;
-    assert.is(refused === null || refused === void 0 ? void 0 : refused.kind, 'spend');
-    assert.is(refused === null || refused === void 0 ? void 0 : refused.vendorLabel, 'Anthropic');
-    assert.is(refused === null || refused === void 0 ? void 0 : refused.upstreamStatus, 400);
-    assert.is(refused === null || refused === void 0 ? void 0 : refused.upstreamType, 'invalid_request_error');
-    const last = driver.getHistory().at(-1);
-    assert.ok((last === null || last === void 0 ? void 0 : last.role) === 'assistant', 'turn ends with an assistant message');
-    // Identity, not a substring: the sentence is provisional copy shared with ai-service via one
-    // exported const, and this is what stops a second copy drifting in.
-    assert.is(last.content, DEFAULT_PROVIDER_REFUSED_MESSAGE);
-    assert.not.ok(last.content.includes('something went wrong'), 'must not fall through to the generic apology');
-    // The copy must not leak the cause, whatever the kind — a user who can see remaining spend must not
-    // be told about a limit, and we must not imply the bill went unpaid.
-    for (const banned of ['credit', 'billing', 'balance', 'quota', 'limit']) {
-        assert.not.ok(last.content.toLowerCase().includes(banned), `copy must not mention "${banned}"`);
-    }
-    const err = getMetaEvents('outcome-provider-refused').find((e) => e.type === 'turn.error');
-    assert.is((_a = err === null || err === void 0 ? void 0 : err.detail) === null || _a === void 0 ? void 0 : _a.reason, 'provider-refused');
-    assert.is((_b = err === null || err === void 0 ? void 0 : err.detail) === null || _b === void 0 ? void 0 : _b.kind, 'spend');
-}));
-outcome('an auth refusal shows the SAME sentence but logs a different kind', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // The whole justification for one type with two kinds: identical user experience, distinct
-    // diagnostics. If these ever diverge in the transcript, the copy decision has been undone.
-    clearMetaEventRegistry();
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, providerRefusedProvider('auth'), 'outcome-refused-auth', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'provider-refused');
-    assert.is(result.reason === 'done' ? (_a = result.providerRefused) === null || _a === void 0 ? void 0 : _a.kind : undefined, 'auth');
-    assert.is(driver.getHistory().at(-1).content, DEFAULT_PROVIDER_REFUSED_MESSAGE);
-}));
-outcome('a host override replaces the provider-refusal sentence verbatim', () => __awaiter(void 0, void 0, void 0, function* () {
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = new ChatDriver(makeRegistry(providerRefusedProvider()), {
-        maxToolIterations: 50,
-        maxFoldOperations: 5,
-        sessionKey: 'outcome-refused-override',
-        providerRefusedMessage: 'Bespoke wording for a white-labelled host.',
-    });
-    driver.applyAgent(config);
-    yield driver.sendMessage('go');
-    assert.is(driver.getHistory().at(-1).content, 'Bespoke wording for a white-labelled host.');
-    driver.dispose();
-}));
-outcome('budget-exhausted surfaces at both seams', () => __awaiter(void 0, void 0, void 0, function* () {
-    yield assertSurfacesReason('budget', budgetExhaustedProvider(), 'budget-exhausted');
-}));
-outcome('a budget wall is terminal — no transient retry, and actionable copy', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d;
-    clearMetaEventRegistry();
-    let calls = 0;
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            calls += 1;
-            throw new BudgetExhaustedError('Anthropic', 25, 25.4);
-        }),
-        // Resolvable vendor, so the per-vendor fields below are exercised.
-        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'anthropic', model: 'test-model' }); }),
-    };
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, provider, 'outcome-budget-once', outcomeBus);
-    const cap = captureLoopEnd();
-    const result = yield driver.sendMessage('go');
-    // The whole point of the typed branch: it sits BEFORE the transient-retry
-    // catch, so the driver must not burn MAX_SETUP_TRANSPORT_RETRIES attempts
-    // against a wall that no retry can clear.
-    assert.is(calls, 1, 'a budget wall is not retried — exactly one model call');
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted', 'the turn ends with the budget-exhausted failure reason');
-    // The figures now reach the CALLER, not just the debug log — this is what lets
-    // the element render "$25.40 of $25" in its banner without catching the
-    // transport error itself.
-    const budget = result.reason === 'done' ? result.budget : undefined;
-    assert.is(budget === null || budget === void 0 ? void 0 : budget.budgetUsd, 25);
-    assert.is(budget === null || budget === void 0 ? void 0 : budget.spentUsd, 25.4);
-    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendorLabel, 'Anthropic');
-    // The bus detail carries the resolved vendor beside the reason.
-    assert.is(cap.detail().failureReason, 'budget-exhausted');
-    assert.is(cap.detail().vendor, 'anthropic');
-    cap.stop();
-    const last = driver.getHistory().at(-1);
-    assert.ok((last === null || last === void 0 ? void 0 : last.role) === 'assistant', 'turn ends with an assistant message');
-    // Identity, not substrings: the transcript bubble and the element's blocked
-    // banner now read from one shared const, and this is what pins them together.
-    assert.is(last.content, DEFAULT_BUDGET_EXHAUSTED_MESSAGE);
-    assert.not.ok(last.content.includes('something went wrong'), 'must not fall through to the generic apology');
-    // The budget figures ride the debug-log entry so a support ticket can show them.
-    const err = getMetaEvents('outcome-budget-once').find((e) => e.type === 'turn.error');
-    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.budgetUsd, 25);
-    assert.is((_b = err.detail) === null || _b === void 0 ? void 0 : _b.spentUsd, 25.4);
-    // The registry ALIAS and the VENDOR are different things; record both.
-    assert.is((_c = err.detail) === null || _c === void 0 ? void 0 : _c.provider, 'test');
-    assert.is((_d = err.detail) === null || _d === void 0 ? void 0 : _d.vendor, 'anthropic');
-}));
-outcome('a non-budget failure emits the historical detail shape, with no vendor', () => __awaiter(void 0, void 0, void 0, function* () {
-    // Back-compat for subscribers that structurally compare the `tool-loop-end`
-    // detail: only a budget failure grew a field.
-    clearMetaEventRegistry();
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, throwingProvider(), 'outcome-vendor-compat', outcomeBus);
-    const cap = captureLoopEnd();
-    yield driver.sendMessage('go');
-    assert.equal(cap.detail(), { failureReason: 'exception' }, 'no vendor key was added');
-    cap.stop();
-}));
-outcome('a 402 with no figures still carries the vendor that refused it', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // The regression this pins: the driver used to drop the ENTIRE budget object
-    // when both figures were absent, and `vendorLabel` — the authoritative
-    // attribution source — went with it. The element then fell back to the
-    // driver's last-resolved provider, i.e. the PREVIOUS turn's vendor, and walled
-    // the wrong one. Three live shapes arrive here with no figures: a bare gateway
-    // 402, a code-only body, and the framed err frame whose figures are `null`.
-    clearMetaEventRegistry();
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            throw new BudgetExhaustedError('Anthropic');
-        }),
-    };
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, provider, 'outcome-budget-nofigures', outcomeBus);
-    const cap = captureLoopEnd();
-    const result = yield driver.sendMessage('go');
-    const budget = result.reason === 'done' ? result.budget : undefined;
-    assert.ok(budget, 'a figure-less wall still reports who refused it');
-    assert.is(budget.vendorLabel, 'Anthropic');
-    assert.is(budget.vendor, 'anthropic');
-    // Still no figures — the element reads their ABSENCE as "leave any host-set
-    // banner copy alone", so they must not be invented.
-    assert.is(budget.budgetUsd, undefined);
-    assert.is(budget.spentUsd, undefined);
-    // Both seams, since the bus one lands first and wins the latch.
-    assert.is((_a = cap.detail().budget) === null || _a === void 0 ? void 0 : _a.vendor, 'anthropic');
-    cap.stop();
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted');
-}));
-outcome('a wall with nothing to report at all still omits the budget key', () => __awaiter(void 0, void 0, void 0, function* () {
-    // The other direction: `budget` is present when there is something to say and
-    // absent when there is not, so presence keeps meaning something. No figures AND
-    // an unclaimed label leaves nothing to carry — and the element's fail-safe
-    // (block everything) is the correct outcome for an unattributable wall.
-    clearMetaEventRegistry();
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            throw new BudgetExhaustedError('Acme AI');
-        }),
-    };
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, provider, 'outcome-budget-nothing', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    assert.not.ok('budget' in result, 'nothing reportable → no budget key');
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted');
-}));
-outcome('a figure-less wall attributes to the refusing transport, not the last turn', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // The exact failure: turn 1 runs on Gemini, turn 2's request is refused by
-    // Anthropic with a figure-less 402. `lastResolvedProvider` still says `gemini`,
-    // so the pre-fix driver reported Gemini and the user was told to switch to the
-    // vendor that had actually run out.
-    clearMetaEventRegistry();
-    let walled = false;
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            if (!walled) {
-                walled = true;
-                return { role: 'assistant', content: 'first turn, on Gemini' };
-            }
-            throw new BudgetExhaustedError('Anthropic');
-        }),
-    };
-    // The registry resolves to Gemini, so `lastResolvedProvider` is `gemini` by the
-    // time the Anthropic wall lands — the disagreement has to be seeded to prove
-    // which source is believed.
-    const registry = {
-        get: () => provider,
-        default: () => provider,
-        defaultName: () => 'test',
-        names: () => ['test'],
-        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model: 'gemini-test' }); }),
-        listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-    };
-    const driver = new ChatDriver(registry, {
-        sessionKey: 'outcome-budget-stale-vendor',
-        activityBus: outcomeBus,
-    });
-    driver.applyAgent(agent({ name: 'Static', toolDefinitions: [def('noop')], toolHandlers: {} }));
-    yield driver.sendMessage('one');
-    const result = yield driver.sendMessage('two');
-    const budget = result.reason === 'done' ? result.budget : undefined;
-    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendor, 'anthropic', 'the transport that said no, not the one before it');
-    const err = getMetaEvents('outcome-budget-stale-vendor').find((e) => e.type === 'turn.error');
-    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.vendor, 'anthropic', 'and the debug log agrees');
-}));
-outcome("the proxy's own `vendor` rescues an unclaimed transport label", () => __awaiter(void 0, void 0, void 0, function* () {
-    // A multiplexing or white-labelled gateway fronts several upstreams behind one
-    // transport, so its static label names none of them. The 402's `vendor` is then
-    // the only thing that knows which pot was actually booked against — second
-    // opinion, never first: the transport's own label still wins where it resolves.
-    clearMetaEventRegistry();
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            throw new BudgetExhaustedError('Acme AI', undefined, undefined, undefined, {
-                serverVendor: 'Gemini',
-            });
-        }),
-    };
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, provider, 'outcome-budget-server-vendor', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    const budget = result.reason === 'done' ? result.budget : undefined;
-    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendorLabel, 'Acme AI', 'the transport label is reported verbatim');
-    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendor, 'gemini', 'and attribution still lands');
-}));
-outcome("the proxy's `otherVendorAvailable` verdict reaches both seams", () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    // The one fact the element cannot re-derive: registry membership says which
-    // vendors EXIST, never which still have budget. It has to survive the trip.
-    clearMetaEventRegistry();
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            throw new BudgetExhaustedError('Anthropic', 25, 25, undefined, {
-                otherVendorAvailable: false,
-            });
-        }),
-    };
-    const config = agent({
-        name: 'Static',
-        toolDefinitions: [def('noop')],
-        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
-    });
-    const driver = makeDriver(config, provider, 'outcome-budget-other-vendor', outcomeBus);
-    const cap = captureLoopEnd();
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason === 'done' ? (_a = result.budget) === null || _a === void 0 ? void 0 : _a.otherVendorAvailable : undefined, false, 'the return-value seam');
-    assert.is((_b = cap.detail().budget) === null || _b === void 0 ? void 0 : _b.otherVendorAvailable, false, 'and the bus seam, which lands first and wins the latch');
-    cap.stop();
-}));
-outcome('a host-supplied budgetExhaustedMessage replaces the transcript copy', () => __awaiter(void 0, void 0, void 0, function* () {
-    clearMetaEventRegistry();
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            throw new BudgetExhaustedError('Anthropic', 25, 25.4);
-        }),
-    };
-    const driver = new ChatDriver(makeRegistry(provider), {
-        sessionKey: 'outcome-budget-custom',
-        activityBus: outcomeBus,
-        budgetExhaustedMessage: 'Contact ops@acme.com',
-    });
-    driver.applyAgent(agent({ name: 'Static', toolDefinitions: [def('noop')], toolHandlers: {} }));
-    yield driver.sendMessage('go');
-    // The banner was already overridable; without this seam a white-labelled host
-    // got its own copy in the banner and 'contact Genesis' directly below it.
-    assert.is(driver.getHistory().at(-1).content, 'Contact ops@acme.com');
-}));
-// ── The composed default bubble (GENC-1464 tester finding) ─────────────────────
-// The blocked banner advises switching when another vendor has headroom; the
-// transcript bubble directly under it used to say only "contact your
-// administrator" regardless. The two surfaces must agree, and the bubble may
-// only advise a switch the proxy positively vouched for.
-/** Drive one walled turn and return the transcript's final (bubble) content. */
-const bubbleAfterWall = (sessionKey, e, budgetExhaustedMessage) => __awaiter(void 0, void 0, void 0, function* () {
-    clearMetaEventRegistry();
-    const provider = {
-        chat: () => __awaiter(void 0, void 0, void 0, function* () {
-            throw e;
-        }),
-    };
-    const driver = new ChatDriver(makeRegistry(provider), Object.assign({ sessionKey, activityBus: outcomeBus }, (budgetExhaustedMessage == null ? {} : { budgetExhaustedMessage })));
-    driver.applyAgent(agent({ name: 'Static', toolDefinitions: [def('noop')], toolHandlers: {} }));
-    yield driver.sendMessage('go');
-    return String(driver.getHistory().at(-1).content);
-});
-outcome('default bubble advises switching when the 402 vouches for headroom elsewhere', () => __awaiter(void 0, void 0, void 0, function* () {
-    const content = yield bubbleAfterWall('outcome-bubble-switch', new BudgetExhaustedError('Anthropic', 25, 25.4, undefined, { otherVendorAvailable: true }));
-    assert.is(content, "You've reached Anthropic's AI usage limit. Switch to another AI provider in Settings to keep going, or contact your administrator to raise it.");
-}));
-outcome('default bubble stays neutral when every other vendor is exhausted too', () => __awaiter(void 0, void 0, void 0, function* () {
-    const content = yield bubbleAfterWall('outcome-bubble-all-walled', new BudgetExhaustedError('Anthropic', 25, 25.4, undefined, { otherVendorAvailable: false }));
-    // Advising a switch to a vendor the proxy just said is empty would be worse
-    // than the neutral copy.
-    assert.is(content, DEFAULT_BUDGET_EXHAUSTED_MESSAGE);
-}));
-outcome('default bubble stays neutral when an older proxy did not say', () => __awaiter(void 0, void 0, void 0, function* () {
-    const content = yield bubbleAfterWall('outcome-bubble-no-verdict', new BudgetExhaustedError('Anthropic', 25, 25.4));
-    // `undefined` is "the proxy did not say", not "another vendor is free".
-    assert.is(content, DEFAULT_BUDGET_EXHAUSTED_MESSAGE);
-}));
-outcome('a host override wins verbatim even when switching would be honest advice', () => __awaiter(void 0, void 0, void 0, function* () {
-    const content = yield bubbleAfterWall('outcome-bubble-override-wins', new BudgetExhaustedError('Anthropic', 25, 25.4, undefined, { otherVendorAvailable: true }), 'Contact ops@acme.com');
-    // The white-label contract: host copy is never composed onto.
-    assert.is(content, 'Contact ops@acme.com');
-}));
-// ── A sub-agent's wall is terminal for the parent too (GENC-1464) ──────────────
-// `SubAgentFailureReason.budget_exhausted` is documented as "terminal for the
-// parent too". Nothing parent-side read it, so the parent's tool loop appended
-// the failed outcome as a tool result and called the model again — into the same
-// wall. With N batched delegations that was N doomed children AND a doomed parent
-// call, and the element's `failureReason === 'budget-exhausted'` latch never fired.
-/** A sub-agent whose own turn is refused for budget; the parent's turns are not. */
-const parentOkChildWalled = () => {
-    let parentCalls = 0;
-    return {
-        parentCalls: () => parentCalls,
-        provider: {
-            chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
-                var _a;
-                const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
-                if (names.includes('delegate')) {
-                    parentCalls += 1;
-                    return callsTool('delegate', `d${parentCalls}`);
-                }
-                throw new BudgetExhaustedError('Anthropic', 25, 25.4);
-            }),
-        },
-    };
-};
-const walledWorker = () => agent({
-    name: 'worker',
-    toolDefinitions: [def('finish')],
-    toolHandlers: { finish: () => __awaiter(void 0, void 0, void 0, function* () { return 'x'; }) },
-});
-/**
- * The child-refused / parent-fine provider, mirroring `parentOkChildWalled` — the parent's turn call
- * succeeds and delegates, and only the child's provider refuses.
- */
-const parentOkChildRefused = (kind = 'spend') => {
-    let parentCalls = 0;
-    return {
-        parentCalls: () => parentCalls,
-        provider: {
-            chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
-                var _a;
-                const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
-                if (names.includes('delegate')) {
-                    parentCalls += 1;
-                    return callsTool('delegate', `d${parentCalls}`);
-                }
-                throw kind === 'auth'
-                    ? new ProviderRefusedError('Anthropic', 'auth', 401, 'authentication_error', 'API key is invalid.')
-                    : new ProviderRefusedError('Anthropic', 'spend', 400, 'invalid_request_error', 'credit too low');
-            }),
-        },
-    };
-};
-outcome('a sub-agent provider refusal ends the parent turn without another model call', () => __awaiter(void 0, void 0, void 0, function* () {
-    /*
-     * The seam a review caught, and it is genuinely counter-intuitive: the child is a SEPARATE driver
-     * instance, so the flag it sets on itself is invisible to the parent. The refusal reaches the parent
-     * only as a tool result, and without an `invokeSubAgent` branch that result was ordinary — so the
-     * parent issued another model call straight into the same wall, and if that call had happened to
-     * succeed the turn could have finished with no `failureReason` at all, reporting a clean turn over a
-     * dead account. `parentCalls() === 1` is the assertion that pins it.
-     */
-    clearMetaEventRegistry();
-    const { parentCalls, provider } = parentOkChildRefused();
-    const parent = delegatingParent(walledWorker(), () => undefined);
-    const driver = makeDriver(parent, provider, 'outcome-subagent-refused', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    assert.is(parentCalls(), 1, 'the parent never calls the model again after the refusal');
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'provider-refused');
-    assert.is(driver.getHistory().at(-1).content, DEFAULT_PROVIDER_REFUSED_MESSAGE);
-}));
-outcome("a sub-agent refusal carries the CHILD's kind and vendor to the parent", () => __awaiter(void 0, void 0, void 0, function* () {
-    // The other half of the same finding. The parent can only report what the child bubbled, so without a
-    // payload on the failure the `providerRefused` diagnostic promised on `ChatDriverResult` would be
-    // absent — and with cause-free user copy that payload is the ONLY place an operator learns whether to
-    // top up an account or rotate a credential.
-    clearMetaEventRegistry();
-    const { provider } = parentOkChildRefused('auth');
-    const parent = delegatingParent(walledWorker(), () => undefined);
-    const driver = makeDriver(parent, provider, 'outcome-subagent-refused-kind', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    const refused = result.reason === 'done' ? result.providerRefused : undefined;
-    assert.is(refused === null || refused === void 0 ? void 0 : refused.kind, 'auth', "the child's kind survives the hop");
-    assert.is(refused === null || refused === void 0 ? void 0 : refused.vendorLabel, 'Anthropic');
-    assert.is(refused === null || refused === void 0 ? void 0 : refused.upstreamStatus, 401);
-}));
-outcome("a GRANDCHILD's refusal keeps its kind and vendor across two hops", () => __awaiter(void 0, void 0, void 0, function* () {
-    /*
-     * The third finding, and the one a single-hop test cannot reach. An INTERMEDIATE sub-agent latches its
-     * grandchild's payload correctly via `invokeSubAgent`, but then has to hand it on through
-     * `failSubAgent` — and passing only the reason there still stopped the top-level turn (the reason
-     * travels) while arriving with no vendor and no kind. The turn looked handled and the diagnostics were
-     * gone, which is the failure mode this payload exists to prevent.
-     *
-     * Three tiers: boss -> middle -> worker. Only the worker's turn is refused; every other model call
-     * succeeds, so nothing but the forwarding can carry the detail to the top.
-     */
-    clearMetaEventRegistry();
-    const worker = agent({
-        name: 'worker',
-        toolDefinitions: [def('finish')],
-        toolHandlers: { finish: () => __awaiter(void 0, void 0, void 0, function* () { return 'x'; }) },
-    });
-    const middle = agent({
-        name: 'middle',
-        subAgents: [worker],
-        toolDefinitions: [def('sub_delegate')],
-        toolHandlers: {
-            sub_delegate: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                const o = yield ctx.requestSubAgent('worker', { task: 'deeper' });
-                return o.ok ? 'ok' : `failed: ${o.reason}`;
-            }),
-        },
-    });
-    const boss = agent({
-        name: 'boss',
-        subAgents: [middle],
-        toolDefinitions: [def('delegate')],
-        toolHandlers: {
-            delegate: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                const o = yield ctx.requestSubAgent('middle', { task: 'do it' });
-                return o.ok ? 'ok' : `failed: ${o.reason}`;
-            }),
-        },
-    });
-    // Routed by the tool surface each tier is given, so only the deepest turn throws.
-    const provider = {
-        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
-            if (names.includes('delegate'))
-                return callsTool('delegate', 'd1');
-            if (names.includes('sub_delegate'))
-                return callsTool('sub_delegate', 's1');
-            throw new ProviderRefusedError('Anthropic', 'auth', 401, 'authentication_error', 'API key is invalid.');
-        }),
-    };
-    const driver = makeDriver(boss, provider, 'outcome-refused-grandchild', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'provider-refused');
-    const refused = result.reason === 'done' ? result.providerRefused : undefined;
-    assert.is(refused === null || refused === void 0 ? void 0 : refused.kind, 'auth', "the grandchild's kind survives BOTH hops");
-    assert.is(refused === null || refused === void 0 ? void 0 : refused.vendorLabel, 'Anthropic');
-    assert.is(refused === null || refused === void 0 ? void 0 : refused.upstreamStatus, 401);
-    assert.is(driver.getHistory().at(-1).content, DEFAULT_PROVIDER_REFUSED_MESSAGE);
-}));
-outcome('a sub-agent budget wall ends the parent turn without another model call', () => __awaiter(void 0, void 0, void 0, function* () {
-    clearMetaEventRegistry();
-    const { parentCalls, provider } = parentOkChildWalled();
-    const parent = delegatingParent(walledWorker(), () => undefined);
-    const driver = makeDriver(parent, provider, 'outcome-subagent-budget', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    assert.is(parentCalls(), 1, 'the parent never calls the model again after the wall');
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted');
-    assert.is(driver.getHistory().at(-1).content, DEFAULT_BUDGET_EXHAUSTED_MESSAGE);
-}));
-outcome("a sub-agent wall with headroom elsewhere composes the parent's switch advice", () => __awaiter(void 0, void 0, void 0, function* () {
-    // The parent's bubble is composed from the latched `budgetWallDetail` — on the
-    // sub-agent path there is NO error object in scope, only the failure payload
-    // the child attributed (this pins the exact seam a scope bug once lived on).
-    clearMetaEventRegistry();
-    let parentCalls = 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 ? _a : []).some((t) => t.name === 'delegate')) {
-                parentCalls += 1;
-                return callsTool('delegate', `d${parentCalls}`);
-            }
-            throw new BudgetExhaustedError('Anthropic', 25, 25.4, undefined, {
-                otherVendorAvailable: true,
-            });
-        }),
-    };
-    const parent = delegatingParent(walledWorker(), () => undefined);
-    const driver = makeDriver(parent, provider, 'outcome-subagent-budget-switch', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted');
-    assert.is(driver.getHistory().at(-1).content, "You've reached Anthropic's AI usage limit. Switch to another AI provider in Settings to keep going, or contact your administrator to raise it.");
-}));
-outcome("a sub-agent's wall is attributed to the CHILD's vendor, not the parent's", () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // A sub-agent can sit on a different vendor from its parent (`applyAgent` reads
-    // `config.provider`). The wall reaches the parent only as a tool result, so
-    // while the parent carried nothing but a boolean it reported
-    // `lastResolvedProvider` — its own vendor, i.e. precisely the one that did NOT
-    // refuse. Under a two-vendor registry that walls Gemini because an Anthropic
-    // child 402'd, and the host then blocks a composer that still had headroom.
-    clearMetaEventRegistry();
-    const { provider } = parentOkChildWalled();
-    // Seeded disagreement: the registry resolves Gemini, so the parent's
-    // `lastResolvedProvider` is `gemini` while the child is refused by Anthropic.
-    const registry = {
-        get: () => provider,
-        default: () => provider,
-        defaultName: () => 'test',
-        names: () => ['test'],
-        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model: 'gemini-test' }); }),
-        listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-    };
-    const driver = new ChatDriver(registry, {
-        sessionKey: 'outcome-subagent-budget-vendor',
-        activityBus: outcomeBus,
-    });
-    driver.applyAgent(delegatingParent(walledWorker(), () => undefined));
-    const result = yield driver.sendMessage('go');
-    const budget = result.reason === 'done' ? result.budget : undefined;
-    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendor, 'anthropic', "the child's refusing vendor survives the hop");
-    assert.is(budget === null || budget === void 0 ? void 0 : budget.budgetUsd, 25, "and so do the child's figures");
-    assert.is(budget === null || budget === void 0 ? void 0 : budget.spentUsd, 25.4);
-    const err = getMetaEvents('outcome-subagent-budget-vendor').find((e) => e.type === 'turn.error');
-    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.vendor, 'anthropic', 'and the debug log agrees');
-}));
-outcome('N batched sub-agent calls still produce at most one doomed parent call', () => __awaiter(void 0, void 0, void 0, function* () {
-    clearMetaEventRegistry();
-    let parentCalls = 0;
-    const provider = {
-        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
-            if (names.includes('delegate')) {
-                parentCalls += 1;
-                return {
-                    role: 'assistant',
-                    content: '',
-                    toolCalls: [
-                        { id: 'd1', name: 'delegate', args: {} },
-                        { id: 'd2', name: 'delegate', args: {} },
-                    ],
-                };
-            }
-            throw new BudgetExhaustedError('Anthropic', 25, 25.4);
-        }),
-    };
-    const parent = delegatingParent(walledWorker(), () => undefined);
-    const driver = makeDriver(parent, provider, 'outcome-subagent-budget-batched', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    assert.is(parentCalls, 1);
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, 'budget-exhausted');
-}));
-outcome('a non-terminal sub-agent failure still lets the parent continue', () => __awaiter(void 0, void 0, void 0, function* () {
-    // The short-circuit is scoped strictly to the budget reason — every other
-    // SubAgentFailureReason is something the parent can legitimately recover from.
-    clearMetaEventRegistry();
-    let parentCalls = 0;
-    const provider = {
-        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
-            if (names.includes('delegate')) {
-                parentCalls += 1;
-                return parentCalls === 1
-                    ? callsTool('delegate', 'd1')
-                    : { role: 'assistant', content: 'carried on regardless' };
-            }
-            // The child answers in free text without calling its completion tool →
-            // `max_iterations`, a recoverable failure.
-            return { role: 'assistant', content: 'no structured result' };
-        }),
-    };
-    let captured;
-    const parent = delegatingParent(walledWorker(), (o) => {
-        captured = o;
-    });
-    const driver = makeDriver(parent, provider, 'outcome-subagent-nonterminal', outcomeBus);
-    const result = yield driver.sendMessage('go');
-    assert.equal(captured, { ok: false, reason: 'max_iterations' });
-    assert.is(parentCalls, 2, 'the parent loop kept running');
-    assert.is(result.reason === 'done' ? result.failureReason : undefined, undefined);
-}));
-outcome("a later unattributable child wall does not erase the first child's attribution", () => __awaiter(void 0, void 0, void 0, function* () {
-    // Batched delegations: child A is refused by Anthropic WITH attribution,
-    // child B by a transport whose label no vendor claims (figure-less 402 → no
-    // BudgetDetail at all). A plain assignment let B's `undefined` clobber A's
-    // attribution, and the fallback then reported the PARENT's vendor — under a
-    // Gemini-resolving registry, precisely the vendor that did not refuse.
-    clearMetaEventRegistry();
-    let childCalls = 0;
-    const provider = {
-        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
-            if (names.includes('delegate')) {
-                return {
-                    role: 'assistant',
-                    content: '',
-                    toolCalls: [
-                        { id: 'd1', name: 'delegate', args: {} },
-                        { id: 'd2', name: 'delegate', args: {} },
-                    ],
-                };
-            }
-            childCalls += 1;
-            throw childCalls === 1
-                ? new BudgetExhaustedError('Anthropic', 25, 25.4)
-                : new BudgetExhaustedError('Acme AI'); // unclaimed label, no figures
-        }),
-    };
-    const registry = {
-        get: () => provider,
-        default: () => provider,
-        defaultName: () => 'test',
-        names: () => ['test'],
-        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model: 'gemini-test' }); }),
-        listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-    };
-    const driver = new ChatDriver(registry, {
-        sessionKey: 'outcome-subagent-budget-clobber',
-        activityBus: outcomeBus,
-    });
-    driver.applyAgent(delegatingParent(walledWorker(), () => undefined));
-    const result = yield driver.sendMessage('one');
-    const budget = result.reason === 'done' ? result.budget : undefined;
-    assert.is(budget === null || budget === void 0 ? void 0 : budget.vendor, 'anthropic', "child A's attribution survives child B's blank wall");
-}));
-outcome('a fully unattributable child wall degrades vendor-agnostic, never to the parent', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    // When NO child wall carries attribution, the honest event is vendor-less.
-    // Falling back to `lastResolvedProvider` named the parent's vendor — walling
-    // BOTH vendors (the child's via its own tool-loop-end, the parent's via this
-    // one) and deriving `blocked` over headroom that still existed.
-    clearMetaEventRegistry();
-    const events = [];
-    const bus = new AgenticActivityBus();
-    bus.subscribe('tool-loop-end', (d) => events.push(d));
-    // The provider must carry its own `getStatus` — `lastResolvedProvider` is
-    // stamped from the PROVIDER's status, not the registry's, and a status-less
-    // mock leaves it unset, which lets the buggy fallback pass vacuously (there
-    // is no wrong vendor to fall back to).
-    const provider = {
-        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model: 'gemini-test' }); }),
-        chat: (_h, _u, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const names = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
-            if (names.includes('delegate'))
-                return callsTool('delegate', 'd1');
-            // The CHILD's turn: refused by a transport whose label no vendor claims.
-            throw new BudgetExhaustedError('Acme AI'); // no figures either
-        }),
-    };
-    const registry = {
-        get: () => provider,
-        default: () => provider,
-        defaultName: () => 'test',
-        names: () => ['test'],
-        getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return ({ provider: 'gemini', model: 'gemini-test' }); }),
-        listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-    };
-    const driver = new ChatDriver(registry, {
-        sessionKey: 'outcome-subagent-budget-agnostic',
-        activityBus: bus,
-    });
-    driver.applyAgent(delegatingParent(walledWorker(), () => undefined));
-    yield driver.sendMessage('go');
-    // The PARENT's loop-end is the last one on the bus. It must carry the
-    // failure without naming the parent's (gemini) vendor.
-    const parentEnd = events.at(-1);
-    assert.is(parentEnd === null || parentEnd === void 0 ? void 0 : parentEnd.failureReason, 'budget-exhausted');
-    assert.is(parentEnd === null || parentEnd === void 0 ? void 0 : parentEnd.vendor, undefined, 'no vendor is better than the wrong vendor');
-    // The CHILD's folded-in turn.error legitimately carries its own best-effort
-    // self-attribution (its resolved provider really did make the refused call);
-    // the record this fix governs is the PARENT's short-circuit, tagged
-    // `via: 'sub-agent'`.
-    const err = getMetaEvents('outcome-subagent-budget-agnostic').find((e) => { var _a; return e.type === 'turn.error' && ((_a = e.detail) === null || _a === void 0 ? void 0 : _a.via) === 'sub-agent'; });
-    assert.ok(err, "the parent's short-circuit recorded the wall");
-    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.vendor, undefined, 'and named no vendor rather than the wrong one');
-}));
-outcome.run();
-// ---------------------------------------------------------------------------
-// recordExternalCost — spend a widget incurs AFTER it has resolved.
-//
-// Some widgets resolve EARLY on purpose, so the assistant stops waiting while the
-// user deliberates, and then keep doing paid work for them. `resolveInteraction`
-// cannot serve that: its whole body is inside `if (interaction)` and it deletes the
-// entry, so a second resolution is a silent no-op and the spend never reached the
-// figure shown to the user.
-// ---------------------------------------------------------------------------
-const postResolveCost = createLogicSuite('ChatDriver post-resolve external cost');
-postResolveCost('adds spend to an interaction that has already resolved', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const pending = driver.requestInteraction('planning-question', { question: 'Pick one' });
-    const id = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id, { status: 'approved', costUsd: 0.5 });
-    yield pending;
-    // The interaction is gone from `pendingInteractions` — this is exactly the state in
-    // which the old path silently did nothing.
-    assert.is(driver.recordExternalCost(id, 0.25), true);
-    assert.is(driver.recordExternalCost(id, 0.25), true);
-    const msg = driver.getHistory().find((m) => { var _a; return ((_a = m.interaction) === null || _a === void 0 ? void 0 : _a.interactionId) === id; });
-    // ADDITIVE: the resolution's 0.5 plus two 0.25 deltas.
-    assert.is(msg === null || msg === void 0 ? void 0 : msg.externalCostUsd, 1);
-    // …and the recorded resolution is untouched — this is not a second resolution.
-    assert.equal((_a = msg === null || msg === void 0 ? void 0 : msg.interaction) === null || _a === void 0 ? void 0 : _a.resolved, { status: 'approved', costUsd: 0.5 });
-}));
-postResolveCost('works on an interaction that resolved with no cost at all', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const pending = driver.requestInteraction('planning-question', { question: 'q' });
-    const id = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id, { status: 'approved' });
-    yield pending;
-    assert.is(driver.recordExternalCost(id, 0.02), true);
-    const msg = driver.getHistory().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.02);
-}));
-postResolveCost('refuses values that are not real spend, and an unknown interaction', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const pending = driver.requestInteraction('planning-question', { question: 'q' });
-    const id = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id, { status: 'approved' });
-    yield pending;
-    // Includes the shapes only an untyped JS caller can produce — which is exactly who the
-    // `typeof` guard is written for, and what the previous `as number` cast asserted nothing about.
-    for (const bad of [0, -1, Number.NaN, Number.POSITIVE_INFINITY, '0.5', null, undefined]) {
-        assert.is(driver.recordExternalCost(id, bad), false);
-    }
-    // …and each refusal leaves a trace: the wrapper no longer pre-validates (it made this
-    // unreachable through the event path, a widget's only way in), so this is the ONE validator
-    // and it has to record what it dropped.
-    const dropped = getMetaEvents('').filter((m) => m.type === 'interaction.external-cost-dropped');
-    assert.ok(dropped.length >= 1, 'a refused amount must record why');
-    // An empty id can never match a message, so it is refused before the search.
-    assert.is(driver.recordExternalCost('', 0.1), false);
-    // A message trimmed or condensed out of history is a real outcome, not a throw.
-    assert.is(driver.recordExternalCost('no-such-interaction', 0.1), false);
-    const msg = driver.getHistory().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, undefined);
-}));
-postResolveCost('announces the change NARROWLY — never on history-updated, which rebuilds the widget', () => __awaiter(void 0, void 0, void 0, function* () {
-    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
-    const pending = driver.requestInteraction('planning-question', { question: 'q' });
-    const id = driver.getHistory().at(-1).interaction.interactionId;
-    driver.resolveInteraction(id, { status: 'approved' });
-    yield pending;
-    let narrow = 0;
-    let costUsd;
-    let interactionId;
-    let historyUpdated = 0;
-    driver.addEventListener('external-cost-recorded', (e) => {
-        narrow += 1;
-        ({ costUsd, interactionId } = e.detail);
-    });
-    driver.addEventListener('history-updated', () => {
-        historyUpdated += 1;
-    });
-    driver.recordExternalCost(id, 0.07);
-    // Announced, or the total is right in history and stale on screen.
-    assert.is(narrow, 1);
-    assert.is(costUsd, 0.07);
-    assert.is(interactionId, id);
-    // REGRESSION (reviewer catch on #2474): `history-updated` makes the host reassign `messages`,
-    // which rebuilds the trailing interaction row — a `recycle: false` repeat that disposes its
-    // views outright. For a RESOLVED interaction there is no `interactionContext` to remount
-    // from, so announcing this way tore down and blanked the very widget that had just reported
-    // its spend. Bookkeeping about a finished turn must not touch what is rendered.
-    assert.is(historyUpdated, 0);
-}));
-postResolveCost.run();