@aragon-agent/cli 0.5.8 → 0.5.9

package/dist/agent/coalesce.d.ts

@@ -8,6 +8,19 @@
  * App buffers per-event actions and runs them through this before dispatching,
  * so a fast token stream re-renders the transcript once per frame instead of
  * once per token. The reducer and event semantics are unchanged.
+ *
+ * A THIRD MERGED KIND ARRIVED WITH THE LIVE TOOL TAIL
+ * (agent-activity-presentation-live §3.3.2 / D-30), and it merges differently:
+ * `toolOutputDelta` carries the store's WHOLE tail rather than an increment, so
+ * consecutive ones with the same `toolCallId` collapse to the LAST rather than
+ * concatenating, and a differing id starts a new pending action because merging
+ * across ids would paint one command's output onto another's card.
+ *
+ * ONE PENDING SLOT, DISCRIMINATED, NEVER TWO (P1-5). A second, independent slot
+ * for the object-shaped payload would let a chunk overtake a token and reorder
+ * the two streams — exactly what I-L4-1 (`ui/render-governor.ts:14-19`) forbids:
+ * "the governor changes only HOW OFTEN the view updates. Never what is
+ * dispatched, never the order."
  */
 import type { ViewAction } from './reducer.js';
 /** Merge consecutive same-kind deltas; flush on kind change or a non-delta. */

package/dist/agent/coalesce.js

@@ -8,28 +8,67 @@
  * App buffers per-event actions and runs them through this before dispatching,
  * so a fast token stream re-renders the transcript once per frame instead of
  * once per token. The reducer and event semantics are unchanged.
+ *
+ * A THIRD MERGED KIND ARRIVED WITH THE LIVE TOOL TAIL
+ * (agent-activity-presentation-live §3.3.2 / D-30), and it merges differently:
+ * `toolOutputDelta` carries the store's WHOLE tail rather than an increment, so
+ * consecutive ones with the same `toolCallId` collapse to the LAST rather than
+ * concatenating, and a differing id starts a new pending action because merging
+ * across ids would paint one command's output onto another's card.
+ *
+ * ONE PENDING SLOT, DISCRIMINATED, NEVER TWO (P1-5). A second, independent slot
+ * for the object-shaped payload would let a chunk overtake a token and reorder
+ * the two streams — exactly what I-L4-1 (`ui/render-governor.ts:14-19`) forbids:
+ * "the governor changes only HOW OFTEN the view updates. Never what is
+ * dispatched, never the order."
  */
-function isDelta(action) {
+function isTextDelta(action) {
     return action.type === 'textDelta' || action.type === 'thinkingDelta';
 }
+function isToolOutputDelta(action) {
+    return action.type === 'toolOutputDelta';
+}
 /** Merge consecutive same-kind deltas; flush on kind change or a non-delta. */
 export function mergeDeltas(actions) {
     const out = [];
-    let pendingType = null;
-    let pendingDelta = '';
+    let pending = null;
     const flush = () => {
-        if (pendingType !== null) {
-            out.push({ type: pendingType, delta: pendingDelta });
-            pendingType = null;
-            pendingDelta = '';
+        if (pending !== null) {
+            out.push(pending.action);
+            pending = null;
         }
     };
     for (const action of actions) {
-        if (isDelta(action)) {
-            if (pendingType !== null && pendingType !== action.type)
+        // Read into a local before the branch: `flush` clears the slot, so the value
+        // a merge decision needs is the one held HERE, before any flush.
+        //
+        // The assertion restores the DECLARED type and asserts nothing beyond it.
+        // `flush` assigns `pending = null` from inside a closure, which TypeScript's
+        // flow analysis does not model, so it pins the reference at this point to
+        // the declaration's `null` and every `prev.kind` below reads as `never`.
+        const prev = pending;
+        if (isTextDelta(action)) {
+            // A pending TOOL tail flushes first, so a chunk cannot overtake a token.
+            const carry = prev !== null && prev.kind === 'text' && prev.action.type === action.type
+                ? prev.action.delta
+                : null;
+            if (carry === null)
+                flush();
+            pending = {
+                kind: 'text',
+                action: { type: action.type, delta: (carry ?? '') + action.delta },
+            };
+        }
+        else if (isToolOutputDelta(action)) {
+            // A pending TEXT run flushes first, for the mirror-image reason, and so
+            // does a tail belonging to a DIFFERENT call: merging across ids would
+            // paint one command's output onto another's card.
+            const merges = prev !== null && prev.kind === 'tool' && prev.action.toolCallId === action.toolCallId;
+            if (!merges)
                 flush();
-            pendingType = action.type;
-            pendingDelta += action.delta;
+            // LAST WINS. The payload is the store's whole tail rather than an
+            // increment, so merging means replacing (D-30).
+            pending = { kind: 'tool', action };
         }
         else {
             flush();

package/dist/agent/controller.d.ts

@@ -8,10 +8,14 @@
  * success — that promise resolves even on failure. Success/failure is derived
  * from the event stream by the reducer (TUI) and the headless writer.
  */
-import { ModelRegistry, type AgentEvent, type AgentTool, type Message, type ModelInfo, type ProviderRegistry, type ThinkingLevel } from '@aragon-agent/core';
-import type { CliConfig, TeamConfig, ThemeName, TodoConfig } from '../config/schema.js';
+import { ModelRegistry, type AgentEvent, type AgentTool, type Message, type ModelInfo, type ModelRef, type ProviderRegistry, type ThinkingLevel } from '@aragon-agent/core';
+import type { CliConfig, FastConfig, RetryConfig, TeamConfig, ThemeName, TodoConfig } from '../config/schema.js';
 import { type ConfirmRequest } from '../tools/index.js';
+import { type ToolOutputListener } from '../tools/tool-output-store.js';
+import type { FilePatch } from '../tools/patch.js';
 import type { TeamEvent, TeamSnapshot } from '../team/types.js';
+import { type FastStatus } from '../fast/wiring.js';
+import type { FastEventListener } from '../fast/types.js';
 import type { TodoEventListener, TodoSnapshot } from '../todo/types.js';
 import { type HumanInputGate } from '../tools/human-input.js';
 import { SkillService, type ApprovalGate } from '../skills/service.js';
@@ -107,6 +111,44 @@ export declare class AgentController {
     private readonly todos;
     /** Static: whether this session could ever render the rail. See the dep. */
     private readonly todoPanelCapable;
+    /**
+     * Structured file diffs on their way to the UI (agent-activity-presentation
+     * §3.3.5). A bounded, take-once ring; see `file-change-store.ts` for why each
+     * of those three words is load-bearing.
+     *
+     * DECLARED WITH AN INITIALIZER, so it exists before `createBuiltinTools` runs
+     * in the constructor body and the recorder closure it hands over is valid from
+     * the first tool call.
+     */
+    private readonly fileChanges;
+    /**
+     * A running tool's output on its way to the UI
+     * (agent-activity-presentation-live §3.1.3).
+     *
+     * NULL WHEN THE FEATURE IS OFF (P1-6). `fileChanges` next door is declared
+     * with an initializer because it is unconditional; this one cannot be, since a
+     * field initializer cannot read a constructor parameter -- and an
+     * unconditional initializer would allocate on every construction and make
+     * AC-31's "no store is allocated" false by construction. `private readonly
+     * fast: FastWiring | null` below is the same declaration shape in the same
+     * class.
+     *
+     * ASSIGNED IN THE CONSTRUCTOR BODY, ABOVE THE `createBuiltinTools` CALL, not
+     * near `this.fast` which runs after it. The binding there is spread
+     * CONDITIONALLY on this field, so an assignment placed after the call would
+     * read `undefined`, add no property, and produce a build in which the feature
+     * is silently off with the key on.
+     */
+    private readonly toolOutputs;
+    private readonly outputListeners;
+    private readonly fast;
+    /**
+     * Set SYNCHRONOUSLY by `abort()` before `agent.abort()` (§3.5.4a guard 1).
+     * Cleared at the next `agent_start`.
+     */
+    private abortRequested;
+    /** User messages queued since the last `turn_start` (§3.5.4a guard 2). */
+    private userSteerCount;
     constructor(config: CliConfig, deps?: ControllerDeps);
     private resolveKey;
     /**
@@ -299,12 +341,56 @@ export declare class AgentController {
     restoreTodos(items: unknown): void;
     /** `/todo clear`. A user override of a projection; refused mid-run by `/todo`. */
     clearTodos(): void;
+    getRetryConfig(): RetryConfig;
+    /**
+     * Adopt a new retry config for this session AND PUSH IT INTO THE REGISTRY.
+     *
+     * THE SECOND CALL IS REQUIRED, NOT A NICETY (§6.3). Without it `/retry off`
+     * would persist correctly and change nothing until the next launch — the
+     * precise failure `config/schema.ts` warns about twice already, and the one a
+     * user reports as "the setting does nothing".
+     *
+     * Clamped here as well as on the persist path, so a bad value can reach neither
+     * the runtime nor the file.
+     */
+    setRetryConfig(patch: Partial<RetryConfig>): RetryConfig;
     setModel(provider: string, model: string, baseUrl?: string): void;
     setThinkingLevel(level: ThinkingLevel): void;
     setMaxTokens(value: number | undefined): void;
     setApiKey(provider: string, key: string): void;
     setCwd(cwd: string): void;
     getCwd(): string;
+    /**
+     * The structured diff a file tool left behind, CONSUMED ONCE.
+     *
+     * Called by `reduceEvent` on `tool_execution_end` and nowhere else, which is
+     * what keeps the store at constant size however many files a session edits.
+     * `undefined` is an ordinary answer — a tool that records nothing, a toolset
+     * built without a recorder, or an entry the 64-write ring has already evicted
+     * — and every one of those falls back to `ToolPreview`.
+     */
+    takeFilePatch(toolCallId: string): FilePatch | undefined;
+    /**
+     * Sanitise a chunk into the store and hand the resulting tail to the view.
+     *
+     * SYNCHRONOUS, INSIDE THE CHILD-PROCESS DATA HANDLER. The alternative (queue
+     * plus timer) adds a second clock to a component that already has one, and
+     * `App` coalesces at the other end anyway (D-34).
+     *
+     * EVERY LISTENER IS WRAPPED, and that is not defensive noise (R-5 / AC-35): a
+     * throw here propagates into `child.stdout.on('data')`, which is the reason a
+     * render-side bug could otherwise kill a ten-minute build. `debug` rather than
+     * `warn` because a listener that throws once throws on every chunk.
+     */
+    private emitToolOutput;
+    /**
+     * Subscribe to the CLI-local live tool-output stream (§3.1.3).
+     *
+     * Returns a no-op unsubscribe when `liveToolOutput` was off at construction,
+     * so every caller can subscribe unconditionally -- the contract
+     * `subscribeTeam` / `subscribeTodos` / `subscribeFast` already set.
+     */
+    subscribeToolOutput(listener: ToolOutputListener): () => void;
     clearMessages(): void;
     /** Read-only view of the live system prompt (regression tests, /debug). */
     getSystemPrompt(): string;
@@ -316,6 +402,59 @@ export declare class AgentController {
     getModelRegistry(): ModelRegistry;
     /** Resolve `ModelInfo` for the active model, falling back to a runtime model. */
     getModelInfo(): ModelInfo;
+    /**
+     * Resolve `ModelInfo` for ANY model (fast-model-tier §3.6 / RV-4).
+     *
+     * ONE RESOLUTION PATH, which is the same reason §3.2 has exactly one
+     * `resolveFastTier`: `getModelInfo()` above is now a call into this, so "the
+     * cost table for the model that actually billed" cannot drift from "the cost
+     * table for the session's model" as two separate bodies.
+     */
+    getModelInfoFor(ref: Pick<ModelRef, 'providerId' | 'modelId'>): ModelInfo;
+    /**
+     * Whether the STATIC table knows this model's price (C-11 / RV-4).
+     *
+     * `buildRuntimeModel` returns `cost: { input: 0, output: 0 }` for a model it
+     * has never seen — a table of zeros, not a missing one — so every consumer
+     * that renders spend needs to be able to tell "free" from "unknown". The fast
+     * tier is precisely where an unrecognised id is likely, and `$0.00` on a
+     * feature that is spending money is the same class of lie as pricing a Haiku
+     * child at Sonnet rates.
+     */
+    isPricedModel(ref: Pick<ModelRef, 'providerId' | 'modelId'>): boolean;
+    /** Whether `task`'s schema carries `model`. Fixed at construction (C-2). */
+    isFastRegistered(): boolean;
+    /** Whether the tier will actually be used. Flipped live by `/fast on|off`. */
+    isFastEnabled(): boolean;
+    /**
+     * Flip the live switch and re-render the prompt.
+     *
+     * Turning it ON in a session that started without the tier deliberately does
+     * NOT register it: the tool array is immutable (C-2), and advertising a schema
+     * field that is not there is the dead end `/team on` already documents.
+     * `/fast` reports that honestly by checking `isFastRegistered()` first.
+     */
+    setFastEnabled(enabled: boolean): void;
+    getFastConfig(): FastConfig;
+    /**
+     * Adopt a new fast config for this session.
+     *
+     * THE RE-RESOLUTION IS NOT OPTIONAL (§3.2 rule 8). `App` reads
+     * `controller.getConfig()` on every render and the block interpolates the
+     * model id, so a persist without this call reports success and changes
+     * nothing until relaunch — the failure `/todo panel` records (P1-2).
+     */
+    setFastConfig(patch: Partial<FastConfig>): FastConfig;
+    /** Everything `/fast status`, the settings line and the chip read. */
+    getFastStatus(): FastStatus;
+    /**
+     * Subscribe to the CLI-local fast event stream.
+     *
+     * Returns a no-op unsubscribe when the tier was off at construction, so every
+     * caller can subscribe unconditionally — the contract `subscribeTeam` and
+     * `subscribeTodos` already set.
+     */
+    subscribeFast(listener: FastEventListener): () => void;
     /** List usable tools (name + description) for the /tools command. */
     listTools(): AgentTool[];
 }