@aragon-agent/cli 0.6.10 → 0.6.12

package/dist/input/stdin-filter.js

@@ -33,9 +33,9 @@
  */
 import { PassThrough } from 'node:stream';
 import { MAX_PENDING_MOUSE_CHARS, splitMouseEvents, isMousePrefix, } from './mouse-events.js';
-import { PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
+import { ENTER_NEWLINE_FRAME, PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
 import { PASTE_BEGIN_MARK, PASTE_END_MARK, classifyChunk, sanitisePaste, trailingPastePrefixLength, } from './paste-parse.js';
-import { rewriteEnterSequences, trailingEnterPrefixLength } from './enter-sequences.js';
+import { splitEnterSequences, trailingEnterPrefixLength } from './enter-sequences.js';
 /**
  * How long a possible-prefix tail is held before being flushed as text.
  *
@@ -89,7 +89,18 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     let burstTimer = null;
     let assemblyTimer = null;
     let disposed = false;
+    let finished = false;
     let paste = { kind: 'idle' };
+    let discardBracketed = false;
+    let outputBatch = null;
+    const writeInput = (text) => {
+        if (disposed || outputBatch?.refused)
+            return;
+        if (outputBatch)
+            outputBatch.chunks.push(text);
+        else
+            wrapper.write(text);
+    };
     // --- The surface Ink reads off the stream it is handed. ------------------
     // `isRawModeSupported()` reads `props.stdin.isTTY` (App.js:34), so this has
     // to be a DELEGATING GETTER rather than a snapshot: a stdin that is not a TTY
@@ -122,6 +133,8 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     };
     /** `.unref()` so a held tail can never keep the process alive on its own. */
     const arm = (fn, ms) => {
+        if (finished || disposed)
+            return null;
         const t = setTimeout(fn, ms);
         t.unref?.();
         return t;
@@ -143,6 +156,10 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         if (disposed)
             return;
         if (overflow || bytes > PASTE_MAX_BYTES) {
+            if (outputBatch?.refused)
+                return;
+            if (outputBatch)
+                outputBatch.refused = true;
             const text = `Paste too large (${formatPasteSize(bytes)}); limit is ` +
                 `${formatPasteSize(PASTE_MAX_BYTES)}. Nothing was inserted.`;
             onWarn?.(text);
@@ -153,7 +170,7 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         if (payload.length === 0)
             return;
         // ONE `write()` call, at the position the paste occupied in the stream.
-        wrapper.write(PASTE_OPEN + payload + PASTE_CLOSE);
+        writeInput(PASTE_OPEN + payload + PASTE_CLOSE);
     };
     const flushBurst = () => {
         burstTimer = clearTimer(burstTimer);
@@ -169,6 +186,12 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             return;
         const { body, bytes, overflow } = paste;
         paste = { kind: 'idle' };
+        if (discardBracketed) {
+            discardBracketed = false;
+            if (outputBatch)
+                outputBatch.refused = true;
+            return;
+        }
         if (reason === 'timeout') {
             // I-4: an unterminated marker must never wedge input. Emitting what
             // arrived is strictly better than holding the keyboard hostage.
@@ -190,20 +213,9 @@ export function createStdinFilter(real, features, bridge, onWarn) {
      * those would corrupt their data silently. v1 covered only Tier 1, which left
      * the loss in place for exactly the terminals Tier 2 exists to serve (P1-7).
      */
-    const handleOutsidePaste = (text, holdTail) => {
+    const handleText = (text, holdTail) => {
         if (text.length === 0)
             return;
-        // ENTER-FAMILY REWRITE, AND IT IS FIRST FOR A REASON
-        // (tui-shift-enter-copy-queue 3.4). The Alt+Enter encoding contains a CR,
-        // and `classifyChunk`'s primary rule -- "longer than one character AND
-        // contains a line break" -- would buffer that two-byte key as a Tier 2
-        // paste body whose sanitiser then strips the ESC, silently swallowing the
-        // keystroke. After the rewrite the frame is NUL-led and classifies as
-        // `keys` under both rules. The cost is that an UNBRACKETED paste whose
-        // body happens to contain the literal Alt+Enter bytes loses that one
-        // pair's newline; a bracketed body never reaches this function at all
-        // (I-3), and losing two bytes of a heuristic tier beats eating the key.
-        text = rewriteEnterSequences(text);
         if (paste.kind === 'burst') {
             paste = { kind: 'burst', body: paste.body + text, bytes: paste.bytes + byteLength(text) };
             burstTimer = clearTimer(burstTimer);
@@ -219,12 +231,12 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         // Step 0: with `mouse` false this degenerates to "pass the text on", which
         // is byte-identical to the unwrapped stream.
         if (!features.mouse) {
-            wrapper.write(text);
+            writeInput(text);
             return;
         }
         const split = splitMouseEvents(text);
         if (split.text.length > 0)
-            wrapper.write(split.text);
+            writeInput(split.text);
         for (const event of split.events)
             emit(event);
         if (split.pending.length === 0)
@@ -236,10 +248,23 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         if (holdTail)
             pending += split.pending;
         else
-            wrapper.write(split.pending);
+            writeInput(split.pending);
+    };
+    const handleOutsidePaste = (text, holdTail) => {
+        const segments = splitEnterSequences(text);
+        for (let index = 0; index < segments.length; index += 1) {
+            const segment = segments[index];
+            if (segment.kind === 'text') {
+                handleText(segment.text, holdTail && index === segments.length - 1);
+                continue;
+            }
+            // A key terminates the heuristic paste before its internal frame is written.
+            flushBurst();
+            writeInput(segment.kind === 'submit' ? '\r' : ENTER_NEWLINE_FRAME);
+        }
     };
     const appendBracketed = (text) => {
-        if (paste.kind !== 'bracketed' || text.length === 0)
+        if (paste.kind !== 'bracketed' || text.length === 0 || discardBracketed)
             return;
         const bytes = paste.bytes + byteLength(text);
         const overflow = paste.overflow || bytes > PASTE_MAX_BYTES;
@@ -315,13 +340,39 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         handleOutsidePaste(text, false);
     };
     const onData = (chunk) => {
-        if (disposed)
+        if (disposed || finished)
             return;
         flushTimer = clearTimer(flushTimer);
         const decoded = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
         const carried = pending;
         pending = '';
-        feed(carried + decoded);
+        // A rejected paste must not leave earlier text or a later Enter executable.
+        const batch = { chunks: [], refused: false };
+        outputBatch = batch;
+        try {
+            feed(carried + decoded.replace(/\u0000/g, ''));
+        }
+        finally {
+            outputBatch = null;
+        }
+        if (batch.refused) {
+            burstTimer = clearTimer(burstTimer);
+            if (paste.kind === 'bracketed') {
+                // Keep consuming an unfinished body so its next chunk cannot become keys.
+                discardBracketed = true;
+                paste = { kind: 'bracketed', body: '', bytes: 0, overflow: false };
+            }
+            else {
+                pending = '';
+                paste = { kind: 'idle' };
+                assemblyTimer = clearTimer(assemblyTimer);
+            }
+            return;
+        }
+        if (disposed || finished)
+            return;
+        for (const text of batch.chunks)
+            wrapper.write(text);
         if (paste.kind === 'bracketed' || pending.length === 0)
             return;
         if (pending.length > MAX_PENDING_CHARS) {
@@ -337,11 +388,24 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     // P2-7: a closed stdin must still terminate Ink's reader, or it waits forever
     // on a stream that will never produce another byte.
     const onEnd = () => {
-        flushBracketed('timeout');
-        flushBurst();
-        flushPending();
-        if (!wrapper.writableEnded)
-            wrapper.end();
+        if (finished || disposed)
+            return;
+        finished = true;
+        flushTimer = clearTimer(flushTimer);
+        burstTimer = clearTimer(burstTimer);
+        assemblyTimer = clearTimer(assemblyTimer);
+        const tail = pending;
+        pending = '';
+        if (paste.kind === 'bracketed') {
+            appendBracketed(tail);
+            flushBracketed('timeout');
+        }
+        else {
+            // The pending prefix belongs to the currently open burst, if any.
+            handleOutsidePaste(tail, false);
+            flushBurst();
+        }
+        wrapper.end();
     };
     // `setEncoding('utf8')` on the REAL stream so Node's StringDecoder handles
     // multi-byte boundaries for us -- the scan works on characters, and a UTF-8

package/dist/logging/install.d.ts

@@ -144,6 +144,9 @@ export interface AgentEventSource {
  */
 export type AgentLogEvent = {
     type: 'agent_start';
+} | {
+    type: 'steering_accepted';
+    ids: readonly string[];
 } | {
     type: 'agent_end';
     messages: unknown[];

package/dist/session/persist.d.ts

@@ -39,14 +39,13 @@ export interface SessionMeta {
 export interface SavedSession {
     version: number;
     savedAt: number;
-    model: ModelRef;
+    model?: ModelRef;
     messages: Message[];
     entries: Entry[];
     /**
      * The live todo list at save time (todo-plan-execution §3.13).
      *
-     * `SESSION_VERSION` STAYS 1: the field is additive and optional, `loadSession`
-     * validates only that `messages` and `entries` are arrays, and an older file
+     * `SESSION_VERSION` STAYS 1: the field is additive and optional, and an older file
      * simply yields `undefined` — which `restoreTodos` treats as "clear", the
      * right answer for a session that predates the feature (D-20 / D-22).
      */
@@ -56,8 +55,8 @@ export interface SavedSession {
      *
      * `SESSION_VERSION` STAYS 1 for the reason `todos?` records above, and this is
      * the precedent that file's own comments already set: the field is additive
-     * and optional, and `loadSession` validates only array-ness of `messages` /
-     * `entries`. A TUI `/save` file simply has no `meta`, which is exactly how
+     * and optional. Boundary validation preserves it without changing its shape.
+     * A TUI `/save` file simply has no `meta`, which is exactly how
      * `sessions list` tells the two apart.
      */
     meta?: SessionMeta;
@@ -88,8 +87,8 @@ export declare function saveSession(filePath: string, data: {
  * Settle any team entry that was saved mid-dispatch (team-subagents §5.3 / P1-5),
  * and any todo card that was saved mid-run (todo-plan-execution §3.8 / C-5).
  *
- * `saveSession` writes `entries` verbatim and `loadSession` validates only
- * array-ness, so a session saved while a dispatch was in flight resumes with a
+ * Structural validation cannot settle live state: a session saved while a
+ * dispatch was in flight can contain a valid
  * `kind: 'team'` entry claiming `active: true` while nothing is running. TWO
  * things then go wrong at once: the card spins forever, and `Transcript`'s
  * settled boundary is MONOTONIC — an entry that never settles never reaches

package/dist/session/persist.js

@@ -8,6 +8,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { getSessionsDir } from '../config/store.js';
+import { validateSession } from './validate-session.js';
 const SESSION_VERSION = 1;
 /** Resolve a `/save` target: absolute/relative path, or a name in the data dir. */
 export function resolveSessionPath(nameOrPath, cwd) {
@@ -109,8 +110,8 @@ export function saveSession(filePath, data) {
  * Settle any team entry that was saved mid-dispatch (team-subagents §5.3 / P1-5),
  * and any todo card that was saved mid-run (todo-plan-execution §3.8 / C-5).
  *
- * `saveSession` writes `entries` verbatim and `loadSession` validates only
- * array-ness, so a session saved while a dispatch was in flight resumes with a
+ * Structural validation cannot settle live state: a session saved while a
+ * dispatch was in flight can contain a valid
  * `kind: 'team'` entry claiming `active: true` while nothing is running. TWO
  * things then go wrong at once: the card spins forever, and `Transcript`'s
  * settled boundary is MONOTONIC — an entry that never settles never reaches
@@ -196,7 +197,7 @@ export function normalizeLoadedEntries(entries) {
         // THE SEVENTH CLAUSE (tui-shift-enter-copy-queue 5.2.5). Core's steering
         // queue is memory-only, so a `queued` entry on disk is a promise this
         // process can no longer keep: the message was never accepted into any
-        // conversation. Downgrade to a WARN NOTICE carrying the first line
+        // conversation. Downgrade to a WARN NOTICE carrying the full text
         // rather than to a `user` entry -- pretending it was sent is the lie
         // that loses the user's words with a straight face.
         //
@@ -204,12 +205,11 @@ export function normalizeLoadedEntries(entries) {
         // live transcript, and a fresh id here would collide with the next
         // `e<n>` the reducer allocates.
         if (entry.kind === 'queued') {
-            const firstLine = entry.text.split('\n', 1)[0] ?? '';
             const downgraded = {
                 id: entry.id,
                 kind: 'notice',
                 level: 'warn',
-                text: `Queued but never sent: ${firstLine}`,
+                text: `Queued but never sent: ${entry.text}`,
             };
             return downgraded;
         }
@@ -218,9 +218,6 @@ export function normalizeLoadedEntries(entries) {
 }
 export function loadSession(filePath) {
     const raw = readFileSync(filePath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || !Array.isArray(parsed.messages) || !Array.isArray(parsed.entries)) {
-        throw new Error('Invalid session file (missing messages/entries).');
-    }
+    const parsed = validateSession(JSON.parse(raw));
     return { ...parsed, entries: normalizeLoadedEntries(parsed.entries) };
 }

package/dist/session/store.d.ts

@@ -18,6 +18,7 @@
  * command the docs recommend. `list` and `prune` therefore see only files
  * carrying `meta.id`; `show` and `rm` accept any id, because the user named it.
  */
+import type { ModelRef } from '@aragon-agent/core';
 import { type SavedSession, type SessionMeta } from './persist.js';
 /**
  * The id is a FILENAME under the user's home directory, and the caller supplying
@@ -84,7 +85,9 @@ export declare function readSessionFile(path: string): SavedSession | null;
 export declare function resolveSessionRef(idOrPath: string, cwd: string): string | null;
 export interface WriteSessionInput {
     id: string;
-    session: Omit<SavedSession, 'version' | 'savedAt' | 'meta'>;
+    session: Omit<SavedSession, 'version' | 'savedAt' | 'meta' | 'model'> & {
+        model: ModelRef;
+    };
     meta: SessionMeta;
 }
 /**

package/dist/session/validate-session.d.ts

@@ -0,0 +1,3 @@
+import type { SavedSession } from './persist.js';
+/** Return a prepared copy, preserving extensions; throw with the corrupt field path. */
+export declare function validateSession(value: unknown): SavedSession;

package/dist/session/validate-session.js

@@ -0,0 +1,207 @@
+import { isAdapterProvider } from '../config/schema.js';
+import { normalizeTodos } from '../todo/normalize.js';
+import { TODO_LIMITS } from '../todo/limits.js';
+function fail(path, expected) {
+    throw new Error(`Invalid session file: ${path} must be ${expected}.`);
+}
+function record(value, path) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        fail(path, 'an object');
+    }
+    return value;
+}
+const string = (value, path) => {
+    if (typeof value !== 'string')
+        fail(path, 'a string');
+};
+const nonempty = (value, path) => {
+    if (typeof value !== 'string' || value.trim().length === 0)
+        fail(path, 'a non-empty string');
+};
+const number = (value, path) => {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        fail(path, 'a finite number');
+};
+const boolean = (value, path) => {
+    if (typeof value !== 'boolean')
+        fail(path, 'a boolean');
+};
+const object = (value, path) => { record(value, path); };
+function optional(check) {
+    return (value, path) => { if (value !== undefined)
+        check(value, path); };
+}
+function enumeration(...values) {
+    return (value, path) => {
+        if (typeof value !== 'string' || !values.includes(value))
+            fail(path, values.join(' | '));
+    };
+}
+function array(check) {
+    return (value, path) => {
+        if (!Array.isArray(value))
+            fail(path, 'an array');
+        value.forEach((item, index) => check(item, `${path}[${index}]`));
+    };
+}
+function shape(fields) {
+    return (value, path) => {
+        const source = record(value, path);
+        for (const [key, check] of Object.entries(fields))
+            check(source[key], `${path}.${key}`);
+    };
+}
+const usage = shape({
+    inputTokens: number, outputTokens: number, cacheReadTokens: optional(number),
+    cacheWriteTokens: optional(number), cost: optional(number),
+});
+function contentPart(value, path) {
+    const part = record(value, path);
+    enumeration('text', 'image')(part.type, `${path}.type`);
+    if (part.type === 'text')
+        string(part.text, `${path}.text`);
+    else
+        shape({ mediaType: string, data: string })(part, path);
+}
+function contentBlock(value, path) {
+    const block = record(value, path);
+    enumeration('text', 'thinking', 'tool_call')(block.type, `${path}.type`);
+    if (block.type === 'tool_call') {
+        shape({ toolCallId: string, toolName: string, args: object })(block, path);
+        return;
+    }
+    string(block.text, `${path}.text`);
+    if (block.type === 'thinking')
+        optional(string)(block.signature, `${path}.signature`);
+}
+function message(value, path) {
+    const source = record(value, path);
+    enumeration('user', 'assistant', 'tool_result')(source.role, `${path}.role`);
+    if (source.role === 'assistant') {
+        shape({ content: array(contentBlock), usage: optional(usage),
+            stopReason: optional(enumeration('end_turn', 'tool_use', 'max_tokens', 'stop_sequence')),
+        })(source, path);
+        return;
+    }
+    if (source.role === 'tool_result') {
+        shape({ toolCallId: string, isError: optional(boolean) })(source, path);
+    }
+    else
+        optional(number)(source.timestamp, `${path}.timestamp`);
+    if (typeof source.content !== 'string')
+        array(contentPart)(source.content, `${path}.content`);
+}
+const patchLine = shape({
+    kind: enumeration('ctx', 'add', 'del'), text: string,
+    oldLine: optional(number), newLine: optional(number),
+});
+const patch = shape({
+    path: string, kind: enumeration('create', 'update'), added: number, removed: number,
+    truncated: boolean, lineCount: number,
+    degraded: optional(enumeration('binary', 'too-large', 'unreadable')),
+    hunks: array(shape({ oldStart: number, oldCount: number, newStart: number, newCount: number,
+        lines: array(patchLine) })),
+});
+const todo = shape({
+    content: string, activeForm: string, status: enumeration('pending', 'in_progress', 'completed'),
+});
+const subagent = shape({
+    label: string, description: string,
+    // Old team archives predate tier; renderers already treat absence as main.
+    tier: optional(enumeration('main', 'fast')),
+    phase: enumeration('queued', 'starting', 'thinking', 'tool', 'waiting', 'done', 'failed', 'aborted'),
+    startedAt: optional(number), endedAt: optional(number), turns: number, toolCalls: number,
+    lastTool: optional(string), usage, filesTouched: array(string), messagesSent: number,
+    summary: optional(string), error: optional(string), truncated: optional(boolean),
+    compactions: optional(number), activity: optional(string),
+    activityArgs: optional(shape({ path: optional(string), pattern: optional(string),
+        command: optional(string), to: optional(string), from: optional(string) })),
+    blockedWaits: optional(number), retries: optional(number), retryable: optional(boolean),
+    retry: optional(shape({ attempt: number, maxRetries: number })),
+});
+const ENTRY_FIELDS = {
+    user: { text: string },
+    queued: { text: string, queueId: optional(nonempty) },
+    notice: { text: string, level: enumeration('info', 'warn', 'error') },
+    assistant: {
+        text: string, thinking: optional(string), thinkingOpen: boolean, streaming: boolean,
+        aborted: optional(boolean), usage: optional(usage),
+        thinkingStartedAt: optional(number), thinkingMs: optional(number),
+    },
+    tool: {
+        toolCallId: string, name: string, label: string, argsRaw: string, args: optional(object),
+        status: enumeration('pending', 'running', 'done', 'error'), preview: optional(string),
+        durationMs: optional(number), isError: optional(boolean), patch: optional(patch),
+        live: optional(array(string)), liveSeq: optional(number), lastOutputAt: optional(number),
+    },
+    team: { dispatchId: string, requested: number, runs: array(subagent), aborted: boolean,
+        durationMs: optional(number), active: boolean },
+    todo: { items: array(todo), doneCount: number, total: number, live: boolean,
+        interrupted: optional(boolean) },
+    retry: {
+        attempt: number, maxRetries: number, errorType: string, message: string, delayMs: number,
+        resumeAt: optional(number), startedAt: number, totalRetries: optional(number),
+        elapsedMs: optional(number),
+        phase: enumeration('waiting', 'retrying', 'recovered', 'exhausted', 'interrupted'),
+    },
+    fast: { reviewIndex: number, model: string,
+        status: enumeration('running', 'ok', 'advice', 'empty', 'failed', 'dropped'),
+        text: optional(string), detail: optional(string), turn: number,
+        durationMs: optional(number), live: boolean },
+    compaction: {
+        index: number, trigger: enumeration('pressure', 'overflow', 'manual'),
+        mode: enumeration('summarized', 'truncated', 'relieved', 'none'), applied: boolean,
+        reason: optional(string), messagesBefore: number, messagesAfter: number,
+        tokensBefore: number, tokensAfter: number, summary: optional(string), model: string,
+        durationMs: optional(number), startedAt: optional(number), live: boolean,
+        tailRelief: optional(shape({ messages: number, charsRemoved: number })),
+    },
+    service: {
+        serviceId: string, command: string,
+        status: enumeration('starting', 'ready', 'running', 'exited', 'failed', 'stopped'),
+        url: optional(string), port: optional(number),
+        exitCode: (value, path) => { if (value !== null)
+            number(value, path); },
+        startedAt: number, readyAt: optional(number), endedAt: optional(number), rows: array(string),
+        rowsSeen: number, terminal: optional(boolean), killIncomplete: optional(boolean),
+    },
+};
+function validateEntries(value) {
+    const ids = new Set();
+    const queues = new Set();
+    array((item, path) => {
+        const entry = record(item, path);
+        nonempty(entry.id, `${path}.id`);
+        if (ids.has(entry.id))
+            fail(`${path}.id`, 'unique');
+        ids.add(entry.id);
+        enumeration(...Object.keys(ENTRY_FIELDS))(entry.kind, `${path}.kind`);
+        shape(ENTRY_FIELDS[entry.kind])(entry, path);
+        if (entry.kind !== 'queued' || entry.queueId === undefined)
+            return;
+        if (queues.has(entry.queueId))
+            fail(`${path}.queueId`, 'unique');
+        queues.add(entry.queueId);
+    })(value, 'entries');
+}
+function validateModel(value) {
+    const model = record(value, 'model');
+    shape({ providerId: nonempty, modelId: nonempty, baseUrl: optional(string) })(model, 'model');
+    if (typeof model.providerId !== 'string' || !isAdapterProvider(model.providerId)) {
+        fail('model.providerId', 'a supported adapter');
+    }
+}
+/** Return a prepared copy, preserving extensions; throw with the corrupt field path. */
+export function validateSession(value) {
+    const source = record(value, 'session');
+    array(message)(source.messages, 'messages');
+    validateEntries(source.entries);
+    if (source.model !== undefined)
+        validateModel(source.model);
+    // Missing fields remain missing in old files, including exec metadata.
+    const prepared = { ...source };
+    if (source.todos !== undefined) {
+        prepared.todos = normalizeTodos(source.todos, TODO_LIMITS.maxItems).items;
+    }
+    return prepared;
+}