@genesislcap/ai-assistant 15.19.6 → 15.20.0

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

@@ -592,6 +592,72 @@ const baseStyles = css `
     opacity: 45%;
   }
 
+  /* Context-gate states on the session-menu pill (GENC-1567).
+
+     ONE accent across both levels rather than amber escalating to red. The
+     escalation is carried by things that survive without colour vision and read
+     on a screen reader: the label changes wording ("Approaching" → "At"), the
+     composer gains an outline, and the composer disables with the remedy in its
+     placeholder. A colour change would have been the one signal adding nothing
+     the others do not already say, while making the composer shout in two hues
+     at once.
+
+     Colour is never the signal on its own here either — the pill swaps ⋮ for a
+     warning triangle and grows a label, and its title and aria-label carry the
+     full reason. */
+
+  /* The pill's own label is the loudest part, so it carries the weight the glyph
+     alone would not. max-width is widened from the agent pin's 45%: this label
+     is a fixed phrase rather than a user-supplied agent name, and ellipsing
+     "Approaching context limit" to "Approaching cont…" would lose the noun that
+     makes it mean anything. */
+  .session-menu-button.context-warn,
+  .session-menu-button.context-blocked {
+    max-width: 65%;
+  }
+
+  .session-menu-button.context-warn,
+  .session-menu-button.context-warn:hover {
+    color: var(--warning-color);
+  }
+
+  .session-menu-button.context-blocked,
+  .session-menu-button.context-blocked:hover {
+    color: var(--error-color);
+  }
+
+  /* The gate disables this button during a turn like any other composer control.
+     Left at the shared 45% it reads as "inactive" at exactly the moment the
+     conversation is running away, so it keeps more of its presence — still
+     clearly not clickable, but not faded out of notice. */
+  .session-menu-button.context-warn[disabled],
+  .session-menu-button.context-blocked[disabled] {
+    opacity: 70%;
+  }
+
+  /* The composer outline (GENC-1567). Drawn from the WARNING onwards, not just at
+     the block: the composer is the control the condition is about, and a user who
+     only ever sees it appear at the moment sending stops has had no warning where
+     they were looking. It escalates amber → red with the state rather than
+     appearing from nothing.
+
+     A border-COLOUR change only: the composer already declares a transparent
+     1px border on all four sides so its box metrics are identical in both the
+     flush and floating layouts, which means this cannot reflow anything or shift
+     the composer as the state flips. */
+  .composer.context-warn,
+  .composer.context-blocked {
+    border-radius: calc(var(--control-corner-radius) * 1px);
+  }
+
+  .composer.context-warn {
+    border-color: var(--warning-color);
+  }
+
+  .composer.context-blocked {
+    border-color: var(--error-color);
+  }
+
   .composer-pill::part(control) {
     min-width: 0;
     padding: 0;
@@ -834,6 +900,26 @@ const baseStyles = css `
     border-color: var(--neutral-stroke-rest);
   }
 
+  /* Announced, not drawn (GENC-1567). The context gate has three visible
+     expressions already; this keeps the role=status region mounted and
+     mutating so the condition is still spoken, which nothing else can do once
+     the composer disables and drops out of the tab order.
+
+     Clipped rather than display:none or visibility:hidden — both of those
+     remove the node from the accessibility tree, which would silence the very
+     announcement this exists for. */
+  .blocked-banner.is-sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    margin: -1px;
+    padding: 0;
+    border: 0;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+  }
+
   .blocked-banner-text {
     font-size: 0.9em;
     line-height: 1.4;
@@ -868,6 +954,48 @@ const baseStyles = css `
     box-shadow: none;
   }
 
+  /* At the context limit the placeholder stops being a hint and becomes the only
+     visible statement of what is wrong and how to clear it — so it has to be
+     readable. The design system dims a disabled control's placeholder towards
+     the point of being skipped over, which is right for "Message assistant..."
+     and wrong for a sentence the user has to act on. Restored to the normal
+     foreground, and left un-dimmed by the disabled treatment. */
+  .composer.context-blocked .chat-input::part(control)::placeholder {
+    color: var(--neutral-foreground-rest);
+    opacity: 100%;
+  }
+
+  /* And tall enough to actually show it. The placeholder here is two sentences,
+     and the input's resting height clipped them — losing the end, which is the
+     half that says what to do about it.
+
+     min-height rather than height, deliberately: it outranks the inline height
+     the drag-to-resize handle writes, so a user who had shrunk the composer
+     earlier still sees the whole message.
+
+     Sized from measurement across the width range rather than from one look at
+     one panel: the wrap count changes with the container, and a value picked at
+     a comfortable width silently clips at a narrow one. Measured need is 76px
+     from 400px up to ~560px, and 56px beyond that.
+
+     **400px is taken as the narrowest supported composer.** Below it the message
+     wraps further and this floor stops being enough — it degrades to a clipped
+     sentence rather than anything broken, but it is not a width the copy is sized
+     for.
+
+     Past 600px the message fits the composer's natural resting height, so the
+     floor is simply removed rather than set to a value it already exceeds. What
+     remains is a floor either way: the input still auto-grows past it on input. */
+  .composer.context-blocked .chat-input {
+    min-height: calc(var(--design-unit) * 20px);
+  }
+
+  @container (width > 600px) {
+    .composer.context-blocked .chat-input {
+      min-height: 0;
+    }
+  }
+
   /* Full-width grab bar above the input row; drag up/down to resize the composer.
      Sits above the row so it never overlaps the send/stop controls. */
   .composer-resize-handle {

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

@@ -268,8 +268,13 @@ const restoringTemplate = html `
  */
 export const blockedBannerClasses = (x) => [
     'blocked-banner',
+    // Only a budget wall is DRAWN here. The context gate states itself through
+    // the pill label, the composer outline and the placeholder, so a strip of
+    // prose on top would be a fourth statement of one condition — but it still
+    // has to be announced, hence `is-sr-only` rather than dropping the region.
     x.bannerVisible ? 'is-visible' : '',
     x.bannerVisible && !x.blocked ? 'is-partial' : '',
+    x.composerNoticeSrOnly ? 'is-sr-only' : '',
 ]
     .filter(Boolean)
     .join(' ');
@@ -305,7 +310,7 @@ export const BLOCKED_BANNER_ID = 'blocked-banner';
  *
  * @internal
  */
-export const composerDescribedBy = (x) => x.bannerVisible ? BLOCKED_BANNER_ID : null;
+export const composerDescribedBy = (x) => x.composerNoticeVisible ? BLOCKED_BANNER_ID : null;
 /**
  * Persistent banner shown above the composer while a backend condition blocks
  * the assistant — today an exhausted AI budget (GENC-1464).
@@ -345,8 +350,8 @@ const blockedBannerTemplate = html `
     part="blocked-banner"
     role="status"
   >
-    ${when((x) => x.bannerVisible, html `
-        <span class="blocked-banner-text">${(x) => x.effectiveBlockedReason}</span>
+    ${when((x) => x.composerNoticeVisible, html `
+        <span class="blocked-banner-text">${(x) => x.composerNoticeText}</span>
       `)}
   </div>
 `;
@@ -560,23 +565,38 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
       appearance="stealth"
       title=${(x) => { var _a; return `Attach file (${(_a = x.chatConfig.ui) === null || _a === void 0 ? void 0 : _a.acceptedFiles})`; }}
       aria-label="Attach file"
-      ?disabled=${(x) => x.busy || x.compacting || x.restoring || x.blocked}
+      ?disabled=${(x) => x.busy || x.compacting || x.restoring || x.blocked || x.contextGate === 'blocked'}
       aria-describedby=${composerDescribedBy}
       @click=${(x) => x.triggerFileInput()}
     ><${iconTag} name="paperclip"></${iconTag}></${buttonTag}>
   `;
+    // The same control carries the context-gate signal (GENC-1567): ⋮ becomes a
+    // warning triangle as the window fills, amber at the warning and red once
+    // sends are blocked. Deliberately this button and not a new one — it is
+    // already the way to reach Compact, and it stays mounted (disabled, not
+    // removed) during a turn, so the colour change is visible through exactly the
+    // runaway tool loop that causes the problem.
+    //
+    // While a turn runs the button is disabled, so the notice copy above must not
+    // point at it as if it were clickable — see `contextGateReason`.
     const sessionMenuButtonTemplate = html `
     <${buttonTag}
-      class="composer-pill session-menu-button"
+      class="${(x) => classNames('composer-pill', 'session-menu-button', 
+    // Borrows the agent pin's labelled shape only while the gate is active,
+    // so the composer's resting state is unchanged — three equal circular
+    // pills — and the label's arrival is itself part of the signal.
+    ['composer-pill-labelled', x.contextGate !== 'ok'], ['context-warn', x.contextGate === 'warn'], ['context-blocked', x.contextGate === 'blocked'])}"
       part="session-menu-button"
       appearance="stealth"
-      title="Session options"
-      aria-label="Session options"
+      title="${(x) => (x.contextGate === 'ok' ? 'Session options' : x.contextGateReason)}"
+      aria-label="${(x) => x.contextGate === 'ok' ? 'Session options' : `Session options — ${x.contextGateReason}`}"
       aria-haspopup="menu"
       aria-expanded=${(x) => (x.sessionMenuOpen ? 'true' : 'false')}
       ?disabled=${(x) => x.busy || x.compacting || x.restoring}
       @click=${(x) => x.toggleSessionMenu()}
-    ><${iconTag} name="ellipsis"></${iconTag}></${buttonTag}>
+    >${when((x) => x.contextGate === 'ok', html `<${iconTag} name="ellipsis"></${iconTag}>`)}${when((x) => x.contextGate !== 'ok', html `<span class="pill-glyph"
+          ><${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
@@ -616,7 +636,12 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
       <${buttonTag}
         class="send-button"
         part="send-button"
-        ?disabled=${(x) => x.busy || x.compacting || x.restoring || x.blocked || (!x.inputValue.trim() && !x.attachments.length)}
+        ?disabled=${(x) => x.busy ||
+        x.compacting ||
+        x.restoring ||
+        x.blocked ||
+        x.contextGate === 'blocked' ||
+        (!x.inputValue.trim() && !x.attachments.length)}
         aria-describedby=${composerDescribedBy}
         @click=${(x) => x.handleSendClick()}
       >Send</${buttonTag}>
@@ -655,29 +680,32 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
       role="menuitem"
       type="button"
       ?disabled=${(x) => !x.compactable}
-      title=${(x) => x.compactable
-        ? 'Summarize older messages to free up context'
-        : 'Not enough conversation yet to be worth compacting'}
+      title=${(x) => x.compactHint}
       @click=${(x) => (x.confirmingCompact = true)}
     >
       <span class="menu-item-icon" aria-hidden="true"><${iconTag} name="compress"></${iconTag}></span>
       <span class="menu-item-body">
         <span class="menu-item-name">Compact</span>
-        <span class="menu-item-hint">Summarize older messages to free up context</span>
-      </span>
-    </button>
-    <button
-      class="menu-item"
-      role="menuitem"
-      type="button"
-      @click=${(x) => (x.confirmingClear = true)}
-    >
-      <span class="menu-item-icon" aria-hidden="true"><${iconTag} name="trash"></${iconTag}></span>
-      <span class="menu-item-body">
-        <span class="menu-item-name">Clear</span>
-        <span class="menu-item-hint">Start a new conversation</span>
+        <span class="menu-item-hint">${(x) => x.compactHint}</span>
       </span>
     </button>
+    ${when(
+    // Clear is withheld from a menu the context gate forced open — but only
+    // while Compact is a real escape. See `clearWithheldByContext`.
+    (x) => !x.clearWithheldByContext, html `
+        <button
+          class="menu-item"
+          role="menuitem"
+          type="button"
+          @click=${(x) => (x.confirmingClear = true)}
+        >
+          <span class="menu-item-icon" aria-hidden="true"><${iconTag} name="trash"></${iconTag}></span>
+          <span class="menu-item-body">
+            <span class="menu-item-name">Clear</span>
+            <span class="menu-item-hint">Start a new conversation</span>
+          </span>
+        </button>
+      `)}
   `;
     // The hint is not decoration. Every other row in this menu has one, and the
     // panel is anchored by its BOTTOM edge to the button: a hintless Cancel makes
@@ -891,7 +919,10 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
                 @pointercancel=${(x, c) => x.onComposerResizeEnd(c.event)}
               ></div>
             `)}
-          <div class="composer" part="composer">
+          <div
+            class="${(x) => classNames('composer', ['context-warn', x.contextGate === 'warn'], ['context-blocked', x.contextGate === 'blocked'])}"
+            part="composer"
+          >
             <${textareaTag}
               ${ref('chatInputEl')}
               class="chat-input"
@@ -899,9 +930,13 @@ ${(tc) => { var _a; return (((_a = tc.foldPath) === null || _a === void 0 ? void
               style=${(x) => x.composerHeightStyle}
               placeholder=${(x) => x.effectivePlaceholder}
               :value=${(x) => x.inputValue}
-              ?disabled=${(x) => x.busy || x.compacting || x.restoring || x.blocked}
-              aria-disabled=${(x) => (x.blocked ? 'true' : null)}
-              aria-label=${(x) => (x.blocked ? x.effectiveBlockedReason : null)}
+              ?disabled=${(x) => x.busy || x.compacting || x.restoring || x.blocked || x.contextGate === 'blocked'}
+              aria-disabled=${(x) => (x.blocked || x.contextGate === 'blocked' ? 'true' : null)}
+              aria-label=${(x) => x.blocked
+        ? x.effectiveBlockedReason
+        : x.contextGate === 'blocked'
+            ? x.contextGateReason
+            : null}
               aria-describedby=${composerDescribedBy}
               @input=${(x, c) => (x.inputValue = c.event.target.value)}
               @keydown=${(x, c) => {

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

@@ -219,7 +219,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, 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, 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; budget_exhausted and provider_refused are both terminal for the PARENT turn too — the parent stops rather than calling the model again into the same wall), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), provider.selected (the resolved provider for the upcoming turns — detail.provider is the registry SLOT/tier name, detail.model the concrete model behind it and detail.vendor its vendor; emitted only when the slot CHANGES, so read the per-turn `model` for the model of any given call rather than assuming the nearest event still applies), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
+    '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, 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, 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; budget_exhausted, provider_refused and context_exhausted are all terminal for the PARENT turn too — the parent stops rather than calling the model again into the same wall), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), provider.selected (the resolved provider for the upcoming turns — detail.provider is the registry SLOT/tier name, detail.model the concrete model behind it and detail.vendor its vendor; emitted only when the slot CHANGES, so read the per-turn `model` for the model of any given call rather than assuming the nearest event still applies), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
     '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.',

package/dist/esm/utils/condense-history.js

@@ -1,4 +1,5 @@
 import { __rest } from "tslib";
+import { APPROX_CHARS_PER_TOKEN } from './context-tokens';
 /**
  * Tool-context condensation: collapse stale tool payloads out of the history
  * sent to the model, while leaving stored history untouched.
@@ -21,11 +22,6 @@ import { __rest } from "tslib";
 export const CONDENSE_MIN_CHARS = 1000;
 /** Key the collapsed args are stored under — a tool-call's args must stay a Record. */
 export const CONDENSED_ARGS_KEY = 'condensed';
-/**
- * Rough chars-per-token divisor for the `tokensSaved` estimate. No tokenizer is
- * available in this stack; ~4 chars/token is the usual English approximation.
- */
-const APPROX_CHARS_PER_TOKEN = 4;
 /** Short human-readable reason for the stub text, per fired trigger. */
 function triggerReason(trigger) {
     switch (trigger.kind) {