@aragon-agent/cli 0.6.1 → 0.6.3

package/dist/agent/reducer.js

@@ -11,6 +11,7 @@
  *     synthesizes a generic error notice (a swallowed throw is never a no-op).
  */
 import process from 'node:process';
+import { occupiedTokens } from '../compaction/pressure.js';
 import { computeCost } from './usage.js';
 import { ENTRY_LIMITS, appendBounded, entryRetain, trimEntries } from './entry-limits.js';
 /** Default auto-dismiss window for a toast. */
@@ -46,11 +47,14 @@ export function initialViewState(seed = {}) {
         todos: null,
         retry: null,
         fast: null,
+        compaction: null,
+        contextTokensEstimated: false,
         seq: 0,
         teamEntryId: undefined,
         todoEntryId: undefined,
         retryEntryId: undefined,
         fastEntryId: undefined,
+        compactionEntryId: undefined,
         streamingId: undefined,
         turnProduced: false,
         errorNoticed: false,
@@ -223,6 +227,17 @@ function reduceStreamEvent(se) {
             return [];
     }
 }
+/**
+ * The opening words of the `context_overflow` banner.
+ *
+ * A SHARED CONSTANT RATHER THAN TWO LITERALS, because `compactionStart` matches
+ * on it to rewrite the notice a successful reactive recovery would otherwise
+ * leave behind (P1-4). Two spellings that must agree, with nothing checking that
+ * they do, is how that rewrite silently stops matching — at which point the red
+ * "start over" banner comes back and only on the recovery path, which is the one
+ * place nobody re-tests.
+ */
+export const CONTEXT_OVERFLOW_NOTICE_PREFIX = 'Context length exceeded';
 /** Turn a provider error into a friendly banner, mapping LLMError.errorType. */
 export function formatStreamError(error) {
     const errorType = error.errorType;
@@ -235,7 +250,13 @@ export function formatStreamError(error) {
         case 'overloaded':
             return `Provider overloaded - please retry shortly. (${base})`;
         case 'context_overflow':
-            return `Context length exceeded - start a new conversation with /reset. (${base})`;
+            // `/compact` IS NAMED FIRST, and adding it is the second half of P1-4's
+            // fix. This remedy list predates context compaction and was, until it
+            // existed, complete: throwing the conversation away really was the only
+            // exit. It is not any more, and a banner that offers only `/reset` now
+            // tells the user to discard a session the very next line of code may be
+            // about to save.
+            return `${CONTEXT_OVERFLOW_NOTICE_PREFIX} - try /compact, or start over with /reset. (${base})`;
         case 'network_error':
             return `Network error reaching the provider. (${base})`;
         case 'timeout':
@@ -295,6 +316,11 @@ function appendEntry(state, entries, entry) {
             // `fastEntryId` IS PART OF THIS LIST for the reason the note above gives:
             // a fifth live card left out of it is a card I-L1-1 does not cover.
             state.fastEntryId,
+            // And `compactionEntryId` is the sixth. Same reason, and it is the one
+            // whose absence would be hardest to notice: a compaction card is rare, so
+            // a `mapEntry` that silently stopped matching would be found by a user
+            // rather than by a test.
+            state.compactionEntryId,
         ].filter((id) => typeof id === 'string');
         for (const id of live) {
             if (!trimmed.entries.some((e) => e.id === id)) {
@@ -584,7 +610,17 @@ export function viewReducer(state, action) {
                 ...state,
                 streamingId: undefined,
                 turnProduced: true,
-                contextTokens: action.usage.inputTokens + action.usage.outputTokens,
+                // ONE FUNCTION, SHARED WITH THE COMPACTION TRIGGER (§3.4.1 / R-11 /
+                // AC-3). The old expression — `inputTokens + outputTokens` — silently
+                // UNDER-reports for anyone behind a caching gateway, because Anthropic
+                // reports `input_tokens` EXCLUDING cached tokens and puts them in two
+                // separate fields. That was a live defect in the number this gauge shows;
+                // it becomes a much worse one the moment a trigger fires on a different
+                // number from the one the user is watching.
+                contextTokens: occupiedTokens(action.usage),
+                // A MEASUREMENT SUPERSEDES A DERIVATION (§6.2). `compactionEnd` writes an
+                // estimate so the bar falls immediately; this is where it stops being one.
+                contextTokensEstimated: false,
                 usageTotal: {
                     inputTokens: state.usageTotal.inputTokens + action.usage.inputTokens,
                     outputTokens: state.usageTotal.outputTokens + action.usage.outputTokens,
@@ -713,6 +749,12 @@ export function viewReducer(state, action) {
                 // holds, it is a projection of an entry that has just been erased.
                 retryEntryId: undefined,
                 retry: null,
+                // Same reasoning again for the compaction card: the entry is gone, so the
+                // id must go with it or `compactionEnd` would `mapEntry` an id that no
+                // longer exists. `compaction` STAYS — unlike `retry` it is not a
+                // projection of an entry, it is the live state of a subsystem that is
+                // still running, and `/clear` clears the screen rather than the session.
+                compactionEntryId: undefined,
             };
         case 'resetConversation':
             return {
@@ -731,6 +773,11 @@ export function viewReducer(state, action) {
                 todoEntryId: undefined,
                 retryEntryId: undefined,
                 retry: null,
+                compactionEntryId: undefined,
+                // `contextTokens` is zeroed above, so the flag that says it is a
+                // DERIVATION has to go with it — otherwise a fresh conversation renders
+                // `~0%` and the tilde is a lie about a number that is simply zero.
+                contextTokensEstimated: false,
             };
         case 'setOverlay':
             return { ...state, overlay: action.overlay };
@@ -957,6 +1004,158 @@ export function viewReducer(state, action) {
             };
         case 'fastTier':
             return { ...state, fast: action.snapshot };
+        // --- Context compaction (context-auto-compaction §5.5) ----------------
+        case 'compactionStart': {
+            const { id, seq } = nextId(state);
+            let entries = state.entries;
+            // RESPONSIBILITY 1 — SEAL ANY LIVE `streamingId` ENTRY, defensively.
+            // C-8's failure mode, and reachable here: `provider.ts` records that
+            // Anthropic can deliver an error IN-STREAM, after the connection is open
+            // and therefore after text deltas have already been emitted. An entry that
+            // never settles pins `Transcript`'s monotonic boundary and re-renders the
+            // tail forever.
+            if (state.streamingId) {
+                entries = mapEntry(entries, state.streamingId, (e) => e.kind === 'assistant' ? { ...e, streaming: false, ...sealThinkingMs(e) } : e);
+            }
+            // RESPONSIBILITY 2 — REWRITE A TRAILING `context_overflow` ERROR NOTICE
+            // (P1-4). `agent-loop.ts` emits `message_update` for EVERY stream event
+            // before the `error` branch throws, and `reduceStreamEvent`'s `case 'error'`
+            // turns that into a `level: 'error'` notice reading "Context length
+            // exceeded". So the HAPPY PATH of the reactive recovery would otherwise end
+            // with a red banner telling the user to throw away the session we are one
+            // frame from saving.
+            //
+            // IT REWRITES RATHER THAN REMOVES, because `<Static>` cannot un-print an
+            // entry it has already drawn — and it matches ONLY when that notice is the
+            // TAIL entry, so it can never touch an older, genuine error. If the
+            // recovery then fails, the ladder's own notice or the re-thrown 400 is what
+            // the user is left with, so neither direction lies.
+            if (action.trigger === 'overflow') {
+                const tail = entries[entries.length - 1];
+                if (tail &&
+                    tail.kind === 'notice' &&
+                    tail.level === 'error' &&
+                    tail.text.startsWith(CONTEXT_OVERFLOW_NOTICE_PREFIX)) {
+                    entries = mapEntry(entries, tail.id, (e) => e.kind === 'notice'
+                        ? { ...e, level: 'info', text: 'Context window exceeded - compacting and retrying.' }
+                        : e);
+                }
+            }
+            const entry = {
+                id,
+                kind: 'compaction',
+                index: action.index,
+                trigger: action.trigger,
+                mode: 'none',
+                applied: false,
+                messagesBefore: 0,
+                messagesAfter: 0,
+                tokensBefore: 0,
+                tokensAfter: 0,
+                model: action.model,
+                startedAt: Date.now(),
+                live: true,
+            };
+            return {
+                ...state,
+                seq,
+                ...appendEntry(state, entries, entry),
+                compactionEntryId: id,
+                streamingId: undefined,
+            };
+        }
+        case 'compactionEnd': {
+            const { record } = action;
+            const settle = (e) => e.kind === 'compaction'
+                ? {
+                    ...e,
+                    index: record.index,
+                    trigger: record.trigger,
+                    mode: record.mode,
+                    applied: record.applied,
+                    ...(record.reason !== undefined ? { reason: record.reason } : {}),
+                    messagesBefore: record.messagesBefore,
+                    messagesAfter: record.messagesAfter,
+                    tokensBefore: record.tokensBefore,
+                    tokensAfter: record.tokensAfter,
+                    ...(record.summary !== undefined ? { summary: record.summary } : {}),
+                    ...(record.tailRelief ? { tailRelief: record.tailRelief } : {}),
+                    model: record.model,
+                    durationMs: record.durationMs,
+                    // SETTLED. `Transcript`'s boundary is monotonic, so a card that
+                    // never settles is re-rendered on every frame for the rest of the
+                    // session (C-8).
+                    live: false,
+                }
+                : e;
+            // THE SECOND BRANCH IS NOT DEFENSIVE PADDING, exactly as `fastEnd`'s is
+            // not: the IDLE `/compact` path settles a record for a card this session
+            // may never have opened, and "it did nothing" must never be the observable
+            // outcome (R-8 / §6.4).
+            if (state.compactionEntryId) {
+                return {
+                    ...state,
+                    entries: mapEntry(state.entries, state.compactionEntryId, settle),
+                    compactionEntryId: undefined,
+                };
+            }
+            const { id, seq } = nextId(state);
+            const entry = {
+                id,
+                kind: 'compaction',
+                index: record.index,
+                trigger: record.trigger,
+                mode: record.mode,
+                applied: record.applied,
+                ...(record.reason !== undefined ? { reason: record.reason } : {}),
+                messagesBefore: record.messagesBefore,
+                messagesAfter: record.messagesAfter,
+                tokensBefore: record.tokensBefore,
+                tokensAfter: record.tokensAfter,
+                ...(record.summary !== undefined ? { summary: record.summary } : {}),
+                ...(record.tailRelief ? { tailRelief: record.tailRelief } : {}),
+                model: record.model,
+                durationMs: record.durationMs,
+                live: false,
+            };
+            return { ...state, seq, ...appendEntry(state, state.entries, entry) };
+        }
+        case 'compactionUsage':
+            // `usageTotal` AND NOTHING ELSE, exactly as `teamUsage` and `fastUsage`. In
+            // particular NOT `contextTokens`: that gauge shows the LEAD's context
+            // occupancy against the lead model's window, and a summarization is a
+            // separate conversation with a possibly different model entirely.
+            return {
+                ...state,
+                usageTotal: {
+                    inputTokens: state.usageTotal.inputTokens + action.usage.inputTokens,
+                    outputTokens: state.usageTotal.outputTokens + action.usage.outputTokens,
+                    costUsd: state.usageTotal.costUsd + action.costDelta,
+                },
+            };
+        case 'compactionSnapshot':
+            return { ...state, compaction: action.snapshot };
+        /**
+         * THE GAUGE MUST FALL IMMEDIATELY (§6.2 / AC-5).
+         *
+         * `contextTokens` is otherwise only written at `turnEnd`, so a compaction
+         * that took the session from 92 % to 24 % would leave the bar at 92 % until
+         * the next turn completes — and the user would reasonably conclude that
+         * nothing happened. This is a small change and it is the difference between
+         * the feature feeling real and feeling broken.
+         *
+         * The value arrives ALREADY CALIBRATED from `App` (§6.2 / P1-11): it replaces
+         * a MEASUREMENT that included the tool schemas, and core's raw estimator
+         * never counts them, so writing the raw figure would make the bar fall too
+         * far and then visibly climb again on the next `turn_end` for no reason the
+         * user can see.
+         */
+        case 'contextTokensEstimated':
+            return {
+                ...state,
+                contextTokens: Math.max(0, Math.round(action.tokens)),
+                contextTokensEstimated: true,
+            };
         // --- API retry (llm-api-retry-backoff §6.4) ---------------------------
         case 'retryScheduled': {
             const snapshot = {