@genesislcap/ai-assistant 15.61.0 → 15.63.0

package/dist/esm/main/main.styles.js

@@ -201,6 +201,14 @@ const baseStyles = css `
     white-space: nowrap;
   }
 
+  /* The user's own messages a compaction kept word for word (GENC-1660), under its divider. */
+  .compaction-preserved {
+    margin: 0 0 calc(var(--design-unit) * 2px);
+    padding-inline-start: calc(var(--design-unit) * 5px);
+    font-size: var(--type-ramp-minus-1-font-size);
+    color: var(--neutral-foreground-hint);
+  }
+
   .message-row {
     display: flex;
     align-items: flex-start;
@@ -637,6 +645,7 @@ const baseStyles = css `
   .composer-resize-handle,
   .attachment-chips,
   .blocked-banner,
+  .autopilot-bar,
   chat-suggestions {
     box-sizing: border-box;
     width: 100%;
@@ -1162,6 +1171,123 @@ const baseStyles = css `
     margin-block-start: calc(var(--blocked-banner-gap) * -1);
   }
 
+  /* ── Autopilot (GENC-1660 §4.10) ──
+     A pending widget the autopilot holds whose registration asks for no chrome: the view renders
+     nothing, so the row is dropped rather than left as an empty bubble. Still mounted, so the view
+     keeps its subscription and reappears the moment the person holds it. */
+  .message-row.held-hidden {
+    display: none;
+  }
+
+  /* Pointed out after the person opened the chat from the "needs you" badge: a brief pulse. */
+  .message.needs-attention {
+    animation: needs-attention 0.8s ease-in-out 3;
+  }
+
+  @keyframes needs-attention {
+    0%,
+    100% {
+      box-shadow: 0 0 0 0 transparent;
+    }
+
+    50% {
+      box-shadow: 0 0 0 3px var(--accent-fill-rest);
+    }
+  }
+
+  /* Without motion, the same ring held still while it is pointed out. */
+  @media (prefers-reduced-motion: reduce) {
+    .message.needs-attention {
+      animation: none;
+      box-shadow: 0 0 0 3px var(--accent-fill-rest);
+    }
+  }
+
+  /* The autopilot mark: subtle, beside the sender label. */
+  .delegate-mark {
+    margin-inline-start: calc(var(--design-unit) * 1px);
+    font-size: var(--type-ramp-minus-1-font-size);
+    color: var(--neutral-foreground-hint);
+  }
+
+  /* The hand-back banner, at the top of the handed-back widget's own bubble. */
+  .autopilot-banner {
+    display: flex;
+    align-items: center;
+    gap: calc(var(--design-unit) * 2px);
+    margin-bottom: calc(var(--design-unit) * 2px);
+    padding: calc(var(--design-unit) * 1.5px) calc(var(--design-unit) * 2px);
+    border-radius: calc(var(--control-corner-radius) * 1px);
+    background: var(--neutral-layer-2);
+    color: var(--neutral-foreground-rest);
+  }
+
+  .autopilot-banner-text {
+    flex: 1 1 auto;
+    min-width: 0;
+  }
+
+  /* Its label sets its width: shrunk by the text beside it, the label spilled out of the bubble. */
+  .autopilot-keep-paused {
+    flex: 0 0 auto;
+  }
+
+  .autopilot-mark {
+    flex: 0 0 auto;
+    color: var(--accent-foreground-rest);
+  }
+
+  /* The slim bar: the composer's footprint with no text box, so nothing can be typed by accident. */
+  .autopilot-bar {
+    display: flex;
+    align-items: center;
+    gap: calc(var(--design-unit) * 2px);
+    padding: calc(var(--design-unit) * 2px) calc(var(--design-unit) * 3px);
+    border-top: calc(var(--stroke-width) * 1px) solid var(--neutral-stroke-rest);
+    background: var(--neutral-layer-1);
+    color: var(--neutral-foreground-rest);
+  }
+
+  .autopilot-status {
+    flex: 1 1 auto;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  /* The autopilot's Pause / Resume pill: its glyph is the mark, tinted as the mark is elsewhere.
+     Uncapped, unlike the agent pill: its label is short and fixed, and clipped it says nothing. */
+  .autopilot-toggle {
+    max-width: none;
+  }
+
+  .autopilot-toggle .pill-glyph {
+    color: var(--accent-foreground-rest);
+  }
+
+  /* On: filled as the person's own bubble is, since it is answering for them. */
+  .autopilot-toggle.is-on,
+  .autopilot-toggle.is-on:hover {
+    color: var(--foreground-on-accent-rest);
+    background: linear-gradient(
+      135deg,
+      var(--accent-fill-rest) 0%,
+      color-mix(in srgb, var(--accent-fill-rest) 70%, black) 100%
+    );
+  }
+
+  .autopilot-toggle.is-on .pill-glyph {
+    color: inherit;
+  }
+
+  .autopilot-bar-end {
+    display: flex;
+    flex: 0 0 auto;
+    align-items: center;
+    gap: calc(var(--design-unit) * 1.5px);
+  }
+
   .file-input {
     display: none;
   }

package/dist/esm/main/main.template.js

@@ -37,6 +37,8 @@ function unknownToolPayload(tc) {
     }
     return lines.join('\n');
 }
+/** The autopilot mark (GENC-1660 §4.5): one icon wherever the assistant acted in autopilot mode. */
+const AUTOPILOT_ICON = 'wand-magic-sparkles';
 const HALO_SPEED_DEFAULT = 1.5;
 const HALO_SPEED_ORCHESTRATING = 0.4;
 const HALO_BORDER_SIZE_DEFAULT = 3;
@@ -47,6 +49,10 @@ const messageType = (m) => {
     switch (true) {
         case m.role === 'system-event':
             return 'agent-switch';
+        // Written on the user's behalf (GENC-1660 §4.5): it renders as the assistant, whatever its
+        // role, so it is never a user bubble the person did not write.
+        case !!m.delegate && (m.role === 'user' || m.role === 'synthetic-user'):
+            return 'ai';
         case m.role === 'user':
         // A synthetic-user message is a display-only echo of an interaction
         // outcome; render it identically to a real user message.
@@ -377,8 +383,8 @@ export const blockedBannerClasses = (x) => [
     .join(' ');
 /**
  * A message's interaction widget, in the wrapper that mounts it. Everything the widget is shown
- * comes from the history message through here, the outcome a tool recorded after the answer
- * included, so a remount, a pop-out and a reload all show the same thing.
+ * comes from the history message through here, the outcome a tool recorded after the answer and the
+ * edits a claimant made included, so a remount, a pop-out and a reload all show the same thing.
  *
  * @internal
  */
@@ -389,6 +395,7 @@ export const interactionWrapperTemplate = html `
     :interactionId=${(m) => m.interaction.interactionId}
     :resolved=${(m) => m.interaction.resolved}
     :outcome=${(m) => m.interaction.outcome}
+    :edits=${(m) => m.interaction.edits}
     @interaction-completed=${(m, c) => c.parent.handleInteractionCompleted(c.event)}
     @interaction-cost=${(m, c) => c.parent.handleInteractionCost(c.event)}
   ></ai-chat-interaction-wrapper>
@@ -583,6 +590,66 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
     ${when((tc) => { var _a; return !!((_a = tc.subAgentTrace) === null || _a === void 0 ? void 0 : _a.length); }, subAgentTraceTemplate)}
   `;
     // ── Message row ─────────────────────────────────────────────────────────────
+    // ── Autopilot (GENC-1660 §4.10) ─────────────────────────────────────────────
+    //
+    // The hand-back banner sits at the top of the handed-back widget's own bubble; the slim bar takes
+    // the composer's place while the autopilot runs. Both read the host's `AutopilotHost`. Neither is
+    // a live region: each is inserted already holding its text, which screen readers widely miss (see
+    // `blockedBannerTemplate`). The announcer below says what they show instead.
+    // Mounted once, empty, and only its text changes: the hand-back reason while the autopilot waits
+    // on an answer, otherwise the slim bar's status while that shows.
+    const autopilotAnnouncerTemplate = html `
+    <span class="visually-hidden" part="autopilot-announcer" role="status">
+      ${(x) => x.autopilotAnnouncement}
+    </span>
+  `;
+    const autopilotBannerTemplate = html `
+    <div class="autopilot-banner" part="autopilot-banner">
+      <${iconTag} class="autopilot-mark" name="${AUTOPILOT_ICON}"></${iconTag}>
+      <span class="autopilot-banner-text" part="autopilot-banner-text">
+        ${(m, c) => {
+        var _a;
+        return [(_a = c.parent.autopilotCopy) === null || _a === void 0 ? void 0 : _a.handBackLead, c.parent.handBackReasonFor(m)]
+            .filter(Boolean)
+            .join(' ');
+    }}
+      </span>
+      <${buttonTag}
+        class="autopilot-keep-paused"
+        part="autopilot-keep-paused"
+        appearance="stealth"
+        @click=${(m, c) => {
+        c.parent.handleKeepPaused(m.interaction.interactionId);
+        return true;
+    }}
+      >${(m, c) => { var _a; return (_a = c.parent.autopilotCopy) === null || _a === void 0 ? void 0 : _a.keepPausedLabel; }}</${buttonTag}>
+    </div>
+  `;
+    // The autopilot's on/off toggle, as the composer's own labelled pill: the mark is its glyph, and
+    // it is filled the way the person's own bubble is while it runs, since it is filling in for them.
+    // A toggle: `aria-pressed` carries its state, so its accessible name is constant (the pill's own
+    // label) and what the click does — Pause / Resume — leads its tooltip instead.
+    const autopilotToggleTemplate = html `
+    <${buttonTag}
+      class="${(x) => classNames('composer-pill', 'composer-pill-labelled', 'autopilot-toggle', [
+        'is-on',
+        x.autopilotCanPause,
+    ])}"
+      part="autopilot-toggle"
+      appearance="stealth"
+      aria-pressed="${(x) => (x.autopilotCanPause ? 'true' : 'false')}"
+      title="${(x) => x.autopilotToggleTitle}"
+      aria-label="${(x) => { var _a; return (_a = x.autopilotCopy) === null || _a === void 0 ? void 0 : _a.toggleLabel; }}"
+      @click=${(x) => {
+        if (x.autopilotCanPause)
+            x.handleAutopilotPause();
+        else
+            x.handleAutopilotResume();
+        return true;
+    }}
+    ><span class="pill-glyph"><${iconTag} name="${AUTOPILOT_ICON}"></${iconTag}></span
+      ><span class="pill-label">${(x) => { var _a; return (_a = x.autopilotCopy) === null || _a === void 0 ? void 0 : _a.toggleLabel; }}</span></${buttonTag}>
+  `;
     const messageRowTemplate = html `
     ${when((m) => m.role === 'system-event', html `
         <div class="agent-switch-indicator" part="agent-switch-indicator">
@@ -593,10 +660,17 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
         <div class="agent-switch-indicator compaction-divider" part="compaction-divider">
           <span class="agent-switch-label">${(m) => compactionDividerLabel(m)}</span>
         </div>
+        ${when((m) => { var _a, _b; return !!((_b = (_a = m.compaction) === null || _a === void 0 ? void 0 : _a.preservedUserMessages) === null || _b === void 0 ? void 0 : _b.length); }, html `
+            <ul class="compaction-preserved" part="compaction-preserved">
+              ${repeat((m) => { var _a, _b; return (_b = (_a = m.compaction) === null || _a === void 0 ? void 0 : _a.preservedUserMessages) !== null && _b !== void 0 ? _b : []; }, html `
+                  <li>${(u) => u.content}</li>
+                `)}
+            </ul>
+          `)}
       `)}
     ${when((m) => m.role !== 'system-event' && m.role !== 'compacted-summary', html `
         <div
-          class="message-row ${(m) => messageType(m)} ${(m) => m.interaction ? `present-${interactionPresentation(m)}` : ''}"
+          class="message-row ${(m) => messageType(m)} ${(m) => m.interaction ? `present-${interactionPresentation(m)}` : ''} ${(m, c) => c.parent.isHiddenWhileHeld(m) ? 'held-hidden' : ''}"
           part="${(m) => messageRowParts(m)}"
         >
           <div
@@ -610,7 +684,11 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
     (m) => messageType(m) === 'user', userAvatarTemplate)}${when((m) => messageType(m) !== 'user', assistantAvatarTemplate)}
           </div>
           <div
-            class="message ${(m) => messageType(m)} ${(m) => classNames(['narration', m.category === 'narration'])}"
+            class="message ${(m) => messageType(m)} ${(m, c) => classNames(['narration', m.category === 'narration'], [
+        'needs-attention',
+        !!m.interaction &&
+            m.interaction.interactionId === c.parent.attentionInteractionId,
+    ])}"
             part="${(m) => messageParts(m)}"
           >
             ${when(
@@ -628,6 +706,15 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
             : senderLabelFor(m);
     }}
                   </span>
+                  ${when((m, c) => c.parent.showsDelegateMark(m), html `
+                      <${iconTag}
+                        class="delegate-mark"
+                        part="delegate-mark"
+                        name="${AUTOPILOT_ICON}"
+                        title="${(m, c) => c.parent.delegateMarkLabel}"
+                        aria-label="${(m, c) => c.parent.delegateMarkLabel}"
+                      ></${iconTag}>
+                    `)}
                   ${when(
     // Guarded on the stamp too: a session persisted before timestamp
     // support restores without one, and an empty <time> would still
@@ -650,6 +737,7 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
               ${when((m) => m.toolCalls, html `
                   ${repeat((m) => { var _a; return (_a = m.toolCalls) !== null && _a !== void 0 ? _a : []; }, toolCallItemTemplate)}
                 `)}
+              ${when((m, c) => c.parent.handBackReasonFor(m) !== undefined, autopilotBannerTemplate)}
               ${when((m) => m.interaction, interactionWrapperTemplate)}
             </div>
             ${when((m, c) => { var _a; return isRateableReply(m) && ((_a = c.parent.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.messageFeedback) != null; }, html `
@@ -687,7 +775,7 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
         class="pill-glyph"
         style="${(x) => (x.pinnedAgentColour ? `color: ${x.pinnedAgentColour}` : '')}"
       ><${iconTag}
-          name="${(x) => (x.pinnedAgentName === null ? 'a' : 'thumbtack')}"
+          name="${(x) => (x.pinnedAgentName === null ? 'sitemap' : 'thumbtack')}"
         ></${iconTag}></span
       ><span class="pill-label">${(x) => x.agentButtonLabel}</span></${buttonTag}>
   `;
@@ -735,13 +823,14 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
           ><${iconTag} name="triangle-exclamation"></${iconTag}></span
         ><span class="pill-label">${(x) => x.contextGateLabel}</span>`)}</${buttonTag}>
   `;
-    // The agent control is LAST in the cluster because it is the only one whose
-    // width changes: pinning an agent swaps `AUTO` for a name, and with it in
-    // front the fixed-size buttons would slide sideways every time the pin
-    // changed. Trailing, it grows into the empty middle of the bar instead.
+    // The agent control comes after the fixed-size buttons because its width changes: pinning an
+    // agent swaps `Orchestration` for a name, and in front of them they would slide sideways every time
+    // the pin changed. The autopilot pill follows it, shown whenever the composer is up with the
+    // autopilot available — paused, or running with nothing happening — and it does move with the
+    // agent pill's width; it sits with the controls it matches rather than at the far end.
     const composerBarStartTemplate = html `
     <div class="composer-bar-start" part="composer-bar-start">
-      ${when((x) => { var _a; return !!((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.acceptedFiles); }, attachButtonTemplate)}${when((x) => x.sessionMenuEnabled, sessionMenuButtonTemplate)}${when((x) => x.agentPickerEnabled, agentToggleButtonTemplate)}
+      ${when((x) => { var _a; return !!((_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.acceptedFiles); }, attachButtonTemplate)}${when((x) => x.sessionMenuEnabled, sessionMenuButtonTemplate)}${when((x) => x.agentPickerEnabled, agentToggleButtonTemplate)}${when((x) => x.composerAutopilotVisible, autopilotToggleTemplate)}
     </div>
   `;
     // ── Send / Stop ─────────────────────────────────────────────────────────────
@@ -783,6 +872,18 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
         @click=${(x) => x.handleSendClick()}
       >Send</${buttonTag}>
     </span>
+  `;
+    // The slim bar, after Stop: it reuses the same button.
+    const autopilotBarTemplate = html `
+    <div class="autopilot-bar" part="autopilot-bar">
+      <span class="autopilot-status" part="autopilot-status">
+        ${(x) => { var _a; return (_a = x.autopilotState) === null || _a === void 0 ? void 0 : _a.status; }}
+      </span>
+      <div class="autopilot-bar-end" part="autopilot-bar-end">
+        ${autopilotToggleTemplate}
+        ${when((x) => x.stopButtonVisible && !x.autopilotSelfPaused, stopButtonTemplate)}
+      </div>
+    </div>
   `;
     // ── Composer menus ──────────────────────────────────────────────────────────
     //
@@ -799,6 +900,8 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
         :agents="${(x) => { var _a; return (_a = x.agents) !== null && _a !== void 0 ? _a : []; }}"
         :pinnedAgentName="${(x) => x.pinnedAgentName}"
         :disablePinColours="${(x) => { var _a; return !!((_a = x.chatConfig.picker) === null || _a === void 0 ? void 0 : _a.disablePinColours); }}"
+        :orchestrationLabel="${(x) => x.orchestrationMenuLabel}"
+        :orchestrationDescription="${(x) => x.orchestrationDescription}"
         @agent-pinned="${(x, c) => {
         x.pinnedAgentName = c.event.detail;
         x.toggleAgentPicker();
@@ -1073,8 +1176,10 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
     /* Rendered above the composer and independently of it — a host that hides the
        built-in composer (`composerHiddenByConfig`) still needs to be told why its own
        input is being refused. */ ''}
-      ${blockedBannerTemplate}
+      ${blockedBannerTemplate} ${autopilotAnnouncerTemplate}
+      ${when((x) => x.slimBarVisible, autopilotBarTemplate)}
       ${when((x) => !x.composerHiddenByConfig &&
+        !x.slimBarVisible &&
         !(x.busy && x.effectiveChatInputDuringExecution === 'hidden'), html `
           ${when((x) => x.isComposerResizable, html `
               <div

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

@@ -76,10 +76,36 @@ export const META_EVENT_IMPORTANCE = {
     'interaction.outcome': 'normal',
     // An outcome that could not be recorded: the widget goes on showing only the answer.
     'interaction.outcome-dropped': 'high',
+    // A long action's step starting, finishing, or skipped on resume because it was already done.
+    'interaction.step': 'low',
+    // A cut checkpoint taken over after a reload, refused (by sameWork, or as malformed), or dropped
+    // at flow end.
+    'interaction.checkpoint': 'normal',
     // A claimant handing a pending interaction to the person, or taking it back.
     'interaction.held': 'normal',
     // A claim on a `userOnly` interaction, refused. Expected when an interceptor claims broadly.
     'interaction.claim-refused': 'low',
+    // A claimant ran one of the surface's actions: what it did, and whether that settled it.
+    'interaction.invoked': 'normal',
+    'autopilot.claimed': 'normal',
+    // One per interaction the autopilot does not take, so frequent and mostly expected.
+    'autopilot.declined': 'low',
+    'autopilot.decision-sent': 'low',
+    'autopilot.acted': 'normal',
+    'autopilot.handed-back': 'normal',
+    'autopilot.paused': 'normal',
+    'autopilot.resumed': 'normal',
+    // The wrapper itself failed: the journey stops being automatic without anyone choosing that.
+    'autopilot.error': 'high',
+    // A written answer counted against the step's limit; reaching it withdraws `reply`.
+    'autopilot.refinement': 'normal',
+    // The autopilot showed its own widget because a working turn ended needing the person.
+    'autopilot.handback-presented': 'normal',
+    // The autopilot was given the whole visible transcript: its first decision, a rebuild, or after
+    // a compaction removed the last message it saw.
+    'autopilot.catch-up': 'normal',
+    // Autopilot spend that reached no message, so it is missing from the session total.
+    'autopilot.cost-dropped': 'high',
     'external-diagnostics.folded': 'normal',
     'session.cleared': 'normal',
     'session.switched': 'low',
@@ -227,6 +253,7 @@ export const DEBUG_LOG_README = [
     '`timeline` is the entire session as one array, already sorted chronologically by `timestamp` (ISO 8601). Every entry has a `kind`.',
     'Timestamps are millisecond-resolution; entries that share the same millisecond are ordered by a fixed kind rank (event, then turn, then message), which is a heuristic and may not reflect exact causal order within that millisecond — e.g. a user message and the turn it triggered, or a final assistant message and its turn.end event, can appear in either order depending on whether they landed in the same millisecond. Read the logical structure of a turn rather than over-interpreting the micro-ordering of co-timestamped entries of different kinds.',
     "kind:'message' — the conversation. `role` is user/assistant/tool/system-event/synthetic-user; `agentName` says which agent produced it; `toolCalls`/`toolResult`/`interaction` carry tool and widget activity; `inputTokens`/`outputTokens`/`cost` are per-message LLM usage, where `inputTokens` is the WHOLE prompt for that request and `cacheReadTokens`/`cacheWriteTokens` BREAK IT DOWN rather than add to it — uncached input is `inputTokens` minus those two, and adding the cache fields to `inputTokens` counts the prompt twice. The cache fields are absent on providers that report no cache split (Gemini reports reads only, since implicit caching bills no write) and on messages persisted before they existed, so read them as 0 when missing. Each bucket bills at a different rate — cache reads a fraction of uncached input, cache writes a premium, output highest — so a large token count at a small cost means the prompt was mostly cache hits. `externalCostUsd` is any non-LLM cost a widget reported for its own external service calls (folded into the session cost total alongside `cost`). On model-produced assistant messages, `model` is the concrete model id that generated it (e.g. 'gemini-2.5-flash-lite') and `providerName` is the registry slot it resolved under (e.g. a tier name like 'high'/'low', or the default); together they attribute the message — and any tool calls it carries — to an exact model even across a mid-session vendor/tier switch, where one slot name can map to different models before and after the switch. Both are undefined on any entry that is NOT an LLM response: non-assistant roles (user/tool/system-event) and 'synthetic-user' echoes; assistant interaction/widget entries (empty content carrying an `interaction` — a rendered widget, not a model turn); driver-authored assistant fallbacks (the timeout, repeated-malformed-call, and empty-response apology messages); and messages restored from a session persisted before these fields existed. One partial case: on a genuine model turn whose provider exposes no `getStatus` (or reports no model), `providerName` is still set but `model` alone is undefined. A 'synthetic-user' message is a display-only echo of an interaction outcome (e.g. the answer a widget reported): it renders on the user's side of the chat and `agentName` is the agent that created it, but it is never sent to the LLM — so it has no matching 'turn' and the model learns the outcome only from the corresponding tool result. An echo of an answer an interceptor (such as an autopilot) gave is NOT synthetic-user: see the delegated-messages paragraph.",
+    '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 › 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) and their results, 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, or the echo of a widget answer it gave, which takes the place of a synthetic-user echo. To tell what the person decided from what was decided for them, read `interaction.answeredBy` and these fields, never the role alone.",
     "Sub-agent messages appear inline. When a tool delegates to a sub-agent (via `requestSubAgent`), the sub-agent's whole conversation — its own assistant/tool messages, each with their own `content`/`thinking`/`toolCalls`/`toolResult` and per-message `model`/`providerName`/`inputTokens`/`outputTokens`/`cacheReadTokens`/`cacheWriteTokens`/`cost` — is hoisted into the timeline as ordinary kind:'message' entries, interleaved by timestamp right after the tool call that spawned them (so you read the delegation top-to-bottom). A hoisted entry is marked: `subAgentDepth` is its delegation depth (1 for a sub-agent, 2 for a sub-agent's sub-agent, …), `subAgentOf` is the id of the parent tool call that spawned it (correlates it back even when two sub-agents run in one parent turn), `subAgentName` is the sub-agent's own name, and `agentName` is rewritten to a `\"<parent> › <sub-agent>\"` breadcrumb (composing when nested, e.g. `\"UI Builder › Planner › Grounding\"`). The sub-agent's per-LLM-call snapshots also surface as kind:'turn' entries with an N-M `turnIndex`, and subagent.started/completed (or subagent.failed) events bracket the run. Per-message `cost` on hoisted entries is already part of the session total (it is summed from the un-flattened history), so summing the top-level timeline does NOT double-count.",
     "kind:'turn' — one LLM call. `turnIndex` is a string: a top-level turn is the bare counter ('0', '1', …); a sub-agent's turns are numbered under the parent turn that activated them ('3-1', '3-2', …, and a nested sub-agent contributes '3-2-1', …), and `agentName` names the agent that ran the turn. `systemPrompt` and `toolNames` are what the model saw. A systemPrompt of '<repeated — identical to turn N>' was byte-identical to turn N and de-duplicated; the full prompt is shown whenever it changes (often because a stateful agent advanced), so prompt evolution is visible.",
@@ -235,7 +262,7 @@ export const DEBUG_LOG_README = [
     "kind:'turn'.`agentSnapshot` — the active agent's own view of its internal state, captured at that turn. An agent opts into this by exposing a `getDebugSnapshot()` that returns JSON-serializable per-state info; stateful/flow agents wire it automatically, so you can watch a flow advance turn-by-turn (e.g. current step, cursor, collected fields, pending changes). Absent for agents that don't expose one.",
     "kind:'event' — a meta/lifecycle event. `type` names it (see below); `detail` carries structured data. `detail.placement` is the emitting UI instance: 'bubble' (collapsed), 'panel' (popped-out), or 'standalone'.",
     "Each 'event' also has an `importance`: 'high' (failures/limits — turn.error, tool.failed, subagent.failed, file.read-failed, suggestions.failed, context.threshold-crossed), 'normal' (session flow — connects, turns, retries, handoffs, agent/provider changes, interactions, sub-agent start/complete), or 'low' (skippable UI/bookkeeping noise — panel.toggled, attachment.added, driver.wired/unwired, context.updated, context.condensed). To skim, ignore importance:'low'; to triage a failure, filter to importance:'high' then read the nearby messages and turns. A 'high' turn.error is often preceded by one or more 'normal' turn.retry events for the same reason — read them together to see how many attempts were made before bailing. 'message' and 'turn' entries carry no importance — they are the substance, always read them.",
-    'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations/response-truncated/refusal/budget-exhausted/provider-refused/context-exhausted/ai-service-error, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, for response-truncated the model + maxTokens + outputTokens + tools, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, for budget-exhausted the budgetUsd + spentUsd figures reported by the proxy plus the resolved vendor, for provider-refused the kind (spend|auth) plus the upstream status and error type — the vendor refusing the ACCOUNT rather than us refusing to spend, so the remedy is a top-up or a key rotation rather than a raised cap, and the kind is the only place that distinction survives because the user-facing copy is deliberately cause-free, for context-exhausted the estimated contextTokens against the guard that stopped the turn plus the iterations reached — the driver ending a runaway tool loop at the edge of the context window rather than issuing a request the provider would reject, so the transcript survives intact and can still be compacted, for ai-service-error the code (one of AI_SERVICE_ERROR_CODES, e.g. NO_API_KEY) and the status the AI service answered with — its own text goes to the browser console only, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout/response_truncated/refusal/budget_exhausted/provider_refused/context_exhausted/ai_service_error; budget_exhausted and provider_refused are terminal for the PARENT turn too, and so is ai_service_error when the refusal is about the service rather than the request and came from the vendor the parent calls — the parent stops rather than calling the model again into the same wall; after context_exhausted the parent goes on, but its own next call is likely to stop on the same guard), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), routing.decided (ONE PER ROUTING DECISION — see its own paragraph below), provider.selected (the resolved provider for the upcoming turns — detail.provider is the registry SLOT/tier name, detail.model the concrete model behind it and detail.vendor its vendor; emitted only when the slot CHANGES, so read the per-turn `model` for the model of any given call rather than assuming the nearest event still applies), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver; detail.ownerPath names the agents that actually asked, outermost first, the last being the one whose tool requested it, and detail.heldBy says who held it when it opened: user, or the id of the interceptor that claimed it, such as autopilot; on interaction.resolved, detail.answeredBy is who answered — the claimant id when it settled through its own hold, user for any other answer (a click counts as the person even on a widget a claimant held) — absent when it closed unanswered (a timeout or a stop); the same value is stamped on the interaction message as answeredBy, and when it is not user the tool result that interaction returned carries a decidedOnUsersBehalf record, so the model was told the choice was not made by the person), interaction.held (a claimant moved a pending interaction to the person or back to itself — detail.heldBy is the new holder, detail.claimant the interceptor; a widget held by anything but user was not answered by the person), interaction.claim-refused (a claim on a userOnly interaction, which stays with the person — detail.claimant + reason), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
+    'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations/response-truncated/refusal/budget-exhausted/provider-refused/context-exhausted/ai-service-error, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, for response-truncated the model + maxTokens + outputTokens + tools, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, for budget-exhausted the budgetUsd + spentUsd figures reported by the proxy plus the resolved vendor, for provider-refused the kind (spend|auth) plus the upstream status and error type — the vendor refusing the ACCOUNT rather than us refusing to spend, so the remedy is a top-up or a key rotation rather than a raised cap, and the kind is the only place that distinction survives because the user-facing copy is deliberately cause-free, for context-exhausted the estimated contextTokens against the guard that stopped the turn plus the iterations reached — the driver ending a runaway tool loop at the edge of the context window rather than issuing a request the provider would reject, so the transcript survives intact and can still be compacted, for ai-service-error the code (one of AI_SERVICE_ERROR_CODES, e.g. NO_API_KEY) and the status the AI service answered with — its own text goes to the browser console only, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout/response_truncated/refusal/budget_exhausted/provider_refused/context_exhausted/ai_service_error; budget_exhausted and provider_refused are terminal for the PARENT turn too, and so is ai_service_error when the refusal is about the service rather than the request and came from the vendor the parent calls — the parent stops rather than calling the model again into the same wall; after context_exhausted the parent goes on, but its own next call is likely to stop on the same guard), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), routing.decided (ONE PER ROUTING DECISION — see its own paragraph below), provider.selected (the resolved provider for the upcoming turns — detail.provider is the registry SLOT/tier name, detail.model the concrete model behind it and detail.vendor its vendor; emitted only when the slot CHANGES, so read the per-turn `model` for the model of any given call rather than assuming the nearest event still applies), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver; detail.ownerPath names the agents that actually asked, outermost first, the last being the one whose tool requested it, and detail.heldBy says who held it when it opened: user, or the id of the interceptor that claimed it, such as autopilot; on interaction.resolved, detail.answeredBy is who answered — the claimant id when it settled through its own hold, user for any other answer (a click counts as the person even on a widget a claimant held) — absent when it closed unanswered (a timeout or a stop); the same value is stamped on the interaction message as answeredBy, and when it is not user the tool result that interaction returned carries a decidedOnUsersBehalf record, so the model was told the choice was not made by the person; 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 — the framing and those choice texts — 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 — detail.heldBy is the new holder, detail.claimant the interceptor; a widget held by anything but user was not answered by the person), interaction.claim-refused (a claim on a userOnly interaction, which stays with the person — detail.claimant + reason), autopilot.* (the autopilot, a decorator that answers interactions on behalf of the user — 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; autopilot.decision-sent is what it was sent (detail.chars); 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.error is the wrapper itself failing; autopilot.refinement counts a written answer against its step (detail.stepKey, detail.count, detail.limitReached, after which reply is withdrawn for that step); 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 — 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 — stale when a pause, a resume, a new turn or the end of its flow came before the answer landed, which then went nowhere — 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 — 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), interaction.step (a long action run as named steps through runSteps, which survive a reload — 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 one checkpoint a conversation keeps for its long action — detail.action: resumed when a reload cut the work and the next request of the same widget type took it over, refused when the registration sameWork said the new request is different work (detail.saved is the identity it kept) or when runSteps found the handed-over checkpoint malformed and started fresh (detail.reason, detail.saved), or cleared when its flow ended with nothing taking it over), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
     'Sub-agent meta events: a sub-agent\'s own turn.retry/turn.error/tool.failed/tool.unresolved events are merged into this same timeline, tagged with `detail.subAgent` — a `"<parent> › <sub-agent>"` breadcrumb that composes when nested (e.g. `"UI Builder › Planner › Grounding"`) — and interleaved by their original timestamps within the subagent.started→completed/failed bracket. These are the per-attempt/per-failure signals that do NOT appear among the sub-agent\'s (hoisted) messages: a malformed/empty attempt that gets retried produces no message, and the stale-vs-hallucinated split and streak counts live only on the event. A sub-agent\'s high-volume, message-derivable events (turn.start/turn.end, provider.selected, context.updated) are intentionally NOT merged — read its hoisted messages for model/tokens/cost and turn-by-turn activity, and the bracketing subagent.* events for the run\'s span.',
     "`meta` holds context captured at export time: agentSummary (full agent configs), context (active model, contextTokens/contextLimit/contextUsagePercent for the last call, and the session totals — sessionCostUsd, sessionTokensConsumed, and the four-bucket sessionUsage lifted to the top of this log), activeDebugSnapshot (the active agent's `getDebugSnapshot()` taken fresh at export — reflects state NOW, which may have advanced beyond the last turn's agentSnapshot), debug (optional host-supplied debug state), host, and the export timestamp.",
     'Note the two different scopes in `meta.context`: `contextTokens` is the prompt size of the LAST call (against `contextLimit`, the model context window), while `sessionUsage`/`sessionTokensConsumed` are cumulative BILLED throughput. Every turn resends the conversation, so the cumulative figure counts each turn’s prompt again in the next turn’s and is expected to dwarf the context size — that is not double-counting.',