@aragon-agent/cli 0.6.14 → 0.6.16

package/dist/input/win32-input-mode.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Win32-input-mode translation (win32 keyboard-enhancement section of the
+ * Shift+Enter newline fix).
+ *
+ * WHY THIS EXISTS. With `CSI ? 9001 h` the Windows console (conhost inside
+ * ConPTY included -- verified byte-level on both conhost and Windows Terminal
+ * 1.24, see docs/diagnoses/shift-enter-newline-dead-by-default) reports EVERY
+ * key as `ESC [ vk ; scan ; char ; keyDown ; mods ; repeat _`. That is the
+ * only Windows-side encoding in which Shift+Enter is distinguishable from
+ * Enter: mods carries SHIFT_PRESSED (0x10) on the record. Nothing else
+ * survives ConPTY: kitty `CSI > 1 u` is swallowed (a `CSI ? u` query never
+ * answers) and modifyOtherKeys is a no-op.
+ *
+ * THE CONTRACT. `splitWin32KeySequences` recognises the records in a chunk;
+ * `translateWin32Key` rewrites each one to the LEGACY bytes the same keypress
+ * would have produced with the mode off -- except the modified-Enter family,
+ * which becomes `ENTER_NEWLINE_FRAME` exactly like `enter-sequences.ts` maps
+ * its CSI-u cousins. Ink therefore sees the stream it has always seen. Key-up
+ * records are dropped (every press arrives as a down/up pair in one chunk).
+ *
+ * Pure: no node/React imports, callable from any test environment.
+ */
+/** Enable / disable win32-input-mode (private mode 9001). */
+export declare const WIN32_INPUT_ENABLE = "\u001B[?9001h";
+export declare const WIN32_INPUT_DISABLE = "\u001B[?9001l";
+/** One decoded `ESC [ vk ; sc ; char ; down ; mods ; rep _` record. */
+export interface Win32KeyRecord {
+    readonly vk: number;
+    readonly scan: number;
+    readonly char: number;
+    readonly down: boolean;
+    readonly mods: number;
+    readonly repeat: number;
+}
+export type Win32Segment = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'key';
+    record: Win32KeyRecord;
+};
+/**
+ * Split a chunk into text spans and win32-input-mode records.
+ *
+ * MATCHES ONLY `ESC [ <digits/semicolons> _`: mouse reports need `<`, paste
+ * markers end in `~`, CSI-u ends in `u`, DECRPM replies start with `?`. A
+ * `_`-terminated all-numeric-parameter sequence is therefore unambiguous in
+ * the stream this filter ever sees.
+ */
+export declare function splitWin32KeySequences(text: string): Win32Segment[];
+/**
+ * Translate one record to the legacy bytes the same keypress would have
+ * produced with win32-input-mode off (Enter family excepted: a modified Enter
+ * becomes the newline frame, mirroring `ENTER_SEQUENCES`).
+ */
+export declare function translateWin32Key(record: Win32KeyRecord): string;
+/**
+ * Length of the trailing run of `text` that could still complete into a
+ * win32-input-mode record, or 0. Longest match, mirroring the other families.
+ */
+export declare function trailingWin32PrefixLength(text: string): number;

package/dist/input/win32-input-mode.js

@@ -0,0 +1,251 @@
+/**
+ * Win32-input-mode translation (win32 keyboard-enhancement section of the
+ * Shift+Enter newline fix).
+ *
+ * WHY THIS EXISTS. With `CSI ? 9001 h` the Windows console (conhost inside
+ * ConPTY included -- verified byte-level on both conhost and Windows Terminal
+ * 1.24, see docs/diagnoses/shift-enter-newline-dead-by-default) reports EVERY
+ * key as `ESC [ vk ; scan ; char ; keyDown ; mods ; repeat _`. That is the
+ * only Windows-side encoding in which Shift+Enter is distinguishable from
+ * Enter: mods carries SHIFT_PRESSED (0x10) on the record. Nothing else
+ * survives ConPTY: kitty `CSI > 1 u` is swallowed (a `CSI ? u` query never
+ * answers) and modifyOtherKeys is a no-op.
+ *
+ * THE CONTRACT. `splitWin32KeySequences` recognises the records in a chunk;
+ * `translateWin32Key` rewrites each one to the LEGACY bytes the same keypress
+ * would have produced with the mode off -- except the modified-Enter family,
+ * which becomes `ENTER_NEWLINE_FRAME` exactly like `enter-sequences.ts` maps
+ * its CSI-u cousins. Ink therefore sees the stream it has always seen. Key-up
+ * records are dropped (every press arrives as a down/up pair in one chunk).
+ *
+ * Pure: no node/React imports, callable from any test environment.
+ */
+import { ENTER_NEWLINE_FRAME } from './limits.js';
+/** Enable / disable win32-input-mode (private mode 9001). */
+export const WIN32_INPUT_ENABLE = '\x1b[?9001h';
+export const WIN32_INPUT_DISABLE = '\x1b[?9001l';
+/** Windows console `dwControlKeyState` modifier bits this module cares about. */
+const RIGHT_ALT = 0x1;
+const LEFT_ALT = 0x2;
+const RIGHT_CTRL = 0x4;
+const LEFT_CTRL = 0x8;
+const SHIFT = 0x10;
+/** Lock states, ENHANCED_KEY and friends must never look like modifiers. */
+const MODIFIER_MASK = SHIFT | LEFT_CTRL | RIGHT_CTRL | LEFT_ALT | RIGHT_ALT;
+/** Virtual-key codes the translator names explicitly. */
+const VK_BACK = 0x08;
+const VK_TAB = 0x09;
+const VK_ENTER = 0x0d;
+const VK_ESCAPE = 0x1b;
+const VK_PACKET = 0xe7;
+/**
+ * Parse one candidate body (`digits and semicolons`, the `_` excluded).
+ * Returns null when the field count is impossible for a real record -- that
+ * is what keeps a random `ESC [ 1 ; 2 3 _`-shaped paste from being eaten.
+ */
+function parseRecord(body) {
+    const fields = body.split(';');
+    if (fields.length !== 6)
+        return null;
+    const nums = fields.map(Number);
+    if (nums.some((n) => !Number.isInteger(n) || n < 0 || n > 0x10ffff))
+        return null;
+    const [vk, , char, down, mods, repeat] = nums;
+    if (vk === undefined || char === undefined || down === undefined)
+        return null;
+    if (mods === undefined || repeat === undefined)
+        return null;
+    if (vk > 0xff)
+        return null;
+    return { vk, scan: nums[1] ?? 0, char, down: down === 1, mods, repeat };
+}
+/**
+ * Split a chunk into text spans and win32-input-mode records.
+ *
+ * MATCHES ONLY `ESC [ <digits/semicolons> _`: mouse reports need `<`, paste
+ * markers end in `~`, CSI-u ends in `u`, DECRPM replies start with `?`. A
+ * `_`-terminated all-numeric-parameter sequence is therefore unambiguous in
+ * the stream this filter ever sees.
+ */
+export function splitWin32KeySequences(text) {
+    const segments = [];
+    let start = 0;
+    let index = 0;
+    while (index < text.length) {
+        if (text[index] !== '\x1b' || text[index + 1] !== '[') {
+            index += 1;
+            continue;
+        }
+        let end = index + 2;
+        while (end < text.length && text[end] !== '_') {
+            const c = text[end];
+            if (c < '0' || c > '9') {
+                if (c !== ';') {
+                    end = -1;
+                    break;
+                }
+            }
+            end += 1;
+        }
+        if (end === -1 || end >= text.length) {
+            index += 1;
+            continue;
+        }
+        const record = parseRecord(text.slice(index + 2, end));
+        if (!record) {
+            index += 1;
+            continue;
+        }
+        if (index > start)
+            segments.push({ kind: 'text', text: text.slice(start, index) });
+        segments.push({ kind: 'key', record });
+        index = end + 1;
+        start = index;
+    }
+    if (start < text.length)
+        segments.push({ kind: 'text', text: text.slice(start) });
+    return segments;
+}
+/** Legacy modifier parameter (xterm): 1 + shift + 2*alt + 4*ctrl. */
+function legacyModifierParam(m) {
+    let p = 1;
+    if (m & SHIFT)
+        p += 1;
+    if (m & (LEFT_ALT | RIGHT_ALT))
+        p += 2;
+    if (m & (LEFT_CTRL | RIGHT_CTRL))
+        p += 4;
+    return p;
+}
+/** Functional keys named by vk, as (letter | tilde-code) legacy shapes. */
+const FUNCTIONAL_KEYS = new Map([
+    [0x21, { code: 5 }], // PgUp
+    [0x22, { code: 6 }], // PgDn
+    [0x23, { letter: 'F' }], // End
+    [0x24, { letter: 'H' }], // Home
+    [0x25, { letter: 'D' }], // Left
+    [0x26, { letter: 'A' }], // Up
+    [0x27, { letter: 'C' }], // Right
+    [0x28, { letter: 'B' }], // Down
+    [0x2d, { code: 2 }], // Insert
+    [0x2e, { code: 3 }], // Delete
+    [0x70, { letter: 'P' }], // F1
+    [0x71, { letter: 'Q' }], // F2
+    [0x72, { letter: 'R' }], // F3
+    [0x73, { letter: 'S' }], // F4
+    [0x74, { code: 15 }], // F5
+    [0x75, { code: 17 }], // F6
+    [0x76, { code: 18 }], // F7
+    [0x77, { code: 19 }], // F8
+    [0x78, { code: 20 }], // F9
+    [0x79, { code: 21 }], // F10
+    [0x7a, { code: 23 }], // F11
+    [0x7b, { code: 24 }], // F12
+]);
+/** Emit the legacy form of a functional key under `m` modifiers. */
+function functionalLegacy(vk, m) {
+    const key = FUNCTIONAL_KEYS.get(vk);
+    if (!key)
+        return '';
+    if (m === 0) {
+        return 'letter' in key
+            ? (key.letter === 'P' || key.letter === 'Q' || key.letter === 'R' || key.letter === 'S'
+                ? `\x1bO${key.letter}`
+                : `\x1b[${key.letter}`)
+            : `\x1b[${key.code}~`;
+    }
+    const p = legacyModifierParam(m);
+    return 'letter' in key ? `\x1b[1;${p}${key.letter}` : `\x1b[${key.code};${p}~`;
+}
+/** Control code for Ctrl+letter, or the char itself when not a letter. */
+function ctrlByte(char) {
+    if (char >= 97 && char <= 122)
+        return char - 96; // a-z -> 1-26
+    if (char >= 65 && char <= 90)
+        return char - 64; // A-Z -> 1-26
+    return char;
+}
+const isPrintable = (char) => char >= 0x20 && char !== 0x7f;
+/**
+ * Translate one record to the legacy bytes the same keypress would have
+ * produced with win32-input-mode off (Enter family excepted: a modified Enter
+ * becomes the newline frame, mirroring `ENTER_SEQUENCES`).
+ */
+export function translateWin32Key(record) {
+    if (!record.down)
+        return '';
+    const m = record.mods & MODIFIER_MASK;
+    const ctrl = (m & (LEFT_CTRL | RIGHT_CTRL)) !== 0;
+    const alt = (m & (LEFT_ALT | RIGHT_ALT)) !== 0;
+    const shift = (m & SHIFT) !== 0;
+    const char = record.char === 0 ? '' : String.fromCodePoint(record.char);
+    // AltGr arrives as RightCtrl|RightAlt (or lone RightAlt) WITH the composed
+    // character already in `char`; prefixing ESC or control-translating it would
+    // break every non-US layout. Plain typing first, exotic combos never.
+    if (isPrintable(record.char) && (m === RIGHT_CTRL + RIGHT_ALT || m === RIGHT_ALT)) {
+        return char;
+    }
+    switch (record.vk) {
+        case VK_ENTER:
+            // A modified Enter NEVER submits -- same rule as `ENTER_SEQUENCES`.
+            return m === 0 ? '\r' : ENTER_NEWLINE_FRAME;
+        case VK_TAB:
+            return shift ? '\x1b[Z' : '\t';
+        case VK_ESCAPE:
+            return alt ? '\x1b\x1b' : '\x1b';
+        case VK_BACK:
+            // POST-normalisation bytes: `handleText` rewrites DEL (0x7f) to BS
+            // (0x08) for Ink, and translated records bypass that walk -- emitting
+            // the final form keeps the stream byte-identical to the baseline.
+            if (alt)
+                return '\x1b\x08';
+            return '\x08';
+        default:
+            break;
+    }
+    if (record.char !== 0 && record.char < 0x20 && record.vk !== VK_PACKET) {
+        // Ctrl combos: Windows already resolves the control character (Ctrl+C is
+        // 0x03). Alt keeps the ESC prefix; Ctrl+Alt prefixes ESC over the code.
+        if (!ctrl && !alt && !shift)
+            return char;
+        if (!ctrl && alt)
+            return `\x1b${char}`;
+        return ctrl ? `${alt ? '\x1b' : ''}${char}` : char;
+    }
+    if (isPrintable(record.char)) {
+        if (ctrl) {
+            const code = ctrlByte(record.char);
+            return `${alt ? '\x1b' : ''}${code === record.char ? char : String.fromCharCode(code)}`;
+        }
+        if (alt)
+            return `\x1b${char}`;
+        return char;
+    }
+    return functionalLegacy(record.vk, m);
+}
+/** True when `s` is a PROPER prefix of some win32-input-mode record. */
+function isWin32Prefix(s) {
+    // A bare ESC (or ESC + anything else) belongs to the Enter/mouse/paste
+    // families' hold; this family only ever extends `\x1b[` with digits and
+    // semicolons, up to but never including the `_`.
+    if (s.length < 3 || s[0] !== '\x1b' || s[1] !== '[')
+        return false;
+    for (let i = 2; i < s.length; i += 1) {
+        const c = s[i];
+        if ((c < '0' || c > '9') && c !== ';')
+            return false;
+    }
+    return true;
+}
+/**
+ * Length of the trailing run of `text` that could still complete into a
+ * win32-input-mode record, or 0. Longest match, mirroring the other families.
+ */
+export function trailingWin32PrefixLength(text) {
+    const max = Math.min(text.length, 32);
+    for (let k = max; k >= 1; k -= 1) {
+        if (isWin32Prefix(text.slice(text.length - k)))
+            return k;
+    }
+    return 0;
+}

package/dist/session/persist.d.ts

@@ -8,6 +8,7 @@
 import type { Message, ModelRef } from '@aragon-agent/core';
 import type { Entry } from '../agent/reducer.js';
 import type { TodoItem } from '../todo/types.js';
+import { type CompactionIdentity } from '../compaction/memory-identity.js';
 /**
  * Bookkeeping `aragon exec` attaches to the sessions it owns
  * (cli-integration-surface §5.2).
@@ -41,6 +42,7 @@ export interface SavedSession {
     savedAt: number;
     model?: ModelRef;
     messages: Message[];
+    compactionIdentity?: CompactionIdentity;
     entries: Entry[];
     /**
      * The live todo list at save time (todo-plan-execution §3.13).
@@ -79,6 +81,7 @@ export declare function resolveSessionPath(nameOrPath: string | undefined, cwd:
 export declare function saveSession(filePath: string, data: {
     model: ModelRef;
     messages: Message[];
+    compactionIdentity?: CompactionIdentity;
     entries: Entry[];
     todos: TodoItem[];
     meta?: SessionMeta;

package/dist/session/persist.js

@@ -9,6 +9,8 @@ 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';
+import { validateCompactionIdentity, verifyCompactionIdentity, } from '../compaction/memory-identity.js';
+import { getLogger } from '../logging/logger.js';
 const SESSION_VERSION = 1;
 /** Resolve a `/save` target: absolute/relative path, or a name in the data dir. */
 export function resolveSessionPath(nameOrPath, cwd) {
@@ -92,6 +94,12 @@ function stripServiceTail(entries) {
  * payload with no such key and a file byte-identical to today's.
  */
 export function saveSession(filePath, data) {
+    if (data.compactionIdentity) {
+        validateCompactionIdentity(data.compactionIdentity);
+        if (!verifyCompactionIdentity(data.messages, data.compactionIdentity)) {
+            getLogger().debug('agent', 'invalid_compaction_session_identity');
+        }
+    }
     const dir = dirname(filePath);
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
@@ -100,6 +108,7 @@ export function saveSession(filePath, data) {
         savedAt: Date.now(),
         model: data.model,
         messages: data.messages,
+        ...(data.compactionIdentity ? { compactionIdentity: data.compactionIdentity } : {}),
         entries: stripServiceTail(stripLiveToolOutput(data.entries)),
         todos: data.todos,
         ...(data.meta ? { meta: data.meta } : {}),

package/dist/session/store.js

@@ -159,6 +159,8 @@ export function writeSession(input) {
     saveSession(path, {
         model: input.session.model,
         messages: input.session.messages,
+        ...(input.session.compactionIdentity
+            ? { compactionIdentity: input.session.compactionIdentity } : {}),
         entries: input.session.entries,
         todos: input.session.todos ?? [],
         meta: input.meta,

package/dist/session/validate-session.js

@@ -1,6 +1,8 @@
 import { isAdapterProvider } from '../config/schema.js';
 import { normalizeTodos } from '../todo/normalize.js';
 import { TODO_LIMITS } from '../todo/limits.js';
+import { validateCompactionIdentity } from '../compaction/memory-identity.js';
+import { MemoryError } from '../compaction/memory.js';
 function fail(path, expected) {
     throw new Error(`Invalid session file: ${path} must be ${expected}.`);
 }
@@ -26,6 +28,25 @@ const boolean = (value, path) => {
     if (typeof value !== 'boolean')
         fail(path, 'a boolean');
 };
+const nonnegative = (value, path) => {
+    number(value, path);
+    if (value < 0)
+        fail(path, 'non-negative');
+};
+const positive = (value, path) => {
+    number(value, path);
+    if (value <= 0)
+        fail(path, 'positive');
+};
+const threshold = (value, path) => {
+    number(value, path);
+    if (value < 0.5 || value > 0.95)
+        fail(path, 'between 0.5 and 0.95');
+};
+const memoryVersion = (value, path) => {
+    if (value !== 2)
+        fail(path, '2');
+};
 const object = (value, path) => { record(value, path); };
 function optional(check) {
     return (value, path) => { if (value !== undefined)
@@ -149,6 +170,9 @@ const ENTRY_FIELDS = {
         text: optional(string), detail: optional(string), turn: number,
         durationMs: optional(number), live: boolean },
     compaction: {
+        decision: optional(shape({ occupied: nonnegative, contextWindow: positive,
+            threshold, source: enumeration('usage', 'estimate'), deltaTokens: nonnegative })),
+        memoryVersion: optional(memoryVersion),
         index: number, trigger: enumeration('pressure', 'overflow', 'manual'),
         mode: enumeration('summarized', 'truncated', 'relieved', 'none'), applied: boolean,
         reason: optional(string), messagesBefore: number, messagesAfter: number,
@@ -198,6 +222,16 @@ export function validateSession(value) {
     validateEntries(source.entries);
     if (source.model !== undefined)
         validateModel(source.model);
+    if (source.compactionIdentity !== undefined) {
+        try {
+            validateCompactionIdentity(source.compactionIdentity);
+        }
+        catch (error) {
+            if (!(error instanceof MemoryError))
+                throw error;
+            fail('compactionIdentity', 'a valid adopted-memory identity');
+        }
+    }
     // Missing fields remain missing in old files, including exec metadata.
     const prepared = { ...source };
     if (source.todos !== undefined) {

package/dist/team/subagent.js

@@ -331,6 +331,14 @@ export function createSubagent(spec, deps, hooks) {
                 }
                 break;
             }
+            case 'compaction_end':
+                contextManager?.onCompactionEnd({
+                    applied: event.applied,
+                    ...(event.reason !== undefined ? { reason: event.reason } : {}),
+                    tokensBefore: event.estimatedTokensBefore,
+                    tokensAfter: event.estimatedTokensAfter,
+                });
+                break;
             case 'tool_execution_start':
                 run.phase = event.toolName === 'team_wait' ? 'waiting' : 'tool';
                 run.lastTool = event.toolName;