@genesislcap/ai-assistant 15.58.2 → 15.59.0

package/dist/custom-elements.json

@@ -894,6 +894,54 @@
             "package": "./utils/tool-fold"
           }
         },
+        {
+          "kind": "js",
+          "name": "DEFAULT_DELEGATE_FRAMING",
+          "declaration": {
+            "name": "DEFAULT_DELEGATE_FRAMING",
+            "module": "./utils/delegated-message"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "isDelegated",
+          "declaration": {
+            "name": "isDelegated",
+            "module": "./utils/delegated-message"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "type",
+          "declaration": {
+            "name": "type",
+            "module": "./utils/delegated-message"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "DelegatedMessage",
+          "declaration": {
+            "name": "DelegatedMessage",
+            "module": "./utils/delegated-message"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "type",
+          "declaration": {
+            "name": "type",
+            "module": "./utils/delegated-message"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "SendMessageOptions",
+          "declaration": {
+            "name": "SendMessageOptions",
+            "module": "./utils/delegated-message"
+          }
+        },
         {
           "kind": "js",
           "name": "assistantSettingsSectionTitleStyles",
@@ -974,6 +1022,62 @@
             "module": "./types/interaction-context"
           }
         },
+        {
+          "kind": "js",
+          "name": "InteractionHolder",
+          "declaration": {
+            "name": "InteractionHolder",
+            "module": "./types/interaction-context"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "DelegatedDecision",
+          "declaration": {
+            "name": "DelegatedDecision",
+            "module": "./types/interaction-interceptor"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "InteractionHold",
+          "declaration": {
+            "name": "InteractionHold",
+            "module": "./types/interaction-interceptor"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "InteractionInterceptor",
+          "declaration": {
+            "name": "InteractionInterceptor",
+            "module": "./types/interaction-interceptor"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "InteractionOpened",
+          "declaration": {
+            "name": "InteractionOpened",
+            "module": "./types/interaction-interceptor"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "HandlerCapabilityFactory",
+          "declaration": {
+            "name": "HandlerCapabilityFactory",
+            "module": "./types/handler-capability"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "HandlerCapabilityScope",
+          "declaration": {
+            "name": "HandlerCapabilityScope",
+            "module": "./types/handler-capability"
+          }
+        },
         {
           "kind": "js",
           "name": "AiChatMarkdown",
@@ -4594,12 +4698,12 @@
             },
             {
               "kind": "field",
-              "name": "orchestrator",
+              "name": "driverKind",
               "type": {
-                "text": "OrchestratingDriver | undefined"
+                "text": "'orchestrating' | 'chat'"
               },
               "privacy": "private",
-              "description": "This element's driver as an orchestrator, or `undefined` when the session is running a bare\n`ChatDriver`. The only place in this element that narrows the type; the test itself lives in\n`asOrchestrator`, shared with the session persister.",
+              "description": "Which kind of driver this element runs, for the `driver.created` / `assistant.connected` log\nlines only. Looks through any decorators (GENC-1660): behaviour goes through `AiDriver`\nmembers, which every layer forwards, so this is the one place the concrete class matters.",
               "readonly": true
             },
             {
@@ -7136,7 +7240,7 @@
           "type": {
             "text": "Record<MetaEventType, MetaEventImportance>"
           },
-          "default": "{\n  'turn.error': 'high',\n  'tool.failed': 'high',\n  'subagent.failed': 'high',\n  'file.read-failed': 'high',\n  'suggestions.failed': 'high',\n  'context.threshold-crossed': 'high',\n  'context.compacted': 'high',\n  'persistence.restore-orphan': 'high',\n  // A save that did not land is silent data loss in progress: the transcript on screen\n  // is no longer backed by the store, and every later turn widens the gap. GENC-1511.\n  'persistence.save-failed': 'high',\n\n  'assistant.connected': 'normal',\n  'assistant.disconnected': 'normal',\n  'assistant.popout': 'normal',\n  'assistant.popin': 'normal',\n  'driver.created': 'normal',\n  'state.changed': 'normal',\n  'turn.start': 'normal',\n  'turn.end': 'normal',\n  'turn.retry': 'normal',\n  'tool.unresolved': 'normal',\n  'subagent.started': 'normal',\n  'subagent.completed': 'normal',\n  // One per routing decision, with what the classifier answered and what the call cost. Same\n  // level as the handoff it produces: you read them together to follow how a turn was routed.\n  'routing.decided': 'normal',\n  'agent.handoff': 'normal',\n  'agent.pinned': 'normal',\n  'agent.unpinned': 'normal',\n  'provider.selected': 'normal',\n  'interaction.requested': 'normal',\n  'interaction.resolved': 'normal',\n  // Bookkeeping about an already-finished turn; interesting when reconciling a session total.\n  'interaction.external-cost': 'normal',\n  // Spend that was billed but could NOT be recorded (the message was trimmed/condensed away, or\n  // the value was not real spend). 'high': it is the one way the session total goes quietly\n  // wrong, so it must stand out when reconciling.\n  'interaction.external-cost-dropped': 'high',\n  // What came of an answer, recorded by the tool that asked (see recordInteractionOutcome).\n  'interaction.outcome': 'normal',\n  // An outcome that could not be recorded: the widget goes on showing only the answer.\n  'interaction.outcome-dropped': 'high',\n  'external-diagnostics.folded': 'normal',\n  'session.cleared': 'normal',\n  'session.switched': 'low',\n  'session.switch-deferred': 'low',\n  'persistence.restored': 'normal',\n  // Whether a restored flow will be re-activated and resumed (GENC-1662), and how much the trim cut.\n  'persistence.resume-planned': 'normal',\n  // A planned resume that did not run, and why (GENC-1662) — the divider was put back to plain.\n  'persistence.resume-withdrawn': 'normal',\n  'persistence.suppressed': 'normal',\n  'persistence.not-resumable': 'normal',\n\n  'driver.wired': 'low',\n  'driver.unwired': 'low',\n  'context.updated': 'low',\n  'context.condensed': 'low',\n  'panel.toggled': 'low',\n  'persistence.toggled': 'low',\n  'persistence.saved': 'low',\n  'attachment.added': 'low',\n}",
+          "default": "{\n  'turn.error': 'high',\n  'tool.failed': 'high',\n  'subagent.failed': 'high',\n  'file.read-failed': 'high',\n  'suggestions.failed': 'high',\n  'context.threshold-crossed': 'high',\n  'context.compacted': 'high',\n  'persistence.restore-orphan': 'high',\n  // A save that did not land is silent data loss in progress: the transcript on screen\n  // is no longer backed by the store, and every later turn widens the gap. GENC-1511.\n  'persistence.save-failed': 'high',\n\n  'assistant.connected': 'normal',\n  'assistant.disconnected': 'normal',\n  'assistant.popout': 'normal',\n  'assistant.popin': 'normal',\n  'driver.created': 'normal',\n  'state.changed': 'normal',\n  'turn.start': 'normal',\n  'turn.end': 'normal',\n  'turn.retry': 'normal',\n  'tool.unresolved': 'normal',\n  'subagent.started': 'normal',\n  'subagent.completed': 'normal',\n  // One per routing decision, with what the classifier answered and what the call cost. Same\n  // level as the handoff it produces: you read them together to follow how a turn was routed.\n  'routing.decided': 'normal',\n  'agent.handoff': 'normal',\n  'agent.pinned': 'normal',\n  'agent.unpinned': 'normal',\n  'provider.selected': 'normal',\n  'interaction.requested': 'normal',\n  'interaction.resolved': 'normal',\n  // Bookkeeping about an already-finished turn; interesting when reconciling a session total.\n  'interaction.external-cost': 'normal',\n  // Spend that was billed but could NOT be recorded (the message was trimmed/condensed away, or\n  // the value was not real spend). 'high': it is the one way the session total goes quietly\n  // wrong, so it must stand out when reconciling.\n  'interaction.external-cost-dropped': 'high',\n  // What came of an answer, recorded by the tool that asked (see recordInteractionOutcome).\n  'interaction.outcome': 'normal',\n  // An outcome that could not be recorded: the widget goes on showing only the answer.\n  'interaction.outcome-dropped': 'high',\n  // A claimant handing a pending interaction to the person, or taking it back.\n  'interaction.held': 'normal',\n  // A claim on a `userOnly` interaction, refused. Expected when an interceptor claims broadly.\n  'interaction.claim-refused': 'low',\n  'external-diagnostics.folded': 'normal',\n  'session.cleared': 'normal',\n  'session.switched': 'low',\n  'session.switch-deferred': 'low',\n  'persistence.restored': 'normal',\n  // Whether a restored flow will be re-activated and resumed (GENC-1662), and how much the trim cut.\n  'persistence.resume-planned': 'normal',\n  // A planned resume that did not run, and why (GENC-1662) — the divider was put back to plain.\n  'persistence.resume-withdrawn': 'normal',\n  'persistence.suppressed': 'normal',\n  'persistence.not-resumable': 'normal',\n\n  'driver.wired': 'low',\n  'driver.unwired': 'low',\n  'context.updated': 'low',\n  'context.condensed': 'low',\n  'panel.toggled': 'low',\n  'persistence.toggled': 'low',\n  'persistence.saved': 'low',\n  'attachment.added': 'low',\n}",
           "description": "Importance is intrinsic to the event *type*, not the instance, so it's\ndefined once here and stamped automatically by recordMetaEvent — call\nsites never pass it. The `Record` is exhaustive: adding a `MetaEventType`\nwithout a level here is a compile error.\n\n- `high`   — failures and hard limits you almost always want to see.\n- `normal` — meaningful session flow you read to follow what happened.\n- `low`    — frequent UI / bookkeeping noise, usually safe to skip."
         },
         {
@@ -7298,7 +7402,7 @@
           "type": {
             "text": "readonly string[]"
           },
-          "default": "[\n  'This is an exported debug log for the Genesis AI assistant. Read it top-to-bottom.',\n  \"`sessionUsage` is what this session spent: `costUsd` (USD, provider-reported per request and summed, cache discounts already applied) plus the four TOKEN BUCKETS — `uncachedInputTokens`, `cacheReadTokens`, `cacheWriteTokens`, `outputTokens`. Those four are disjoint and safe to add up for a total-tokens figure; the per-message fields further down are NOT (see kind:'message'). Each bucket bills at a different rate — cache reads a fraction of uncached input, cache writes a premium, output highest — so a big token count against a small cost means the prompt was mostly cache hits, not a missing charge. It covers sub-agent turns and spend a compaction banked, so for the CONVERSATION it is the authoritative total: prefer it over re-summing the timeline, which can be short by whatever the ring buffers evicted. The same figures appear under `meta.context`. It is as current as the snapshot it came from: the assistant's own download stamps a fresh one, but a log stitched by another tool can carry an older one — compare `meta.timestamp` with the last timeline entry, and if it is well behind, read these totals as historical and fall back to summing the timeline. One scope caveat: it is derived from the transcript, so it excludes billed calls that produced no message (a blank or refused attempt that was retried — see kind:'turn'.`usage`). Summing the turns can therefore come out HIGHER than this, and the difference is exactly that discarded spend, not a double-count.\",\n  \"What 'session' means for those figures: the CURRENT conversation under this session key (a host-supplied per-project id, or the element id + header title when the host supplies none) — which is not necessarily everything in `timeline`. It is re-derived from the live transcript, so it spans page loads only when the chat is being remembered, and a Clear resets it to zero. `timeline` is append-only regardless: it keeps every page load and the pre-Clear conversation, with the session.cleared event as the boundary. So on a long-lived log, read these totals as the latest conversation's and the earlier sections as history — not as a total of the whole file.\",\n  '`timeline` is the entire session as one array, already sorted chronologically by `timestamp` (ISO 8601). Every entry has a `kind`.',\n  '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.',\n  \"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, where `inputTokens` is the WHOLE prompt for that request and `cacheReadTokens`/`cacheWriteTokens` BREAK IT DOWN rather than add to it — uncached input is `inputTokens` minus those two, and adding the cache fields to `inputTokens` counts the prompt twice. The cache fields are absent on providers that report no cache split (Gemini reports reads only, since implicit caching bills no write) and on messages persisted before they existed, so read them as 0 when missing. Each bucket bills at a different rate — cache reads a fraction of uncached input, cache writes a premium, output highest — so a large token count at a small cost means the prompt was mostly cache hits. `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.\",\n  \"Sub-agent messages appear inline. When a tool delegates to a sub-agent (via `requestSubAgent`), the sub-agent's whole conversation — its own assistant/tool messages, each with their own `content`/`thinking`/`toolCalls`/`toolResult` and per-message `model`/`providerName`/`inputTokens`/`outputTokens`/`cacheReadTokens`/`cacheWriteTokens`/`cost` — is hoisted into the timeline as ordinary kind:'message' entries, interleaved by timestamp right after the tool call that spawned them (so you read the delegation top-to-bottom). A hoisted entry is marked: `subAgentDepth` is its delegation depth (1 for a sub-agent, 2 for a sub-agent's sub-agent, …), `subAgentOf` is the id of the parent tool call that spawned it (correlates it back even when two sub-agents run in one parent turn), `subAgentName` is the sub-agent's own name, and `agentName` is rewritten to a `\\\"<parent> › <sub-agent>\\\"` breadcrumb (composing when nested, e.g. `\\\"UI Builder › Planner › Grounding\\\"`). The sub-agent's per-LLM-call snapshots also surface as kind:'turn' entries with an N-M `turnIndex`, and subagent.started/completed (or subagent.failed) events bracket the run. Per-message `cost` on hoisted entries is already part of the session total (it is summed from the un-flattened history), so summing the top-level timeline does NOT double-count.\",\n  \"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.\",\n  \"kind:'turn'.`model`/`providerName`/`provider` — which model ran that call: the concrete model id, the registry slot it resolved under (a tier name like 'high'/'low', or the default), and the vendor. Recorded per CALL, so an agent whose `provider` selector varies by state — a flow that plans on a high tier and executes on a low one — has every step attributed, including calls that produced no message. `model` is the SERVING model where the provider reports one, so a turn answered by a server-side fallback names the model that answered rather than the one requested; it always matches the `model` on the message that call produced. Absent when the provider exposes no `getStatus` and the transport stamped nothing.\",\n  \"kind:'turn'.`usage` — what that ONE call cost, in the same four-bucket + `costUsd` shape as `sessionUsage`. Absent while a call is in flight and on providers that report no usage. This is the SAME money as the message the call produced, not extra money: never add turn usage to message usage, and read a turn plus its message as one charge. Its distinct value is the calls that produced NO message — a blank or refused response is billed and then discarded before the retry, so the turn entry is the only record of that spend, and a turn with `usage` but no message after it is exactly that. `costUsd: 0` alongside a nonzero token count means the provider reported no price, not that the call was free.\",\n  \"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.\",\n  \"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'.\",\n  \"Each 'event' also has an `importance`: 'high' (failures/limits — turn.error, tool.failed, subagent.failed, file.read-failed, suggestions.failed, context.threshold-crossed), 'normal' (session flow — connects, turns, retries, handoffs, agent/provider changes, interactions, sub-agent start/complete), or 'low' (skippable UI/bookkeeping noise — panel.toggled, attachment.added, driver.wired/unwired, context.updated, context.condensed). To skim, ignore importance:'low'; to triage a failure, filter to importance:'high' then read the nearby messages and turns. A 'high' turn.error is often preceded by one or more 'normal' turn.retry events for the same reason — read them together to see how many attempts were made before bailing. 'message' and 'turn' entries carry no importance — they are the substance, always read them.\",\n  'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations/response-truncated/refusal/budget-exhausted/provider-refused/context-exhausted/ai-service-error, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, for response-truncated the model + maxTokens + outputTokens + tools, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, for budget-exhausted the budgetUsd + spentUsd figures reported by the proxy plus the resolved vendor, for provider-refused the kind (spend|auth) plus the upstream status and error type — the vendor refusing the ACCOUNT rather than us refusing to spend, so the remedy is a top-up or a key rotation rather than a raised cap, and the kind is the only place that distinction survives because the user-facing copy is deliberately cause-free, for context-exhausted the estimated contextTokens against the guard that stopped the turn plus the iterations reached — the driver ending a runaway tool loop at the edge of the context window rather than issuing a request the provider would reject, so the transcript survives intact and can still be compacted, for ai-service-error the code (one of AI_SERVICE_ERROR_CODES, e.g. NO_API_KEY) and the status the AI service answered with — its own text goes to the browser console only, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout/response_truncated/refusal/budget_exhausted/provider_refused/context_exhausted/ai_service_error; budget_exhausted and provider_refused are terminal for the PARENT turn too, and so is ai_service_error when the refusal is about the service rather than the request and came from the vendor the parent calls — the parent stops rather than calling the model again into the same wall; after context_exhausted the parent goes on, but its own next call is likely to stop on the same guard), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), routing.decided (ONE PER ROUTING DECISION — see its own paragraph below), provider.selected (the resolved provider for the upcoming turns — detail.provider is the registry SLOT/tier name, detail.model the concrete model behind it and detail.vendor its vendor; emitted only when the slot CHANGES, so read the per-turn `model` for the model of any given call rather than assuming the nearest event still applies), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',\n  'Sub-agent meta events: a sub-agent\\'s own turn.retry/turn.error/tool.failed/tool.unresolved events are merged into this same timeline, tagged with `detail.subAgent` — a `\"<parent> › <sub-agent>\"` breadcrumb that composes when nested (e.g. `\"UI Builder › Planner › Grounding\"`) — and interleaved by their original timestamps within the subagent.started→completed/failed bracket. These are the per-attempt/per-failure signals that do NOT appear among the sub-agent\\'s (hoisted) messages: a malformed/empty attempt that gets retried produces no message, and the stale-vs-hallucinated split and streak counts live only on the event. A sub-agent\\'s high-volume, message-derivable events (turn.start/turn.end, provider.selected, context.updated) are intentionally NOT merged — read its hoisted messages for model/tokens/cost and turn-by-turn activity, and the bracketing subagent.* events for the run\\'s span.',\n  \"`meta` holds context captured at export time: agentSummary (full agent configs), context (active model, contextTokens/contextLimit/contextUsagePercent for the last call, and the session totals — sessionCostUsd, sessionTokensConsumed, and the four-bucket sessionUsage lifted to the top of this log), activeDebugSnapshot (the active agent's `getDebugSnapshot()` taken fresh at export — reflects state NOW, which may have advanced beyond the last turn's agentSnapshot), debug (optional host-supplied debug state), host, and the export timestamp.\",\n  'Note the two different scopes in `meta.context`: `contextTokens` is the prompt size of the LAST call (against `contextLimit`, the model context window), while `sessionUsage`/`sessionTokensConsumed` are cumulative BILLED throughput. Every turn resends the conversation, so the cumulative figure counts each turn’s prompt again in the next turn’s and is expected to dwarf the context size — that is not double-counting.',\n  \"kind:'event' type 'routing.decided' — how ONE turn was routed, emitted by the orchestrating driver before the agent runs (and again after every handoff). `decision` is why that agent was chosen: 'classified' (the classifier ran and picked one), 'no-match' (it ran and answered -1 — nothing listed covers the request), 'ballot-exhausted' (every eligible specialist had already handed off this turn, so the ballot was empty and NO call was made — distinct from 'no-match', where one ran and declined), 'pinned' (a user pin or an active stateful flow owned the turn, so no call was made), 'single-candidate'/'no-specialists' (configuration left nothing to decide), 'provider-unavailable' (the registry default exposes no chat()), 'classifier-failed' (every attempt threw — `error` carries the last one). `to` names the agent and `fallback` says whether that agent is the fallback. `candidates` is what was actually ON THE BALLOT, in ballot order, so `index` — the classifier's own answer — indexes it directly; `excluded` names the specialists left off because they already handed off this turn, so the full eligible set is `candidates` ∪ `excluded`. `candidates` is absent on the four decisions that put nothing to a vote — 'pinned', 'single-candidate', 'no-specialists', 'ballot-exhausted'. It IS present on 'provider-unavailable', which is not an exception worth removing: the ballot was built there, it simply never got sent. `attempts` covers the retry ladder. `durationMs` is on EVERY routing.decided, and is the field to read when a decision looks wrong: the four decisions that can reach the fallback are told apart by the clock as much as by their name, because a fallback routing that resolved in tens of milliseconds made no network call at all whatever its `decision` says.\",\n  \"kind:'event' type 'routing.decided'.`usage` — what that classifier call cost, in the same four-bucket + costUsd shape as `sessionUsage`, plus `model`. Absent on the decisions that make no call (see 'pinned' and the configuration ones). THIS SPEND IS NOT IN `sessionUsage`: a classifier call never enters the transcript and `sessionUsage` is derived from the transcript, so classifier cost is missing from the session total by construction, not by accident. Sum these events to close that gap — it is the one component of a session's real spend that the totals cannot see.\",\n  'To debug a failure: find the last turn.error or tool.failed, then read upward for the user message, the turn(s), and the agent/provider/state events that led into it. For a turn that went to the wrong agent, read its routing.decided first — `decision` says whether anything was actually asked.',\n]",
+          "default": "[\n  'This is an exported debug log for the Genesis AI assistant. Read it top-to-bottom.',\n  \"`sessionUsage` is what this session spent: `costUsd` (USD, provider-reported per request and summed, cache discounts already applied) plus the four TOKEN BUCKETS — `uncachedInputTokens`, `cacheReadTokens`, `cacheWriteTokens`, `outputTokens`. Those four are disjoint and safe to add up for a total-tokens figure; the per-message fields further down are NOT (see kind:'message'). Each bucket bills at a different rate — cache reads a fraction of uncached input, cache writes a premium, output highest — so a big token count against a small cost means the prompt was mostly cache hits, not a missing charge. It covers sub-agent turns and spend a compaction banked, so for the CONVERSATION it is the authoritative total: prefer it over re-summing the timeline, which can be short by whatever the ring buffers evicted. The same figures appear under `meta.context`. It is as current as the snapshot it came from: the assistant's own download stamps a fresh one, but a log stitched by another tool can carry an older one — compare `meta.timestamp` with the last timeline entry, and if it is well behind, read these totals as historical and fall back to summing the timeline. One scope caveat: it is derived from the transcript, so it excludes billed calls that produced no message (a blank or refused attempt that was retried — see kind:'turn'.`usage`). Summing the turns can therefore come out HIGHER than this, and the difference is exactly that discarded spend, not a double-count.\",\n  \"What 'session' means for those figures: the CURRENT conversation under this session key (a host-supplied per-project id, or the element id + header title when the host supplies none) — which is not necessarily everything in `timeline`. It is re-derived from the live transcript, so it spans page loads only when the chat is being remembered, and a Clear resets it to zero. `timeline` is append-only regardless: it keeps every page load and the pre-Clear conversation, with the session.cleared event as the boundary. So on a long-lived log, read these totals as the latest conversation's and the earlier sections as history — not as a total of the whole file.\",\n  '`timeline` is the entire session as one array, already sorted chronologically by `timestamp` (ISO 8601). Every entry has a `kind`.',\n  '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.',\n  \"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, where `inputTokens` is the WHOLE prompt for that request and `cacheReadTokens`/`cacheWriteTokens` BREAK IT DOWN rather than add to it — uncached input is `inputTokens` minus those two, and adding the cache fields to `inputTokens` counts the prompt twice. The cache fields are absent on providers that report no cache split (Gemini reports reads only, since implicit caching bills no write) and on messages persisted before they existed, so read them as 0 when missing. Each bucket bills at a different rate — cache reads a fraction of uncached input, cache writes a premium, output highest — so a large token count at a small cost means the prompt was mostly cache hits. `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. An echo of an answer an interceptor (such as an autopilot) gave is NOT synthetic-user: see the delegated-messages paragraph.\",\n  \"Delegated messages (GENC-1660): a message with a `delegate` field was written or sent ON THE USER'S BEHALF by a driver decorator, and `delegate` names it (e.g. autopilot). The platform stamps it; nothing else can. It renders as the assistant whatever its role. A delegated `user` message was NOT typed by the user: it is an answer given on their behalf, and the model read it with `delegateFraming` in brackets in front of the content (the stored `content` is the bare text). A delegated `assistant` message is display-only (`excludeFromProvider`): the decorator's narration, or the echo of a widget answer it gave, which takes the place of a synthetic-user echo. To tell what the person decided from what was decided for them, read `interaction.answeredBy` and these fields, never the role alone.\",\n  \"Sub-agent messages appear inline. When a tool delegates to a sub-agent (via `requestSubAgent`), the sub-agent's whole conversation — its own assistant/tool messages, each with their own `content`/`thinking`/`toolCalls`/`toolResult` and per-message `model`/`providerName`/`inputTokens`/`outputTokens`/`cacheReadTokens`/`cacheWriteTokens`/`cost` — is hoisted into the timeline as ordinary kind:'message' entries, interleaved by timestamp right after the tool call that spawned them (so you read the delegation top-to-bottom). A hoisted entry is marked: `subAgentDepth` is its delegation depth (1 for a sub-agent, 2 for a sub-agent's sub-agent, …), `subAgentOf` is the id of the parent tool call that spawned it (correlates it back even when two sub-agents run in one parent turn), `subAgentName` is the sub-agent's own name, and `agentName` is rewritten to a `\\\"<parent> › <sub-agent>\\\"` breadcrumb (composing when nested, e.g. `\\\"UI Builder › Planner › Grounding\\\"`). The sub-agent's per-LLM-call snapshots also surface as kind:'turn' entries with an N-M `turnIndex`, and subagent.started/completed (or subagent.failed) events bracket the run. Per-message `cost` on hoisted entries is already part of the session total (it is summed from the un-flattened history), so summing the top-level timeline does NOT double-count.\",\n  \"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.\",\n  \"kind:'turn'.`model`/`providerName`/`provider` — which model ran that call: the concrete model id, the registry slot it resolved under (a tier name like 'high'/'low', or the default), and the vendor. Recorded per CALL, so an agent whose `provider` selector varies by state — a flow that plans on a high tier and executes on a low one — has every step attributed, including calls that produced no message. `model` is the SERVING model where the provider reports one, so a turn answered by a server-side fallback names the model that answered rather than the one requested; it always matches the `model` on the message that call produced. Absent when the provider exposes no `getStatus` and the transport stamped nothing.\",\n  \"kind:'turn'.`usage` — what that ONE call cost, in the same four-bucket + `costUsd` shape as `sessionUsage`. Absent while a call is in flight and on providers that report no usage. This is the SAME money as the message the call produced, not extra money: never add turn usage to message usage, and read a turn plus its message as one charge. Its distinct value is the calls that produced NO message — a blank or refused response is billed and then discarded before the retry, so the turn entry is the only record of that spend, and a turn with `usage` but no message after it is exactly that. `costUsd: 0` alongside a nonzero token count means the provider reported no price, not that the call was free.\",\n  \"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.\",\n  \"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'.\",\n  \"Each 'event' also has an `importance`: 'high' (failures/limits — turn.error, tool.failed, subagent.failed, file.read-failed, suggestions.failed, context.threshold-crossed), 'normal' (session flow — connects, turns, retries, handoffs, agent/provider changes, interactions, sub-agent start/complete), or 'low' (skippable UI/bookkeeping noise — panel.toggled, attachment.added, driver.wired/unwired, context.updated, context.condensed). To skim, ignore importance:'low'; to triage a failure, filter to importance:'high' then read the nearby messages and turns. A 'high' turn.error is often preceded by one or more 'normal' turn.retry events for the same reason — read them together to see how many attempts were made before bailing. 'message' and 'turn' entries carry no importance — they are the substance, always read them.\",\n  'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations/response-truncated/refusal/budget-exhausted/provider-refused/context-exhausted/ai-service-error, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, for response-truncated the model + maxTokens + outputTokens + tools, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, for budget-exhausted the budgetUsd + spentUsd figures reported by the proxy plus the resolved vendor, for provider-refused the kind (spend|auth) plus the upstream status and error type — the vendor refusing the ACCOUNT rather than us refusing to spend, so the remedy is a top-up or a key rotation rather than a raised cap, and the kind is the only place that distinction survives because the user-facing copy is deliberately cause-free, for context-exhausted the estimated contextTokens against the guard that stopped the turn plus the iterations reached — the driver ending a runaway tool loop at the edge of the context window rather than issuing a request the provider would reject, so the transcript survives intact and can still be compacted, for ai-service-error the code (one of AI_SERVICE_ERROR_CODES, e.g. NO_API_KEY) and the status the AI service answered with — its own text goes to the browser console only, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout/response_truncated/refusal/budget_exhausted/provider_refused/context_exhausted/ai_service_error; budget_exhausted and provider_refused are terminal for the PARENT turn too, and so is ai_service_error when the refusal is about the service rather than the request and came from the vendor the parent calls — the parent stops rather than calling the model again into the same wall; after context_exhausted the parent goes on, but its own next call is likely to stop on the same guard), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), routing.decided (ONE PER ROUTING DECISION — see its own paragraph below), provider.selected (the resolved provider for the upcoming turns — detail.provider is the registry SLOT/tier name, detail.model the concrete model behind it and detail.vendor its vendor; emitted only when the slot CHANGES, so read the per-turn `model` for the model of any given call rather than assuming the nearest event still applies), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver; detail.ownerPath names the agents that actually asked, outermost first, the last being the one whose tool requested it, and detail.heldBy says who held it when it opened: user, or the id of the interceptor that claimed it, such as autopilot; on interaction.resolved, detail.answeredBy is who answered — the claimant id when it settled through its own hold, user for any other answer (a click counts as the person even on a widget a claimant held) — absent when it closed unanswered (a timeout or a stop); the same value is stamped on the interaction message as answeredBy, and when it is not user the tool result that interaction returned carries a decidedOnUsersBehalf record, so the model was told the choice was not made by the person), interaction.held (a claimant moved a pending interaction to the person or back to itself — detail.heldBy is the new holder, detail.claimant the interceptor; a widget held by anything but user was not answered by the person), interaction.claim-refused (a claim on a userOnly interaction, which stays with the person — detail.claimant + reason), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',\n  'Sub-agent meta events: a sub-agent\\'s own turn.retry/turn.error/tool.failed/tool.unresolved events are merged into this same timeline, tagged with `detail.subAgent` — a `\"<parent> › <sub-agent>\"` breadcrumb that composes when nested (e.g. `\"UI Builder › Planner › Grounding\"`) — and interleaved by their original timestamps within the subagent.started→completed/failed bracket. These are the per-attempt/per-failure signals that do NOT appear among the sub-agent\\'s (hoisted) messages: a malformed/empty attempt that gets retried produces no message, and the stale-vs-hallucinated split and streak counts live only on the event. A sub-agent\\'s high-volume, message-derivable events (turn.start/turn.end, provider.selected, context.updated) are intentionally NOT merged — read its hoisted messages for model/tokens/cost and turn-by-turn activity, and the bracketing subagent.* events for the run\\'s span.',\n  \"`meta` holds context captured at export time: agentSummary (full agent configs), context (active model, contextTokens/contextLimit/contextUsagePercent for the last call, and the session totals — sessionCostUsd, sessionTokensConsumed, and the four-bucket sessionUsage lifted to the top of this log), activeDebugSnapshot (the active agent's `getDebugSnapshot()` taken fresh at export — reflects state NOW, which may have advanced beyond the last turn's agentSnapshot), debug (optional host-supplied debug state), host, and the export timestamp.\",\n  'Note the two different scopes in `meta.context`: `contextTokens` is the prompt size of the LAST call (against `contextLimit`, the model context window), while `sessionUsage`/`sessionTokensConsumed` are cumulative BILLED throughput. Every turn resends the conversation, so the cumulative figure counts each turn’s prompt again in the next turn’s and is expected to dwarf the context size — that is not double-counting.',\n  \"kind:'event' type 'routing.decided' — how ONE turn was routed, emitted by the orchestrating driver before the agent runs (and again after every handoff). `decision` is why that agent was chosen: 'classified' (the classifier ran and picked one), 'no-match' (it ran and answered -1 — nothing listed covers the request), 'ballot-exhausted' (every eligible specialist had already handed off this turn, so the ballot was empty and NO call was made — distinct from 'no-match', where one ran and declined), 'pinned' (a user pin or an active stateful flow owned the turn, so no call was made), 'single-candidate'/'no-specialists' (configuration left nothing to decide), 'provider-unavailable' (the registry default exposes no chat()), 'classifier-failed' (every attempt threw — `error` carries the last one). `to` names the agent and `fallback` says whether that agent is the fallback. `candidates` is what was actually ON THE BALLOT, in ballot order, so `index` — the classifier's own answer — indexes it directly; `excluded` names the specialists left off because they already handed off this turn, so the full eligible set is `candidates` ∪ `excluded`. `candidates` is absent on the four decisions that put nothing to a vote — 'pinned', 'single-candidate', 'no-specialists', 'ballot-exhausted'. It IS present on 'provider-unavailable', which is not an exception worth removing: the ballot was built there, it simply never got sent. `attempts` covers the retry ladder. `durationMs` is on EVERY routing.decided, and is the field to read when a decision looks wrong: the four decisions that can reach the fallback are told apart by the clock as much as by their name, because a fallback routing that resolved in tens of milliseconds made no network call at all whatever its `decision` says.\",\n  \"kind:'event' type 'routing.decided'.`usage` — what that classifier call cost, in the same four-bucket + costUsd shape as `sessionUsage`, plus `model`. Absent on the decisions that make no call (see 'pinned' and the configuration ones). THIS SPEND IS NOT IN `sessionUsage`: a classifier call never enters the transcript and `sessionUsage` is derived from the transcript, so classifier cost is missing from the session total by construction, not by accident. Sum these events to close that gap — it is the one component of a session's real spend that the totals cannot see.\",\n  'To debug a failure: find the last turn.error or tool.failed, then read upward for the user message, the turn(s), and the agent/provider/state events that led into it. For a turn that went to the wrong agent, read its routing.decided first — `decision` says whether anything was actually asked.',\n]",
           "description": "Human/agent-facing guide emitted as the first key of the exported debug log,\nso whoever opens the JSON (often an AI agent) knows how to read it without\nreverse-engineering the shape. Kept here next to the event catalogue it\ndescribes — but proximity alone demonstrably did NOT keep the two in sync\n(`refusal` was missing from both reason lists for a whole release), so\n`debug-event-log.test.ts` now asserts that every `TurnFailureReason` and every\n`SubAgentFailureReason` is named here, and fails the build when one is added\nwithout a matching sentence. Enumerations below read as exhaustive and WILL be\ntrusted by an agent reading the JSON — keep them so."
         }
       ],
@@ -8038,12 +8142,24 @@
       "declarations": [],
       "exports": []
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/types/handler-capability.ts",
+      "declarations": [],
+      "exports": []
+    },
     {
       "kind": "javascript-module",
       "path": "src/types/interaction-context.ts",
       "declarations": [],
       "exports": []
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/types/interaction-interceptor.ts",
+      "declarations": [],
+      "exports": []
+    },
     {
       "kind": "javascript-module",
       "path": "src/utils/agents-key.ts",
@@ -8965,6 +9081,57 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/utils/delegated-message.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "isDelegated",
+          "return": {
+            "type": {
+              "text": "message is DelegatedMessage"
+            }
+          },
+          "parameters": [
+            {
+              "name": "message",
+              "type": {
+                "text": "ChatMessage"
+              }
+            }
+          ],
+          "description": "Whether `message` was written or sent on the user's behalf. A delegated message renders as the\nassistant, whatever its role."
+        },
+        {
+          "kind": "variable",
+          "name": "DEFAULT_DELEGATE_FRAMING",
+          "type": {
+            "text": "string"
+          },
+          "default": "\"Sent on the user's behalf.\"",
+          "description": "How a delegated `user` message is framed for the model when its sender gives no phrase. Names no\ndecorator, so the model has none to repeat."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "isDelegated",
+          "declaration": {
+            "name": "isDelegated",
+            "module": "src/utils/delegated-message.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "DEFAULT_DELEGATE_FRAMING",
+          "declaration": {
+            "name": "DEFAULT_DELEGATE_FRAMING",
+            "module": "src/utils/delegated-message.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/utils/derive-cost-session-title.ts",
@@ -10908,6 +11075,25 @@
               },
               "description": "Release the active agent: fire `onDeactivate` and drop the flow lock.\n\nThe user pin is intentionally **not** cleared — someone who explicitly picked this agent\nshould stay on it after the flow ends, so the next message starts a fresh flow on the same\nagent rather than routing through the classifier.\n\nReturns `undefined` when there was no active agent, so a caller can skip its events."
             },
+            {
+              "kind": "method",
+              "name": "reportTransition",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "transition",
+                  "type": {
+                    "text": "AgentTransition"
+                  }
+                }
+              ],
+              "description": "Hand a transition to the owner. A throwing listener is logged rather than propagated, for the\nsame reason a throwing hook is: the transition has already happened, and failing the caller\nwould leave it believing it had not."
+            },
             {
               "kind": "method",
               "name": "dispose",
@@ -10975,135 +11161,809 @@
     {
       "kind": "javascript-module",
       "path": "src/components/ai-driver/ai-driver.ts",
-      "declarations": [],
-      "exports": []
-    },
-    {
-      "kind": "javascript-module",
-      "path": "src/components/ai-driver/index.ts",
-      "declarations": [],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "AiDriver",
-          "declaration": {
-            "name": "AiDriver",
-            "module": "./ai-driver"
-          }
-        }
-      ]
-    },
-    {
-      "kind": "javascript-module",
-      "path": "src/components/ai-driver/stub-driver.ts",
-      "declarations": [],
-      "exports": []
-    },
-    {
-      "kind": "javascript-module",
-      "path": "src/components/chat-bubble/chat-bubble.styles.ts",
       "declarations": [
         {
           "kind": "variable",
-          "name": "styles",
-          "default": "css`\n  :host {\n    position: fixed;\n    inset: 0;\n    pointer-events: none;\n    z-index: 9999;\n    overflow: visible;\n  }\n\n  :host([hidden]) {\n    display: none;\n  }\n\n  .bubble {\n    position: absolute;\n    width: 62px;\n    height: 62px;\n    border-radius: 50%;\n    cursor: grab;\n    pointer-events: all;\n    overflow: visible;\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    user-select: none;\n    transition:\n      transform 0.25s cubic-bezier(0.34, 1.56, 0.64, 1),\n      box-shadow 0.25s ease;\n    background: linear-gradient(135deg, #0e1628 0%, #192340 100%);\n    box-shadow: 0 4px 20px rgb(0 0 0 / 45%);\n    border: 2px solid rgb(255 255 255 / 15%);\n    color: white;\n  }\n\n  .bubble img {\n    width: 62px;\n    height: 62px;\n    border-radius: 50%;\n    object-fit: cover;\n    pointer-events: none;\n    box-shadow: 0 4px 20px rgb(0 0 0 / 45%);\n    border: 2px solid rgb(255 255 255 / 15%);\n  }\n\n  .bubble svg {\n    pointer-events: none;\n  }\n\n  .bubble:hover,\n  .bubble.hovered {\n    transform: scale(1.18);\n  }\n\n  .bubble:hover img,\n  .bubble.hovered img {\n    box-shadow:\n      0 6px 32px rgb(0 100 255 / 55%),\n      0 0 0 3px rgb(0 120 255 / 35%);\n  }\n\n  .bubble:active {\n    cursor: grabbing;\n  }\n\n  .tooltip {\n    position: absolute;\n    bottom: calc(100% + 10px);\n    background: linear-gradient(135deg, #0078ff 0%, #0050d0 100%);\n    color: #fff;\n    font-size: 0.78em;\n    font-weight: 600;\n    letter-spacing: 0.03em;\n    white-space: nowrap;\n    padding: 5px 10px;\n    border-radius: 8px;\n    box-shadow: 0 4px 14px rgb(0 120 255 / 45%);\n    pointer-events: none;\n    opacity: 0%;\n    translate: 0 4px;\n    transition:\n      opacity 0.18s ease,\n      translate 0.18s ease;\n  }\n\n  .tooltip::after {\n    content: '';\n    position: absolute;\n    top: 100%;\n    left: var(--arrow-left, 50%);\n    transform: translateX(-50%);\n    border: 5px solid transparent;\n    border-top-color: #0050d0;\n  }\n\n  .bubble:hover .tooltip,\n  .bubble.hovered .tooltip {\n    opacity: 100%;\n    translate: 0 0;\n  }\n\n  .pulse-ring {\n    position: absolute;\n    width: 62px;\n    height: 62px;\n    border-radius: 50%;\n    border: 2px solid rgb(0 120 255 / 50%);\n    animation: pulse 2.5s ease-out infinite;\n    pointer-events: none;\n  }\n\n  @keyframes pulse {\n    0% {\n      transform: scale(1);\n      opacity: 70%;\n    }\n\n    70% {\n      transform: scale(1.5);\n      opacity: 0%;\n    }\n\n    100% {\n      transform: scale(1.5);\n      opacity: 0%;\n    }\n  }\n\n  .dialog {\n    position: absolute;\n    box-sizing: border-box;\n    width: 400px;\n    height: 520px;\n    min-width: 300px;\n    min-height: 300px;\n    max-width: 50vw;\n    max-height: calc(100vh - 40px);\n    background: var(--neutral-layer-1);\n    border-radius: 14px;\n    box-shadow:\n      0 12px 50px rgb(0 0 0 / 55%),\n      0 0 0 1px rgb(255 255 255 / 6%);\n    pointer-events: all;\n    display: flex;\n    flex-direction: column;\n    overflow: hidden;\n    resize: both;\n    border: 1px solid var(--neutral-stroke-rest);\n    animation: dialog-in 0.25s cubic-bezier(0.34, 1.56, 0.64, 1);\n  }\n\n  @keyframes dialog-in {\n    from {\n      opacity: 0%;\n      transform: scale(0.85) translateY(12px);\n    }\n\n    to {\n      opacity: 100%;\n      transform: scale(1) translateY(0);\n    }\n  }\n\n  @keyframes dialog-out {\n    from {\n      opacity: 100%;\n      transform: scale(1) translateY(0);\n    }\n\n    to {\n      opacity: 0%;\n      transform: scale(0.85) translateY(12px);\n    }\n  }\n\n  .dialog.closing {\n    animation: dialog-out 0.2s cubic-bezier(0.4, 0, 0.6, 1) forwards;\n  }\n\n  .dialog-content {\n    flex: 1;\n    overflow: hidden;\n    display: flex;\n    min-height: 0;\n  }\n\n  .dialog-content ::slotted(*) {\n    display: flex;\n    flex: 1;\n    width: 100%;\n    min-height: 0;\n  }\n`"
-        }
-      ],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "styles",
-          "declaration": {
-            "name": "styles",
-            "module": "src/components/chat-bubble/chat-bubble.styles.ts"
-          }
-        }
-      ]
-    },
-    {
-      "kind": "javascript-module",
-      "path": "src/components/chat-bubble/chat-bubble.template.ts",
-      "declarations": [
-        {
-          "kind": "function",
-          "name": "AiChatBubbleTemplate",
-          "return": {
-            "type": {
-              "text": "ViewTemplate<AiChatBubble>"
-            }
-          }
+          "name": "AI_DRIVER_EVENT_TYPES",
+          "description": "The event types in AiDriverEventMap, as a runtime list. Built from a record keyed by the\nmap, so adding an event to the map without adding it here is a compile error."
         }
       ],
       "exports": [
         {
           "kind": "js",
-          "name": "AiChatBubbleTemplate",
+          "name": "AI_DRIVER_EVENT_TYPES",
           "declaration": {
-            "name": "AiChatBubbleTemplate",
-            "module": "src/components/chat-bubble/chat-bubble.template.ts"
+            "name": "AI_DRIVER_EVENT_TYPES",
+            "module": "src/components/ai-driver/ai-driver.ts"
           }
         }
       ]
     },
     {
       "kind": "javascript-module",
-      "path": "src/components/chat-bubble/chat-bubble.ts",
+      "path": "src/components/ai-driver/base-driver-decorator.ts",
       "declarations": [
         {
           "kind": "class",
-          "description": "Floating chat bubble component that provides a draggable orb and dialog panel\nfor embedding an AI assistant without a full-page layout.",
-          "name": "AiChatBubble",
+          "description": "The base of every driver decorator (GENC-1660): an AiDriver that wraps another and\npasses every member, and every event in AiDriverEventMap, through to it.\n\nA decorator extends this and overrides only what it changes, so decorators stack in any order\nand a member or event added to `AiDriver` reaches the host through every layer by default.\n`OrchestratingDriver` is one; it used to forward by hand, and twice a member it did not forward\nsilently did nothing for every multi-agent host (`recordExternalCost`, then\n`getHistoryForPersistence`).\n\nAbstract with no abstract members, so it cannot be constructed on its own: a decorator that\nchanges nothing is not one.\n\nOptional `AiDriver` members are implemented here unconditionally, as a forward that falls back\nto the \"not supported\" answer when the inner driver lacks them. A host that feature-detects with\n`?.` therefore always finds them, and gets the same answer it would from the inner driver.",
+          "name": "BaseDriverDecorator",
           "members": [
             {
               "kind": "field",
-              "name": "title",
-              "type": {
-                "text": "string"
-              },
-              "default": "'AI Assistant'"
-            },
-            {
-              "kind": "field",
-              "name": "imageSrc",
-              "type": {
-                "text": "string | undefined"
-              }
-            },
-            {
-              "kind": "field",
-              "name": "designSystemPrefix",
+              "name": "detachers",
               "type": {
-                "text": "string"
+                "text": "Array<() => void>"
               },
-              "default": "'rapid'"
+              "privacy": "private",
+              "readonly": true,
+              "default": "[]",
+              "description": "Undoes this layer's hold on its inner driver; see BaseDriverDecorator.detach."
             },
             {
-              "kind": "field",
-              "name": "bubbleLeft",
-              "type": {
-                "text": "number"
+              "kind": "method",
+              "name": "detach",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
               },
-              "default": "0",
-              "description": "Current left position of the bubble orb (px from viewport left). @internal"
+              "description": "Let go of the inner driver WITHOUT disposing it: stop forwarding its events, and undo whatever\na subclass registered through BaseDriverDecorator.onDetach (its interceptors, its\ncapabilities, its own listeners). For dropping or replacing a decorator while the driver it\nwrapped lives on — otherwise the old layer keeps re-dispatching every event and is never\ncollected. Idempotent. `dispose()` detaches too."
             },
             {
-              "kind": "field",
-              "name": "bubbleTop",
-              "type": {
-                "text": "number"
+              "kind": "method",
+              "name": "onDetach",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
               },
-              "default": "0",
-              "description": "Current top position of the bubble orb (px from viewport top). @internal"
+              "parameters": [
+                {
+                  "name": "undo",
+                  "type": {
+                    "text": "() => void"
+                  }
+                }
+              ],
+              "description": "Register something BaseDriverDecorator.detach must undo."
             },
             {
-              "kind": "field",
-              "name": "dialogLeft",
-              "type": {
-                "text": "number"
+              "kind": "method",
+              "name": "sendMessage",
+              "return": {
+                "type": {
+                  "text": "Promise<ChatDriverResult>"
+                }
               },
-              "default": "0",
-              "description": "Current left position of the dialog panel (px from viewport left). @internal"
-            },
+              "parameters": [
+                {
+                  "name": "input",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "attachments",
+                  "optional": true,
+                  "type": {
+                    "text": "ChatAttachment[]"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "SendMessageOptions"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "continueFromHistory",
+              "return": {
+                "type": {
+                  "text": "Promise<ChatDriverResult>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "transientPrimer",
+                  "optional": true,
+                  "type": {
+                    "text": "ChatMessage[]"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "ContinueFromHistoryOptions"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "resolveInteraction",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "interactionId",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "result",
+                  "type": {
+                    "text": "unknown"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "recordExternalCost",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "interactionId",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "costUsd",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "getInteractionContext",
+              "return": {
+                "type": {
+                  "text": "InteractionContext | undefined"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "interactionId",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "loadHistory",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "messages",
+                  "type": {
+                    "text": "ChatMessage[]"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "primeRestoredAgentState",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "snapshots",
+                  "type": {
+                    "text": "Record<string, unknown>"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "canRestoreFlowOwner",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "agentName",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "canResumeRestoredFlow",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "agentName",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "resumeRestoredFlow",
+              "return": {
+                "type": {
+                  "text": "Promise<ChatDriverResult | undefined>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "resumeNote",
+                  "optional": true,
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "agent",
+                  "optional": true,
+                  "type": {
+                    "text": "AgentConfig"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "getRawHistory",
+              "return": {
+                "type": {
+                  "text": "readonly ChatMessage[]"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "getHistoryForPersistence",
+              "return": {
+                "type": {
+                  "text": "ChatMessage[]"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "getCondensePoliciesForPersistence",
+              "return": {
+                "type": {
+                  "text": "PersistedCondensePolicy[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "messages",
+                  "type": {
+                    "text": "readonly ChatMessage[]"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "restoreCondensePolicies",
+              "return": {
+                "type": {
+                  "text": "{\n    restored: number;\n    awaitingReactivation: number;\n  }"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "entries",
+                  "type": {
+                    "text": "readonly unknown[] | undefined"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "getActiveAgent",
+              "return": {
+                "type": {
+                  "text": "AgentConfig | undefined"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "setPinnedAgent",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string | null"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "setFlowOwner",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string | null"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "getFlowOwner",
+              "return": {
+                "type": {
+                  "text": "string | null"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "addInteractionInterceptor",
+              "return": {
+                "type": {
+                  "text": "() => void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "interceptor",
+                  "type": {
+                    "text": "InteractionInterceptor"
+                  }
+                }
+              ],
+              "description": "Forwarded, so an interceptor installed on any layer lands on the driver that opens the\ninteractions. A decorator that answers interactions installs its own on `this.inner`."
+            },
+            {
+              "kind": "method",
+              "name": "presentInteraction",
+              "return": {
+                "type": {
+                  "text": "Promise<T>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "componentName",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "data",
+                  "type": {
+                    "text": "unknown"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "InteractionRequestOptions"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "provideHandlerCapability",
+              "return": {
+                "type": {
+                  "text": "() => void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "factory",
+                  "type": {
+                    "text": "HandlerCapabilityFactory"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "getContextReserve",
+              "return": {
+                "type": {
+                  "text": "ContextReserveResolution | undefined"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "getPreambleTokens",
+              "return": {
+                "type": {
+                  "text": "number | undefined"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "setContextGuard",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "policy",
+                  "optional": true,
+                  "type": {
+                    "text": "ContextGuardPolicy"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "compact",
+              "return": {
+                "type": {
+                  "text": "Promise<ChatMessage | null>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "CompactionPlanOptions"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "getCompactionPlan",
+              "return": {
+                "type": {
+                  "text": "CompactionProjection | null"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "CompactionPlanOptions"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "canCompact",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "CompactionPlanOptions"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "isBusy",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "getSuggestions",
+              "return": {
+                "type": {
+                  "text": "Promise<string[]>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "history",
+                  "type": {
+                    "text": "ChatMessage[]"
+                  }
+                },
+                {
+                  "name": "prompt",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "count",
+                  "type": {
+                    "text": "number"
+                  }
+                },
+                {
+                  "name": "allAgentInfo",
+                  "optional": true,
+                  "type": {
+                    "text": "AllAgentSummary[]"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "getTurnSnapshots",
+              "return": {
+                "type": {
+                  "text": "ReadonlyArray<TurnSnapshot>"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "getExternalDiagnostics",
+              "return": {
+                "type": {
+                  "text": "ReadonlyArray<DiagnosticEntry>"
+                }
+              },
+              "description": "The inner driver's entries. Diagnostics compose down the stack: a decorator with entries of\nits own overrides this and appends them to `super.getExternalDiagnostics()`."
+            },
+            {
+              "kind": "method",
+              "name": "getActiveProviderName",
+              "return": {
+                "type": {
+                  "text": "string"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "dispose",
+              "return": {
+                "type": {
+                  "text": "void | Promise<void>"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "cancel",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              }
+            }
+          ],
+          "superclass": {
+            "name": "EventTarget",
+            "module": "src/components/ai-driver/base-driver-decorator.ts"
+          }
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "BaseDriverDecorator",
+          "declaration": {
+            "name": "BaseDriverDecorator",
+            "module": "src/components/ai-driver/base-driver-decorator.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/components/ai-driver/index.ts",
+      "declarations": [],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "AiDriver",
+          "declaration": {
+            "name": "AiDriver",
+            "module": "./ai-driver"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AiDriverEventMap",
+          "declaration": {
+            "name": "AiDriverEventMap",
+            "module": "./ai-driver"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AI_DRIVER_EVENT_TYPES",
+          "declaration": {
+            "name": "AI_DRIVER_EVENT_TYPES",
+            "module": "./ai-driver"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "BaseDriverDecorator",
+          "declaration": {
+            "name": "BaseDriverDecorator",
+            "module": "./base-driver-decorator"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/components/ai-driver/stub-driver.ts",
+      "declarations": [],
+      "exports": []
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/components/chat-bubble/chat-bubble.styles.ts",
+      "declarations": [
+        {
+          "kind": "variable",
+          "name": "styles",
+          "default": "css`\n  :host {\n    position: fixed;\n    inset: 0;\n    pointer-events: none;\n    z-index: 9999;\n    overflow: visible;\n  }\n\n  :host([hidden]) {\n    display: none;\n  }\n\n  .bubble {\n    position: absolute;\n    width: 62px;\n    height: 62px;\n    border-radius: 50%;\n    cursor: grab;\n    pointer-events: all;\n    overflow: visible;\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    user-select: none;\n    transition:\n      transform 0.25s cubic-bezier(0.34, 1.56, 0.64, 1),\n      box-shadow 0.25s ease;\n    background: linear-gradient(135deg, #0e1628 0%, #192340 100%);\n    box-shadow: 0 4px 20px rgb(0 0 0 / 45%);\n    border: 2px solid rgb(255 255 255 / 15%);\n    color: white;\n  }\n\n  .bubble img {\n    width: 62px;\n    height: 62px;\n    border-radius: 50%;\n    object-fit: cover;\n    pointer-events: none;\n    box-shadow: 0 4px 20px rgb(0 0 0 / 45%);\n    border: 2px solid rgb(255 255 255 / 15%);\n  }\n\n  .bubble svg {\n    pointer-events: none;\n  }\n\n  .bubble:hover,\n  .bubble.hovered {\n    transform: scale(1.18);\n  }\n\n  .bubble:hover img,\n  .bubble.hovered img {\n    box-shadow:\n      0 6px 32px rgb(0 100 255 / 55%),\n      0 0 0 3px rgb(0 120 255 / 35%);\n  }\n\n  .bubble:active {\n    cursor: grabbing;\n  }\n\n  .tooltip {\n    position: absolute;\n    bottom: calc(100% + 10px);\n    background: linear-gradient(135deg, #0078ff 0%, #0050d0 100%);\n    color: #fff;\n    font-size: 0.78em;\n    font-weight: 600;\n    letter-spacing: 0.03em;\n    white-space: nowrap;\n    padding: 5px 10px;\n    border-radius: 8px;\n    box-shadow: 0 4px 14px rgb(0 120 255 / 45%);\n    pointer-events: none;\n    opacity: 0%;\n    translate: 0 4px;\n    transition:\n      opacity 0.18s ease,\n      translate 0.18s ease;\n  }\n\n  .tooltip::after {\n    content: '';\n    position: absolute;\n    top: 100%;\n    left: var(--arrow-left, 50%);\n    transform: translateX(-50%);\n    border: 5px solid transparent;\n    border-top-color: #0050d0;\n  }\n\n  .bubble:hover .tooltip,\n  .bubble.hovered .tooltip {\n    opacity: 100%;\n    translate: 0 0;\n  }\n\n  .pulse-ring {\n    position: absolute;\n    width: 62px;\n    height: 62px;\n    border-radius: 50%;\n    border: 2px solid rgb(0 120 255 / 50%);\n    animation: pulse 2.5s ease-out infinite;\n    pointer-events: none;\n  }\n\n  @keyframes pulse {\n    0% {\n      transform: scale(1);\n      opacity: 70%;\n    }\n\n    70% {\n      transform: scale(1.5);\n      opacity: 0%;\n    }\n\n    100% {\n      transform: scale(1.5);\n      opacity: 0%;\n    }\n  }\n\n  .dialog {\n    position: absolute;\n    box-sizing: border-box;\n    width: 400px;\n    height: 520px;\n    min-width: 300px;\n    min-height: 300px;\n    max-width: 50vw;\n    max-height: calc(100vh - 40px);\n    background: var(--neutral-layer-1);\n    border-radius: 14px;\n    box-shadow:\n      0 12px 50px rgb(0 0 0 / 55%),\n      0 0 0 1px rgb(255 255 255 / 6%);\n    pointer-events: all;\n    display: flex;\n    flex-direction: column;\n    overflow: hidden;\n    resize: both;\n    border: 1px solid var(--neutral-stroke-rest);\n    animation: dialog-in 0.25s cubic-bezier(0.34, 1.56, 0.64, 1);\n  }\n\n  @keyframes dialog-in {\n    from {\n      opacity: 0%;\n      transform: scale(0.85) translateY(12px);\n    }\n\n    to {\n      opacity: 100%;\n      transform: scale(1) translateY(0);\n    }\n  }\n\n  @keyframes dialog-out {\n    from {\n      opacity: 100%;\n      transform: scale(1) translateY(0);\n    }\n\n    to {\n      opacity: 0%;\n      transform: scale(0.85) translateY(12px);\n    }\n  }\n\n  .dialog.closing {\n    animation: dialog-out 0.2s cubic-bezier(0.4, 0, 0.6, 1) forwards;\n  }\n\n  .dialog-content {\n    flex: 1;\n    overflow: hidden;\n    display: flex;\n    min-height: 0;\n  }\n\n  .dialog-content ::slotted(*) {\n    display: flex;\n    flex: 1;\n    width: 100%;\n    min-height: 0;\n  }\n`"
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "styles",
+          "declaration": {
+            "name": "styles",
+            "module": "src/components/chat-bubble/chat-bubble.styles.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/components/chat-bubble/chat-bubble.template.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "AiChatBubbleTemplate",
+          "return": {
+            "type": {
+              "text": "ViewTemplate<AiChatBubble>"
+            }
+          }
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "AiChatBubbleTemplate",
+          "declaration": {
+            "name": "AiChatBubbleTemplate",
+            "module": "src/components/chat-bubble/chat-bubble.template.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/components/chat-bubble/chat-bubble.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "Floating chat bubble component that provides a draggable orb and dialog panel\nfor embedding an AI assistant without a full-page layout.",
+          "name": "AiChatBubble",
+          "members": [
+            {
+              "kind": "field",
+              "name": "title",
+              "type": {
+                "text": "string"
+              },
+              "default": "'AI Assistant'"
+            },
+            {
+              "kind": "field",
+              "name": "imageSrc",
+              "type": {
+                "text": "string | undefined"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "designSystemPrefix",
+              "type": {
+                "text": "string"
+              },
+              "default": "'rapid'"
+            },
+            {
+              "kind": "field",
+              "name": "bubbleLeft",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "Current left position of the bubble orb (px from viewport left). @internal"
+            },
+            {
+              "kind": "field",
+              "name": "bubbleTop",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "Current top position of the bubble orb (px from viewport top). @internal"
+            },
+            {
+              "kind": "field",
+              "name": "dialogLeft",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "Current left position of the dialog panel (px from viewport left). @internal"
+            },
             {
               "kind": "field",
               "name": "dialogTop",
@@ -12085,6 +12945,23 @@
               "privacy": "private",
               "description": "A sub-agent runs inside its parent's message: the parent's `turnSignal`, handed down."
             },
+            {
+              "kind": "field",
+              "name": "handlerCapabilities",
+              "privacy": "private",
+              "readonly": true,
+              "default": "new Map<string, HandlerCapabilityFactory>()",
+              "description": "Capabilities provided on this driver by decorators (GENC-1660). Only the root's are used."
+            },
+            {
+              "kind": "field",
+              "name": "capabilityParent",
+              "type": {
+                "text": "ChatDriver | undefined"
+              },
+              "privacy": "private",
+              "description": "For a sub-agent's driver, the driver that invoked it: its capabilities, flow owner and owner\npath are the ones this driver's handlers see, so a capability reaches sub-agents unchanged."
+            },
             {
               "kind": "field",
               "name": "activeProviderInput",
@@ -12730,6 +13607,51 @@
               ],
               "description": "Make `config` the active agent, firing its lifecycle hooks — `onDeactivate` on the outgoing\nagent, then `onActivate` on this one — before installing it.\n\nThis is the entry point a host should use. ChatDriver.installAgent installs a config\n*without* firing hooks, which is right for the two callers that need it (the orchestrator,\nwhich fires them through the shared session, and `invokeSubAgent`, where a child's config is\nnot an activation) and wrong for everyone else."
             },
+            {
+              "kind": "method",
+              "name": "resumeRestoredFlow",
+              "return": {
+                "type": {
+                  "text": "Promise<ChatDriverResult | undefined>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "resumeNote",
+                  "optional": true,
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "agent",
+                  "optional": true,
+                  "type": {
+                    "text": "AgentConfig"
+                  }
+                }
+              ],
+              "description": "{@inheritDoc AiDriver.resumeRestoredFlow}\n\nThis driver holds no list of agents, so it resumes only the `agent` it is handed (GENC-1660):\nwhoever runs a bare `ChatDriver` knows which agent that is, and after a reload only the name\nsurvived. Without one it does nothing, as a driver without this member did before; given one\nthat is not the restored flow owner, it refuses.\n\nFor headless callers: the shipped host restores and resumes through `OrchestratingDriver`,\nand a bare `ChatDriver` does not answer `canRestoreFlowOwner`, so the host never plans a resume\nfor one.\n\nThe orchestrator does not delegate here, because it installs a decorated config of its own;\nthis is the bare-driver path."
+            },
+            {
+              "kind": "method",
+              "name": "dispatchAgentTransition",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "t",
+                  "type": {
+                    "text": "AgentTransition"
+                  }
+                }
+              ],
+              "description": "Raise the host-facing lifecycle events for one session transition (GENC-1485), in the order\nthe orchestrator raised them before it stopped doing so itself: the flow lock first, then the\nrelease, then the active agent."
+            },
             {
               "kind": "method",
               "name": "getActiveAgent",
@@ -12794,6 +13716,16 @@
               ],
               "description": "Record the transient flow lock. See AiDriver.setFlowOwner for the contract.\n\nRecorded, not acted on, for the same reason as ChatDriver.setPinnedAgent."
             },
+            {
+              "kind": "method",
+              "name": "getFlowOwner",
+              "return": {
+                "type": {
+                  "text": "string | null"
+                }
+              },
+              "description": "{@inheritDoc AiDriver.getFlowOwner}"
+            },
             {
               "kind": "method",
               "name": "installAgent",
@@ -13396,9 +14328,118 @@
                   "type": {
                     "text": "(interactionId: string) => void"
                   }
+                },
+                {
+                  "name": "innerPath",
+                  "optional": true,
+                  "type": {
+                    "text": "readonly string[]"
+                  }
+                },
+                {
+                  "name": "onSettled",
+                  "optional": true,
+                  "type": {
+                    "text": "(settled: InteractionSettled) => void"
+                  }
+                }
+              ],
+              "description": "Request a custom UI interaction. Emits a new message with the interaction.\nTool handlers can call this to pause execution until the user completes the UI interaction.\n\nIf a host requester is wired (sub-agent case), the call delegates upward\nso the interaction lives on the parent — the main UI is only listening to\nthe root driver. Only one interaction may be in flight at any time on a\ngiven root: concurrent calls (e.g. two parallel sub-agents both spawning a\nwidget) throw. Parallel sub-agents are for parallel work, not for user\ninteraction, which is inherently sequential."
+            },
+            {
+              "kind": "method",
+              "name": "addInteractionInterceptor",
+              "return": {
+                "type": {
+                  "text": "() => void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "interceptor",
+                  "type": {
+                    "text": "InteractionInterceptor"
+                  }
+                }
+              ],
+              "description": "{@inheritDoc AiDriver.addInteractionInterceptor}\n\nConsulted only on the root driver, where every interaction opens: a sub-agent's request\ntravels up to its root, carrying its owner path, and is offered there once."
+            },
+            {
+              "kind": "method",
+              "name": "presentInteraction",
+              "return": {
+                "type": {
+                  "text": "Promise<T>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "componentName",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "data",
+                  "type": {
+                    "text": "unknown"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "InteractionRequestOptions"
+                  }
+                }
+              ],
+              "description": "{@inheritDoc AiDriver.presentInteraction}"
+            },
+            {
+              "kind": "method",
+              "name": "provideHandlerCapability",
+              "return": {
+                "type": {
+                  "text": "() => void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "factory",
+                  "type": {
+                    "text": "HandlerCapabilityFactory"
+                  }
+                }
+              ],
+              "description": "{@inheritDoc AiDriver.provideHandlerCapability}\n\nThrows if `name` is already provided: two decorators answering to one name would leave a\nhandler unable to tell which it is talking to."
+            },
+            {
+              "kind": "method",
+              "name": "capabilityScope",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "{\n    factories: ReadonlyMap<string, HandlerCapabilityFactory>;\n    scope: HandlerCapabilityScope;\n  }"
+                }
+              },
+              "description": "The capabilities this driver's handlers see, and who they see them as: the root's factories,\nthe root's flow owner, and the owner path from the root down to this driver's agent."
+            },
+            {
+              "kind": "method",
+              "name": "buildCapabilities",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Partial<ChatHandlerCapabilities> | undefined"
                 }
-              ],
-              "description": "Request a custom UI interaction. Emits a new message with the interaction.\nTool handlers can call this to pause execution until the user completes the UI interaction.\n\nIf a host requester is wired (sub-agent case), the call delegates upward\nso the interaction lives on the parent — the main UI is only listening to\nthe root driver. Only one interaction may be in flight at any time on a\ngiven root: concurrent calls (e.g. two parallel sub-agents both spawning a\nwidget) throw. Parallel sub-agents are for parallel work, not for user\ninteraction, which is inherently sequential."
+              },
+              "description": "Build `context.capabilities` for one handler call, or `undefined` when nothing is provided."
             },
             {
               "kind": "method",
@@ -13536,6 +14577,13 @@
                   "type": {
                     "text": "ChatAttachment[]"
                   }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "SendMessageOptions"
+                  }
                 }
               ]
             },
@@ -13559,6 +14607,13 @@
                     "text": "{ traces: ChatMessage[][] }"
                   },
                   "description": "Optional per-tool-call accumulator. When provided, every\nsub-agent call's trace is **appended** here rather than written to shared\ninstance state, so parallel tool calls each capture their own traces\nindependently.\n\nDeliberately a list of traces, not one slot. A single handler may call\n`requestSubAgent` more than once — a code-driven scheduler dispatching a\ndependency graph, a retry of a timed-out child, any fan-out helper — and a\nsingle slot kept only the last, so every other child ran, was billed by the\nprovider, and then vanished from history. The loss was silent in the worst\nway: `sumUsage` and `usageRows` both recurse into the trace, so they summed a\ntruncated input and still agreed with each other. Measured at 1 of 7 traces\nkept on a seven-way fan-out, reporting ~2.3x under the real cost, with the\nerror growing as the fan-out widens."
+                },
+                {
+                  "name": "decisions",
+                  "optional": true,
+                  "type": {
+                    "text": "DelegatedDecision[]"
+                  }
                 }
               ],
               "description": "Builds the context object passed to every tool handler call.\nCentralised here so fold shortcut dispatch and the main tool loop use the\nsame context without duplication."
@@ -13704,6 +14759,24 @@
             }
           ],
           "events": [
+            {
+              "name": "flow-owner-changed",
+              "type": {
+                "text": "CustomEvent"
+              }
+            },
+            {
+              "name": "agent-released",
+              "type": {
+                "text": "CustomEvent"
+              }
+            },
+            {
+              "name": "agent-changed",
+              "type": {
+                "text": "CustomEvent"
+              }
+            },
             {
               "name": "provider-changed",
               "type": {
@@ -14101,6 +15174,91 @@
               "privacy": "private",
               "description": "Wired with `hostRequester`: an outcome goes where its interaction went."
             },
+            {
+              "kind": "field",
+              "name": "interceptors",
+              "type": {
+                "text": "InteractionInterceptor[]"
+              },
+              "privacy": "private",
+              "readonly": true,
+              "default": "[]",
+              "description": "Told about every interaction this controller opens (GENC-1660), in registration order. Only\nthe root's are ever consulted: a sub-agent's request is opened by the root."
+            },
+            {
+              "kind": "method",
+              "name": "addInterceptor",
+              "return": {
+                "type": {
+                  "text": "() => void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "interceptor",
+                  "type": {
+                    "text": "InteractionInterceptor"
+                  }
+                }
+              ],
+              "description": "See `ChatDriver.addInteractionInterceptor`. Returns a remover."
+            },
+            {
+              "kind": "method",
+              "name": "offer",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "InteractionHolder"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "handle",
+                  "type": {
+                    "text": "InteractionContextHandle"
+                  }
+                },
+                {
+                  "name": "opened",
+                  "type": {
+                    "text": "Omit<InteractionOpened, 'ctx' | 'hold'>"
+                  }
+                }
+              ],
+              "description": "Offer a new interaction to the interceptors and record who ends up holding it.\n\n**Outermost first.** A decorator installs its interceptor on the driver it wraps when it is\nconstructed, and decorators are constructed innermost first, so registration order is\ninnermost first and the walk runs it backwards. The first claim wins; later interceptors still\nsee the interaction but their `hold` does nothing. A claim on a `userOnly` interaction is\nrefused.\n\nRuns before the interaction's message is appended, so the widget's first render already knows\nits holder and nothing appears only to disappear."
+            },
+            {
+              "kind": "method",
+              "name": "holdFor",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "InteractionHold"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "handle",
+                  "type": {
+                    "text": "InteractionContextHandle"
+                  }
+                },
+                {
+                  "name": "interceptor",
+                  "type": {
+                    "text": "InteractionInterceptor"
+                  }
+                },
+                {
+                  "name": "isClaimant",
+                  "type": {
+                    "text": "() => boolean"
+                  }
+                }
+              ],
+              "description": "The InteractionHold for one interceptor: it applies only while that one is the claimant."
+            },
             {
               "kind": "method",
               "name": "setHostRequester",
@@ -14160,9 +15318,23 @@
                   "type": {
                     "text": "(interactionId: string) => void"
                   }
+                },
+                {
+                  "name": "innerPath",
+                  "default": "[]",
+                  "type": {
+                    "text": "readonly string[]"
+                  }
+                },
+                {
+                  "name": "onSettled",
+                  "optional": true,
+                  "type": {
+                    "text": "(settled: InteractionSettled) => void"
+                  }
                 }
               ],
-              "description": "See `ChatDriver.requestInteraction`. `onOpened` is told the id of the interaction this call\nopens, wherever it opens it, so the caller can later record its outcome and no other's."
+              "description": "See `ChatDriver.requestInteraction`. `onOpened` is told the id of the interaction this call\nopens, wherever it opens it, so the caller can later record its outcome and no other's.\n`innerPath` is the owner path a sub-agent's request has gathered on its way up, and\n`onSettled` is told who answered, wherever it resolves (GENC-1660)."
             },
             {
               "kind": "method",
@@ -14948,7 +16120,7 @@
         },
         {
           "kind": "class",
-          "description": "Orchestrates multiple specialist agents. Sits between `FoundationAiAssistant`\nand `ChatDriver`, classifying each user message and routing it to the right\nspecialist — each with its own focused system prompt, tools, and primer.",
+          "description": "Orchestrates multiple specialist agents. Sits between `FoundationAiAssistant`\nand `ChatDriver`, classifying each user message and routing it to the right\nspecialist — each with its own focused system prompt, tools, and primer.\n\nA BaseDriverDecorator over the `ChatDriver` it constructs (GENC-1485, GENC-1660): every\n`AiDriver` member and event it does not override passes straight through. Its inner driver is\nalways one it built, never a composition choice, because routing reaches `ChatDriver`-only\nmembers (`installAgent`, `agentSession`, `getHistory`, `setProviderHistoryTransform`, the\nrelease flag and the `report…` exits). Other decorators go outside it.",
           "name": "OrchestratingDriver",
           "members": [
             {
@@ -14958,8 +16130,8 @@
                 "text": "ChatDriver"
               },
               "privacy": "private",
-              "readonly": true,
-              "default": "new ChatDriver(providerRegistry, {\n      maxToolIterations: options.maxToolIterations,\n      maxFoldOperations: options.maxFoldOperations,\n      maxTurnSnapshots: options.maxTurnSnapshots,\n      sessionKey: this.sessionKey,\n      activityBus: options.activityBus,\n      budgetExhaustedMessage: options.budgetExhaustedMessage,\n      aiServiceErrorMessages: options.aiServiceErrorMessages,\n      // This driver releases after the turn so it can fire the host-facing events; see the option.\n      deferAgentRelease: true,\n    })"
+              "description": "The inner driver this one built and routes onto.",
+              "readonly": true
             },
             {
               "kind": "field",
@@ -15056,198 +16228,290 @@
             },
             {
               "kind": "method",
-              "name": "resolveInteraction",
+              "name": "createInner",
+              "privacy": "private",
+              "static": true,
               "return": {
                 "type": {
-                  "text": "void"
+                  "text": "ChatDriver"
                 }
               },
               "parameters": [
                 {
-                  "name": "interactionId",
+                  "name": "providerRegistry",
                   "type": {
-                    "text": "string"
+                    "text": "AIProviderRegistry"
                   }
                 },
                 {
-                  "name": "result",
+                  "name": "agents",
                   "type": {
-                    "text": "unknown"
+                    "text": "AgentConfig[]"
+                  }
+                },
+                {
+                  "name": "options",
+                  "default": "{}",
+                  "type": {
+                    "text": "ConstructorParameters<typeof OrchestratingDriver>[2]"
                   }
                 }
-              ]
+              ],
+              "description": "Build the inner driver, after validating the agents' providers, so a bad config throws before\na driver exists to subscribe to the registry. Static because it runs before `super()`."
             },
             {
               "kind": "method",
-              "name": "recordExternalCost",
+              "name": "getSuggestions",
               "return": {
                 "type": {
-                  "text": "boolean"
+                  "text": "Promise<string[]>"
                 }
               },
               "parameters": [
                 {
-                  "name": "interactionId",
+                  "name": "history",
+                  "type": {
+                    "text": "ChatMessage[]"
+                  }
+                },
+                {
+                  "name": "prompt",
                   "type": {
                     "text": "string"
                   }
                 },
                 {
-                  "name": "costUsd",
+                  "name": "count",
                   "type": {
                     "text": "number"
                   }
+                },
+                {
+                  "name": "allAgentInfo",
+                  "optional": true,
+                  "type": {
+                    "text": "AllAgentSummary[]"
+                  }
                 }
               ],
-              "description": "Delegated for the same reason as `resolveInteraction`: the history that owns the\ninteraction — and therefore the cost — lives on the wrapped driver, not here."
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "getInteractionContext",
+              "name": "sendMessage",
               "return": {
                 "type": {
-                  "text": "InteractionContext | undefined"
+                  "text": "Promise<ChatDriverResult>"
                 }
               },
               "parameters": [
                 {
-                  "name": "interactionId",
+                  "name": "input",
                   "type": {
                     "text": "string"
                   }
+                },
+                {
+                  "name": "attachments",
+                  "optional": true,
+                  "type": {
+                    "text": "ChatAttachment[]"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "SendMessageOptions"
+                  }
                 }
-              ]
-            },
-            {
-              "kind": "method",
-              "name": "isBusy",
-              "return": {
-                "type": {
-                  "text": "boolean"
-                }
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
               }
             },
             {
               "kind": "method",
-              "name": "getActiveProviderName",
+              "name": "runOrchestratedTurn",
+              "privacy": "private",
               "return": {
                 "type": {
-                  "text": "string"
+                  "text": "Promise<ChatDriverResult>"
                 }
               },
-              "description": "Currently active provider name from the underlying ChatDriver."
+              "parameters": [
+                {
+                  "name": "input",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "attachments",
+                  "type": {
+                    "text": "ChatAttachment[] | undefined"
+                  }
+                },
+                {
+                  "name": "options",
+                  "type": {
+                    "text": "SendMessageOptions | undefined"
+                  }
+                },
+                {
+                  "name": "delegated",
+                  "type": {
+                    "text": "Pick<ChatMessage, 'delegate' | 'delegateFraming'>"
+                  }
+                }
+              ]
             },
             {
               "kind": "method",
-              "name": "setPinnedAgent",
+              "name": "canRestoreFlowOwner",
               "return": {
                 "type": {
-                  "text": "void"
+                  "text": "boolean"
                 }
               },
               "parameters": [
                 {
-                  "name": "name",
+                  "name": "agentName",
                   "type": {
-                    "text": "string | null"
+                    "text": "string"
                   }
                 }
               ],
-              "description": "Pins routing to a specific agent by name. While pinned, the classifier is\nskipped and the continuation tool is hidden from the agent's tool list, so\nthe agent cannot quietly hand back to the orchestrator. Pass `null` to\nreturn to automatic routing."
+              "description": "{@inheritDoc AiDriver.canRestoreFlowOwner}",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "setFlowOwner",
+              "name": "canResumeRestoredFlow",
               "return": {
                 "type": {
-                  "text": "void"
+                  "text": "boolean"
                 }
               },
               "parameters": [
                 {
-                  "name": "name",
+                  "name": "agentName",
                   "type": {
-                    "text": "string | null"
+                    "text": "string"
                   }
                 }
               ],
-              "description": "Set the flow-owner lock — used to restore state from Redux on driver\nreconstruction (agents-array changes, pop-in/pop-out). Not intended for\nexternal callers to manipulate routing; that's what `setPinnedAgent` is\nfor."
+              "description": "{@inheritDoc AiDriver.canResumeRestoredFlow}",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "loadHistory",
+              "name": "resumeRestoredFlow",
               "return": {
                 "type": {
-                  "text": "void"
+                  "text": "Promise<ChatDriverResult | undefined>"
                 }
               },
               "parameters": [
                 {
-                  "name": "messages",
+                  "name": "resumeNote",
+                  "optional": true,
                   "type": {
-                    "text": "ChatMessage[]"
+                    "text": "string"
                   }
                 }
-              ]
+              ],
+              "description": "{@inheritDoc AiDriver.resumeRestoredFlow}\n\nInstalls the flow owner directly rather than through `handleTurn`: there is no user message\nto classify, and a restored lock already says which agent owns the flow. `continueFromHistory`\non its own would not do — it neither routes nor installs, so it would run on whatever agent\nhappened to be installed (none, straight after a reload).\n\nLooks the owner up in its own agents list, so the `agent` argument is not needed and is\nignored; and does not delegate to the inner driver's resume, which would install the agent\nundecorated.",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "getRawHistory",
+              "name": "getContextReserve",
               "return": {
                 "type": {
-                  "text": "readonly ChatMessage[]"
+                  "text": "ContextReserveResolution | undefined"
+                }
+              },
+              "description": "{@inheritDoc AiDriver.getContextReserve}\n\nTwo cases, because routing has two modes and they need opposite answers.",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "installAgent",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Promise<void>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "agent",
+                  "type": {
+                    "text": "AgentConfig"
+                  }
                 }
-              }
+              ]
             },
             {
               "kind": "method",
-              "name": "getHistoryForPersistence",
+              "name": "releaseActiveAgent",
+              "privacy": "private",
               "return": {
                 "type": {
-                  "text": "ChatMessage[]"
+                  "text": "Promise<void>"
                 }
               },
-              "description": "Delegates to the inner ChatDriver — condensation policies are registered there, so it\nis the only object that knows which payloads the model has stopped seeing (GENC-1566).\n\n**This forward is the whole feature, for any multi-agent host.** `AiDriver` declares\n`getHistoryForPersistence` optional, and `SessionPersister` calls it through `?.`, falling back\nto OrchestratingDriver.getRawHistory. This class does NOT extend `ChatDriver` — it\nwraps one — so without an explicit forward the optional call resolves to `undefined` and every\nhost on an orchestrating driver silently keeps persisting the full payloads. Measured exactly\nthat way on a Create run: 10 `context.condensed` events fired, and the session still stored\nthe two largest `read_context` results at 26,907 and 23,060 chars. The method existed, the\ntests passed, and the feature did nothing."
+              "description": "Release the current stateful agent: fire `onDeactivate` and clear the flow-owner lock. The\ninner driver raises the events from the session's transition, so the host (and Redux) reflect\nthe unlocked state (GENC-1485). Called automatically when a tool handler invokes\n`context.releaseAgent`.\n\nThe user-pin (`pinnedAgentName`) is intentionally *not* cleared — a user\nwho explicitly picked this agent should stay on it after the flow ends,\nso the next message starts a fresh flow on the same agent rather than\nrouting through the classifier."
             },
             {
               "kind": "method",
-              "name": "getCondensePoliciesForPersistence",
+              "name": "cancel",
               "return": {
                 "type": {
-                  "text": "PersistedCondensePolicy[]"
+                  "text": "void"
                 }
               },
-              "parameters": [
-                {
-                  "name": "messages",
-                  "type": {
-                    "text": "readonly ChatMessage[]"
-                  }
-                }
-              ],
-              "description": "Delegates to the inner ChatDriver, which owns the condensation registry and clocks\n(GENC-1632). The forward matters for the same reason as `getHistoryForPersistence` above: the\npersister reaches it through `?.`, so a missing forward would compile, pass the ChatDriver\ntests, and do nothing for every orchestrated host — which is every host with an agents array."
+              "description": "Stop the current turn (user \"stop\" button). Cancels the inner chat driver's\nin-flight request and breaks the handoff loop so no further agent turn or\nclassify runs. The driver stays usable for the next message.",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "restoreCondensePolicies",
+              "name": "dispose",
               "return": {
                 "type": {
-                  "text": "{\n    restored: number;\n    awaitingReactivation: number;\n  }"
+                  "text": "Promise<void>"
                 }
               },
-              "parameters": [
-                {
-                  "name": "entries",
-                  "type": {
-                    "text": "readonly unknown[] | undefined"
-                  }
-                }
-              ],
-              "description": "Delegates to the inner ChatDriver (GENC-1632). The deferred activation stamp it\nperforms is taken by the inner driver's `installAgent`, which this driver's own\n`installAgent` always reaches, so nothing extra is needed here."
+              "description": "Fire `onDeactivate` on the current active agent and abort any pending\nlifecycle work. Called by the host on session teardown so machines can\nrelease resources cleanly.",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "setContextGuard",
+              "name": "recordRouting",
+              "privacy": "private",
               "return": {
                 "type": {
                   "text": "void"
@@ -15255,515 +16519,709 @@
               },
               "parameters": [
                 {
-                  "name": "policy",
-                  "optional": true,
+                  "name": "decision",
                   "type": {
-                    "text": "ContextGuardPolicy"
+                    "text": "RoutingDecision"
+                  }
+                },
+                {
+                  "name": "agent",
+                  "type": {
+                    "text": "AgentConfig"
+                  }
+                },
+                {
+                  "name": "detail",
+                  "default": "{}",
+                  "type": {
+                    "text": "{\n      index?: number;\n      durationMs?: number;\n      attempts?: number;\n      error?: string;\n      response?: ChatMessage;\n      excluded?: readonly string[];\n      /**\n       * What was actually on the ballot for this classification, in ballot order — so `index`\n       * indexes it. Omitted on the decisions that hold no vote at all.\n       */\n      ballot?: readonly string[];\n    }"
                   }
                 }
               ],
-              "description": "{@inheritDoc AiDriver.setContextGuard}"
+              "description": "Record one routing decision on the debug timeline — what was chosen, why, what it cost, and\n(on a failure) what went wrong.\n\nThis is the event whose absence made GENC-1573 undiagnosable. `classify` reaches the fallback\nby four different routes and every one of them only warned to the console; because it runs\noutside any ChatDriver turn it produces no `kind:'turn'` entry either, so both the decision\nand its spend were invisible in an exported log.\n\n`usage` is why the spend line exists at all. A classifier call is a real billed request that\nnever enters the transcript, and `sessionUsage` is derived from the transcript — so classifier\nspend is absent from the session total by construction. Recording it per decision keeps it\nauditable and tells a reconciler exactly where the gap comes from: sum these to close it."
             },
             {
               "kind": "method",
-              "name": "compact",
+              "name": "classifierTranscript",
+              "privacy": "private",
               "return": {
                 "type": {
-                  "text": "Promise<ChatMessage | null>"
+                  "text": "string"
                 }
               },
               "parameters": [
                 {
-                  "name": "options",
-                  "optional": true,
+                  "name": "history",
                   "type": {
-                    "text": "CompactionPlanOptions"
+                    "text": "ChatMessage[]"
                   }
                 }
               ],
-              "description": "{@inheritDoc AiDriver.compact}"
+              "description": "The recent-conversation excerpt for the classifier prompt, bounded in size as well as in\nmessage count — see the `CLASSIFIER_MESSAGE_CHARS` docblock for why."
             },
             {
               "kind": "method",
-              "name": "canCompact",
+              "name": "classify",
+              "privacy": "private",
               "return": {
                 "type": {
-                  "text": "boolean"
+                  "text": "Promise<RoutingOutcome>"
                 }
               },
               "parameters": [
                 {
-                  "name": "options",
+                  "name": "input",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "history",
+                  "type": {
+                    "text": "ChatMessage[]"
+                  }
+                },
+                {
+                  "name": "contextAgent",
                   "optional": true,
                   "type": {
-                    "text": "CompactionPlanOptions"
+                    "text": "AgentConfig"
+                  }
+                },
+                {
+                  "name": "excludeAgents",
+                  "default": "[]",
+                  "type": {
+                    "text": "readonly string[]"
                   }
                 }
-              ],
-              "description": "{@inheritDoc AiDriver.canCompact}"
+              ]
             },
             {
               "kind": "method",
-              "name": "getPreambleTokens",
+              "name": "resolvePinnedAgent",
+              "privacy": "private",
               "return": {
                 "type": {
-                  "text": "number | undefined"
+                  "text": "AgentConfig | undefined"
                 }
               },
-              "description": "{@inheritDoc AiDriver.getPreambleTokens}"
+              "description": "Returns the agent that the current turn is locked to, if any. Flow-owner\n(transient, set by stateful-agent activation) wins over user-pin (sticky,\nset by picker click). `undefined` falls back to the classifier.\n\nLogs and returns `undefined` if a name no longer matches the agents array\n— protects against stale state after an agents-array reassignment."
             },
             {
               "kind": "method",
-              "name": "getCompactionPlan",
+              "name": "appendInlineMessage",
+              "privacy": "private",
               "return": {
                 "type": {
-                  "text": "CompactionProjection | null"
+                  "text": "void"
                 }
               },
               "parameters": [
                 {
-                  "name": "options",
-                  "optional": true,
+                  "name": "content",
                   "type": {
-                    "text": "CompactionPlanOptions"
+                    "text": "string"
                   }
                 }
               ],
-              "description": "{@inheritDoc AiDriver.getCompactionPlan}"
+              "description": "Append prose the ORCHESTRATOR wrote — the handoff cap, the no-specialist apology. Flagged\n`excludeFromProvider` for the same reason the driver's own notices are: it is not something a\nmodel said, and feeding it back invites the model to echo it. See\n`ChatMessage.excludeFromProvider`."
+            },
+            {
+              "kind": "field",
+              "name": "detachers",
+              "type": {
+                "text": "Array<() => void>"
+              },
+              "privacy": "private",
+              "readonly": true,
+              "default": "[]",
+              "description": "Undoes this layer's hold on its inner driver; see BaseDriverDecorator.detach.",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "getTurnSnapshots",
+              "name": "detach",
               "return": {
                 "type": {
-                  "text": "ReadonlyArray<TurnSnapshot>"
+                  "text": "void"
                 }
               },
-              "description": "Delegates to the inner ChatDriver — turns are captured there."
+              "description": "Let go of the inner driver WITHOUT disposing it: stop forwarding its events, and undo whatever\na subclass registered through BaseDriverDecorator.onDetach (its interceptors, its\ncapabilities, its own listeners). For dropping or replacing a decorator while the driver it\nwrapped lives on — otherwise the old layer keeps re-dispatching every event and is never\ncollected. Idempotent. `dispose()` detaches too.",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "getExternalDiagnostics",
+              "name": "onDetach",
+              "privacy": "protected",
               "return": {
                 "type": {
-                  "text": "ReadonlyArray<DiagnosticEntry>"
+                  "text": "void"
                 }
               },
-              "description": "Delegates to the inner ChatDriver — interactions resolve there, so it holds the buffer."
+              "parameters": [
+                {
+                  "name": "undo",
+                  "type": {
+                    "text": "() => void"
+                  }
+                }
+              ],
+              "description": "Register something BaseDriverDecorator.detach must undo.",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "getSuggestions",
+              "name": "continueFromHistory",
               "return": {
                 "type": {
-                  "text": "Promise<string[]>"
+                  "text": "Promise<ChatDriverResult>"
                 }
               },
               "parameters": [
                 {
-                  "name": "history",
+                  "name": "transientPrimer",
+                  "optional": true,
                   "type": {
                     "text": "ChatMessage[]"
                   }
                 },
                 {
-                  "name": "prompt",
+                  "name": "options",
+                  "optional": true,
                   "type": {
-                    "text": "string"
+                    "text": "ContinueFromHistoryOptions"
                   }
-                },
+                }
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "resolveInteraction",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
                 {
-                  "name": "count",
+                  "name": "interactionId",
                   "type": {
-                    "text": "number"
+                    "text": "string"
                   }
                 },
                 {
-                  "name": "allAgentInfo",
-                  "optional": true,
+                  "name": "result",
                   "type": {
-                    "text": "AllAgentSummary[]"
+                    "text": "unknown"
                   }
                 }
-              ]
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "sendMessage",
+              "name": "recordExternalCost",
               "return": {
                 "type": {
-                  "text": "Promise<ChatDriverResult>"
+                  "text": "boolean"
                 }
               },
               "parameters": [
                 {
-                  "name": "input",
+                  "name": "interactionId",
                   "type": {
                     "text": "string"
                   }
                 },
                 {
-                  "name": "attachments",
-                  "optional": true,
+                  "name": "costUsd",
                   "type": {
-                    "text": "ChatAttachment[]"
+                    "text": "number"
                   }
                 }
-              ]
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "runOrchestratedTurn",
-              "privacy": "private",
+              "name": "getInteractionContext",
               "return": {
                 "type": {
-                  "text": "Promise<ChatDriverResult>"
+                  "text": "InteractionContext | undefined"
                 }
               },
               "parameters": [
                 {
-                  "name": "input",
+                  "name": "interactionId",
                   "type": {
                     "text": "string"
                   }
-                },
-                {
-                  "name": "attachments",
-                  "optional": true,
-                  "type": {
-                    "text": "ChatAttachment[]"
-                  }
                 }
-              ]
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "continueFromHistory",
+              "name": "loadHistory",
               "return": {
                 "type": {
-                  "text": "Promise<ChatDriverResult>"
+                  "text": "void"
                 }
               },
               "parameters": [
                 {
-                  "name": "transientPrimer",
-                  "optional": true,
+                  "name": "messages",
                   "type": {
                     "text": "ChatMessage[]"
                   }
-                },
+                }
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "primeRestoredAgentState",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
                 {
-                  "name": "options",
-                  "optional": true,
+                  "name": "snapshots",
                   "type": {
-                    "text": "ContinueFromHistoryOptions"
+                    "text": "Record<string, unknown>"
                   }
                 }
-              ]
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "getRawHistory",
+              "return": {
+                "type": {
+                  "text": "readonly ChatMessage[]"
+                }
+              },
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "getHistoryForPersistence",
+              "return": {
+                "type": {
+                  "text": "ChatMessage[]"
+                }
+              },
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "primeRestoredAgentState",
+              "name": "getCondensePoliciesForPersistence",
               "return": {
                 "type": {
-                  "text": "void"
+                  "text": "PersistedCondensePolicy[]"
                 }
               },
               "parameters": [
                 {
-                  "name": "snapshots",
+                  "name": "messages",
                   "type": {
-                    "text": "Record<string, unknown>"
+                    "text": "readonly ChatMessage[]"
                   }
                 }
               ],
-              "description": "{@inheritDoc AiDriver.primeRestoredAgentState}"
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "canRestoreFlowOwner",
+              "name": "restoreCondensePolicies",
               "return": {
                 "type": {
-                  "text": "boolean"
+                  "text": "{\n    restored: number;\n    awaitingReactivation: number;\n  }"
                 }
               },
               "parameters": [
                 {
-                  "name": "agentName",
+                  "name": "entries",
                   "type": {
-                    "text": "string"
+                    "text": "readonly unknown[] | undefined"
                   }
                 }
               ],
-              "description": "{@inheritDoc AiDriver.canRestoreFlowOwner}"
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "canResumeRestoredFlow",
+              "name": "getActiveAgent",
               "return": {
                 "type": {
-                  "text": "boolean"
+                  "text": "AgentConfig | undefined"
+                }
+              },
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "setPinnedAgent",
+              "return": {
+                "type": {
+                  "text": "void"
                 }
               },
               "parameters": [
                 {
-                  "name": "agentName",
+                  "name": "name",
                   "type": {
-                    "text": "string"
+                    "text": "string | null"
                   }
                 }
               ],
-              "description": "{@inheritDoc AiDriver.canResumeRestoredFlow}"
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "resumeRestoredFlow",
+              "name": "setFlowOwner",
               "return": {
                 "type": {
-                  "text": "Promise<ChatDriverResult | undefined>"
+                  "text": "void"
                 }
               },
               "parameters": [
                 {
-                  "name": "resumeNote",
-                  "optional": true,
+                  "name": "name",
                   "type": {
-                    "text": "string"
+                    "text": "string | null"
                   }
                 }
               ],
-              "description": "{@inheritDoc AiDriver.resumeRestoredFlow}\n\nInstalls the flow owner directly rather than through `handleTurn`: there is no user message\nto classify, and a restored lock already says which agent owns the flow. `continueFromHistory`\non its own would not do — it neither routes nor installs, so it would run on whatever agent\nhappened to be installed (none, straight after a reload)."
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "getContextReserve",
+              "name": "getFlowOwner",
               "return": {
                 "type": {
-                  "text": "ContextReserveResolution | undefined"
+                  "text": "string | null"
                 }
               },
-              "description": "{@inheritDoc AiDriver.getContextReserve}\n\nTwo cases, because routing has two modes and they need opposite answers."
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "getActiveAgent",
+              "name": "addInteractionInterceptor",
               "return": {
                 "type": {
-                  "text": "AgentConfig | undefined"
+                  "text": "() => void"
                 }
               },
-              "description": "{@inheritDoc AiDriver.getActiveAgent}"
+              "parameters": [
+                {
+                  "name": "interceptor",
+                  "type": {
+                    "text": "InteractionInterceptor"
+                  }
+                }
+              ],
+              "description": "Forwarded, so an interceptor installed on any layer lands on the driver that opens the\ninteractions. A decorator that answers interactions installs its own on `this.inner`.",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "installAgent",
-              "privacy": "private",
+              "name": "presentInteraction",
               "return": {
                 "type": {
-                  "text": "Promise<void>"
+                  "text": "Promise<T>"
                 }
               },
               "parameters": [
                 {
-                  "name": "agent",
+                  "name": "componentName",
                   "type": {
-                    "text": "AgentConfig"
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "data",
+                  "type": {
+                    "text": "unknown"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "InteractionRequestOptions"
                   }
                 }
-              ]
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "releaseActiveAgent",
-              "privacy": "private",
+              "name": "provideHandlerCapability",
               "return": {
                 "type": {
-                  "text": "Promise<void>"
+                  "text": "() => void"
                 }
               },
-              "description": "Release the current stateful agent: fire `onDeactivate`, clear the\nflow-owner lock, dispatch events so the host (and Redux) reflect the\nunlocked state. Called automatically when a tool handler invokes\n`context.releaseAgent`.\n\nThe user-pin (`pinnedAgentName`) is intentionally *not* cleared — a user\nwho explicitly picked this agent should stay on it after the flow ends,\nso the next message starts a fresh flow on the same agent rather than\nrouting through the classifier."
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "factory",
+                  "type": {
+                    "text": "HandlerCapabilityFactory"
+                  }
+                }
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "cancel",
+              "name": "getPreambleTokens",
               "return": {
                 "type": {
-                  "text": "void"
+                  "text": "number | undefined"
                 }
               },
-              "description": "Stop the current turn (user \"stop\" button). Cancels the inner chat driver's\nin-flight request and breaks the handoff loop so no further agent turn or\nclassify runs. The driver stays usable for the next message."
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "dispose",
+              "name": "setContextGuard",
               "return": {
                 "type": {
-                  "text": "Promise<void>"
+                  "text": "void"
                 }
               },
-              "description": "Fire `onDeactivate` on the current active agent and abort any pending\nlifecycle work. Called by the host on session teardown so machines can\nrelease resources cleanly."
+              "parameters": [
+                {
+                  "name": "policy",
+                  "optional": true,
+                  "type": {
+                    "text": "ContextGuardPolicy"
+                  }
+                }
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "recordRouting",
-              "privacy": "private",
+              "name": "compact",
               "return": {
                 "type": {
-                  "text": "void"
+                  "text": "Promise<ChatMessage | null>"
                 }
               },
               "parameters": [
                 {
-                  "name": "decision",
-                  "type": {
-                    "text": "RoutingDecision"
-                  }
-                },
-                {
-                  "name": "agent",
-                  "type": {
-                    "text": "AgentConfig"
-                  }
-                },
-                {
-                  "name": "detail",
-                  "default": "{}",
+                  "name": "options",
+                  "optional": true,
                   "type": {
-                    "text": "{\n      index?: number;\n      durationMs?: number;\n      attempts?: number;\n      error?: string;\n      response?: ChatMessage;\n      excluded?: readonly string[];\n      /**\n       * What was actually on the ballot for this classification, in ballot order — so `index`\n       * indexes it. Omitted on the decisions that hold no vote at all.\n       */\n      ballot?: readonly string[];\n    }"
+                    "text": "CompactionPlanOptions"
                   }
                 }
               ],
-              "description": "Record one routing decision on the debug timeline — what was chosen, why, what it cost, and\n(on a failure) what went wrong.\n\nThis is the event whose absence made GENC-1573 undiagnosable. `classify` reaches the fallback\nby four different routes and every one of them only warned to the console; because it runs\noutside any ChatDriver turn it produces no `kind:'turn'` entry either, so both the decision\nand its spend were invisible in an exported log.\n\n`usage` is why the spend line exists at all. A classifier call is a real billed request that\nnever enters the transcript, and `sessionUsage` is derived from the transcript — so classifier\nspend is absent from the session total by construction. Recording it per decision keeps it\nauditable and tells a reconciler exactly where the gap comes from: sum these to close it."
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "classifierTranscript",
-              "privacy": "private",
+              "name": "getCompactionPlan",
               "return": {
                 "type": {
-                  "text": "string"
+                  "text": "CompactionProjection | null"
                 }
               },
               "parameters": [
                 {
-                  "name": "history",
+                  "name": "options",
+                  "optional": true,
                   "type": {
-                    "text": "ChatMessage[]"
+                    "text": "CompactionPlanOptions"
                   }
                 }
               ],
-              "description": "The recent-conversation excerpt for the classifier prompt, bounded in size as well as in\nmessage count — see the `CLASSIFIER_MESSAGE_CHARS` docblock for why."
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "classify",
-              "privacy": "private",
+              "name": "canCompact",
               "return": {
                 "type": {
-                  "text": "Promise<RoutingOutcome>"
+                  "text": "boolean"
                 }
               },
               "parameters": [
                 {
-                  "name": "input",
-                  "type": {
-                    "text": "string"
-                  }
-                },
-                {
-                  "name": "history",
-                  "type": {
-                    "text": "ChatMessage[]"
-                  }
-                },
-                {
-                  "name": "contextAgent",
+                  "name": "options",
                   "optional": true,
                   "type": {
-                    "text": "AgentConfig"
-                  }
-                },
-                {
-                  "name": "excludeAgents",
-                  "default": "[]",
-                  "type": {
-                    "text": "readonly string[]"
+                    "text": "CompactionPlanOptions"
                   }
                 }
-              ]
+              ],
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "resolvePinnedAgent",
-              "privacy": "private",
+              "name": "isBusy",
               "return": {
                 "type": {
-                  "text": "AgentConfig | undefined"
+                  "text": "boolean"
                 }
               },
-              "description": "Returns the agent that the current turn is locked to, if any. Flow-owner\n(transient, set by stateful-agent activation) wins over user-pin (sticky,\nset by picker click). `undefined` falls back to the classifier.\n\nLogs and returns `undefined` if a name no longer matches the agents array\n— protects against stale state after an agents-array reassignment."
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
+              }
             },
             {
               "kind": "method",
-              "name": "appendInlineMessage",
-              "privacy": "private",
+              "name": "getTurnSnapshots",
               "return": {
                 "type": {
-                  "text": "void"
+                  "text": "ReadonlyArray<TurnSnapshot>"
                 }
               },
-              "parameters": [
-                {
-                  "name": "content",
-                  "type": {
-                    "text": "string"
-                  }
-                }
-              ],
-              "description": "Append prose the ORCHESTRATOR wrote — the handoff cap, the no-specialist apology. Flagged\n`excludeFromProvider` for the same reason the driver's own notices are: it is not something a\nmodel said, and feeding it back invites the model to echo it. See\n`ChatMessage.excludeFromProvider`."
-            }
-          ],
-          "events": [
-            {
-              "name": "history-updated",
-              "type": {
-                "text": "CustomEvent"
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
               }
             },
             {
-              "name": "orchestrating-start",
-              "type": {
-                "text": "CustomEvent"
+              "kind": "method",
+              "name": "getExternalDiagnostics",
+              "return": {
+                "type": {
+                  "text": "ReadonlyArray<DiagnosticEntry>"
+                }
+              },
+              "description": "The inner driver's entries. Diagnostics compose down the stack: a decorator with entries of\nits own overrides this and appends them to `super.getExternalDiagnostics()`.",
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
               }
             },
             {
-              "name": "flow-owner-changed",
-              "type": {
-                "text": "CustomEvent"
+              "kind": "method",
+              "name": "getActiveProviderName",
+              "return": {
+                "type": {
+                  "text": "string"
+                }
+              },
+              "inheritedFrom": {
+                "name": "BaseDriverDecorator",
+                "module": "src/components/ai-driver/base-driver-decorator.ts"
               }
-            },
+            }
+          ],
+          "events": [
             {
-              "name": "orchestrating-stop",
+              "name": "history-updated",
               "type": {
                 "text": "CustomEvent"
               }
             },
             {
-              "name": "agent-changed",
+              "name": "orchestrating-start",
               "type": {
                 "text": "CustomEvent"
               }
             },
             {
-              "name": "agent-released",
+              "name": "orchestrating-stop",
               "type": {
                 "text": "CustomEvent"
               }
             }
           ],
           "superclass": {
-            "name": "EventTarget",
-            "module": "src/components/orchestrating-driver/orchestrating-driver.ts"
+            "name": "BaseDriverDecorator",
+            "module": "/src/components/ai-driver/base-driver-decorator"
           }
         }
       ],