@aragon-agent/cli 0.5.6 → 0.5.9

package/dist/agent/entry-limits.js

@@ -0,0 +1,133 @@
+/**
+ * Bounded view state (tui-render-performance L1 / R5).
+ *
+ * `ViewState.entries` used to grow without any ceiling: `argsRaw`, assistant
+ * `text` and `thinking` all concatenated forever, and the entry array was never
+ * trimmed. That makes the per-frame cost of the renderer proportional to the
+ * total number of characters the session has ever produced, because Ink's
+ * `renderNodeToOutput` walks and measures every mounted text node whether or not
+ * `overflow: hidden` clips it.
+ *
+ * Two bounds live here, both pure and React-free:
+ *   - `appendBounded` caps one field by eliding its MIDDLE, and
+ *   - `trimEntries` ring-trims the entry array itself.
+ *
+ * ASCII ONLY. This module is produced outside `src/ui/**`, where no terminal
+ * capabilities are available, so the elision marker has to be safe on a legacy
+ * `cmd.exe` -- the same rule `PREVIEW_TRUNCATION_MARK` in `reducer.ts` records.
+ */
+import { DEFAULT_TRANSCRIPT_RETAIN } from '../config/schema.js';
+/**
+ * The per-field ceilings.
+ *
+ * `text` is the generous one on purpose: a 256 KiB answer is already far past
+ * anything a terminal can usefully show, and the middle is what gets elided, so
+ * both the opening and the live cursor survive. `argsRaw` is the tight one --
+ * it is a streamed JSON fragment rendered as a 60-character card summary, so
+ * anything past a few KiB is invisible by construction.
+ */
+export const ENTRY_LIMITS = {
+    text: 262_144,
+    thinking: 65_536,
+    argsRaw: 16_384,
+};
+/** Marker inserted at the elision point. ASCII -- produced outside `src/ui/**`. */
+export const ELISION_MARK_PREFIX = '\n[... ';
+export const ELISION_MARK_SUFFIX = ' characters elided ...]\n';
+/** Matches a marker this module wrote, so re-elision collapses rather than nests. */
+const ELISION_RE = /\n\[\.\.\. (\d+) characters elided \.\.\.\]\n/;
+/** Fixed cost of the marker, before the digits of the count. */
+const MARKER_FIXED = ELISION_MARK_PREFIX.length + ELISION_MARK_SUFFIX.length;
+/**
+ * Fraction of the cap reserved for the HEAD. The tail gets the rest because that
+ * is where the cursor is; the head exists so the answer still starts where the
+ * model started it.
+ */
+const HEAD_FRACTION = 4;
+/** Undo one elision, so a second one merges into it rather than nesting. */
+function splitElided(prev) {
+    const m = ELISION_RE.exec(prev);
+    if (!m)
+        return { head: '', elided: 0, tail: prev };
+    const index = m.index;
+    return {
+        head: prev.slice(0, index),
+        elided: Number.parseInt(m[1], 10) || 0,
+        tail: prev.slice(index + m[0].length),
+    };
+}
+/**
+ * Append `delta` to `prev`, keeping the result at or below `cap` by eliding the
+ * MIDDLE. Head and tail are both preserved: the head is the answer's opening,
+ * the tail is where the cursor is. Idempotent -- re-eliding an already elided
+ * string collapses the two markers into one.
+ *
+ * The returned string is NEVER longer than `cap` (AC-7). The marker's own digit
+ * count is bounded before the tail budget is computed, so the arithmetic cannot
+ * overshoot by a digit the way a naive `cap - marker.length` would.
+ */
+export function appendBounded(prev, delta, cap) {
+    if (!Number.isFinite(cap) || cap <= 0)
+        return '';
+    const split = splitElided(prev);
+    let head = split.head;
+    let tail = split.tail + delta;
+    let elided = split.elided;
+    // Fast path: nothing has ever been elided and it still fits. This is the path
+    // every ordinary answer takes, so it must allocate nothing beyond the concat.
+    if (elided === 0 && tail.length <= cap)
+        return tail;
+    const headBudget = Math.max(0, Math.min(Math.floor(cap / HEAD_FRACTION), cap - MARKER_FIXED - 1));
+    if (elided === 0) {
+        // First elision: the head has to be carved out of the accumulated text.
+        head = tail.slice(0, headBudget);
+        tail = tail.slice(headBudget);
+    }
+    else if (head.length > headBudget) {
+        // A later `cap` reduction can leave the stored head oversized; charge the
+        // difference to the elision count rather than silently keeping it.
+        elided += head.length - headBudget;
+        head = head.slice(0, headBudget);
+    }
+    if (head.length + MARKER_FIXED >= cap) {
+        // Degenerate cap (only reachable from a hand-written test): keep the tail.
+        return tail.slice(Math.max(0, tail.length - cap));
+    }
+    // `elided + tail.length` is an UPPER BOUND on the final count, so its digit
+    // count is an upper bound on the marker's width. Budgeting against the bound
+    // is what makes the `<= cap` guarantee hold without a second pass.
+    const digitBound = String(elided + tail.length).length;
+    const markerBound = MARKER_FIXED + digitBound;
+    const tailKeep = Math.max(0, Math.min(tail.length, cap - head.length - markerBound));
+    const total = elided + (tail.length - tailKeep);
+    return `${head}${ELISION_MARK_PREFIX}${total}${ELISION_MARK_SUFFIX}${tail.slice(tail.length - tailKeep)}`;
+}
+/**
+ * Ring-trim to `retain` entries; returns the SAME array reference when no-op.
+ *
+ * The identity return is load-bearing: the reducer spreads this result into a
+ * new `ViewState` on every append, and a fresh array on every action would
+ * defeat the `React.memo` boundaries L2 installs on the transcript.
+ */
+export function trimEntries(entries, retain) {
+    const keep = Math.max(1, Math.floor(retain));
+    if (entries.length <= keep)
+        return { entries, dropped: 0 };
+    return { entries: entries.slice(entries.length - keep), dropped: entries.length - keep };
+}
+// ---------------------------------------------------------------------------
+// The resolved retain ceiling
+// ---------------------------------------------------------------------------
+/**
+ * `viewReducer` is pure and takes no config, so the resolved `transcriptRetain`
+ * reaches it through a module-level singleton -- the shape `prompt-history.ts`
+ * already uses for `setHistoryEnabled`. `load.ts` is the ONLY writer.
+ */
+let resolvedRetain = DEFAULT_TRANSCRIPT_RETAIN;
+export function setEntryRetain(value) {
+    if (Number.isFinite(value) && value > 0)
+        resolvedRetain = Math.floor(value);
+}
+export function entryRetain() {
+    return resolvedRetain;
+}

package/dist/agent/headless.d.ts

@@ -8,6 +8,7 @@ import type { AgentEvent, ModelInfo } from '@aragon-agent/core';
 import type { PreflightResult } from './controller.js';
 import type { TeamEvent } from '../team/types.js';
 import type { TodoEvent, TodoSnapshot } from '../todo/types.js';
+import type { FastEvent } from '../fast/types.js';
 import { type FollowThroughMode } from '../todo/follow-through.js';
 /** The minimal controller surface headless mode needs (real or stubbed). */
 export interface HeadlessController {
@@ -35,6 +36,13 @@ export interface HeadlessController {
      * keeps a `--no-todo` headless run byte-identical to today's.
      */
     subscribeTodos?(listener: (event: TodoEvent) => void): () => void;
+    /**
+     * The CLI-local fast-tier stream — OPTIONAL, for the identical reason the two
+     * above are (fast-model-tier §3.9). A controller with no tier has no fast
+     * events, and `runHeadless` calls it with `?.`, which keeps a default `-p` run
+     * byte-identical to today's.
+     */
+    subscribeFast?(listener: (event: FastEvent) => void): () => void;
     /**
      * The current plan — OPTIONAL, for the identical reason the two subscriptions
      * above are (todo-plan-followthrough §3.6 rule 2). ABSENT MEANS THE

package/dist/agent/headless.js

@@ -21,6 +21,8 @@ export async function runHeadless(controller, prompt, options = {}) {
     let sawTurnEnd = false;
     let wroteText = false;
     const total = { inputTokens: 0, outputTokens: 0 };
+    /** Retries seen this run, so the recovery line can name a count. */
+    let retryCount = 0;
     const unsubscribe = controller.subscribe((event) => {
         switch (event.type) {
             case 'message_update': {
@@ -33,6 +35,25 @@ export async function runHeadless(controller, prompt, options = {}) {
                     errored = true;
                     err.write(`\n${formatStreamError(se.error)}\n`);
                 }
+                else if (se.type === 'retry_scheduled') {
+                    // STDERR, NEVER STDOUT (llm-api-retry-backoff §6.7). stdout is the
+                    // machine-readable answer and has to stay parseable by
+                    // `aragon -p | jq`; a retry line on it would corrupt every consumer.
+                    // Not `--quiet`-gated, unlike the tool lines: a three-minute pause with
+                    // no explanation anywhere is not a "compact" run, it is a hang.
+                    retryCount = se.attempt;
+                    // The em dash is a literal because `agent/headless.ts` is the CLI's one
+                    // documented glyph-scanner exemption: `aragon -p` does no capability
+                    // probe, so there is no `Glyphs` set to read here.
+                    err.write(`\n[retry ${se.attempt}/${se.maxRetries}] ${se.errorType} — ` +
+                        `waiting ${Math.round(se.delayMs / 1000)}s\n`);
+                }
+                else if (se.type === 'stream_restart') {
+                    // The partial answer already on stdout is about to be replayed. Saying so
+                    // is the only way a piped consumer can tell a duplicated paragraph from
+                    // a model that repeated itself.
+                    err.write(`[retry] discarding a partial response and restarting\n`);
+                }
                 break;
             }
             case 'tool_execution_start':
@@ -46,6 +67,10 @@ export async function runHeadless(controller, prompt, options = {}) {
                 break;
             case 'turn_end':
                 sawTurnEnd = true;
+                if (retryCount > 0) {
+                    err.write(`[retry] recovered after ${retryCount} ${retryCount === 1 ? 'retry' : 'retries'}\n`);
+                    retryCount = 0;
+                }
                 total.inputTokens += event.usage.inputTokens;
                 total.outputTokens += event.usage.outputTokens;
                 break;
@@ -128,6 +153,20 @@ export async function runHeadless(controller, prompt, options = {}) {
         lastActive = activeIndex;
         err.write(`[todo] ${activeIndex + 1}/${total} ${items[activeIndex]?.content ?? ''}\n`);
     });
+    // Fast-tier review spend must reach the `[usage]` footer, or `-p` under-reports
+    // by however much the reviewer consumed (§3.6).
+    //
+    // NOTHING IS WRITTEN TO STDOUT, AND NOTHING TO STDERR EITHER (D-12). stdout is
+    // the answer channel and is piped into other tools; stderr in `-p` carries the
+    // tool trace, and an unrequested second opinion is not a tool the user asked
+    // for. The reviews are in the log records either way, which is where a `-p`
+    // user goes to ask what happened.
+    const unsubscribeFast = controller.subscribeFast?.((event) => {
+        if (event.type !== 'usage')
+            return;
+        total.inputTokens += event.usage.inputTokens;
+        total.outputTokens += event.usage.outputTokens;
+    });
     // --- The bounded continuation loop (todo-plan-followthrough §3.6). --------
     //
     // THE THREE `unsubscribe` CALLS STAY OUTSIDE IT (rule 4). The loop wraps the
@@ -187,6 +226,7 @@ export async function runHeadless(controller, prompt, options = {}) {
         unsubscribe();
         unsubscribeTeam?.();
         unsubscribeTodos?.();
+        unsubscribeFast?.();
     }
     // Ensure a trailing newline so piped output is well-formed.
     if (wroteText)

package/dist/agent/reducer.d.ts

@@ -13,7 +13,10 @@
 import type { AgentEvent, ModelCost, ToolResult, TokenUsage } from '@aragon-agent/core';
 import type { AgentMode } from './agent-mode.js';
 import type { DispatchOutcome, SubagentRun, SubagentSpec, TeamSnapshot } from '../team/types.js';
+import type { FastReview, FastSnapshot } from '../fast/types.js';
 import type { TodoItem, TodoSnapshot } from '../todo/types.js';
+import type { RetryPhase } from './retry-view.js';
+import type { FilePatch } from '../tools/patch.js';
 export type NoticeLevel = 'info' | 'warn' | 'error';
 export type ToastLevel = NoticeLevel | 'success';
 export type Overlay = null | 'settings' | 'model' | 'help' | 'confirm' | 'question' | 'plan';
@@ -40,6 +43,21 @@ export type Entry = {
     streaming: boolean;
     aborted?: boolean;
     usage?: TokenUsage;
+    /**
+     * Epoch ms the turn started reasoning (agent-activity-presentation §3.1.2).
+     * Set by `thinkingStart`, cleared by `streamRestart`.
+     */
+    thinkingStartedAt?: number;
+    /**
+     * Wall-clock reasoning time, SEALED ONCE — at the first text delta, or at
+     * turn/run end for a turn that thought and then called a tool without
+     * emitting any text.
+     *
+     * With thinking hidden this is the only thing the collapsed marker can say
+     * that the user could not otherwise know, which is the whole argument for
+     * having a marker at all (§1.2).
+     */
+    thinkingMs?: number;
 } | {
     id: string;
     kind: 'tool';
@@ -52,6 +70,44 @@ export type Entry = {
     preview?: string;
     durationMs?: number;
     isError?: boolean;
+    /**
+     * The structured file diff (agent-activity-presentation §3.3), or absent.
+     *
+     * IMMUTABLE AND WRITTEN ONCE, by `toolExecEnd`. `ToolCard` is `React.memo`'d
+     * with the DEFAULT comparator, so this object is only free while its
+     * reference is stable — which it is, because the reducer never rebuilds it
+     * and `mapEntry` preserves identity for untouched entries. A future action
+     * that recomputed or normalized a patch would turn that memo boundary into
+     * a no-op WITH NOTHING FAILING (P2-9).
+     *
+     * Needs no clause in `normalizeLoadedEntries` (D-9): the four that exist
+     * are all about a LIVE flag that would never settle, and a patch is settled
+     * by construction.
+     */
+    patch?: FilePatch;
+    /**
+     * The sanitised live tail while the tool runs
+     * (agent-activity-presentation-live §3.3.1). Cleared at settle (D-23), and
+     * cleared again by EVERY path that reaches `status: 'idle'` (D-35).
+     *
+     * REDUCER STATE RATHER THAN A STORE READ DURING RENDER, and that is the
+     * load-bearing decision of the round (D-22): `entryRevision` is what tells
+     * the height cache an entry's rendered output changed, and an entry mutated
+     * outside `ViewState` keeps its revision and freezes at a stale height AND
+     * a stale subtree with nothing anywhere reporting it (I-L3-1).
+     */
+    live?: readonly string[];
+    /**
+     * Monotonic counter -- the revision term for a NON-APPEND mutation (D-22).
+     *
+     * A COUNTER AND NOT `live.length`: a fixed-size tail evicting its oldest
+     * row while appending a new one of the same width leaves the joined length
+     * unchanged, which is exactly the lossy case `virtual-window.ts` says the
+     * reducer cannot produce today and that this round introduces.
+     */
+    liveSeq?: number;
+    /** Epoch ms of the last output row, for the stall row (§3.3.4). */
+    lastOutputAt?: number;
 } | {
     id: string;
     kind: 'notice';
@@ -107,12 +163,85 @@ export type Entry = {
      * card this session produced.
      */
     interrupted?: boolean;
+}
+/**
+ * The turn's retry story (llm-api-retry-backoff §6.4). ONE per turn, REWRITTEN
+ * IN PLACE — ten retries rendered as ten notices would bury the transcript in
+ * the one moment the user most needs it legible.
+ *
+ * JSON-SERIALIZABLE by construction, so `/save` needs no format change.
+ *
+ * `phase: 'waiting' | 'retrying'` is normalized away ON LOAD, in
+ * `session/persist.ts`, exactly as the team entry's `active` and the todo
+ * card's `live` are (R-10): `Transcript`'s settled boundary is MONOTONIC, so a
+ * card that never settles never reaches `<Static>` and is re-rendered on every
+ * frame for the rest of the session.
+ */
+ | {
+    id: string;
+    kind: 'retry';
+    /** 1-based retry index of the LATEST attempt this card has seen. */
+    attempt: number;
+    maxRetries: number;
+    errorType: string;
+    message: string;
+    delayMs: number;
+    /** Epoch ms the next attempt fires; the UI ticks against this. */
+    resumeAt?: number;
+    phase: RetryPhase;
+    startedAt: number;
+    /** Filled on settle. */
+    totalRetries?: number;
+    elapsedMs?: number;
+}
+/**
+ * One fast-model review (fast-model-tier §5.4). ONE CARD PER REVIEW, never
+ * rewritten across reviews — a critique is a single event, unlike the todo
+ * card's per-turn checklist.
+ *
+ * JSON-SERIALIZABLE by construction, so `/save` needs no format change.
+ *
+ * `live: true` is normalized away ON LOAD, in `session/persist.ts`, next to
+ * `team.active`, `todo.live` and the retry card's phase, and for the identical
+ * reason (C-5): `Transcript`'s settled boundary is MONOTONIC, so an entry that
+ * never settles never reaches `<Static>` and is re-rendered on every frame for
+ * the rest of the session. The reducer never legitimately sees a stale-live
+ * entry — only the file does.
+ */
+ | {
+    id: string;
+    kind: 'fast';
+    /** 1-based within the session, so the card can name itself. */
+    reviewIndex: number;
+    model: string;
+    status: 'running' | 'ok' | 'advice' | 'empty' | 'failed' | 'dropped';
+    /** Present only for `advice`. */
+    text?: string;
+    /** Failure / drop reason, shown as one muted line. */
+    detail?: string;
+    turn: number;
+    durationMs?: number;
+    live: boolean;
 };
 export interface UsageTotal {
     inputTokens: number;
     outputTokens: number;
     costUsd: number;
 }
+/**
+ * The ephemeral retry projection held in `ViewState.retry` (§9).
+ *
+ * Only the two IN-FLIGHT phases exist here: once a card settles the projection is
+ * `null`, because the settled card IS the history and a chip that reported a
+ * finished retry would never go away.
+ */
+export interface RetrySnapshot {
+    attempt: number;
+    maxRetries: number;
+    resumeAt?: number;
+    phase: 'waiting' | 'retrying';
+    errorType: string;
+}
 export interface ViewState {
     entries: Entry[];
     status: 'idle' | 'running';
@@ -150,18 +279,64 @@ export interface ViewState {
      * build (AC-24).
      */
     todos: TodoSnapshot | null;
+    /**
+     * The live retry projection, or `null` when nothing is retrying.
+     *
+     * NEVER PERSISTED — `entries` is the history and the settled card is the
+     * record. It drives the status-bar chip and the 1 Hz tick, and it is nulled on
+     * every settle path. Same contract as `team`.
+     */
+    retry: RetrySnapshot | null;
+    /**
+     * The live fast-tier projection, or `null` when the tier is off for this
+     * session (fast-model-tier §5.2).
+     *
+     * NEVER PERSISTED — `entries` is the history and the settled cards are the
+     * record. It drives the status chip and `/fast status`'s totals. `null` is
+     * what leaves an ordinary session's status bar byte-identical (AC-4).
+     */
+    fast: FastSnapshot | null;
     seq: number;
     /** The `kind: 'team'` entry the live dispatch is writing into. */
     teamEntryId?: string;
     /** The `kind: 'todo'` entry this turn is writing into. */
     todoEntryId?: string;
+    /** The `kind: 'retry'` entry this turn is writing into. */
+    retryEntryId?: string;
+    /** The `kind: 'fast'` entry the in-flight review is writing into. */
+    fastEntryId?: string;
     streamingId?: string;
     turnProduced: boolean;
     errorNoticed: boolean;
     /** The current run was aborted by the user (suppresses the failure guard). */
     aborted: boolean;
+    /**
+     * Entries removed by `transcriptRetain` (tui-render-performance L1).
+     *
+     * Rendered by `transcript-text` and reported by `/perf`; NEVER PERSISTED —
+     * `SavedSession` keeps `{ model, messages, entries, todos }` exactly as it is,
+     * so `/save` and `/resume` need no format change and old files load unchanged.
+     */
+    droppedEntries: number;
+}
+export interface ViewStateSeed {
+    /** Start with thinking blocks expanded. Defaults to FALSE, the product default. */
+    thinkingVisible?: boolean;
 }
-export declare function initialViewState(): ViewState;
+/**
+ * The initial view state, optionally seeded from config.
+ *
+ * THE DEFAULT IS `false`, NOT `true`, AND THAT IS THE WHOLE SAFETY ARGUMENT
+ * (D-2). There is exactly one production call site — `App`'s `useReducer`, which
+ * passes `cfg.showThinking`. Every other caller is a test. A future call site
+ * that forgets the seed fails CLOSED, toward the product default, rather than
+ * silently restoring the reasoning firehose for one code path with nothing
+ * reporting it.
+ *
+ * The seed is a PARAMETER rather than a post-mount dispatch so that `/resume`
+ * cannot flash a restored thinking block on frame 1.
+ */
+export declare function initialViewState(seed?: ViewStateSeed): ViewState;
 export type ViewAction = {
     type: 'submit';
     text: string;
@@ -199,6 +374,22 @@ export type ViewAction = {
     isError: boolean;
     duration: number;
     preview: string;
+    /** A fully-built, immutable diff, so the reducer stays pure (§3.3.7). */
+    patch?: FilePatch;
+}
+/**
+ * A running tool's live tail (agent-activity-presentation-live §3.3.1).
+ *
+ * `rows` IS THE WHOLE TAIL, not an increment: the store replaces it on every
+ * chunk, which is what lets `mergeDeltas` keep only the last action per
+ * `toolCallId` (D-30). `at` is read in `App`'s listener rather than here, so
+ * this reducer stays pure.
+ */
+ | {
+    type: 'toolOutputDelta';
+    toolCallId: string;
+    rows: readonly string[];
+    at: number;
 } | {
     type: 'turnEnd';
     usage: TokenUsage;
@@ -258,6 +449,54 @@ export type ViewAction = {
     snapshot: TodoSnapshot;
 } | {
     type: 'todoCleared';
+} | {
+    type: 'retryScheduled';
+    attempt: number;
+    maxRetries: number;
+    delayMs: number;
+    resumeAt: number;
+    errorType: string;
+    message: string;
+} | {
+    type: 'retryAttempt';
+    attempt: number;
+    maxRetries: number;
+} | {
+    type: 'streamRestart';
+    discardedToolCallIds: string[];
+}
+/**
+ * The 1 Hz countdown tick. NO STATE OF ITS OWN — it bumps `seq` so the frame
+ * re-renders and the card recomputes `resumeAt - Date.now()`. `App` runs the
+ * interval ONLY while `state.retry?.phase === 'waiting'`, so an idle session has
+ * no timer at all.
+ */
+ | {
+    type: 'retryTick';
+} | {
+    type: 'fastStart';
+    index: number;
+    turn: number;
+    model: string;
+} | {
+    type: 'fastEnd';
+    review: FastReview;
+}
+/**
+ * Review spend.
+ *
+ * `costDelta` IS PRECOMPUTED BY THE CALLER, exactly as `teamUsage`'s is: the
+ * reducer stays pure and cost-table-free, which is the property that makes it
+ * testable — and the fast tier has a DIFFERENT cost table from the lead, so a
+ * reducer that computed its own would have to know about both (§3.6 / R-7).
+ */
+ | {
+    type: 'fastUsage';
+    usage: TokenUsage;
+    costDelta: number;
+} | {
+    type: 'fastTier';
+    snapshot: FastSnapshot;
 };
 export declare const STORED_PREVIEW_CHARS = 8000;
 export declare const STORED_PREVIEW_LINES = 200;
@@ -276,12 +515,23 @@ export declare const PREVIEW_TRUNCATION_MARK = "...";
  * over-promises how much more is expandable.
  */
 export declare function buildToolPreview(result: ToolResult): string;
+/**
+ * Where a `FilePatch` is collected from on `tool_execution_end`.
+ *
+ * Supplying one makes `reduceEvent` CONSUME-ONCE rather than pure, which is safe
+ * because `App.tsx` calls it exactly once per event and `mergeDeltas` only ever
+ * merges `textDelta` / `thinkingDelta`, never `toolExecEnd`.
+ */
+export interface PatchSource {
+    take(toolCallId: string): FilePatch | undefined;
+}
 /**
  * Map one core `AgentEvent` to view actions. `cost` (the active model's cost
  * table) lets `turn_end` accumulate USD cost; omit it in tests that only assert
- * token totals.
+ * token totals. `patches` is the CLI-local diff side channel (§3.3.7); omitting
+ * it — every existing test, and headless mode — produces byte-identical actions.
  */
-export declare function reduceEvent(event: AgentEvent, cost?: ModelCost): ViewAction[];
+export declare function reduceEvent(event: AgentEvent, cost?: ModelCost, patches?: PatchSource): ViewAction[];
 /** Turn a provider error into a friendly banner, mapping LLMError.errorType. */
 export declare function formatStreamError(error: Error): string;
 export declare function viewReducer(state: ViewState, action: ViewAction): ViewState;