@genesislcap/ai-assistant 15.86.1 → 15.87.0

package/dist/chat-driver.cjs

@@ -39,6 +39,7 @@ __export(chat_driver_node_exports, {
   GEMINI_LONG_CONTEXT_THRESHOLD: () => GEMINI_LONG_CONTEXT_THRESHOLD,
   GeminiProvider: () => GeminiProvider,
   GeminiTransport: () => GeminiTransport,
+  HeadlessSession: () => HeadlessSession,
   MALFORMED_CALL_NUDGE: () => MALFORMED_CALL_NUDGE,
   MutableAIProviderRegistry: () => MutableAIProviderRegistry,
   NOOP_ACTIVITY_BUS: () => NOOP_ACTIVITY_BUS,
@@ -56,18 +57,24 @@ __export(chat_driver_node_exports, {
   anthropicRatesFor: () => anthropicRatesFor,
   anthropicTokenCost: () => anthropicTokenCost,
   assembleDebugLog: () => assembleDebugLog,
+  buildDiagnosticEntries: () => buildDiagnosticEntries,
   buildTimelineEntries: () => buildTimelineEntries,
   clearSession: () => clearSession,
   defineAgent: () => defineAgent,
   defineAutopilot: () => defineAutopilot,
   defineStatefulAgent: () => defineStatefulAgent,
+  describeInteraction: () => describeInteraction,
   emptyUsage: () => emptyUsage,
   friendlyFallbackAgent: () => friendlyFallbackAgent,
   geminiRatesFor: () => geminiRatesFor,
   geminiTokenCost: () => geminiTokenCost,
   getMetaEvents: () => getMetaEvents,
+  headlessCurrentDebugLog: () => headlessCurrentDebugLog,
+  headlessDiagnosticEntries: () => headlessDiagnosticEntries,
+  headlessMetaSnapshot: () => headlessMetaSnapshot,
   isObservableAIProviderRegistry: () => isObservableAIProviderRegistry,
   isTerminalAIServiceRefusal: () => isTerminalAIServiceRefusal,
+  lifetimeDebugLog: () => lifetimeDebugLog,
   messageUsage: () => messageUsage,
   resolveAITiers: () => resolveAITiers,
   restoreMachine: () => restoreMachine,
@@ -4146,6 +4153,11 @@ var META_EVENT_IMPORTANCE = {
   "autopilot.catch-up": "normal",
   // Autopilot spend that reached no message, so it is missing from the session total.
   "autopilot.cost-dropped": "high",
+  // A headless session attached to the driver: from here a host with no screen is the person.
+  "headless.attached": "normal",
+  // The host settled an interaction raw, without the widget's own actions: its result went to the
+  // tool as given, unchecked by anything the widget would have enforced.
+  "headless.raw-resolved": "normal",
   "external-diagnostics.folded": "normal",
   "session.cleared": "normal",
   "session.switched": "low",
@@ -4223,6 +4235,30 @@ function mergeMetaEvents(targetKey, events) {
 function clearSession(key) {
   registry.delete(key);
 }
+var DEBUG_LOG_README = [
+  "This is an exported debug log for the Genesis AI assistant. Read it top-to-bottom.",
+  "`sessionUsage` is what this session spent: `costUsd` (USD, provider-reported per request and summed, cache discounts already applied) plus the four TOKEN BUCKETS \u2014 `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 \u2014 cache reads a fraction of uncached input, cache writes a premium, output highest \u2014 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 \u2014 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 \u2014 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.",
+  "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) \u2014 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 \u2014 not as a total of the whole file.",
+  "`timeline` is the entire session as one array, already sorted chronologically by `timestamp` (ISO 8601). Every entry has a `kind`.",
+  "Timestamps are millisecond-resolution; entries that share the same millisecond are ordered by a fixed kind rank (event, then turn, then message), which is a heuristic and may not reflect exact causal order within that millisecond \u2014 e.g. a user message and the turn it triggered, or a final assistant message and its turn.end event, can appear in either order depending on whether they landed in the same millisecond. Read the logical structure of a turn rather than over-interpreting the micro-ordering of co-timestamped entries of different kinds.",
+  "kind:'message' \u2014 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 \u2014 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 \u2014 cache reads a fraction of uncached input, cache writes a premium, output highest \u2014 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 \u2014 and any tool calls it carries \u2014 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` \u2014 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 \u2014 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.",
+  "The autopilot (GENC-1660) runs on a driver of its own, and everything it did is harvested into this log: entries with delegate: autopilot and an agentName ending in \u203A Autopilot are its turns (the decision message it was sent is the user message of its turn, so what it was shown is there verbatim; its systemPrompt is its grounding, such as the brief), its tool calls (widget_read, widget_act, hand_back, any read-only tools of its own, and its widget tools \u2014 reads with parameters that a widget type declares, routed to the interaction of that type being decided and refused with a reason when none is, offered on every decision so its tool list never changes; while one is open its tail starts with a line naming them) and their results (a read, view or widget tool, is capped at about 20,000 characters, cut with a note asking for less, and leaves its history at the end of the decision as a one-line note), and its own events. Its cost is already in the session total: it is booked as externalCostUsd on the interaction each decision answered, or, for a written question it answered, on the user message it sent on the user behalf (delegate: autopilot), so do not add its turns to that total. Spend that reached no message is recorded as autopilot.cost-dropped instead.",
+  "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 note, or, when its answer carried no note, the widget's own echo of the answer (its `userMessage`), shown as the assistant and never as the person. A widget answer a decorator gave with a note is not echoed at all: the note already says what was chosen. To tell what the person decided from what was decided for them, read `interaction.answeredBy` and these fields, never the role alone.",
+  "Sub-agent messages appear inline. When a tool delegates to a sub-agent (via `requestSubAgent`), the sub-agent's whole conversation \u2014 its own assistant/tool messages, each with their own `content`/`thinking`/`toolCalls`/`toolResult` and per-message `model`/`providerName`/`inputTokens`/`outputTokens`/`cacheReadTokens`/`cacheWriteTokens`/`cost` \u2014 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, \u2026), `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> \u203A <sub-agent>\"` breadcrumb (composing when nested, e.g. `\"UI Builder \u203A Planner \u203A 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.",
+  "kind:'turn' \u2014 one LLM call. `turnIndex` is a string: a top-level turn is the bare counter ('0', '1', \u2026); a sub-agent's turns are numbered under the parent turn that activated them ('3-1', '3-2', \u2026, and a nested sub-agent contributes '3-2-1', \u2026), and `agentName` names the agent that ran the turn. `systemPrompt` and `toolNames` are what the model saw. A systemPrompt of '<repeated \u2014 identical to turn N>' was byte-identical to turn N and de-duplicated; the full prompt is shown whenever it changes (often because a stateful agent advanced), so prompt evolution is visible.",
+  "kind:'turn'.`model`/`providerName`/`provider` \u2014 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 \u2014 a flow that plans on a high tier and executes on a low one \u2014 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.",
+  "kind:'turn'.`usage` \u2014 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 \u2014 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.",
+  "kind:'turn'.`agentSnapshot` \u2014 the active agent's own view of its internal state, captured at that turn. An agent opts into this by exposing a `getDebugSnapshot()` that returns JSON-serializable per-state info; stateful/flow agents wire it automatically, so you can watch a flow advance turn-by-turn (e.g. current step, cursor, collected fields, pending changes). Absent for agents that don't expose one.",
+  "kind:'event' \u2014 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'.",
+  "Each 'event' also has an `importance`: 'high' (failures/limits \u2014 turn.error, tool.failed, subagent.failed, file.read-failed, suggestions.failed, context.threshold-crossed), 'normal' (session flow \u2014 connects, turns, retries, handoffs, agent/provider changes, interactions, sub-agent start/complete), or 'low' (skippable UI/bookkeeping noise \u2014 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 \u2014 read them together to see how many attempts were made before bailing. 'message' and 'turn' entries carry no importance \u2014 they are the substance, always read them.",
+  "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\u2194loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry \u2014 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 \u2014 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 \u2014 real earlier this activation but retired by the current state or hidden behind an open exclusive fold \u2014 and hallucinatedTools \u2014 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 \u2014 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 \u2014 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 \u2014 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 \u2014 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 \u2014 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 \u2014 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 \u2014 see its own paragraph below), provider.selected (the resolved provider for the upcoming turns \u2014 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 \u2014 explain quiet gaps; note that when a sub-agent opens a widget, detail.agent \u2014 and the agentName on the interaction message \u2014 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 \u2014 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) \u2014 absent when it closed unanswered (a timeout or a stop), and absent too when it settled by itself other than through the hold of a claimant \u2014 a widget registered resolvesItself (one that does its work and settles on its own, asking the person nothing, such as a generation run), or one outcome its controller said settled itself (ctx.resolve with resolvedItself, such as a generation phase that failed outright before its review gate ever asked anything) \u2014 which then carries detail.resolvedItself: true instead, as the interaction message does \u2014 nobody answered it, and the platform cannot tell it finishing from the person interrupting it (a Skip), so only the result of the widget itself can say which; the same value is stamped on the interaction message as answeredBy and on the result the asking tool handler receives (absent there in the same cases), 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; detail.edits, present only when non-zero, counts the editing actions a claimant ran on the widget before it was settled, whoever settled it, and those edits are stamped on the interaction message as edits, each with by, action, choice and args when it had some, in the order they ran, while a decidedOnUsersBehalf record carries their choice texts as edits, and when the person settled it after such edits the tool result carries an editedOnUsersBehalf record instead \u2014 the framing and those choice texts \u2014 so the model knows the widget was changed on the user behalf before the user answered, and that the user then confirmed it by finishing it), interaction.held (a claimant moved a pending interaction to the person or back to itself \u2014 detail.heldBy is the new holder, detail.claimant the interceptor; detail.late: true is an interceptor that declined it when it opened claiming it afterwards, such as the autopilot resumed while it was open; 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 \u2014 detail.claimant + reason), autopilot.* (the autopilot, a decorator that answers interactions on behalf of the user \u2014 autopilot.claimed / autopilot.declined say whether it took each interaction and, for a decline, detail.reason: paused, other-flow, no-autopilot, unavailable, userOnly, policy or no-controller; one declined as paused that is still open when the person resumes the autopilot is looked at again, and the autopilot.claimed or autopilot.declined recorded for it then carries detail.onResume: true (a decline then can also be claimed-elsewhere, another interceptor having claimed it first); a restored mode looks at nothing; autopilot.decision-sent is what it was sent (detail.chars; detail.nothingEnabled: true when every action on the widget was unavailable \u2014 a gate whose controller said it was asking, such as a failed build the autopilot may not cancel \u2014 so it could only hand it back, which it may then do even after the person asked it to decide it itself; a widget whose controller says it is working (ctx.setWorking) is never sent a decision until it says it is asking, even when an action is enabled or the person resumes the autopilot); autopilot.acted is what it did (detail.action, detail.note, detail.finished); autopilot.handed-back is a decision it gave to the person (detail.reason and detail.trigger: model, no-decision or error); autopilot.paused / autopilot.resumed are mode changes (detail.scope, detail.trigger, detail.decideYourself when the person resumed during a hand-back; detail.trigger is restored when the mode came back with the session after a reload, applied once its flow re-activated, which starts nothing by itself); autopilot.carried is the mode, running or paused, going with the task to the agent that took it over, rather than ending with the flow as on any other change of flow owner: to the target of a hand-off, or back to its caller on the hand-back (detail.from, detail.to, detail.mode); a pause the person chose goes with it, and Stop and Clear still end it; a mode restored for the target of a hand-off applies to its caller when the reload hands back; autopilot.error is the wrapper itself failing; autopilot.refinement counts a refining action against its step \u2014 a written answer (reply) or a widget action declared refines, such as a regenerate with instructions, counted together (detail.action, detail.stepKey, detail.count, detail.limitReached, after which every refining action is withdrawn for that step: not listed, and refused; the decision and every relisting of its actions say how many are left at the step, as a line Refinements left at this step: N, wherever the widget has a refining action); autopilot.handback-presented is the turn-level hand-back, shown when a working turn ended needing the person with no widget to hand over (detail.why: max-iterations, context-exhausted, failure or question; detail.options; detail.choice once answered); autopilot.catch-up is the autopilot being given the whole visible transcript at once (detail.why: first, for its first decision in a flow or after a reload; size, when its own history passed its budget and was rebuilt short \u2014 detail.ownChars; or compacted, when a compaction removed the last message it had seen, so it reads the summary and everything since, short; in each, what it had sent on the user behalf is included and labelled as its own, since its own history does not hold it); autopilot.cost-dropped is autopilot spend that no message carries, so it is NOT in the session total (detail.costUsd and detail.why: handed-back, aborted or stale for a written question it answered that no reply was sent for \u2014 stale when a pause, a resume, a new turn or the end of its flow came before the answer landed, which then went nowhere \u2014 or no-recorder when the driver had no way to book a decision to its interaction); a hand-back trigger can also be budget (the decision passed its spend cap), watchdog (its work went quiet: no ready surface and no heartbeat, or its own decision stalled with no model call landing, which stops that decision) or detached (the autopilot was removed while it held the interaction, which went to the person with no reason shown). To debug one autopilot decision, follow its interactionId: interaction.requested (heldBy), autopilot.claimed, autopilot.decision-sent, autopilot.acted or autopilot.handed-back, interaction.invoked, interaction.resolved (answeredBy), then the next turn of the working agent), interaction.invoked (a claimant ran one of the actions the widget itself exposes, through its hold, the same code the button runs \u2014 detail.claimant, detail.action (an option id, select or reply) and detail.finished, whether that settled the interaction, and when it did not, the run is recorded as an edit; the choice and narration it recorded reach the result of the tool that asked as decidedOnUsersBehalf; the person's own programmatic action, from a host with no DOM to click, carries detail.by: user in place of detail.claimant, and is not recorded as an edit nor as a decision on their behalf, so what it settles is answered by user), interaction.step (a long action run as named steps through runSteps, which survive a reload \u2014 detail.step and detail.outcome: started, done, skipped when the step was already done before a reload, or resumed when it started before a reload and runs again with what it saved part-way, such as a job id it re-attaches to), interaction.checkpoint (the checkpoints a conversation keeps for its long actions: the one in flight, and each one a reload cut, held apart until a request of its own widget type takes it over, so a resumed flow that opens other long widgets first, which save their own, loses nothing \u2014 detail.action: resumed when a reload cut the work and a request of the same widget type that the registration sameWork agrees is the same work took it over, refused when sameWork said a new request is different work (detail.saved is the identity it kept; detail.kept: true, since it stays for a later request of that type, and is offered to every one until one agrees) or when runSteps found the handed-over checkpoint malformed and started fresh (detail.reason, detail.saved), or cleared when its flow ended, once per checkpoint, with detail.cut: true for one a reload cut that nothing took over), context.updated/threshold-crossed (token + cost), headless.attached (a HeadlessSession attached, for a host that drives the assistant with no screen \u2014 detail.label, what the host called itself, when it gave one) and headless.raw-resolved (that host settled an interaction raw, bypassing the widget's own actions: detail.interactionId and detail.component; the result went to the tool as given, so check what the widget would have enforced), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool \u2014 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.",
+  "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` \u2014 a `\"<parent> \u203A <sub-agent>\"` breadcrumb that composes when nested (e.g. `\"UI Builder \u203A Planner \u203A Grounding\"`) \u2014 and interleaved by their original timestamps within the subagent.started\u2192completed/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 \u2014 read its hoisted messages for model/tokens/cost and turn-by-turn activity, and the bracketing subagent.* events for the run's span.",
+  "`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 \u2014 sessionCostUsd, sessionTokensConsumed, and the four-bucket sessionUsage lifted to the top of this log), activeDebugSnapshot (the active agent's `getDebugSnapshot()` taken fresh at export \u2014 reflects state NOW, which may have advanced beyond the last turn's agentSnapshot), debug (optional host-supplied debug state), host, and the export timestamp.",
+  "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\u2019s prompt again in the next turn\u2019s and is expected to dwarf the context size \u2014 that is not double-counting.",
+  "kind:'event' type 'routing.decided' \u2014 how ONE user turn was routed, emitted by the orchestrating driver before the agent runs. Only a user turn is routed: a hand-off names its target, so the agents a hand-off runs show up as agent.handoff events, not as more routing.decided. `decision` is why that agent was chosen: 'classified' (the classifier ran and picked one), 'no-match' (it ran and answered -1 \u2014 nothing listed covers the request), 'pinned' (a user pin, an agent named for that one message by the send's `agent` option, 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 \u2014 `error` carries the last one). `to` names the agent and `fallback` says whether that agent is the fallback. `candidates` is what was ON THE BALLOT \u2014 every classifier-eligible specialist \u2014 in ballot order, so `index` \u2014 the classifier's own answer \u2014 indexes it directly. `candidates` is absent on the three decisions that put nothing to a vote \u2014 'pinned', 'single-candidate', 'no-specialists'. 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 decisions that can reach the fallback ('no-match', 'no-specialists', 'provider-unavailable', 'classifier-failed') 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.",
+  "kind:'event' type 'routing.decided'.`usage` \u2014 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 \u2014 it is the one component of a session's real spend that the totals cannot see.",
+  "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 \u2014 `decision` says whether anything was actually asked."
+];
 
 // src/utils/delegated-message.ts
 var DEFAULT_DELEGATE_FRAMING = "Sent on the user's behalf.";
@@ -4372,9 +4408,15 @@ function calibrate(history, preambleTokens) {
   if (heaviest >= 0) estimates[heaviest] += messages - assigned;
   return { overhead, total, estimates, scale };
 }
+function isContextMeasurable(history) {
+  return history.some((m) => m.inputTokens != null || m.role === "compacted-summary");
+}
 function estimateMessageTokens(history, preambleTokens) {
   return calibrate(history, preambleTokens).estimates;
 }
+function estimateContextTokens(history) {
+  return calibrate(history).total;
+}
 function estimateRequestTokens(storedHistory, requestHistory, preambleTokens) {
   const { overhead } = calibrate(storedHistory, preambleTokens);
   let requestBaseline = 0;
@@ -5306,6 +5348,16 @@ var HARVESTED_SUBAGENT_EVENTS = /* @__PURE__ */ new Set([
 
 // src/utils/tool-fold.ts
 var TOOL_FOLD_SYMBOL = Symbol("toolFold");
+function expandToolTree(definitions, handlers) {
+  return definitions.map((def) => {
+    const handler = handlers[def.name];
+    const fold = handler ? handler[TOOL_FOLD_SYMBOL] : void 0;
+    if (fold) {
+      return { ...def, tools: expandToolTree(fold.tools, fold.handlers) };
+    }
+    return { ...def };
+  });
+}
 
 // src/components/chat-driver/fold-controller.ts
 var foldOf = (handler) => handler ? handler[TOOL_FOLD_SYMBOL] : void 0;
@@ -5494,8 +5546,15 @@ function buildDecisionSurface(spec) {
     }
     ids.add(id);
   }
+  const extra = spec.actions ?? {};
+  assertActionShapes("exposeDecision", extra);
+  for (const name of Object.keys(extra)) {
+    if (ids.has(name) || spec.multi && name === SELECT_ACTION || spec.freeText && name === REPLY_ACTION) {
+      throw new Error(`exposeDecision: the action "${name}" is also an option or a reserved name.`);
+    }
+  }
   const byIdOrLabel = (key) => typeof key === "string" ? options.find((o) => o.id === key || o.label === key) : void 0;
-  const actions = () => {
+  const builtIn = () => {
     const enabled = options.filter(isEnabled);
     return [
       ...options.map((o) => {
@@ -5519,6 +5578,10 @@ function buildDecisionSurface(spec) {
       ...spec.freeText ? [replyAction()] : []
     ];
   };
+  const actions = () => [
+    ...builtIn(),
+    ...Object.entries(extra).map(([name, a]) => describeSpecAction(name, a))
+  ];
   const replyReason = () => unavailableReason(spec.freeTextUnavailable);
   const replyAction = () => {
     const unavailable = replyReason();
@@ -5543,7 +5606,7 @@ function buildDecisionSurface(spec) {
     facts,
     ...readable,
     actions,
-    isReady: () => actions().some((a) => a.finishes && a.enabled),
+    isReady: () => builtIn().some((a) => a.finishes && a.enabled),
     prepare(name, args) {
       if (spec.multi && name === SELECT_ACTION) {
         const picked = args?.options;
@@ -5585,6 +5648,8 @@ function buildDecisionSurface(spec) {
       }
       const option = options.find((o) => o.id === name);
       if (!option) {
+        const own = ownAction(extra, name);
+        if (own) return prepareSpecAction(name, own, args);
         return { error: "unknown-action", message: `No action "${name}" here.` };
       }
       const why = reasonFor(option);
@@ -5631,31 +5696,88 @@ function checkArgs(args, schema) {
   const wrong = Object.entries(properties).filter(([key, prop]) => record[key] !== void 0 && !matchesType(record[key], prop?.type)).map(([key, prop]) => `${key} should be ${String(prop?.type)}`);
   return wrong.length ? `${wrong.join("; ")}.` : void 0;
 }
-function buildFullSurface(spec) {
-  for (const [name, action] of Object.entries(spec.actions)) {
+function exampleArgs(schema) {
+  const properties = schema.properties ?? {};
+  const required = new Set(schema.required ?? []);
+  const placeholder = (type) => {
+    switch (type) {
+      case "string":
+        return "\u2026";
+      case "number":
+      case "integer":
+        return 0;
+      case "boolean":
+        return false;
+      case "array":
+        return [];
+      case "object":
+        return {};
+      default:
+        return null;
+    }
+  };
+  const names = Object.keys(properties).sort(
+    (a, b) => Number(required.has(b)) - Number(required.has(a))
+  );
+  return Object.fromEntries(names.map((name) => [name, placeholder(properties[name]?.type)]));
+}
+var describeSpecAction = (name, a) => {
+  const unavailable = unavailableReason(a.unavailable);
+  return {
+    name,
+    finishes: !!a.finishes,
+    enabled: unavailable === void 0,
+    ...unavailable !== void 0 ? { unavailable } : {},
+    description: a.description,
+    ...a.text ? { args: "text" } : {},
+    ...a.argsSchema ? { args: "fields", argsSchema: a.argsSchema } : {},
+    ...a.refines ? { refines: true } : {}
+  };
+};
+var prepareSpecAction = (name, action, args) => {
+  const why = unavailableReason(action.unavailable);
+  if (why !== void 0) {
+    return { error: "disabled", message: `"${name}" is not available right now: ${why}.` };
+  }
+  if (action.text) {
+    const text = args?.text;
+    if (typeof text !== "string" || !text.trim()) {
+      return {
+        error: "invalid-args",
+        message: `"${name}" takes its argument as \`text\`, not empty.`
+      };
+    }
+    const trimmed = text.trim();
+    return {
+      choice: `${name}: ${trimmed}`.slice(0, CHOICE_CHARS),
+      finishes: !!action.finishes,
+      run: () => action.run(trimmed)
+    };
+  }
+  const problem = checkArgs(args ?? {}, action.argsSchema);
+  if (problem) return { error: "invalid-args", message: `"${name}": ${problem}` };
+  const shown = args && Object.keys(args).length ? ` ${JSON.stringify(args)}` : "";
+  return {
+    choice: `${name}${shown}`.slice(0, CHOICE_CHARS),
+    finishes: !!action.finishes,
+    run: () => action.run(args ?? {})
+  };
+};
+var ownAction = (actions, name) => Object.prototype.hasOwnProperty.call(actions, name) ? actions[name] : void 0;
+var assertActionShapes = (who, actions) => {
+  for (const [name, action] of Object.entries(actions)) {
     if (action.text && action.argsSchema) {
-      throw new Error(
-        `exposeSurface: action "${name}" takes \`text\` or \`argsSchema\`, not both.`
-      );
+      throw new Error(`${who}: action "${name}" takes \`text\` or \`argsSchema\`, not both.`);
     }
   }
+};
+function buildFullSurface(spec) {
+  assertActionShapes("exposeSurface", spec.actions);
   const views = spec.views && Object.keys(spec.views).length ? spec.views : void 0;
   if (spec.preview !== void 0 && !(views && Object.prototype.hasOwnProperty.call(views, spec.preview))) {
     throw new Error(`exposeSurface: the preview "${spec.preview}" is not one of its views.`);
   }
-  const actions = () => Object.entries(spec.actions).map(([name, a]) => {
-    const unavailable = unavailableReason(a.unavailable);
-    return {
-      name,
-      finishes: !!a.finishes,
-      enabled: unavailable === void 0,
-      ...unavailable !== void 0 ? { unavailable } : {},
-      description: a.description,
-      ...a.text ? { args: "text" } : {},
-      ...a.argsSchema ? { args: "fields", argsSchema: a.argsSchema } : {},
-      ...a.refines ? { refines: true } : {}
-    };
-  });
+  const actions = () => Object.entries(spec.actions).map(([name, a]) => describeSpecAction(name, a));
   return {
     prompt: spec.prompt,
     facts: () => ({}),
@@ -5671,35 +5793,9 @@ function buildFullSurface(spec) {
     actions,
     isReady: () => actions().some((a) => a.enabled),
     prepare(name, args) {
-      const action = Object.prototype.hasOwnProperty.call(spec.actions, name) ? spec.actions[name] : void 0;
+      const action = ownAction(spec.actions, name);
       if (!action) return { error: "unknown-action", message: `No action "${name}" here.` };
-      const why = unavailableReason(action.unavailable);
-      if (why !== void 0) {
-        return { error: "disabled", message: `"${name}" is not available right now: ${why}.` };
-      }
-      if (action.text) {
-        const text = args?.text;
-        if (typeof text !== "string" || !text.trim()) {
-          return {
-            error: "invalid-args",
-            message: `"${name}" takes its argument as \`text\`, not empty.`
-          };
-        }
-        const trimmed = text.trim();
-        return {
-          choice: `${name}: ${trimmed}`.slice(0, CHOICE_CHARS),
-          finishes: !!action.finishes,
-          run: () => action.run(trimmed)
-        };
-      }
-      const problem = checkArgs(args ?? {}, action.argsSchema);
-      if (problem) return { error: "invalid-args", message: `"${name}": ${problem}` };
-      const shown = args && Object.keys(args).length ? ` ${JSON.stringify(args)}` : "";
-      return {
-        choice: `${name}${shown}`.slice(0, CHOICE_CHARS),
-        finishes: !!action.finishes,
-        run: () => action.run(args ?? {})
-      };
+      return prepareSpecAction(name, action, args);
     }
   };
 }
@@ -6565,6 +6661,66 @@ var InteractionController = class {
     this.contexts.get(interactionId)?.dispose();
     this.contexts.delete(interactionId);
   }
+  /**
+   * See `ChatDriver.invokeAsUser`: `hold.invoke`'s sibling for the person (GENC-1660).
+   *
+   * Runs the action the way the widget's own button does, and records nothing against a claimant:
+   * no `settledBy`, no `decision`. So `whoAnswered` credits a settle to the person
+   * (`answeredBy: 'user'`), exactly as a click would be. Refused unless the person holds the
+   * interaction: a claimant that does is not pushed aside, the person takes it back first. An
+   * editing action leaves no edit record either — those mark what a claimant changed on the
+   * person's behalf, and this is the person's own change.
+   */
+  async invokeAsUser(interactionId, action, args) {
+    const pending = this.pending.get(interactionId);
+    const handle = this.contexts.get(interactionId);
+    if (!pending || !handle) {
+      return { ok: false, error: "not-held", message: "This interaction has already ended." };
+    }
+    if (handle.context.heldBy !== "user") {
+      return {
+        ok: false,
+        error: "not-held",
+        message: "Another agent holds this interaction, so it was not acted on. The person has to take it back first, for example by pausing the autopilot."
+      };
+    }
+    const { surface } = handle;
+    if (!surface) {
+      return { ok: false, error: "no-surface", message: "Nothing has been exposed here yet." };
+    }
+    if (pending.running) {
+      return { ok: false, ...BUSY, actions: surface.actions() };
+    }
+    const prepared = surface.prepare(action, args);
+    if ("error" in prepared) {
+      return { ok: false, ...prepared, actions: surface.actions() };
+    }
+    const token = {};
+    pending.running = { token, finishes: prepared.finishes, note: void 0 };
+    let output;
+    try {
+      const ran = prepared.run();
+      output = isThenable(ran) ? await ran : ran;
+    } catch (e) {
+      logger2.warn(`InteractionController: action "${action}" threw:`, e);
+      return { ok: false, error: "threw", message: e instanceof Error ? e.message : String(e) };
+    } finally {
+      if (pending.running?.token === token) pending.running = void 0;
+    }
+    const finished = !this.pending.has(interactionId) || pending.early !== void 0;
+    recordMetaEvent(this.deps.sessionKey, "interaction.invoked", {
+      interactionId,
+      by: "user",
+      action,
+      finished
+    });
+    return {
+      ok: true,
+      finished,
+      actions: finished ? [] : surface.actions(),
+      ...output !== void 0 && !finished ? { output } : {}
+    };
+  }
   /**
    * See `ChatDriver.recordExternalCost`.
    *
@@ -8509,6 +8665,14 @@ var ChatDriver = class _ChatDriver extends EventTarget {
   addInteractionInterceptor(interceptor) {
     return this.interactions.addInterceptor(interceptor);
   }
+  /**
+   * {@inheritDoc AiDriver.invokeAsUser}
+   *
+   * @beta
+   */
+  invokeAsUser(interactionId, action, args) {
+    return this.interactions.invokeAsUser(interactionId, action, args);
+  }
   /**
    * {@inheritDoc AiDriver.presentInteraction}
    *
@@ -10005,6 +10169,17 @@ var BaseDriverDecorator = class _BaseDriverDecorator extends EventTarget {
   addInteractionInterceptor(interceptor) {
     return this.inner.addInteractionInterceptor?.(interceptor) ?? (() => void 0);
   }
+  /**
+   * Forwarded: the interaction belongs to the driver that opened it. An inner driver that cannot
+   * run actions answers as if the interaction had ended.
+   */
+  invokeAsUser(interactionId, action, args) {
+    return this.inner.invokeAsUser?.(interactionId, action, args) ?? Promise.resolve({
+      ok: false,
+      error: "not-held",
+      message: "This interaction has already ended."
+    });
+  }
   presentInteraction(componentName, data, options) {
     return this.inner.presentInteraction?.(componentName, data, options) ?? Promise.reject(new Error("presentInteraction: the inner driver cannot show interactions."));
   }
@@ -11301,67 +11476,404 @@ var strictFallbackAgent = {
 Answer in a single short sentence. Do not elaborate.`
 };
 
-// src/utils/usage-rows.ts
-function hasUsage(m) {
-  return m.cost != null || m.externalCostUsd != null || m.inputTokens != null || m.outputTokens != null || m.cacheReadTokens != null || m.cacheWriteTokens != null;
+// src/utils/message-partition.ts
+var SESSION_RESTORED_LABEL = "Restored previous conversation";
+var SESSION_RESUMED_LABEL = "Restored previous conversation. Resuming from where we were interrupted.";
+var SESSION_RESTORE_FAILED_LABEL = "Couldn't restore the previous conversation";
+var isSessionRestoredMarker = (m) => m.role === "system-event" && (m.content === SESSION_RESTORED_LABEL || m.content === SESSION_RESUMED_LABEL);
+var isSessionRestoreFailedMarker = (m) => m.role === "system-event" && m.content === SESSION_RESTORE_FAILED_LABEL;
+var isSessionNoticeMarker = (m) => isSessionRestoredMarker(m) || isSessionRestoreFailedMarker(m);
+function filterVisibleMessages(messages, toggles) {
+  return messages.filter((m) => {
+    if (m.role === "compacted-summary") {
+      return true;
+    }
+    if (m.role === "system-event") {
+      return isSessionNoticeMarker(m) ? toggles.showRestoreNotices : toggles.showAgentSwitchIndicator;
+    }
+    if (m.role === "tool") {
+      return false;
+    }
+    if (m.category === "reasoning") {
+      return toggles.showThinkingSteps;
+    }
+    if (m.category === "narration") {
+      return toggles.showNarration;
+    }
+    if (m.thinking && !toggles.showThinkingSteps) {
+      return false;
+    }
+    if (m.role === "assistant" && !m.content?.trim() && !m.toolCalls?.length && !m.interaction) {
+      return false;
+    }
+    const isToolRelated = !!(m.toolCalls?.length || m.toolResult);
+    return !isToolRelated || toggles.showToolCalls;
+  });
 }
-function usageRows(messages) {
-  return collectRows(messages, 0, void 0);
+
+// src/autopilot/decision-message.ts
+var FALLBACK_DATA_CHARS = 2e3;
+var READ_CAP_CHARS = 2e4;
+function capRead(text, max = READ_CAP_CHARS) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}
+[Cut at ${max} of ${text.length} characters. Ask for less: a narrower view, or a smaller page (an offset or a limit) where the tool takes one.]`;
+}
+function widgetAsText(componentName, data, result) {
+  const asText = getInteractionRegistration(componentName)?.asText;
+  if (asText) {
+    try {
+      return asText(data, result);
+    } catch {
+    }
+  }
+  const dump = JSON.stringify(data) ?? "";
+  return `[${componentName}] ${dump.length > FALLBACK_DATA_CHARS ? `${dump.slice(0, FALLBACK_DATA_CHARS)}\u2026` : dump}`;
+}
+var NOTHING_ENABLED_LINE = "Nothing here can be done right now: every action is unavailable. Hand it back with hand_back, saying in your reason what is unavailable and why, so the user knows what to do.";
+var anyActionable = (actions, withholdRefining) => actions.some((a) => a.enabled && !(withholdRefining && a.refines));
+function renderActions(actions, options = {}) {
+  const numbering = [];
+  const lines = [];
+  for (const action of actions) {
+    if (options.withholdRefining && action.refines) continue;
+    const unavailable = action.enabled ? "" : ` (not available right now${action.unavailable ? `: ${action.unavailable}` : ""})`;
+    if (action.description !== void 0) {
+      const call = action.args === "fields" ? `${action.name}({fields})` : action.args === "text" ? `${action.name}({text})` : `${action.name}()`;
+      const settles = action.finishes ? "settles it" : "does not settle it";
+      lines.push(`  ${call} \u2014 ${action.description} (${settles})${unavailable}`);
+      if (action.argsSchema) lines.push(`    fields schema: ${JSON.stringify(action.argsSchema)}`);
+    } else if (action.args === "options") {
+      lines.push(`  select({options}) \u2014 choose several, by number or label${unavailable}`);
+    } else if (action.args === "text") {
+      lines.push(`  reply({text}) \u2014 answer in your own words${unavailable}`);
+    } else {
+      numbering.push(action.name);
+      lines.push(`  [${numbering.length}] "${action.label ?? action.name}"${unavailable}`);
+    }
+  }
+  const allSettle = actions.every((a) => a.description === void 0);
+  const actionable = anyActionable(actions, options.withholdRefining);
+  const left = options.refinementsLeft;
+  const refinements = left !== void 0 && Number.isFinite(left) && actions.some((a) => a.refines) ? [
+    `Refinements left at this step: ${left}${left > 0 ? "" : " (written answers and other refining actions are withdrawn)"}`
+  ] : [];
+  return {
+    text: [
+      `${allSettle ? "Actions (each settles it)" : "Actions"}:`,
+      ...lines,
+      ...refinements,
+      ...actionable ? [] : [NOTHING_ENABLED_LINE]
+    ].join("\n"),
+    numbering,
+    actionable
+  };
 }
-function bucketsOf(usage) {
+function renderViews(surface) {
+  const views = Object.entries(surface.views ?? {});
+  if (!views.length) return [];
+  return [
+    "Views (widget_read):",
+    ...views.map(([name, description]) => {
+      const shown = name === surface.preview ? " (shown below as Now)" : "";
+      return description ? `  ${name} \u2014 ${description}${shown}` : `  ${name}${shown}`;
+    })
+  ];
+}
+function renderDecision(opts) {
+  const { surface } = opts;
+  const facts = surface.facts();
+  const actions = renderActions(surface.actions(), {
+    withholdRefining: opts.withholdRefining,
+    refinementsLeft: opts.refinementsLeft
+  });
+  let full = renderViews(surface);
+  if (surface.describe) {
+    let preview = "";
+    if (surface.preview !== void 0) {
+      try {
+        preview = capRead(JSON.stringify(surface.read?.(surface.preview)) ?? "");
+      } catch {
+        preview = "";
+      }
+    }
+    full = [surface.describe(), ...full, ...preview ? [`Now: ${preview}`] : []];
+  }
+  const parts = [
+    `<interaction id="${opts.interactionId}" widget="${opts.componentName}">`,
+    widgetAsText(opts.componentName, opts.data),
+    ...full,
+    ...Object.keys(facts).length ? [`Facts: ${JSON.stringify(facts)}`] : [],
+    ...surface.prompt ? [`Guidance: ${surface.prompt}`] : [],
+    actions.text,
+    // Asked to decide it themselves, with nothing that can be done: handing it back is the only way
+    // out, so it stays open, and the reason tells the person why the autopilot could not.
+    ...opts.decideYourself ? [
+      actions.actionable ? "The user handed this one back to you and asked you to use your best judgement: decide it yourself. hand_back is not available." : "The user handed this one back to you and asked you to decide it yourself, but nothing here can be done right now, so hand_back is available after all: use it, and say why you could not decide."
+    ] : [],
+    "</interaction>"
+  ];
+  return { text: parts.join("\n"), numbering: actions.numbering, actionable: actions.actionable };
+}
+var DEFAULT_VISIBILITY = {
+  showToolCalls: false,
+  showThinkingSteps: false,
+  showNarration: false,
+  showAgentSwitchIndicator: false,
+  showRestoreNotices: false
+};
+var answeredPhrase = (componentName, resolved, answeredBy, claimant, resolvedItself) => {
+  if (resolved?.status === "timeout") {
+    return "answered by nobody";
+  }
+  if (answeredBy === claimant) return "answered by you";
+  if (resolvedItself && answeredBy === void 0) return "finished";
+  if (answeredBy === void 0 || answeredBy === "user") {
+    return getInteractionRegistration(componentName)?.resolvesItself === true ? "finished" : "answered by the user";
+  }
+  return "answered on the user's behalf";
+};
+var SHORT_FORM_RECENT = 20;
+function visibleTranscript(messages, opts) {
+  const visible = filterVisibleMessages([...messages], DEFAULT_VISIBILITY);
+  const olderThan = opts.short ? visible.length - SHORT_FORM_RECENT : -1;
+  const lines = [];
+  visible.forEach((m, i) => {
+    if (m.interaction) {
+      const { interactionId, componentName, data, resolved, answeredBy, resolvedItself } = m.interaction;
+      if (interactionId === opts.skipInteractionId || !resolved) return;
+      const answered = answeredPhrase(
+        componentName,
+        resolved,
+        answeredBy,
+        opts.claimant,
+        resolvedItself
+      );
+      const text = widgetAsText(componentName, data, resolved);
+      lines.push(`[${componentName}, ${answered}] ${i < olderThan ? text.split("\n")[0] : text}`);
+      return;
+    }
+    if (m.role === "compacted-summary") {
+      lines.push(`[Earlier, summarised] ${m.content ?? ""}`);
+      for (const u of m.compaction?.preservedUserMessages ?? []) {
+        lines.push(
+          u.delegate === opts.claimant && opts.includeOwn ? `You (on the user's behalf, earlier): ${u.content}` : u.delegate ? `User (on their behalf, earlier): ${u.content}` : `User (earlier): ${u.content}`
+        );
+      }
+      return;
+    }
+    if (m.delegate === opts.claimant) {
+      if (!opts.includeOwn || !m.content?.trim()) return;
+      lines.push(
+        m.role === "assistant" ? `You (to the user): ${m.content}` : `You (on the user's behalf): ${m.content}`
+      );
+      return;
+    }
+    if ((m.role === "user" || m.role === "synthetic-user") && m.content?.trim()) {
+      lines.push(m.delegate ? `User (on their behalf): ${m.content}` : `User: ${m.content}`);
+      return;
+    }
+    if (m.role === "assistant" && m.content?.trim()) lines.push(`Assistant: ${m.content}`);
+  });
+  return lines;
+}
+
+// src/headless/describe-interaction.ts
+var describeAction = (action, n) => ({
+  ...n !== void 0 ? { n } : {},
+  name: action.name,
+  ...action.label !== void 0 ? { label: action.label } : {},
+  ...action.description !== void 0 ? { description: action.description } : {},
+  enabled: action.enabled,
+  ...action.unavailable !== void 0 ? { unavailable: action.unavailable } : {},
+  ...action.args !== void 0 ? { args: action.args } : {},
+  ...action.argsSchema !== void 0 ? { argsSchema: action.argsSchema } : {},
+  finishes: action.finishes,
+  ...action.refines ? { refines: true } : {}
+});
+function describeInteraction(input) {
+  const { ctx, componentName, data } = input;
+  const base = {
+    interactionId: ctx.interactionId,
+    component: componentName,
+    heldBy: ctx.heldBy
+  };
+  const { surface } = ctx;
+  if (!surface) {
+    const hasController = ctx.controller !== void 0;
+    return {
+      ...base,
+      controller: hasController,
+      // A controller that has not exposed its surface yet will: wait for it. Without one, the
+      // widget is all there is.
+      ready: !hasController,
+      text: widgetAsText(componentName, data),
+      actions: []
+    };
+  }
+  const rendered = renderDecision({
+    interactionId: ctx.interactionId,
+    componentName,
+    data,
+    surface
+  });
+  const actions = surface.actions().map((a) => {
+    const index = rendered.numbering.indexOf(a.name);
+    return describeAction(a, index >= 0 && a.description === void 0 ? index + 1 : void 0);
+  });
+  let facts;
+  try {
+    const read = surface.facts();
+    if (Object.keys(read).length) facts = { ...read };
+  } catch {
+  }
   return {
-    uncachedInputTokens: usage.uncachedInputTokens,
-    cacheReadTokens: usage.cacheReadTokens,
-    cacheWriteTokens: usage.cacheWriteTokens,
-    outputTokens: usage.outputTokens
+    ...base,
+    controller: true,
+    ready: surface.isReady(),
+    text: rendered.text,
+    actions,
+    ...surface.views && Object.keys(surface.views).length ? { views: { ...surface.views } } : {},
+    ...facts ? { facts } : {}
   };
 }
-function collectRows(messages, depth, subAgentOf) {
-  const rows = [];
-  for (const m of messages) {
-    if (hasUsage(m)) {
-      const cacheReadTokens = m.cacheReadTokens ?? 0;
-      const cacheWriteTokens = m.cacheWriteTokens ?? 0;
-      rows.push({
-        source: "request",
-        model: m.model,
-        // The driver stamps `ChatMessage.provider` from the resolved provider's own
-        // status, so it is AUTHORITATIVE and covers vendors the model allowlists do
-        // not — a server-proxied `gpt-5` turn is `provider: 'openai'` on the message
-        // and unknown to `vendorOfModel`. Prefer it; fall back to resolving the model
-        // id only for messages persisted before the field existed. Still left
-        // undefined when neither knows, rather than guessed at.
-        provider: m.provider ?? (m.model ? vendorOfModel(m.model) : void 0),
-        ...m.cost != null && { costUsd: m.cost },
-        ...m.externalCostUsd != null && { externalCostUsd: m.externalCostUsd },
-        // Uncached input is the REMAINDER, matching `sumUsage`: `inputTokens` is the
-        // whole prompt and the cache fields break it down. Clamped for the same
-        // reason — hand-edited history must not drive a total negative.
-        uncachedInputTokens: Math.max(0, (m.inputTokens ?? 0) - cacheReadTokens - cacheWriteTokens),
-        cacheReadTokens,
-        cacheWriteTokens,
-        outputTokens: m.outputTokens ?? 0,
-        ...m.agentName != null && { agentName: m.agentName },
-        subAgentDepth: depth,
-        ...subAgentOf != null && { subAgentOf }
-      });
+
+// src/state/persistence/diagnostics.ts
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+var DIGEST_RADIX = 36;
+function configDigest(json) {
+  let a = FNV_OFFSET_BASIS;
+  let b = FNV_PRIME;
+  for (let i = 0; i < json.length; i += 1) {
+    const c = json.charCodeAt(i);
+    a = Math.imul(a ^ c, FNV_PRIME) >>> 0;
+    b = Math.imul(b ^ c, FNV_OFFSET_BASIS) >>> 0;
+  }
+  return [json.length, a, b].map((n) => n.toString(DIGEST_RADIX)).join("-");
+}
+function turnIdentity(entry) {
+  return `turn::${String(entry.turnIndex ?? "")}::${entry.timestamp ?? ""}::${String(entry.agentName ?? "")}`;
+}
+var KIND_RANK = { event: 0, turn: 1, message: 2 };
+var UNKNOWN_KIND_RANK = 99;
+function assembleDebugLog(entries, readme) {
+  const seenAt = /* @__PURE__ */ new Map();
+  let latestMeta;
+  const timeline = [];
+  for (const entry of entries) {
+    if (entry.kind === "meta-snapshot") {
+      if (!latestMeta || (entry.timestamp ?? "") >= (latestMeta.timestamp ?? "")) {
+        latestMeta = entry;
+      }
+      continue;
     }
-    const rolled = m.compaction?.rolledUpUsage;
-    if (rolled) {
-      rows.push({
-        source: "compaction",
-        ...rolled.costUsd != null && { costUsd: rolled.costUsd },
-        ...bucketsOf(rolled),
-        ...m.agentName != null && { agentName: m.agentName },
-        subAgentDepth: depth,
-        ...subAgentOf != null && { subAgentOf }
-      });
+    const id = entry.kind === "turn" ? turnIdentity(entry) : JSON.stringify(entry);
+    const at = seenAt.get(id);
+    if (at !== void 0) {
+      if (entry.usage && !timeline[at].usage) timeline[at] = entry;
+      continue;
     }
-    for (const tc of m.toolCalls ?? []) {
-      if (tc.subAgentTrace) rows.push(...collectRows(tc.subAgentTrace, depth + 1, tc.id));
+    seenAt.set(id, timeline.length);
+    timeline.push(entry);
+  }
+  timeline.sort((a, b) => {
+    const ta = a.timestamp ?? "";
+    const tb = b.timestamp ?? "";
+    if (ta < tb) return -1;
+    if (ta > tb) return 1;
+    return (KIND_RANK[a.kind] ?? UNKNOWN_KIND_RANK) - (KIND_RANK[b.kind] ?? UNKNOWN_KIND_RANK);
+  });
+  const context = latestMeta?.meta?.context;
+  return { readme, sessionUsage: context?.sessionUsage, timeline, meta: latestMeta?.meta };
+}
+function withFreshMetaSnapshot(stored, fresh) {
+  return [...stored.filter((e) => e.kind !== "meta-snapshot"), fresh];
+}
+
+// src/utils/strip-agent-handlers.ts
+function stripAgentHandlers(agent) {
+  const serializable = {};
+  for (const [key, value] of Object.entries(agent)) {
+    if (key === "subAgents") continue;
+    if (typeof value === "function") continue;
+    if (value !== null && typeof value === "object" && Object.values(value).some((v) => typeof v === "function")) {
+      continue;
     }
+    serializable[key] = value;
   }
-  return rows;
+  if (agent.subAgents?.length) {
+    serializable.subAgents = agent.subAgents.map(stripAgentHandlers);
+  }
+  return serializable;
+}
+
+// src/main/meta-snapshot.ts
+function buildMetaSnapshot(input) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
+  let activeDebugSnapshot;
+  try {
+    activeDebugSnapshot = input.liveActiveAgent?.getDebugSnapshot?.();
+  } catch (e) {
+    activeDebugSnapshot = `<getDebugSnapshot threw: ${e instanceof Error ? e.message : String(e)}>`;
+  }
+  const contextUsagePercent = input.contextTokens != null && input.contextLimit != null && input.contextLimit > 0 ? Math.round(input.contextTokens / input.contextLimit * 100) : void 0;
+  const metaSnapshot = {
+    kind: "meta-snapshot",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    meta: {
+      timestamp,
+      host: input.host,
+      // stripAgentHandlers drops every function-valued field (handlers, lifecycle
+      // hooks, onUnresolvedTool, function-form resolvers) AND object handler bags
+      // like an object-form `toolHandlers`, and recurses subAgents — no manual
+      // exclusion list to keep in sync. We only override toolDefinitions
+      // afterwards to expand the fold tree for the log.
+      agentSummary: input.agents?.map((a) => ({
+        ...stripAgentHandlers(a),
+        toolDefinitions: Array.isArray(a.toolDefinitions) ? typeof a.toolHandlers === "function" ? (
+          // Static defs + dynamic handlers — can't walk fold tree
+          // because the handler map isn't materialized at log time.
+          a.toolDefinitions
+        ) : expandToolTree(a.toolDefinitions, a.toolHandlers ?? {}) : typeof a.toolDefinitions === "function" ? "<dynamic \u2014 resolved per turn>" : []
+      })),
+      activeSystemPrompt: typeof input.activeAgent?.systemPrompt === "function" ? "<dynamic \u2014 resolved per turn>" : input.activeAgent?.systemPrompt,
+      activePrimerHistory: input.activeAgent?.primerHistory,
+      activeFoldStack: input.activeFoldStack,
+      // Context window + cost snapshot. `sessionCostUsd` is the chat-scoped
+      // total (per-message `cost` summed); the transport's lifetime cost is
+      // not included here because it pools other call sites (suggestions,
+      // criteria interpretation, etc.) and would be misleading next to the
+      // chat-only token counts.
+      context: {
+        model: input.activeModel,
+        contextTokens: input.contextTokens,
+        contextLimit: input.contextLimit,
+        contextUsagePercent,
+        sessionCostUsd: input.sessionCostUsd,
+        sessionTokensConsumed: input.sessionTokensConsumed,
+        // The per-bucket split alongside the total. Without it a log shows a large
+        // token count next to a small cost with no way to tell why — the answer is
+        // almost always that most of the prompt was a cache hit.
+        sessionUsage: input.sessionUsage
+      },
+      // Snapshot captured fresh at log-export time — reflects state NOW, which
+      // may have transitioned since the last LLM call.
+      activeDebugSnapshot,
+      debug: input.debugState
+    }
+  };
+  const m = metaSnapshot.meta;
+  metaSnapshot.dedupSignature = configDigest(
+    JSON.stringify({
+      host: m.host,
+      agentSummary: m.agentSummary,
+      activeSystemPrompt: m.activeSystemPrompt,
+      activePrimerHistory: m.activePrimerHistory,
+      activeFoldStack: m.activeFoldStack
+    })
+  );
+  return metaSnapshot;
 }
 
 // src/utils/flatten-sub-agent-messages.ts
@@ -11415,44 +11927,880 @@ function buildTimelineEntries(input) {
   return [...messageEntries, ...turns, ...eventEntries];
 }
 
-// src/state/persistence/diagnostics.ts
-function turnIdentity(entry) {
-  return `turn::${String(entry.turnIndex ?? "")}::${entry.timestamp ?? ""}::${String(entry.agentName ?? "")}`;
+// src/state/persistence/debug-log-assembly.ts
+function buildDiagnosticEntries(input) {
+  const { driver, stateKey } = input;
+  const timelineEntries = buildTimelineEntries({
+    turnSnapshots: driver?.getTurnSnapshots?.() ?? [],
+    messages: driver?.getRawHistory?.() ?? input.messages ?? [],
+    metaEvents: stateKey ? getMetaEvents(stateKey) : []
+  });
+  return [
+    ...timelineEntries,
+    ...driver?.getExternalDiagnostics?.() ?? [],
+    input.metaSnapshot()
+  ];
+}
+async function lifetimeDebugLog(input) {
+  const { provider, stateKey } = input;
+  if (provider?.loadDiagnostics && stateKey) {
+    try {
+      await input.flush();
+      const stored = await provider.loadDiagnostics(stateKey);
+      if (stored.length) {
+        return assembleDebugLog(
+          withFreshMetaSnapshot(stored, input.metaSnapshot()),
+          DEBUG_LOG_README
+        );
+      }
+    } catch (e) {
+      logger2.error("Diagnostics load failed \u2014 using current-page log:", e);
+    }
+  }
+  return input.fallback();
 }
-var KIND_RANK = { event: 0, turn: 1, message: 2 };
-var UNKNOWN_KIND_RANK = 99;
-function assembleDebugLog(entries, readme) {
-  const seenAt = /* @__PURE__ */ new Map();
-  let latestMeta;
-  const timeline = [];
-  for (const entry of entries) {
-    if (entry.kind === "meta-snapshot") {
-      if (!latestMeta || (entry.timestamp ?? "") >= (latestMeta.timestamp ?? "")) {
-        latestMeta = entry;
+
+// src/headless/headless-debug.ts
+var DEFAULT_HOST = "headless";
+function headlessMetaSnapshot(driver, options = {}) {
+  const history = driver.getRawHistory?.() ?? [];
+  const usage = sumUsage(history);
+  const live2 = driver.getActiveAgent();
+  const context = options.context?.();
+  return buildMetaSnapshot({
+    agents: options.agents ? [...options.agents()] : void 0,
+    activeAgent: live2 ? stripAgentHandlers(live2) : void 0,
+    liveActiveAgent: live2,
+    activeFoldStack: driver instanceof ChatDriver ? driver.getActiveFoldNames() : void 0,
+    activeModel: context?.model,
+    contextTokens: isContextMeasurable(history) ? estimateContextTokens(history) : void 0,
+    contextLimit: context?.contextLimit,
+    sessionCostUsd: usage.costUsd,
+    sessionTokensConsumed: totalTokens(usage),
+    sessionUsage: usage,
+    debugState: options.debugState?.(),
+    host: options.host ?? DEFAULT_HOST
+  });
+}
+function headlessDiagnosticEntries(driver, stateKey, options = {}) {
+  return buildDiagnosticEntries({
+    driver,
+    stateKey,
+    metaSnapshot: () => headlessMetaSnapshot(driver, options)
+  });
+}
+function headlessCurrentDebugLog(driver, stateKey, options = {}) {
+  return assembleDebugLog(headlessDiagnosticEntries(driver, stateKey, options), DEBUG_LOG_README);
+}
+
+// src/autopilot/autopilot-session.ts
+function parseFields(fields) {
+  if (typeof fields === "object") return { ok: true, value: fields };
+  if (typeof fields !== "string") return { ok: false };
+  const fenced = /^\s*```[a-zA-Z]*\s*\n?([\s\S]*?)\n?\s*```\s*$/.exec(fields);
+  try {
+    return { ok: true, value: JSON.parse(fenced ? fenced[1] : fields) };
+  } catch {
+    return { ok: false };
+  }
+}
+var byNumberOf = (numbering) => (value) => /^\d+$/.test(value.trim()) ? numbering[Number(value.trim()) - 1] : void 0;
+function invokeArgsFor(listed, given, byNumber) {
+  if (listed?.args === "text") return { ok: true, args: { text: given.text } };
+  if (given.fields !== void 0 && given.fields !== null && given.fields !== "") {
+    const parsed = parseFields(given.fields);
+    return parsed.ok ? { ok: true, args: parsed.value } : { ok: false };
+  }
+  return {
+    ok: true,
+    args: {
+      ...given.options ? { options: given.options.map((o) => byNumber(o) ?? o) } : {},
+      ...given.text !== void 0 ? { text: given.text } : {}
+    }
+  };
+}
+function fieldsExample(action, schema) {
+  if (!schema) return "Send fields as a JSON object, as text.";
+  const call = JSON.stringify({ action, fields: JSON.stringify(exampleArgs(schema)) });
+  return `Send them as a JSON object inside a string, e.g. widget_act(${call}).`;
+}
+
+// src/headless/headless-session.ts
+var HEADLESS_INTERCEPTOR_ID = "headless";
+var NOT_A_CLAIMANT = HEADLESS_INTERCEPTOR_ID;
+var LINE_CAP_CHARS = 4e3;
+var MAX_EVENTS = 5e3;
+var TURN_POLL_MS = 50;
+var MAX_TIMER_MS = 2147483647;
+var capped = (text) => text.length > LINE_CAP_CHARS ? { text: `${text.slice(0, LINE_CAP_CHARS)}\u2026`, chars: text.length } : { text };
+var timerMs = (ms) => Number.isNaN(Number(ms)) ? 0 : Math.min(Math.max(0, Number(ms)), MAX_TIMER_MS);
+var messageOf = (e) => e instanceof Error ? e.message : String(e);
+var isAutopilotLike = (value) => {
+  const v = value;
+  return !!v && typeof v === "object" && typeof v.subscribe === "function" && typeof v.pause === "function" && typeof v.resume === "function" && typeof v.stop === "function" && typeof v.state === "object" && v.state !== null;
+};
+var HeadlessSession = class {
+  constructor(driver, options = {}) {
+    this.driver = driver;
+    this.options = options;
+    this.events = [];
+    this.seq = 0;
+    this.tracked = /* @__PURE__ */ new Map();
+    /** What the session did to an interaction itself, for `settled` to say when the driver reports it. */
+    this.origin = /* @__PURE__ */ new Map();
+    this.waiters = /* @__PURE__ */ new Set();
+    this.teardown = [];
+    this.lastProbe = {};
+    this.lastAutopilot = "";
+    this.disposed = false;
+    if (typeof driver.addInteractionInterceptor !== "function") {
+      throw new Error(
+        "HeadlessSession needs a driver that supports interaction interceptors (addInteractionInterceptor), and this one does not."
+      );
+    }
+    this.sessionKey = options.sessionKey ?? options.persistence?.stateKey ?? "";
+    this.allowRaw = options.allowRaw ?? true;
+    this.clock = options.clock ?? Date.now;
+    this.seen = this.history().length;
+    this.base = this.seen;
+    this.lastProbe = this.readProbe();
+    this.teardown.push(
+      driver.addInteractionInterceptor({
+        id: HEADLESS_INTERCEPTOR_ID,
+        onInteractionOpened: (opened) => {
+          this.onOpened(opened);
+          return void 0;
+        }
+      })
+    );
+    this.listen("history-updated", () => this.onHistory());
+    this.listen(
+      "interaction-settled",
+      (e) => this.onSettled(
+        e.detail
+      )
+    );
+    if (options.activityBus) {
+      this.teardown.push(
+        options.activityBus.subscribe("tool-loop-start", () => this.observe()),
+        options.activityBus.subscribe("tool-loop-end", (detail) => {
+          if (detail?.failureReason && this.open) this.open.failureReason = detail.failureReason;
+          this.observe();
+        })
+      );
+    }
+    const autopilot = options.autopilot ?? (isAutopilotLike(driver) ? driver : void 0);
+    this.autopilotHost = autopilot;
+    if (autopilot) {
+      this.lastAutopilot = this.autopilotSignature();
+      this.teardown.push(autopilot.subscribe(() => this.onAutopilot()));
+    }
+    this.persistence = options.persistence?.attach({ driver, sessionKey: this.sessionKey });
+    recordMetaEvent(
+      this.sessionKey,
+      "headless.attached",
+      options.label !== void 0 ? { label: options.label } : void 0
+    );
+  }
+  // ---------------------------------------------------------------------------------------------
+  // The calls
+  // ---------------------------------------------------------------------------------------------
+  /**
+   * Send the person's message, and start the turn. Returns as soon as the turn has started, not
+   * when it ends: a turn includes every interaction parked on the person, so it can run as long as
+   * the journey. Its end is the `turn` event.
+   *
+   * Refused, never thrown, when the message is empty, or a turn is already running.
+   */
+  send(text, options = {}) {
+    if (this.disposed) return { ok: false, error: "This session has been disposed." };
+    if (typeof text !== "string" || !text.trim()) {
+      return { ok: false, error: "There is nothing to send: the message is empty." };
+    }
+    if (this.turn || this.driver.isBusy()) {
+      return {
+        ok: false,
+        error: "A turn is already running. Wait for it to end (the turn event), or answer what it is waiting on."
+      };
+    }
+    this.closeTurn();
+    const start = this.history().length;
+    this.open = { start };
+    this.startPolling();
+    this.persistence?.notePrompt(text);
+    let running;
+    try {
+      running = this.driver.sendMessage(
+        text,
+        options.attachments,
+        options.agent !== void 0 ? { agent: options.agent } : void 0
+      ).then(
+        (result) => {
+          this.turn = void 0;
+          if (this.open) {
+            this.open.reason = result.reason;
+            this.open.failureReason = result.failureReason;
+          }
+          this.observe();
+        },
+        (e) => {
+          this.turn = void 0;
+          this.log({ type: "error", where: "turn", message: messageOf(e) });
+          if (this.open) this.open.reason = "error";
+          this.observe();
+        }
+      );
+    } catch (e) {
+      this.open = void 0;
+      this.stopPolling();
+      return { ok: false, error: messageOf(e) };
+    }
+    this.turn = running;
+    return { ok: true };
+  }
+  /**
+   * Run one of a pending interaction's actions as the person, as a click would (the answer is
+   * credited `answeredBy: 'user'`). `action` is a number from the description's actions, or an
+   * action's name; `args` carry the text, the options (numbers or labels) or the form's fields it
+   * takes. Refused, with the reason and what is enabled, when a claimant holds the interaction,
+   * the action is unknown or disabled, or its arguments do not fit: nothing runs then.
+   *
+   * The result is the driver's `InvokeResult`, plus `description` of the interaction when it is
+   * still open.
+   */
+  async act(interactionId, action, args = {}) {
+    if (typeof this.driver.invokeAsUser !== "function") {
+      return {
+        ok: false,
+        error: "no-surface",
+        message: "This driver cannot run an action as the person (it has no invokeAsUser)."
+      };
+    }
+    const t = this.tracked.get(interactionId);
+    const requested = String(action ?? "").trim();
+    let name = requested;
+    let invokeArgs = args;
+    if (t?.ctx.surface) {
+      const surface = t.ctx.surface;
+      const numbering = this.describe(t).actions.filter((a) => a.n !== void 0).map((a) => a.name);
+      const byNumber = byNumberOf(numbering);
+      name = byNumber(requested) ?? requested;
+      const listed = surface.actions().find((a) => a.name === name);
+      const built = invokeArgsFor(listed, args, byNumber);
+      if (!built.ok) {
+        return {
+          ok: false,
+          error: "invalid-args",
+          message: `fields is not valid JSON. ${fieldsExample(name, listed?.argsSchema)}`
+        };
       }
-      continue;
+      invokeArgs = built.args;
     }
-    const id = entry.kind === "turn" ? turnIdentity(entry) : JSON.stringify(entry);
-    const at = seenAt.get(id);
-    if (at !== void 0) {
-      if (entry.usage && !timeline[at].usage) timeline[at] = entry;
-      continue;
+    const result = await this.driver.invokeAsUser(interactionId, name, invokeArgs);
+    if (t) this.evaluate(t);
+    const still = this.tracked.get(interactionId);
+    return still && !still.settled ? { ...result, description: this.describe(still) } : result;
+  }
+  /**
+   * Settle a pending interaction raw, with `result` as the widget would have resolved it,
+   * bypassing its actions and everything they check: an escape hatch for a widget with no
+   * controller, or one that cannot be acted on. Logs `settled` with `raw: true` and records
+   * `headless.raw-resolved`. Refused when `allowRaw` is `false`, when the interaction is not
+   * pending, or when a claimant holds it: as for `act`, the person takes it back first.
+   */
+  resolve(interactionId, result) {
+    if (!this.allowRaw) {
+      return { ok: false, error: "Settling an interaction raw is not allowed in this session." };
     }
-    seenAt.set(id, timeline.length);
-    timeline.push(entry);
+    const t = this.tracked.get(interactionId);
+    if (!t || t.settled) {
+      return { ok: false, error: `No pending interaction "${interactionId}".` };
+    }
+    if (t.ctx.heldBy !== "user") {
+      return {
+        ok: false,
+        error: "Another agent holds this interaction, so it was not resolved. The person has to take it back first, for example by pausing the autopilot."
+      };
+    }
+    this.origin.set(interactionId, { raw: true });
+    try {
+      this.driver.resolveInteraction(interactionId, result);
+    } catch (e) {
+      this.origin.delete(interactionId);
+      return { ok: false, error: messageOf(e) };
+    }
+    recordMetaEvent(this.sessionKey, "headless.raw-resolved", {
+      interactionId,
+      component: t.componentName
+    });
+    return { ok: true };
   }
-  timeline.sort((a, b) => {
-    const ta = a.timestamp ?? "";
-    const tb = b.timestamp ?? "";
-    if (ta < tb) return -1;
-    if (ta > tb) return 1;
-    return (KIND_RANK[a.kind] ?? UNKNOWN_KIND_RANK) - (KIND_RANK[b.kind] ?? UNKNOWN_KIND_RANK);
-  });
-  const context = latestMeta?.meta?.context;
-  return { readme, sessionUsage: context?.sessionUsage, timeline, meta: latestMeta?.meta };
+  /**
+   * Read from a pending interaction without changing it: one of its views, or (with `tool`) one of
+   * the widget tools given to the session. The text is capped. A view the surface does not list is
+   * refused, naming those it does, as the autopilot's `widget_read` does.
+   */
+  async read(interactionId, request = {}) {
+    const t = this.tracked.get(interactionId);
+    if (!t || t.settled) return { ok: false, error: `No pending interaction "${interactionId}".` };
+    if (request.tool !== void 0 && request.view !== void 0) {
+      return { ok: false, error: "Ask for a view or a tool, not both." };
+    }
+    if (request.tool !== void 0) return this.readTool(t, request.tool, request.args);
+    const { surface } = t.ctx;
+    if (!surface)
+      return { ok: false, error: "This widget has nothing to read: it has no surface." };
+    const view = typeof request.view === "string" && request.view.trim() ? request.view.trim() : void 0;
+    const names = Object.keys(surface.views ?? {});
+    if (view !== void 0 && names.length && !names.includes(view)) {
+      return { ok: false, error: `No view "${view}" here. Views: ${names.join(", ")}.` };
+    }
+    let state;
+    try {
+      state = surface.read ? surface.read(view) : surface.facts();
+    } catch (e) {
+      return { ok: false, error: `Could not read: ${messageOf(e)}` };
+    }
+    if (state === void 0) {
+      return {
+        ok: false,
+        error: `Nothing to read without a view.${names.length ? ` Views: ${names.join(", ")}.` : ""}`
+      };
+    }
+    return { ok: true, content: capRead(JSON.stringify(state) ?? "null") };
+  }
+  /**
+   * Wait for the log to say something, then return what it said. Resolves as soon as an event in
+   * `until` is in the log after `since` (immediately, when one already is), or at `maxWaitMs` with
+   * status `'working'`. Either way it returns every event after `since`, and `nextSeq`, the cursor
+   * for the next call: poll with it and nothing is lost.
+   */
+  wait(request) {
+    const since = request.since ?? 0;
+    const { until } = request;
+    if (this.events.some((e) => e.seq > since && wanted(e, until))) {
+      return Promise.resolve(this.waited(since, "ready"));
+    }
+    if (this.disposed) return Promise.resolve(this.waited(since, "closed"));
+    const { signal } = request;
+    if (signal?.aborted) return Promise.resolve(this.waited(since, "working"));
+    return new Promise((resolve) => {
+      const onAbort = () => waiter.finish("working");
+      const waiter = {
+        since,
+        until,
+        finish: (status) => {
+          clearTimeout(timer);
+          signal?.removeEventListener("abort", onAbort);
+          this.waiters.delete(waiter);
+          resolve(this.waited(since, status));
+        }
+      };
+      this.waiters.add(waiter);
+      const timer = setTimeout(() => waiter.finish("working"), timerMs(request.maxWaitMs));
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  /** Every event logged after `since` (default: all the log keeps), without waiting. */
+  eventsSince(since = 0) {
+    return this.events.filter((e) => e.seq > since);
+  }
+  /**
+   * What is going on now: whether a turn runs, the interaction the person should answer first (and
+   * the others open behind it), the autopilot, what it has cost, and the host's probe.
+   */
+  state() {
+    const open = [...this.tracked.values()].filter((t) => t.armed && !t.settled);
+    const described = open.map((t) => ({ t, d: this.describe(t) }));
+    const mine = described.find(({ d }) => d.heldBy === "user" && d.ready);
+    const others = described.filter((entry) => entry !== mine).map(({ d }) => ({
+      interactionId: d.interactionId,
+      component: d.component,
+      heldBy: d.heldBy,
+      ready: d.ready
+    }));
+    const host = this.autopilotHost;
+    return {
+      busy: this.turn !== void 0 || this.driver.isBusy() || host?.state.working === true,
+      pending: mine?.d ?? null,
+      others,
+      ...host ? {
+        autopilot: {
+          mode: host.state.mode,
+          status: host.state.status,
+          needsUser: host.state.needsUser,
+          working: host.state.working
+        }
+      } : {},
+      cost: sumUsage(this.history()),
+      probe: this.readProbe(),
+      lastSeq: this.seq
+    };
+  }
+  /**
+   * Save the session now: the snapshot, and the diagnostics appended since the last flush, rather
+   * than at the next throttled save. A no-op without `persistence`.
+   */
+  async flush() {
+    await this.persistence?.flush();
+  }
+  /**
+   * The debug log, the document the browser's Download gives. With `persistence`, the log of the
+   * whole session stitched from the stored stream with a fresh `meta-snapshot` (`lifetimeDebugLog`,
+   * the same code); without, the current page's, from `buildDiagnosticEntries`. Never throws.
+   */
+  debugLog() {
+    if (this.persistence) return this.persistence.debugLog();
+    return Promise.resolve(
+      headlessCurrentDebugLog(this.driver, this.sessionKey, this.options.debug)
+    );
+  }
+  /** Stop the running turn, when the driver can. */
+  stop() {
+    if (typeof this.driver.cancel !== "function") {
+      return { ok: false, error: "This driver cannot cancel a turn." };
+    }
+    this.driver.cancel();
+    return { ok: true };
+  }
+  /**
+   * Pause, resume or stop the autopilot, when there is one. Pausing hands what it holds to the
+   * person, which then appears as a `decision`.
+   *
+   * `'keepPaused'` is the hand-back banner's "Keep paused": it turns the autopilot's own hand-back
+   * of one interaction into an ordinary pause, so it does not take the question back once it is
+   * answered. `interactionId` names the interaction handed back; omitted, it is the one the
+   * autopilot's own pause is waiting on (`state().autopilot`'s hand-back, the `decision` it left
+   * with the person). Refused, with why, when the autopilot has handed nothing back, when
+   * `interactionId` is not the one it handed back, or when the host cannot keep paused; the host's
+   * own `keepPaused` would do nothing in those cases without saying so.
+   */
+  autopilot(mode, interactionId) {
+    const host = this.autopilotHost;
+    if (!host) return { ok: false, error: "There is no autopilot on this driver." };
+    try {
+      if (mode === "keepPaused") return this.keepPaused(host, interactionId);
+      host[mode]();
+    } catch (e) {
+      return { ok: false, error: messageOf(e) };
+    }
+    return { ok: true };
+  }
+  keepPaused(host, interactionId) {
+    if (typeof host.keepPaused !== "function") {
+      return { ok: false, error: "This autopilot cannot keep paused." };
+    }
+    const pause = host.state.pause;
+    if (pause?.scope !== "this-interaction" || !pause.interactionId) {
+      return {
+        ok: false,
+        error: "The autopilot has not handed a question back, so there is nothing to keep paused."
+      };
+    }
+    const handedBack = pause.interactionId;
+    if (interactionId !== void 0 && interactionId !== handedBack) {
+      return {
+        ok: false,
+        error: `The autopilot handed back ${handedBack}, not ${interactionId}.`
+      };
+    }
+    host.keepPaused(handedBack);
+    return { ok: true };
+  }
+  /** Detach: remove the interceptor and every subscription, and release anyone waiting. */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const t of this.tracked.values()) this.release(t);
+    clearTimeout(this.quiesceTimer);
+    this.stopPolling();
+    this.persistence?.dispose();
+    for (const off of this.teardown.splice(0)) {
+      try {
+        off();
+      } catch (e) {
+        logger2.warn("HeadlessSession: a teardown threw:", e);
+      }
+    }
+    for (const waiter of this.waiters) waiter.finish("closed");
+  }
+  // ---------------------------------------------------------------------------------------------
+  // Watching the driver
+  // ---------------------------------------------------------------------------------------------
+  listen(type, handler) {
+    this.driver.addEventListener(type, handler);
+    this.teardown.push(() => this.driver.removeEventListener(type, handler));
+  }
+  history() {
+    return this.driver.getRawHistory?.() ?? [];
+  }
+  /** An interaction opened: watch it. Who holds it is not decided yet, so it is reported later. */
+  onOpened(opened) {
+    if (this.disposed) return;
+    const { ctx } = opened;
+    const t = {
+      id: opened.interactionId,
+      ctx,
+      componentName: opened.componentName,
+      data: opened.data,
+      ownerPath: opened.ownerPath,
+      unsubs: [],
+      armed: false,
+      settled: false,
+      autoTried: false
+    };
+    this.tracked.set(t.id, t);
+    t.unsubs.push(ctx.subscribe(() => this.evaluate(t)));
+    t.unsubs.push(ctx.onSurfaceReady(() => this.evaluate(t)));
+    ctx.onDispose(() => this.onEnded(t));
+    queueMicrotask(() => {
+      if (this.disposed || t.settled) return;
+      t.armed = true;
+      this.evaluate(t);
+    });
+  }
+  /** The driver says an interaction settled, by whatever route. */
+  onSettled(detail) {
+    const t = this.tracked.get(detail.interactionId);
+    if (!t || t.settled) return;
+    const origin = this.origin.get(t.id);
+    this.settle(t, {
+      ...detail.answeredBy ? { answeredBy: detail.answeredBy } : {},
+      ...detail.resolvedItself ? { resolvedItself: true } : {},
+      ...origin?.auto ? { auto: true } : {},
+      ...origin?.raw ? { raw: true } : {}
+    });
+  }
+  /** The interaction's context was disposed: if nothing said it settled, say it did. */
+  onEnded(t) {
+    if (!t.settled) this.settle(t, {});
+  }
+  settle(t, how) {
+    t.settled = true;
+    if (!this.disposed) {
+      this.log({ type: "settled", interactionId: t.id, component: t.componentName, ...how });
+    }
+    this.release(t);
+  }
+  release(t) {
+    for (const off of t.unsubs.splice(0)) {
+      try {
+        off();
+      } catch {
+      }
+    }
+    t.settled = true;
+    this.tracked.delete(t.id);
+    this.origin.delete(t.id);
+  }
+  /** New messages in the driver's history: report what the person would see of them. */
+  onHistory() {
+    if (this.disposed) return;
+    this.reportMessages();
+    this.observe();
+  }
+  reportMessages() {
+    const history = this.history();
+    if (history.length < this.seen) {
+      this.seen = history.length;
+      return;
+    }
+    const fresh = history.slice(this.seen);
+    this.seen = history.length;
+    const lines = visibleTranscript(
+      fresh.filter((m) => !m.interaction),
+      { claimant: NOT_A_CLAIMANT }
+    );
+    for (const line of lines) this.log({ type: "message", ...capped(line) });
+  }
+  onAutopilot() {
+    if (this.disposed || !this.autopilotHost) return;
+    const signature = this.autopilotSignature();
+    if (signature === this.lastAutopilot) return;
+    this.lastAutopilot = signature;
+    const { state } = this.autopilotHost;
+    this.log({
+      type: "autopilot",
+      mode: state.mode,
+      status: state.status,
+      needsUser: state.needsUser,
+      working: state.working,
+      ...state.pause?.reason ? { reason: state.pause.reason } : {}
+    });
+  }
+  autopilotSignature() {
+    const s = this.autopilotHost?.state;
+    return s ? JSON.stringify([s.mode, s.status, s.needsUser, s.working]) : "";
+  }
+  // ---------------------------------------------------------------------------------------------
+  // Reporting an interaction
+  // ---------------------------------------------------------------------------------------------
+  describe(t) {
+    return describeInteraction({ ctx: t.ctx, componentName: t.componentName, data: t.data });
+  }
+  /**
+   * Report where an interaction stands, when that has changed. A `decision` when the person holds
+   * it and can act; `working` when a claimant holds it or it is not ready yet. A `decision` is
+   * logged again only when its description changed materially: who holds it, whether it is ready
+   * or has a controller, or which actions are enabled. The text and facts alone do not count.
+   */
+  evaluate(t) {
+    if (this.disposed || !t.armed || t.settled) return;
+    if (this.autoSettle(t)) return;
+    let d;
+    try {
+      d = this.describe(t);
+    } catch (e) {
+      this.log({ type: "error", where: "describe", message: messageOf(e) });
+      return;
+    }
+    if (d.heldBy === "user" && d.ready) {
+      const sig2 = JSON.stringify([d.controller, d.actions.map((a) => [a.name, a.enabled])]);
+      if (t.last?.kind === "decision" && t.last.sig === sig2) return;
+      t.last = { kind: "decision", sig: sig2 };
+      this.log({
+        type: "decision",
+        ...d,
+        ...t.ownerPath.length ? { ownerPath: t.ownerPath } : {}
+      });
+      return;
+    }
+    const sig = `${d.heldBy}|${d.ready}`;
+    if (t.last?.kind === "working" && t.last.sig === sig) return;
+    t.last = { kind: "working", sig };
+    this.log({
+      type: "working",
+      interactionId: t.id,
+      component: t.componentName,
+      heldBy: d.heldBy
+    });
+  }
+  /**
+   * Settle a widget that settles itself in a browser, as it would on mounting. Once, and only when
+   * the person holds it. Returns whether it settled it.
+   */
+  autoSettle(t) {
+    const result = this.options.autoSettle?.[t.componentName];
+    if (!result || t.autoTried || t.ctx.heldBy !== "user") return false;
+    t.autoTried = true;
+    try {
+      const value = result(t.data);
+      this.origin.set(t.id, { auto: true });
+      this.driver.resolveInteraction(t.id, value);
+      return true;
+    } catch (e) {
+      this.origin.delete(t.id);
+      this.log({
+        type: "error",
+        where: "auto-settle",
+        message: `${t.componentName}: ${messageOf(e)}`
+      });
+      return false;
+    }
+  }
+  async readTool(t, name, args) {
+    const sets = (this.options.widgetTools ?? []).filter(
+      (s) => s.componentName === t.componentName
+    );
+    const names = sets.flatMap((s) => Object.keys(s.tools)).sort();
+    const spec = sets.map((s) => Object.prototype.hasOwnProperty.call(s.tools, name) ? s.tools[name] : void 0).find((s) => s !== void 0);
+    if (!spec) {
+      return {
+        ok: false,
+        error: names.length ? `No tool "${name}" for the "${t.componentName}" widget. Tools: ${names.join(", ")}.` : `The "${t.componentName}" widget has no tools.`
+      };
+    }
+    const { controller } = t.ctx;
+    if (controller === void 0) {
+      return { ok: false, error: `The "${t.componentName}" widget has nothing to read from.` };
+    }
+    const why = unavailableReason(spec.unavailable, controller);
+    if (why !== void 0) return { ok: false, error: `Not available right now: ${name}: ${why}.` };
+    const problem = checkArgs(args ?? {}, spec.definition.parameters);
+    if (problem) return { ok: false, error: `Not done: ${name}: ${problem}` };
+    try {
+      const output = await spec.run(controller, args ?? {});
+      return {
+        ok: true,
+        content: capRead(typeof output === "string" ? output : JSON.stringify(output) ?? "null")
+      };
+    } catch (e) {
+      return { ok: false, error: `Could not read: ${messageOf(e)}` };
+    }
+  }
+  // ---------------------------------------------------------------------------------------------
+  // The log
+  // ---------------------------------------------------------------------------------------------
+  /**
+   * Notice a turn begin or end, whoever started it. The driver being busy (or a `send` in flight)
+   * is a turn; once it has been idle for a beat the turn is over and is reported, once. The beat
+   * covers the gaps inside one turn, such as a hand-off continuing it, which are a microtask long.
+   * A turn that begins the instant another ends, with no idle between, is reported as one.
+   */
+  observe() {
+    if (this.disposed) return;
+    if (this.turn || this.driver.isBusy()) {
+      clearTimeout(this.quiesceTimer);
+      this.quiesceTimer = void 0;
+      if (!this.open) {
+        this.open = { start: this.base };
+        this.startPolling();
+      }
+      return;
+    }
+    if (this.open && this.quiesceTimer === void 0) {
+      this.quiesceTimer = setTimeout(() => {
+        this.quiesceTimer = void 0;
+        this.closeTurn();
+      }, 0);
+    }
+  }
+  /** Report the open turn as ended, unless the driver is busy again. */
+  closeTurn() {
+    const { open } = this;
+    if (this.disposed || !open || this.turn || this.driver.isBusy()) return;
+    clearTimeout(this.quiesceTimer);
+    this.quiesceTimer = void 0;
+    this.open = void 0;
+    this.stopPolling();
+    this.logTurn(open.reason ?? "done", open.failureReason, open.start);
+    this.base = this.history().length;
+  }
+  /** Without a shared bus nothing says a turn ended, so while one is open the driver is asked. */
+  startPolling() {
+    if (this.options.activityBus || this.poller !== void 0) return;
+    this.poller = setInterval(() => this.observe(), TURN_POLL_MS);
+    this.poller.unref?.();
+  }
+  stopPolling() {
+    if (this.poller !== void 0) clearInterval(this.poller);
+    this.poller = void 0;
+  }
+  logTurn(reason, failureReason, start) {
+    const text = finalText(this.history().slice(start));
+    this.log({
+      type: "turn",
+      reason,
+      ...failureReason ? { failureReason } : {},
+      ...text !== void 0 ? capped(text) : {}
+    });
+  }
+  log(event) {
+    this.append(event);
+    this.checkProbe();
+  }
+  append(event) {
+    this.seq += 1;
+    const entry = {
+      ...event,
+      seq: this.seq,
+      at: new Date(this.clock()).toISOString()
+    };
+    this.events.push(entry);
+    if (this.events.length > MAX_EVENTS) this.events.splice(0, this.events.length - MAX_EVENTS);
+    for (const waiter of this.waiters) {
+      if (wanted(entry, waiter.until)) waiter.finish("ready");
+    }
+  }
+  readProbe() {
+    try {
+      const read = this.options.probe?.();
+      return read ? { ...read } : {};
+    } catch (e) {
+      logger2.warn("HeadlessSession: the probe threw:", e);
+      return {};
+    }
+  }
+  /** Read the probe again; a change in any top-level value is a `probe` event. */
+  checkProbe() {
+    if (!this.options.probe || this.disposed) return;
+    const now = this.readProbe();
+    const keys = /* @__PURE__ */ new Set([...Object.keys(this.lastProbe), ...Object.keys(now)]);
+    const changed = [...keys].filter(
+      (k) => JSON.stringify(this.lastProbe[k]) !== JSON.stringify(now[k])
+    );
+    this.lastProbe = now;
+    if (changed.length) this.append({ type: "probe", probe: now, changed });
+  }
+  waited(since, status) {
+    return { events: this.eventsSince(since), status, nextSeq: this.seq };
+  }
+};
+function wanted(event, until) {
+  if (until) return until.includes(event.type);
+  return event.type === "decision" || event.type === "turn" || event.type === "error" || event.type === "autopilot" && event.needsUser;
 }
-function withFreshMetaSnapshot(stored, fresh) {
-  return [...stored.filter((e) => e.kind !== "meta-snapshot"), fresh];
+function finalText(messages) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const m = messages[i];
+    if (m.role === "assistant" && !m.interaction && !m.toolCalls?.length && !m.thinking && m.category !== "reasoning" && m.category !== "narration" && m.content?.trim()) {
+      return m.content;
+    }
+  }
+  return void 0;
+}
+
+// src/utils/usage-rows.ts
+function hasUsage(m) {
+  return m.cost != null || m.externalCostUsd != null || m.inputTokens != null || m.outputTokens != null || m.cacheReadTokens != null || m.cacheWriteTokens != null;
+}
+function usageRows(messages) {
+  return collectRows(messages, 0, void 0);
+}
+function bucketsOf(usage) {
+  return {
+    uncachedInputTokens: usage.uncachedInputTokens,
+    cacheReadTokens: usage.cacheReadTokens,
+    cacheWriteTokens: usage.cacheWriteTokens,
+    outputTokens: usage.outputTokens
+  };
+}
+function collectRows(messages, depth, subAgentOf) {
+  const rows = [];
+  for (const m of messages) {
+    if (hasUsage(m)) {
+      const cacheReadTokens = m.cacheReadTokens ?? 0;
+      const cacheWriteTokens = m.cacheWriteTokens ?? 0;
+      rows.push({
+        source: "request",
+        model: m.model,
+        // The driver stamps `ChatMessage.provider` from the resolved provider's own
+        // status, so it is AUTHORITATIVE and covers vendors the model allowlists do
+        // not — a server-proxied `gpt-5` turn is `provider: 'openai'` on the message
+        // and unknown to `vendorOfModel`. Prefer it; fall back to resolving the model
+        // id only for messages persisted before the field existed. Still left
+        // undefined when neither knows, rather than guessed at.
+        provider: m.provider ?? (m.model ? vendorOfModel(m.model) : void 0),
+        ...m.cost != null && { costUsd: m.cost },
+        ...m.externalCostUsd != null && { externalCostUsd: m.externalCostUsd },
+        // Uncached input is the REMAINDER, matching `sumUsage`: `inputTokens` is the
+        // whole prompt and the cache fields break it down. Clamped for the same
+        // reason — hand-edited history must not drive a total negative.
+        uncachedInputTokens: Math.max(0, (m.inputTokens ?? 0) - cacheReadTokens - cacheWriteTokens),
+        cacheReadTokens,
+        cacheWriteTokens,
+        outputTokens: m.outputTokens ?? 0,
+        ...m.agentName != null && { agentName: m.agentName },
+        subAgentDepth: depth,
+        ...subAgentOf != null && { subAgentOf }
+      });
+    }
+    const rolled = m.compaction?.rolledUpUsage;
+    if (rolled) {
+      rows.push({
+        source: "compaction",
+        ...rolled.costUsd != null && { costUsd: rolled.costUsd },
+        ...bucketsOf(rolled),
+        ...m.agentName != null && { agentName: m.agentName },
+        subAgentDepth: depth,
+        ...subAgentOf != null && { subAgentOf }
+      });
+    }
+    for (const tc of m.toolCalls ?? []) {
+      if (tc.subAgentTrace) rows.push(...collectRows(tc.subAgentTrace, depth + 1, tc.id));
+    }
+  }
+  return rows;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -11476,6 +12824,7 @@ function withFreshMetaSnapshot(stored, fresh) {
   GEMINI_LONG_CONTEXT_THRESHOLD,
   GeminiProvider,
   GeminiTransport,
+  HeadlessSession,
   MALFORMED_CALL_NUDGE,
   MutableAIProviderRegistry,
   NOOP_ACTIVITY_BUS,
@@ -11493,18 +12842,24 @@ function withFreshMetaSnapshot(stored, fresh) {
   anthropicRatesFor,
   anthropicTokenCost,
   assembleDebugLog,
+  buildDiagnosticEntries,
   buildTimelineEntries,
   clearSession,
   defineAgent,
   defineAutopilot,
   defineStatefulAgent,
+  describeInteraction,
   emptyUsage,
   friendlyFallbackAgent,
   geminiRatesFor,
   geminiTokenCost,
   getMetaEvents,
+  headlessCurrentDebugLog,
+  headlessDiagnosticEntries,
+  headlessMetaSnapshot,
   isObservableAIProviderRegistry,
   isTerminalAIServiceRefusal,
+  lifetimeDebugLog,
   messageUsage,
   resolveAITiers,
   restoreMachine,