@genesislcap/ai-assistant 14.461.2 → 14.462.0

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

@@ -803,6 +803,45 @@ interactionPresentation('presentation is absent when the option is omitted', ()
 }));
 interactionPresentation.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');
+interactionBus.after(() => {
+    agenticActivityBus.close();
+});
+interactionBus('brackets a park with interaction-requested then -resolved', () => __awaiter(void 0, void 0, void 0, function* () {
+    const events = [];
+    const unsubs = [
+        agenticActivityBus.subscribe('interaction-requested', () => events.push('requested')),
+        agenticActivityBus.subscribe('interaction-resolved', () => events.push('resolved')),
+    ];
+    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
+    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 unsub = agenticActivityBus.subscribe('interaction-resolved', () => events.push('resolved'));
+    const driver = makeDriver(agent({ name: 'a' }), scriptedProvider([]));
+    // 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.
 // ---------------------------------------------------------------------------
@@ -863,3 +902,180 @@ interactionCost('leaves externalCostUsd unset for a missing, zero, or negative c
     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, {}, [], undefined, undefined, 50, 5, undefined, '');
+    driver.applyAgent(config);
+    return driver;
+};
+const observable = createLogicSuite('ChatDriver observable provider registry');
+observable.after(() => {
+    agenticActivityBus.close();
+});
+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.after(() => {
+    agenticActivityBus.close();
+});
+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');
+    // 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.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();

package/dist/esm/main/main.js

@@ -22,7 +22,7 @@
 // =============================================================================
 var FoundationAiAssistant_1;
 import { __awaiter, __decorate, __rest } from "tslib";
-import { AIProviderRegistry } from '@genesislcap/foundation-ai';
+import { AIProviderRegistry, isObservableAIProviderRegistry } from '@genesislcap/foundation-ai';
 import { avoidTreeShaking } from '@genesislcap/foundation-utils';
 import { customElement, html, GenesisElement, observable, volatile, attr, } from '@genesislcap/web-core';
 import DOMPurify from 'dompurify';
@@ -900,7 +900,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.driverCleanup = undefined;
     }
     connectedCallback() {
-        var _a, _b, _c, _d, _e, _f, _j, _k, _l;
+        var _a, _b, _c, _d, _e, _f, _j, _k, _l, _m;
         // Initialise the store reference BEFORE super.connectedCallback() so that
         // the first FAST render has access to the store. The store Proxy calls
         // Observable.track(observableStore, sliceName) whenever a slice is read,
@@ -969,6 +969,21 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this.fetchSuggestions();
         void this.resolveContextLimit();
         void this.loadProviderStatuses();
+        // When the host registered an observable registry (runtime provider
+        // switching), refresh the displayed model/limit and the provider list the
+        // instant its contents change — so the header reflects the new provider
+        // immediately on switch, not only when the next turn re-emits
+        // `provider-changed`. Feature-detected: a no-op for immutable registries.
+        // Re-subscribed per connect (docking/popout remounts); balanced in
+        // disconnectedCallback.
+        (_k = this.unsubProviderRegistry) === null || _k === void 0 ? void 0 : _k.call(this);
+        this.unsubProviderRegistry = undefined;
+        if (isObservableAIProviderRegistry(this.providerRegistry)) {
+            this.unsubProviderRegistry = this.providerRegistry.subscribe(() => {
+                void this.resolveContextLimit();
+                void this.loadProviderStatuses();
+            });
+        }
         if (this.messagesEl) {
             this._scrollListener = () => {
                 this._userScrolledAway =
@@ -992,18 +1007,20 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             restoredMessages: this.messages.length,
             driver: driverExisted ? 'reused' : 'created',
             driverKind: this.driver instanceof OrchestratingDriver ? 'orchestrating' : 'chat',
-            driverBusy: (_l = (_k = this.driver) === null || _k === void 0 ? void 0 : _k.isBusy()) !== null && _l !== void 0 ? _l : false,
+            driverBusy: (_m = (_l = this.driver) === null || _l === void 0 ? void 0 : _l.isBusy()) !== null && _m !== void 0 ? _m : false,
         });
     }
     disconnectedCallback() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         super.disconnectedCallback();
         this.stopLoadingTimer();
         this.state = 'idle';
         this.unwireDriver();
         (_a = this.unsubBus) === null || _a === void 0 ? void 0 : _a.call(this);
         this.unsubBus = undefined;
-        (_b = this._executionCompletionUnsub) === null || _b === void 0 ? void 0 : _b.call(this);
+        (_b = this.unsubProviderRegistry) === null || _b === void 0 ? void 0 : _b.call(this);
+        this.unsubProviderRegistry = undefined;
+        (_c = this._executionCompletionUnsub) === null || _c === void 0 ? void 0 : _c.call(this);
         this._executionCompletionUnsub = undefined;
         if (this.messagesEl && this._scrollListener) {
             this.messagesEl.removeEventListener('scroll', this._scrollListener);
@@ -1019,7 +1036,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         this._agentPickerToggle.finalize();
         this._settingsToggle.finalize();
         // Capture before clearing — `wasBusy` reads the driver, which is dropped below.
-        this.logMeta('assistant.disconnected', { wasBusy: (_d = (_c = this.driver) === null || _c === void 0 ? void 0 : _c.isBusy()) !== null && _d !== void 0 ? _d : false });
+        this.logMeta('assistant.disconnected', { wasBusy: (_e = (_d = this.driver) === null || _d === void 0 ? void 0 : _d.isBusy()) !== null && _e !== void 0 ? _e : false });
         // Clear local references only — driver and store stay in their registries.
         this.driver = undefined;
         this._sessionRef = undefined;

package/dist/esm/state/debug-event-log.js

@@ -138,7 +138,7 @@ export const DEBUG_LOG_README = [
     'This is an exported debug log for the Genesis AI assistant. Read it top-to-bottom.',
     '`timeline` is the entire session as one array, already sorted chronologically by `timestamp` (ISO 8601). Every entry has a `kind`.',
     'Timestamps are millisecond-resolution; entries that share the same millisecond are ordered by a fixed kind rank (event, then turn, then message), which is a heuristic and may not reflect exact causal order within that millisecond — e.g. a user message and the turn it triggered, or a final assistant message and its turn.end event, can appear in either order depending on whether they landed in the same millisecond. Read the logical structure of a turn rather than over-interpreting the micro-ordering of co-timestamped entries of different kinds.',
-    "kind:'message' — the conversation. `role` is user/assistant/tool/system-event/synthetic-user; `agentName` says which agent produced it; `toolCalls`/`toolResult`/`interaction` carry tool and widget activity; `inputTokens`/`outputTokens`/`cost` are per-message LLM usage, and `externalCostUsd` is any non-LLM cost a widget reported for its own external service calls (folded into the session cost total alongside `cost`). A 'synthetic-user' message is a display-only echo of an interaction outcome (e.g. the answer a widget reported): it renders on the user's side of the chat and `agentName` is the agent that created it, but it is never sent to the LLM — so it has no matching 'turn' and the model learns the outcome only from the corresponding tool result.",
+    "kind:'message' — the conversation. `role` is user/assistant/tool/system-event/synthetic-user; `agentName` says which agent produced it; `toolCalls`/`toolResult`/`interaction` carry tool and widget activity; `inputTokens`/`outputTokens`/`cost` are per-message LLM usage, and `externalCostUsd` is any non-LLM cost a widget reported for its own external service calls (folded into the session cost total alongside `cost`). On model-produced assistant messages, `model` is the concrete model id that generated it (e.g. 'gemini-2.5-flash-lite') and `providerName` is the registry slot it resolved under (e.g. a tier name like 'high'/'low', or the default); together they attribute the message — and any tool calls it carries — to an exact model even across a mid-session vendor/tier switch, where one slot name can map to different models before and after the switch. Both are undefined on any entry that is NOT an LLM response: non-assistant roles (user/tool/system-event) and 'synthetic-user' echoes; assistant interaction/widget entries (empty content carrying an `interaction` — a rendered widget, not a model turn); driver-authored assistant fallbacks (the timeout, repeated-malformed-call, and empty-response apology messages); and messages restored from a session persisted before these fields existed. One partial case: on a genuine model turn whose provider exposes no `getStatus` (or reports no model), `providerName` is still set but `model` alone is undefined. A 'synthetic-user' message is a display-only echo of an interaction outcome (e.g. the answer a widget reported): it renders on the user's side of the chat and `agentName` is the agent that created it, but it is never sent to the LLM — so it has no matching 'turn' and the model learns the outcome only from the corresponding tool result.",
     "kind:'turn' — one LLM call. `turnIndex` is a string: a top-level turn is the bare counter ('0', '1', …); a sub-agent's turns are numbered under the parent turn that activated them ('3-1', '3-2', …, and a nested sub-agent contributes '3-2-1', …), and `agentName` names the agent that ran the turn. `systemPrompt` and `toolNames` are what the model saw. A systemPrompt of '<repeated — identical to turn N>' was byte-identical to turn N and de-duplicated; the full prompt is shown whenever it changes (often because a stateful agent advanced), so prompt evolution is visible.",
     "kind:'turn'.`agentSnapshot` — the active agent's own view of its internal state, captured at that turn. An agent opts into this by exposing a `getDebugSnapshot()` that returns JSON-serializable per-state info; stateful/flow agents wire it automatically, so you can watch a flow advance turn-by-turn (e.g. current step, cursor, collected fields, pending changes). Absent for agents that don't expose one.",
     "kind:'event' — a meta/lifecycle event. `type` names it (see below); `detail` carries structured data. `detail.placement` is the emitting UI instance: 'bubble' (collapsed), 'panel' (popped-out), or 'standalone'.",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "14.461.2",
+  "version": "14.462.0",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/ai-assistant.d.ts",
@@ -64,24 +64,24 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.461.2",
-    "@genesislcap/genx": "14.461.2",
-    "@genesislcap/rollup-builder": "14.461.2",
-    "@genesislcap/ts-builder": "14.461.2",
-    "@genesislcap/uvu-playwright-builder": "14.461.2",
-    "@genesislcap/vite-builder": "14.461.2",
-    "@genesislcap/webpack-builder": "14.461.2",
+    "@genesislcap/foundation-testing": "14.462.0",
+    "@genesislcap/genx": "14.462.0",
+    "@genesislcap/rollup-builder": "14.462.0",
+    "@genesislcap/ts-builder": "14.462.0",
+    "@genesislcap/uvu-playwright-builder": "14.462.0",
+    "@genesislcap/vite-builder": "14.462.0",
+    "@genesislcap/webpack-builder": "14.462.0",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "14.461.2",
-    "@genesislcap/foundation-logger": "14.461.2",
-    "@genesislcap/foundation-redux": "14.461.2",
-    "@genesislcap/foundation-ui": "14.461.2",
-    "@genesislcap/foundation-utils": "14.461.2",
-    "@genesislcap/rapid-design-system": "14.461.2",
-    "@genesislcap/web-core": "14.461.2",
+    "@genesislcap/foundation-ai": "14.462.0",
+    "@genesislcap/foundation-logger": "14.462.0",
+    "@genesislcap/foundation-redux": "14.462.0",
+    "@genesislcap/foundation-ui": "14.462.0",
+    "@genesislcap/foundation-utils": "14.462.0",
+    "@genesislcap/rapid-design-system": "14.462.0",
+    "@genesislcap/web-core": "14.462.0",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },
@@ -93,5 +93,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7999f5af9df17157002c463d10fe75a14ac43521"
+  "gitHead": "d332227a536531b1b807ae33f65ce4639f0991ba"
 }

package/src/channel/ai-activity-channel.ts

@@ -61,4 +61,24 @@ export interface AgenticActivityEvents {
    * (telemetry flushes, post-turn workspace transitions, deferred state recomputation).
    */
   'tool-loop-end': undefined;
+  /**
+   * Fired when a tool handler hands a widget to the user mid-loop and parks awaiting it
+   * (`requestInteraction`) — the turn is suspended between provider calls, with no request
+   * in flight. Pairs with {@link AgenticActivityEvents.'interaction-resolved'}.
+   *
+   * This is the inverse boundary to {@link AgenticActivityEvents.'tool-loop-start'}: the
+   * loop is running (still inside `tool-loop-start`/`tool-loop-end`) but is momentarily idle,
+   * waiting on the user. Use it for hooks that are unsafe *while computing* but safe *while
+   * parked* — e.g. enabling a control that must not change mid-request but is fine to change
+   * during a long journey step. Tab-local (not forwarded cross-tab): the widget and its
+   * waiting state belong to the tab that opened it.
+   */
+  'interaction-requested': undefined;
+  /**
+   * Fired when a parked widget interaction ends — by user completion, timeout, or
+   * cancellation — just before the suspended tool handler resumes and the loop continues.
+   * Pairs with {@link AgenticActivityEvents.'interaction-requested'}. After this the turn is
+   * computing again (until `tool-loop-end`). Tab-local.
+   */
+  'interaction-resolved': undefined;
 }