@genesislcap/ai-assistant 15.26.0 → 15.27.0-agent-log-submit.3

package/dist/ai-assistant.d.ts

@@ -23,6 +23,7 @@ import { InterfaceSymbol } from '@microsoft/fast-foundation';
 import type { Modal } from '@genesislcap/rapid-design-system';
 import { ModelTagAppearance } from '@genesislcap/foundation-ai';
 import type { SubAgentFailureReason } from '@genesislcap/foundation-ai';
+import type { TimestampDisplay } from '@genesislcap/foundation-ai';
 import type { TurnFailureReason } from '@genesislcap/foundation-ai';
 import { ViewTemplate } from '@genesislcap/web-core';
 
@@ -1463,17 +1464,8 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
     private busy;
     /** Epoch ms when the current turn loop began — drives the `turn.end` duration. */
     private turnStartedAt;
-    private pendingInteractions;
-    /**
-     * Live per-interaction contexts (GENC-1390), keyed by interactionId. Created in
-     * `requestInteraction` alongside the pending entry, disposed + removed in
-     * `resolveInteraction`. Non-serialisable (sockets, timers, subscriber sets), so
-     * they live here on the driver — not on the DOM, not in the persisted store — and
-     * therefore survive the element remounts (layout reflow/drag, transcript
-     * re-render) that this feature exists to make harmless. At most one is live at a
-     * time (see the one-interaction-at-a-time guard in `requestInteraction`).
-     */
-    private interactionContexts;
+    /** Custom UI interactions: the pending call, its live context, and any host to delegate to. */
+    private readonly interactions;
     private systemPrompt?;
     /**
      * Preamble cost of the most recent request, set at the request-build site.
@@ -1518,13 +1510,6 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      */
     private activeAgentLabel?;
     private displayName?;
-    /**
-     * When set, `requestInteraction` delegates to this callback instead of using
-     * this driver's own pending map. Wired by `invokeSubAgent` so a sub-agent's
-     * widget renders in — and resolves through — the parent (ultimately the
-     * root) driver, where the main UI is listening.
-     */
-    private hostInteractionRequester?;
     /**
      * When set (e.g. by OrchestratingDriver), applied only to the conversation slice
      * sent to the model — stored `history` stays unchanged for UI and logging.
@@ -1637,33 +1622,10 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      */
     private agentReleaseRequested;
     /**
-     * Ring buffer of per-LLM-call snapshots. Cap is configurable via
-     * `chatConfig.agent.maxTurnSnapshots`; older entries drop off as new ones
-     * arrive. See {@link TurnSnapshot} for the captured shape.
-     */
-    private turnSnapshots;
-    /**
-     * `turn` + `message` diagnostic-log entries harvested from an out-of-band source (a resolved
-     * interaction whose widget returned `InteractionResult.diagnostics` — e.g. a server-side
-     * ChatDriver's debug log). `event` entries are NOT kept here — they're folded into the session's
-     * meta-event registry via `mergeMetaEvents` (see `resolveInteraction`) so they inherit fresh host
-     * indices, and reach the log through `getMetaEvents`. Append-only; the host folds these into its
-     * debug log alongside this driver's own timeline. Not cleared here — it lives with the driver
-     * instance, like `turnSnapshots`, so a new chat (fresh driver) starts empty while a compaction
-     * (same instance) keeps it. (GENC-1461.)
+     * Per-turn snapshots, forwarded sub-agent snapshots, and harvested external diagnostics —
+     * everything the exported debug log draws from this driver.
      */
-    private readonly externalDiagnostics;
-    /**
-     * Monotonic count of external-diagnostics batches harvested this driver-lifetime. Namespaces each
-     * batch's re-keyed `turn` entries so distinct server generations in one chat session can't collide
-     * on `turnIndex` in the forward-capture persister (which dedups turns by that key). (GENC-1461.)
-     */
-    private externalDiagnosticsBatches;
-    /** Monotonic counter that survives agent swaps — useful for cross-referencing with history. */
-    private globalTurnIndex;
-    /** Captured from `applyAgent` so we don't store the whole `AgentConfig`. */
-    private debugSnapshotter?;
-    private readonly maxTurnSnapshots;
+    private readonly turnRecorder;
     /**
      * Aborted by `dispose()` on driver teardown (e.g. an agent-config swap).
      * Threaded into every provider call as `ChatRequestOptions.signal`, so a
@@ -1855,7 +1817,7 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      * on to completion or the transport timeout. Called by the host on driver
      * swap and by `OrchestratingDriver.dispose()`. Idempotent.
      *
-     * Deliberately does NOT settle `pendingInteractions` here: dispose is never
+     * Deliberately does NOT settle pending interactions here: dispose is never
      * reached while one is pending. The only host-level dispose is the agent-swap
      * rebuild, which is guarded by `isBusy()` — a pending interaction keeps the
      * tool loop suspended (`busy === true`), so the swap is deferred until the
@@ -2096,7 +2058,7 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      * log exporter to show what the LLM saw on each turn — system prompt, tool
      * surface, and agent-supplied state (e.g. a machine snapshot).
      *
-     * Ring-buffered at `MAX_TURN_SNAPSHOTS`; older entries are dropped.
+     * Ring-buffered at `maxTurnSnapshots`; older entries are dropped.
      */
     getTurnSnapshots(): ReadonlyArray<TurnSnapshot>;
     /**
@@ -2104,37 +2066,10 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      * `InteractionResult.diagnostics` (e.g. a server-side ChatDriver's collated debug log). The host
      * concatenates these into its own debug log so `downloadDebugLog`/the persisted diagnostics stream
      * include external-engine logs; `event` entries are excluded here because they're merged into the
-     * session's meta-event registry instead (see `resolveInteraction`) and reach the log via
-     * `getMetaEvents`. Opaque, chronologically sorted by the host at assemble time. (GENC-1461.)
+     * session's meta-event registry instead and reach the log via `getMetaEvents`. Opaque,
+     * chronologically sorted by the host at assemble time. (GENC-1461.)
      */
     getExternalDiagnostics(): ReadonlyArray<DiagnosticEntry>;
-    /**
-     * Merge a sub-agent's turn snapshots into this driver's buffer so they surface
-     * as `kind:'turn'` entries in the exported debug log. The child runs as a
-     * separate, discarded driver, so its snapshots would otherwise be lost. Each is
-     * re-labelled under the parent turn that activated the sub-agent: the child's
-     * own (numeric) turns become `"<parentTurn>-1"`, `"-2"`, … (1-based, in order);
-     * any already-forwarded grand-child labels (strings) have their leading segment
-     * remapped the same way, so nesting composes (`"5-2"` → `"5-2-1"`).
-     *
-     * Note: two sub-agents invoked in the *same* parent turn share the prefix, so
-     * their labels can repeat — `agentName` on each snapshot disambiguates them.
-     */
-    private forwardSubAgentSnapshots;
-    /**
-     * Push one snapshot to the ring buffer. Called inside `runToolLoop` just
-     * before each LLM call — that's the latest point where the prompt, tool
-     * surface, and agent state line up with what the model is about to see.
-     *
-     * Returns the pushed object so the caller can back-fill what only the response
-     * knows (`usage`). Mutating it after the fact is safe whether or not the ring
-     * buffer has since evicted it — an evicted snapshot is simply no longer exported.
-     */
-    private recordTurnSnapshot;
-    /**
-     * Optional transform applied to conversation history immediately before each LLM request.
-     * Cleared when `undefined`. Does not alter stored history.
-     */
     /**
      * Mid-loop context guard policy (GENC-1567). `undefined` disables the guard.
      *
@@ -2168,6 +2103,10 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      * far is not lost.
      */
     private contextExhausted;
+    /**
+     * Optional transform applied to conversation history immediately before each LLM request.
+     * Cleared when `undefined`. Does not alter stored history.
+     */
     setProviderHistoryTransform(transform?: (history: ChatMessage[]) => ChatMessage[]): void;
     getHistory(): ReadonlyArray<ChatMessage>;
     getRawHistory(): readonly ChatMessage[];
@@ -2253,21 +2192,12 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      */
     requestInteraction<T>(componentName: string, data: any, options?: InteractionRequestOptions): Promise<T>;
     /**
-     * Add external (non-LLM) spend to an interaction's message AFTER it has resolved.
-     *
-     * **Why this exists separately from `resolveInteraction`.** A widget's spend reaches the session
-     * total only through `InteractionResult.costUsd`, which is read exactly once — `resolveInteraction`
-     * does its whole job inside `if (interaction)` and then deletes the entry from
-     * `pendingInteractions`. That is correct for the resolution itself, but it assumes a widget stops
-     * costing money when it resolves, and several deliberately do not: a widget that resolves EARLY so
-     * the assistant stops waiting (options shown, a preview rendered) may stay interactive for minutes
-     * afterwards and do more paid work on the user's behalf. Re-emitting `interaction-completed` does
-     * not help — with the interaction gone from the map the call is a silent no-op — so that spend had
-     * nowhere to go and was simply missing from the figure shown to the user.
+     * Add external (non-LLM) spend to an interaction's message AFTER it has resolved — for a widget
+     * that resolves early so the assistant stops waiting, then keeps doing paid work on the user's
+     * behalf. `InteractionController.recordExternalCost` explains why the resolution path cannot
+     * carry this.
      *
-     * Additive by design: the caller reports a DELTA, not a running total, so repeated calls sum. It
-     * touches only `externalCostUsd`; the recorded `interaction.resolved` payload is left exactly as
-     * the resolution wrote it, because this is not a second resolution and must not read like one.
+     * Additive by design: the caller reports a DELTA, not a running total, so repeated calls sum.
      *
      * Deliberately does NOT require the interaction to be pending, does not resurrect it, and has no
      * loading/turn side effects — this is bookkeeping about a turn that already happened.
@@ -2277,8 +2207,8 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      * @returns `true` when the spend was recorded; `false` when it was not — either the value was
      *   not a positive finite amount, or the message is no longer in history (trimmed or condensed
      *   away). A real outcome a caller may want to log rather than a failure to throw on; every
-     *   `false` also records an `interaction.external-cost-dropped` meta event here, so money can
-     *   never disappear without a trace.
+     *   `false` also records an `interaction.external-cost-dropped` meta event, so money can never
+     *   disappear without a trace.
      * @beta
      */
     recordExternalCost(interactionId: string, costUsd: number): boolean;
@@ -2294,14 +2224,10 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      */
     getInteractionContext(interactionId: string): InteractionContext | undefined;
     /**
-     * Resolve every in-flight interaction with a `'timeout'` result, closing its
-     * widget read-only. Used when a sub-agent that owns the open widget times out:
-     * the widget is parked in *this* driver's map (interactions resolve on the
-     * host, not the child), so cancelling it here unblocks the sub-agent handler
-     * awaiting it. The "one interaction at a time" invariant means there is at
-     * most one.
+     * Replace the history message owning `interactionId`. `false` when it is no longer in history.
+     * Does not announce the change — the interaction paths differ on whether they should.
      */
-    private cancelPendingInteractions;
+    private patchInteractionMessage;
     /**
      * Seeds the driver with a prior conversation history so a new component instance
      * can continue an existing conversation. Call this before the first user message.
@@ -2364,6 +2290,8 @@ export declare class ChatDriver extends EventTarget implements AiDriver {
      */
     private appendDriverNotice;
     private appendToHistory;
+    /** Announce the current history to the host. */
+    private notifyHistoryUpdated;
 }
 
 /**
@@ -3218,6 +3146,37 @@ export declare class FoundationAiAssistant extends GenesisElement {
     /** Current user-facing toggle state for agent switch indicator visibility. */
     get showAgentSwitchIndicator(): boolean;
     set showAgentSwitchIndicator(value: boolean);
+    /**
+     * When each message shows its timestamp — `'off'`, `'hover'` (default) or `'always'`.
+     *
+     * Falls back to `DEFAULT_TIMESTAMP_DISPLAY` rather than `'off'` when there is no
+     * store yet: this preference defaults ON, so the pre-store render must match the state
+     * the baseline is about to resolve to, or timestamps would visibly pop in on connect.
+     */
+    get timestampDisplay(): TimestampDisplay;
+    set timestampDisplay(value: TimestampDisplay);
+    /**
+     * Epoch ms the transcript's relative timestamps are measured against.
+     *
+     * A relative label is only correct at the instant it renders: FAST evaluates the
+     * binding once, and an idle conversation never re-renders, so "2 minutes ago" would
+     * still read "2 minutes ago" an hour later. Making the formatter read this observable
+     * instead of `Date.now()` gives every row one shared, invalidatable clock — a tick
+     * re-evaluates them all.
+     */
+    timestampClock: number;
+    /** Handle for the `TIMESTAMP_CLOCK_INTERVAL_MS` ticker; undefined while stopped. */
+    private _timestampClockTimer?;
+    /**
+     * Start or stop the timestamp clock to match the current mode and connection state.
+     *
+     * Idempotent, and safe to call from either lifecycle end — it is driven from
+     * `connectedCallback`, `disconnectedCallback` and the `timestampDisplay` setter, which
+     * can fire in any order. Nothing runs while the mode is `'off'` (no binding reads the
+     * clock) or while disconnected (a timer outliving its element is a leak, and a
+     * popped-out view disconnects without the session ending).
+     */
+    private syncTimestampClock;
     /** Currently enabled animations. */
     get enabledAnimations(): AiAssistantAnimation[];
     set enabledAnimations(value: AiAssistantAnimation[]);
@@ -3651,6 +3610,38 @@ export declare class FoundationAiAssistant extends GenesisElement {
      * element has its own settings modal.
      */
     downloadingDebugLog: boolean;
+    /**
+     * True while `submitDebugLog` is building and handing off the log. Same role as
+     * `downloadingDebugLog` for the Send button: the lifetime-stitch and the host's
+     * `send` callback are async, so the button needs a visible in-flight state.
+     */
+    submittingDebugLog: boolean;
+    /**
+     * Outcome of the last log submission, shown briefly on the button ('Sent' /
+     * 'Failed — retry') then cleared by `setDebugLogSubmitResult`'s timer. `null` when idle.
+     */
+    debugLogSubmitResult: 'sent' | 'error' | null;
+    /** Timer that clears `debugLogSubmitResult` back to idle. */
+    private debugLogSubmitResultTimer?;
+    /**
+     * Whether the agent-log compose box (note + Send/Cancel) is open. Opened by the row's
+     * Send button when `debugLogSubmit.note` is not `false`; closed by Cancel or a
+     * successful send. Stays open after a failure so the typed note is not lost.
+     */
+    debugLogComposeOpen: boolean;
+    /** The note typed in the compose box, raw (trimmed only at submit time). */
+    debugLogNote: string;
+    /** Bound to the compose box's text-area via the template ref, for focus on open. */
+    debugLogNoteEl?: HTMLElement;
+    /** How long 'Sent' shows before idle. Overridable so tests need not wait 4 seconds. */
+    debugLogSubmitResultFlashMs: number;
+    /**
+     * Bumped by `resetDebugLogSubmitState`. An in-flight `submitDebugLog` captures it and
+     * drops its continuation when a reset (disconnect, session switch, Clear) happened
+     * while it awaited — otherwise the stale submission would write state, arm a timer on
+     * a torn-down element, or report 'Sent' into a session it never belonged to.
+     */
+    private debugLogSubmitGeneration;
     /** Active tab inside the settings modal. */
     get settingsModalTab(): SettingsModalTab;
     set settingsModalTab(value: SettingsModalTab);
@@ -4302,6 +4293,65 @@ export declare class FoundationAiAssistant extends GenesisElement {
     get settingsCostTabVisible(): boolean;
     /** Whether session token usage should render on the Usage tab. */
     get settingsSessionTokensVisible(): boolean;
+    /**
+     * Whether the settings "Agent log" section renders — shown when either action is
+     * enabled: the download button (`allowDebugDownload`) or the host-transport Send
+     * button (`debugLogSubmit`). Each button is additionally gated on its own flag
+     * inside the section, so a host can enable one without the other.
+     */
+    get settingsAgentLogSectionVisible(): boolean;
+    /**
+     * The resolved compose-box settings for the agent-log Send button, or `null` when the
+     * host opted out (`debugLogSubmit.note: false`) and the button sends on first click.
+     */
+    get debugLogNoteConfig(): ResolvedDebugLogNoteConfig | null;
+    /**
+     * Whether the typed note counts as empty — the ONE emptiness rule, shared by the
+     * compose box's disabled state and its "required" hint so the two cannot drift apart.
+     */
+    get debugLogNoteMissing(): boolean;
+    /** The Send button's idle label, as the host configured it. */
+    get debugLogSubmitLabel(): string;
+    /**
+     * Label on the agent-log row's Send button. While the compose box is open the row
+     * button is just the (disabled) trigger, so it keeps its idle label; otherwise it
+     * reflects the in-flight / flashed outcome of the last submission.
+     */
+    get debugLogSubmitButtonLabel(): string;
+    /**
+     * The compose box's footer hint: a failure first, then the "required" nudge, else the
+     * live counter. Visual only — the same information reaches assistive technology via
+     * `debugLogNoteAriaLabel` (counter, required) and `debugLogSubmitAnnouncement` (outcome),
+     * because IDREF attributes such as `aria-describedby` cannot point across the
+     * design-system text-area's shadow boundary.
+     */
+    get debugLogComposeHint(): string;
+    /**
+     * Accessible name for the note. Deliberately STATIC apart from "(required)": a name
+     * that changed per keystroke would be re-read in full by NVDA on every key and never
+     * updated by JAWS. The running count reaches AT through `debugLogSubmitAnnouncement`
+     * at the thresholds where it matters.
+     */
+    get debugLogNoteAriaLabel(): string;
+    /**
+     * Text for the always-present live region beside the agent-log row, so the outcome of
+     * a submission is announced even when the compose box is closed or opted out
+     * (`note: false`), where the only visible change is the button label.
+     */
+    get debugLogSubmitAnnouncement(): string;
+    /**
+     * The agent-log row's description, phrased for whichever actions the host enabled.
+     * Send is called out as transmitting: Download keeps the log on the user's machine,
+     * Send hands the full conversation to wherever the host's transport delivers it.
+     */
+    get debugLogRowDescription(): string;
+    /**
+     * Whether the compose box's Send button is inert: a send is already in flight, or the
+     * host made the note required and it is still blank.
+     */
+    get debugLogSendDisabled(): boolean;
+    /** Live "typed / max" counter for the compose box. */
+    get debugLogNoteCounter(): string;
     /** Whether the chat header (and settings cog) should render. */
     get settingsCogVisible(): boolean;
     openSettingsModal(): void;
@@ -4372,6 +4422,62 @@ export declare class FoundationAiAssistant extends GenesisElement {
      */
     private buildMetaSnapshot;
     downloadDebugLog(): Promise<void>;
+    /**
+     * Hand the agent log to the host's `ui.debugLogSubmit.send` callback — the Send
+     * button next to Download. Reuses `buildDownloadLog`, so the submitted log is
+     * byte-identical to what Download saves (lifetime-stitched when the provider
+     * persists diagnostics). The assistant is vendor-agnostic: the callback owns the
+     * transport (Sentry feedback, a support API, an upload endpoint). Outcome lands in
+     * `debugLogSubmitResult` so the button can flash 'Sent'/'Failed'; failures also go
+     * to the logger with the cause.
+     */
+    submitDebugLog(): Promise<void>;
+    /** The agent name stamped on the log: the active agent, else the header title. */
+    private get debugLogAgentName();
+    /**
+     * Filename for the agent log — the ONE derivation Download saves under and Send hands
+     * to the host, so `ChatDebugLogSubmission.filename`'s "same stem as the download"
+     * promise is enforced rather than relying on two copies agreeing.
+     */
+    private debugLogFilename;
+    /**
+     * Back to idle: nothing in flight, no flash, no open compose box, no note. Called on
+     * disconnect and on a session switch / Clear (a note typed against one conversation
+     * must not caption the next one's log). On disconnect — the
+     * flash timer would otherwise fire against a torn-down element, and clearing ONLY the
+     * timer would strand `debugLogSubmitResult` at 'sent'/'error' for good on a pop-out /
+     * pop-in (nothing else resets it), with the box remounting open on a stale note.
+     */
+    private resetDebugLogSubmitState;
+    /**
+     * The row's Send button. With a compose box configured (the default) it opens the box
+     * and focuses the note so the user can caption the log; with `note: false` it sends
+     * straight away, as before.
+     */
+    openDebugLogCompose(): void;
+    /** The note's `@input`: track the text, and let typing dismiss a standing failure. */
+    noteDebugLogInput(value: string): void;
+    /** Close the compose box and discard the typed note. */
+    cancelDebugLogCompose(): void;
+    /**
+     * Closing the compose box unmounts the focused text-area, which drops focus to the
+     * document body and strands keyboard and screen-reader users. Hand it back to the row's
+     * Send button — next frame, once the `when` block has torn down and the button, disabled
+     * while the box was open, is interactive again.
+     */
+    private restoreDebugLogTriggerFocus;
+    /**
+     * After a FAILED send the controls come back but the element that started the send
+     * was disabled meanwhile, so focus has already dropped to the document body. Put it
+     * where the retry happens: the note when the box is open, else the row trigger.
+     */
+    private restoreDebugLogRetryFocus;
+    /**
+     * Record the submit outcome. 'sent' flashes and falls back to idle; 'error' PERSISTS
+     * until the user acts (types, reopens the box, cancels, or retries) — a failure that
+     * silently reverted to the counter after four seconds left no trace it had happened.
+     */
+    private setDebugLogSubmitResult;
     /**
      * The log to download (GENC-1351 §5.8). When the provider persists diagnostics,
      * stitch the **whole lifetime** stream (every page load) rather than just the
@@ -4794,6 +4900,25 @@ export declare interface ManualSelectionConfig {
     hint?: string;
 }
 
+/**
+ * The timestamp shown beside the sender name (GENC-1257).
+ *
+ * Two strings, not one. A screen reader announces a `<time>` element's TEXT — it has no
+ * implicit ARIA role, and the `datetime` attribute is never surfaced to the user — so the
+ * relative text is hidden from assistive tech and paired with a visually-hidden absolute
+ * string. Otherwise AT would hear "5 minutes ago" with nothing to anchor it, and in
+ * `'hover'` mode would hear it for a timestamp sighted users never asked to see.
+ * `datetime` stays because it is correct HTML and useful to tooling, not for a11y.
+ *
+ * Only the VISUAL reveal is hover-gated, in CSS — see `.message-timestamp`. `opacity: 0`
+ * leaves the element in the accessibility tree, so AT gets a time in both visible modes;
+ * `'off'` is the only mode that removes it.
+ *
+ * Reads `timestampClock` rather than `Date.now()` so every row shares one invalidatable
+ * clock and a tick re-evaluates them all; see `FoundationAiAssistant.timestampClock`.
+ */
+export declare const messageTimestampTemplate: ViewTemplate<ChatMessage, FoundationAiAssistant>;
+
 export { ModelTagAppearance }
 
 /**
@@ -5169,6 +5294,13 @@ declare interface ResolvedCostHistoryConfig {
     summaryHint?: string;
 }
 
+/** `ChatDebugLogNoteConfig` with every option resolved. */
+export declare interface ResolvedDebugLogNoteConfig {
+    placeholder: string;
+    required: boolean;
+    maxLength: number;
+}
+
 /**
  * Structured-output schema for an agent. When set, the model's final (non-tool) answer is
  * constrained to this JSON Schema instead of free text. Either a static schema or a function
@@ -5381,6 +5513,11 @@ export declare interface SessionPreferences {
     showThinkingSteps?: boolean;
     showNarration?: boolean;
     showAgentSwitchIndicator?: boolean;
+    /**
+     * When message timestamps are shown (`TimestampDisplay` values, as plain strings).
+     * Absent keeps the `chatConfig.ui.showTimestamps` default, which is `'hover'`.
+     */
+    timestampDisplay?: string;
     /** Enabled loading-animation ids (`AiAssistantAnimation` values, as plain strings). */
     animations?: string[];
 }
@@ -5979,7 +6116,7 @@ export declare interface TurnSnapshot {
      * up from a sub-agent are re-labelled under the parent turn that activated them
      * — a sub-agent invoked on parent turn 5 contributes `"5-1"`, `"5-2"`, …, and a
      * nested sub-agent on `"5-2"` contributes `"5-2-1"`, …. See
-     * `forwardSubAgentSnapshots`.
+     * `forwardSubAgent`.
      */
     turnIndex: string;
     /** ISO timestamp captured just before the LLM call. */