@aragon-agent/cli 0.6.1 → 0.6.3

package/dist/config/schema.js

@@ -169,6 +169,42 @@ export const DEFAULT_DIFF_RENDER = true;
  */
 export const DEFAULT_SYNC_OUTPUT = true;
 // ---------------------------------------------------------------------------
+// Selection + scroll follow (tui-selection-and-scroll-follow §6.1)
+// ---------------------------------------------------------------------------
+/**
+ * Drag-select + copy, and — because §4.4.1 gates `\x1b[?1002h` on exactly this
+ * value — whether motion reporting is requested from the terminal at all.
+ *
+ * That gating is what makes `false` BYTE-IDENTICAL to a pre-feature session
+ * rather than merely equivalent (AC-8 / D-15). Ignored when `mouse` is false,
+ * since there is no capture to select with.
+ */
+export const DEFAULT_MOUSE_SELECT = true;
+/**
+ * Idle delay before a paused viewport returns to the newest line, in ms.
+ *
+ * Five seconds is chosen to be LONGER than a glance and SHORTER than a read.
+ * `0` disables auto-resume entirely, and it is a real value rather than a
+ * sentinel-shaped default: `shouldArmResume` refuses on it before any timer is
+ * created (AC-9), so the revert for Rule B is one config key.
+ *
+ * NO CLI FLAG (§6.1). It is a comfort preference, set once
+ * (`aragon config set scrollResumeMs 8000`) and then forgotten — the same
+ * argument this file already makes for `historyEnabled`. Adding a flag for every
+ * scalar is how a CLI ends up with sixty of them.
+ */
+export const DEFAULT_SCROLL_RESUME_MS = 5000;
+const SCROLL_RESUME_RANGE = { min: 0, max: 120_000 };
+/**
+ * `clampIntAllowingZero`, and the choice is load-bearing: `clampInt` delegates to
+ * `coercePositiveInt`, which returns the FALLBACK for `n <= 0` — so `0` would
+ * silently become 5000 and the documented off switch would not be an off switch.
+ * Exactly the trap `retry.maxRetries` needed this helper for.
+ */
+export function clampScrollResumeMs(v, fallback) {
+    return clampIntAllowingZero(v, fallback, SCROLL_RESUME_RANGE);
+}
+// ---------------------------------------------------------------------------
 // Plan mode (plan-mode §4.4)
 //
 // THREE FLAT KEYS, not a nested `planMode` object. `store.ts` documents that its
@@ -669,6 +705,99 @@ function isRegistryUrl(raw) {
         return false;
     }
 }
+export const DEFAULT_COMPACTION_CONFIG = {
+    enabled: true,
+    threshold: 0.9,
+    warnThreshold: 0.75,
+    keepRecentTurns: 4,
+    useFastTier: true,
+    onFailure: 'truncate',
+    subagents: true,
+    archive: true,
+};
+const THRESHOLD_RANGE = { min: 0.5, max: 0.95 };
+const WARN_THRESHOLD_FLOOR = 0.4;
+/** The gap the warn mark must stay below the trigger by. */
+const WARN_THRESHOLD_GAP = 0.05;
+const KEEP_RECENT_TURNS_RANGE = { min: 1, max: 20 };
+const COMPACTION_FAILURE_MODES = ['truncate', 'stop'];
+/**
+ * Round a ratio to two decimals — the precision a percentage actually has.
+ *
+ * BINARY FLOATING POINT MAKES `0.95 - 0.05` EQUAL `0.8999999999999999`, and both
+ * numbers here are produced by subtraction (`threshold - WARN_THRESHOLD_GAP`) and
+ * by division (`parseThresholdInput` turning `90` into `90/100`). Without this,
+ * `aragon config list` shows a seventeen-digit value for a setting the user typed
+ * as `90%`, and `config.json` records one — which looks like corruption and
+ * invites a hand-edit that the clamp then has to defend against.
+ *
+ * Two decimals is exact for every value the range can hold: the clamp is
+ * `[0.5, 0.95]` and the UI reads it as a whole percentage.
+ */
+function ratio(value) {
+    return Math.round(value * 100) / 100;
+}
+function failureMode(value, fallback) {
+    return typeof value === 'string' && COMPACTION_FAILURE_MODES.includes(value)
+        ? value
+        : fallback;
+}
+/**
+ * THE single gate for every compaction-config read AND write, mirroring the six
+ * clamps above for the reason all of them record: hardening only the read path
+ * leaves a bad value on disk that reverts to the default on every launch, which
+ * presents to the user as "my setting won't stick".
+ *
+ * THE ORDER IS FIXED AND IT MATTERS (§4.2 / P2-5). `threshold` is clamped to
+ * `[0.5, 0.95]` FIRST, then `warnThreshold` to
+ * `[0.4, clampedThreshold - 0.05]`. The other order lets a file holding
+ * `{threshold: 0.6, warnThreshold: 0.9}` produce a warn mark ABOVE the trigger —
+ * a gauge that turns amber after it has already gone red. Both bounds of the
+ * second range stay reachable at the extremes: `threshold` floored at `0.5`
+ * gives `warnThreshold` a range of `[0.4, 0.45]`.
+ */
+export function clampCompactionConfig(raw) {
+    const src = (raw && typeof raw === 'object' ? raw : {});
+    const threshold = ratio(clampNumber(src.threshold, DEFAULT_COMPACTION_CONFIG.threshold, THRESHOLD_RANGE));
+    const warnCeiling = ratio(threshold - WARN_THRESHOLD_GAP);
+    return {
+        enabled: bool(src.enabled, DEFAULT_COMPACTION_CONFIG.enabled),
+        threshold,
+        warnThreshold: ratio(clampNumber(src.warnThreshold, DEFAULT_COMPACTION_CONFIG.warnThreshold, {
+            min: Math.min(WARN_THRESHOLD_FLOOR, warnCeiling),
+            max: warnCeiling,
+        })),
+        keepRecentTurns: clampInt(src.keepRecentTurns, DEFAULT_COMPACTION_CONFIG.keepRecentTurns, KEEP_RECENT_TURNS_RANGE),
+        useFastTier: bool(src.useFastTier, DEFAULT_COMPACTION_CONFIG.useFastTier),
+        // CLAMPED TO THE DEFAULT, NEVER REJECTED — the discipline every other key in
+        // this file follows. `ARAGON_COMPACTION_ON_FAILURE=garbage` resolves to
+        // `truncate` and throws nothing.
+        onFailure: failureMode(src.onFailure, DEFAULT_COMPACTION_CONFIG.onFailure),
+        subagents: bool(src.subagents, DEFAULT_COMPACTION_CONFIG.subagents),
+        archive: bool(src.archive, DEFAULT_COMPACTION_CONFIG.archive),
+    };
+}
+/**
+ * Parse `0.9`, `90%` or `90` into a ratio, or `null` when it is neither.
+ *
+ * `null` RATHER THAN A CLAMPED DEFAULT, because this is a COMMAND argument and
+ * not a config value: `/compact threshold banana` must say so rather than
+ * silently setting 0.9 and reporting success.
+ */
+export function parseThresholdInput(raw) {
+    const trimmed = raw.trim().replace(/%$/, '');
+    if (trimmed.length === 0)
+        return null;
+    const n = Number.parseFloat(trimmed);
+    if (!Number.isFinite(n))
+        return null;
+    // `90` means 90 %, `0.9` means 0.9. The ambiguity is only at `1`, which is
+    // above the clamp ceiling either way.
+    const ratio = n > 1 ? n / 100 : n;
+    if (ratio <= 0 || ratio > 1)
+        return null;
+    return ratio;
+}
 export const DEFAULT_CONFIG = {
     version: CONFIG_VERSION,
     provider: 'anthropic',
@@ -703,6 +832,8 @@ export const DEFAULT_CONFIG = {
     density: 'comfortable',
     hints: true,
     mouse: true,
+    mouseSelect: DEFAULT_MOUSE_SELECT,
+    scrollResumeMs: DEFAULT_SCROLL_RESUME_MS,
     planModeDefault: false,
     planModeMaxAskRounds: DEFAULT_PLAN_MAX_ASK_ROUNDS,
     planModeHumanTimeoutMs: DEFAULT_PLAN_HUMAN_TIMEOUT_MS,
@@ -728,6 +859,12 @@ export const DEFAULT_CONFIG = {
     // (`cfg.update.mode !== 'off'`) would read TRUE and the feature would be on
     // for a reason nobody could point at.
     update: DEFAULT_UPDATE_CONFIG,
+    // And one section later again, for the fourth time. Without this line a user
+    // whose `config.json` predates compaction resolves `config.compaction.enabled`
+    // to `undefined`, which is FALSY — so a feature that is `true` by default would
+    // arrive OFF for every existing user, which is the one direction this
+    // particular default must never fail in.
+    compaction: DEFAULT_COMPACTION_CONFIG,
 };
 /**
  * Runtime state that used to be stored in `config.json` by mistake

package/dist/config/store.js

@@ -14,7 +14,7 @@ import { dirname } from 'node:path';
 import process from 'node:process';
 import { getConfigPath, getSessionsDir } from './app-paths.js';
 import { registerSecretsFrom } from '../logging/secret-registry.js';
-import { CONFIG_VERSION, DEFAULT_CONFIG, clampFastConfig, clampLogConfig, clampMaxTokens, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampUpdateConfig, isAutoToken, stripLegacyStateKeys, } from './schema.js';
+import { CONFIG_VERSION, DEFAULT_CONFIG, clampCompactionConfig, clampFastConfig, clampLogConfig, clampMaxTokens, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampUpdateConfig, isAutoToken, stripLegacyStateKeys, } from './schema.js';
 /**
  * Normalize `maxTokens` for both directions of the config file.
  *
@@ -139,6 +139,15 @@ export function loadPersistedConfig() {
         // predates auto-update, which is all of them. Without it `config.update.mode`
         // reads `undefined`, and the §3.8 gate tests `!== 'off'`.
         update: clampUpdateConfig({ ...DEFAULT_CONFIG.update, ...(partial.update ?? {}) }),
+        // `compaction` is the ninth. Same one-level rule, same merge — and the READ
+        // half supplies a whole section to every user whose `config.json` predates
+        // this feature, which is all of them. Without it `config.compaction.enabled`
+        // reads `undefined`, which is FALSY, so a feature that is `true` by default
+        // would arrive off for every existing user.
+        compaction: clampCompactionConfig({
+            ...DEFAULT_CONFIG.compaction,
+            ...(partial.compaction ?? {}),
+        }),
     };
 }
 /**
@@ -208,6 +217,13 @@ export function updatePersistedConfig(patch) {
         // enterprise mirror the user configured last month is gone with no error
         // anywhere. AC-20 is the assertion that proves both halves exist.
         update: clampUpdateConfig({ ...current.update, ...(patch.update ?? {}) }),
+        // The ninth section, and the fourth time this file records the same trap.
+        // `/compact threshold 0.8` sends `{ compaction: { threshold: 0.8 } }`;
+        // without this line the shallow top-level spread REPLACES the section,
+        // `enabled` is written absent, and a user who deliberately turned compaction
+        // OFF finds it back on tomorrow — a feature that spends money on their behalf
+        // re-enabling itself because they nudged a threshold.
+        compaction: clampCompactionConfig({ ...current.compaction, ...(patch.compaction ?? {}) }),
     };
     writeConfigFile(merged);
     return merged;

package/dist/config/ui-state.d.ts

@@ -32,11 +32,35 @@ export interface UiState {
     schema: number;
     /** Lifetime submit count; drives the composer hint fade (`HINT_FADE_AFTER`). */
     submitCount: number;
-    /** Whether the one-shot "hold Shift to select text" notice has been shown. */
+    /**
+     * Whether the one-shot "hold Shift to select text" notice has been shown.
+     *
+     * DELIBERATELY NOT READ BY THE LIVE GATE ANY MORE (tui-selection-and-scroll-
+     * follow P1-8). It is kept in the shape so `importLegacyUiState` still has
+     * somewhere to put a migrated value and so a file written by 0.6.2 round-trips
+     * unchanged; `mouseNoticeVersion` below is what the notice now consults.
+     */
     mouseNoticeSeen: boolean;
     /**
-     * Whether the one-shot "this Windows console cannot deliver Shift+Tab or the
-     * wheel" notice has been shown.
+     * Which revision of the mouse notice this user has already been shown
+     * (`0` = none).
+     *
+     * A VERSION BESIDE THE BOOLEAN, NOT A BUMPED SCHEMA, and this is the second
+     * time this file has had to say so. The audience for the CORRECTED text — "drag
+     * to select, releasing copies" — is exactly the set of users who already have
+     * `mouseNoticeSeen: true` on disk from the old "hold Shift" text, so a boolean
+     * can only say "shown", never "shown WHAT". And bumping `UI_STATE_SCHEMA`, the
+     * nearest thing to "bump the key", makes `readFromDisk` discard the WHOLE
+     * object: every user's `submitCount` resets and the composer hint un-fades for
+     * all of them, to re-show one notice.
+     *
+     * `vtInputNoticeVersion` below is the precedent, written about this exact
+     * situation one feature earlier.
+     */
+    mouseNoticeVersion: number;
+    /**
+     * Which revision of the "this Windows console cannot deliver Shift+Tab or the
+     * wheel" notice this user has already been shown (`0` = none).
      *
      * A SEPARATE KEY FROM `mouseNoticeSeen`, AND THAT IS THE WHOLE POINT. The
      * people this notice exists for are precisely the ones who have already
@@ -44,12 +68,22 @@ export interface UiState {
      * them, and therefore already have `mouseNoticeSeen: true` on disk. Folding
      * the two would make the fix inert for its entire audience, in silence.
      *
+     * A VERSION RATHER THAN A BOOLEAN, for the second turn of that same screw.
+     * The predecessor of this field was `vtInputNoticeSeen: boolean`, written by
+     * builds whose text knew nothing about `MODE_TOGGLE_KEYS.fallback` — and the
+     * audience for the text that DOES name it is, once again, exactly the set of
+     * users who already have the old flag set. A boolean can only say "shown",
+     * never "shown WHAT", so the only way to reach them without re-showing the
+     * notice on every launch is to let the wording carry a number. That old key
+     * is deliberately not read: it is absent from the shape below, so a file
+     * written by 0.6.1 reads as `0` and replays exactly once.
+     *
      * NOT ADDED TO `UI_STATE_SCHEMA`: bumping the schema makes `readFromDisk`
      * discard the whole object, which would reset everyone's submit counter and
      * re-show the mouse notice. A new field simply reads as its default on an
      * older file, which is the behaviour wanted here anyway.
      */
-    vtInputNoticeSeen: boolean;
+    vtInputNoticeVersion: number;
 }
 /** Read the state, caching it for the life of the process. Never throws. */
 export declare function loadUiState(): UiState;
@@ -58,8 +92,12 @@ export declare function readSubmitCount(): number;
 export declare function bumpSubmitCount(): number;
 export declare function getMouseNoticeSeen(): boolean;
 export declare function setMouseNoticeSeen(seen: boolean): void;
-export declare function getVtInputNoticeSeen(): boolean;
-export declare function setVtInputNoticeSeen(seen: boolean): void;
+/** `0` on a file written before the field existed — see the field's comment. */
+export declare function getMouseNoticeVersion(): number;
+export declare function setMouseNoticeVersion(version: number): void;
+/** `0` on a file written before the field existed — see the field's comment. */
+export declare function getVtInputNoticeVersion(): number;
+export declare function setVtInputNoticeVersion(version: number): void;
 /**
  * Migration-only: fill in fields that are still at their default, and never
  * overwrite a value already here. A second import — after a half-finished

package/dist/config/ui-state.js

@@ -35,13 +35,15 @@ const DEFAULT_UI_STATE = {
     schema: UI_STATE_SCHEMA,
     submitCount: 0,
     mouseNoticeSeen: false,
-    vtInputNoticeSeen: false,
+    mouseNoticeVersion: 0,
+    vtInputNoticeVersion: 0,
 };
 let memory = null;
-function coerceCount(value) {
+/** Non-negative integer or `fallback`; shared by both numeric fields. */
+function coerceCount(value, fallback) {
     const n = typeof value === 'number' ? value : Number.parseInt(String(value ?? ''), 10);
     if (!Number.isFinite(n) || n < 0)
-        return DEFAULT_UI_STATE.submitCount;
+        return fallback;
     return Math.floor(n);
 }
 /**
@@ -61,13 +63,12 @@ function readFromDisk() {
             return { ...DEFAULT_UI_STATE };
         return {
             schema: UI_STATE_SCHEMA,
-            submitCount: coerceCount(parsed.submitCount),
+            submitCount: coerceCount(parsed.submitCount, DEFAULT_UI_STATE.submitCount),
             mouseNoticeSeen: typeof parsed.mouseNoticeSeen === 'boolean'
                 ? parsed.mouseNoticeSeen
                 : DEFAULT_UI_STATE.mouseNoticeSeen,
-            vtInputNoticeSeen: typeof parsed.vtInputNoticeSeen === 'boolean'
-                ? parsed.vtInputNoticeSeen
-                : DEFAULT_UI_STATE.vtInputNoticeSeen,
+            mouseNoticeVersion: coerceCount(parsed.mouseNoticeVersion, DEFAULT_UI_STATE.mouseNoticeVersion),
+            vtInputNoticeVersion: coerceCount(parsed.vtInputNoticeVersion, DEFAULT_UI_STATE.vtInputNoticeVersion),
         };
     }
     catch {
@@ -127,11 +128,19 @@ export function getMouseNoticeSeen() {
 export function setMouseNoticeSeen(seen) {
     update({ mouseNoticeSeen: seen });
 }
-export function getVtInputNoticeSeen() {
-    return loadUiState().vtInputNoticeSeen;
+/** `0` on a file written before the field existed — see the field's comment. */
+export function getMouseNoticeVersion() {
+    return loadUiState().mouseNoticeVersion;
 }
-export function setVtInputNoticeSeen(seen) {
-    update({ vtInputNoticeSeen: seen });
+export function setMouseNoticeVersion(version) {
+    update({ mouseNoticeVersion: version });
+}
+/** `0` on a file written before the field existed — see the field's comment. */
+export function getVtInputNoticeVersion() {
+    return loadUiState().vtInputNoticeVersion;
+}
+export function setVtInputNoticeVersion(version) {
+    update({ vtInputNoticeVersion: version });
 }
 /**
  * Migration-only: fill in fields that are still at their default, and never
@@ -143,7 +152,7 @@ export function importLegacyUiState(patch) {
     const next = {};
     if (patch.submitCount !== undefined &&
         current.submitCount === DEFAULT_UI_STATE.submitCount) {
-        next.submitCount = coerceCount(patch.submitCount);
+        next.submitCount = coerceCount(patch.submitCount, DEFAULT_UI_STATE.submitCount);
     }
     if (patch.mouseNoticeSeen !== undefined &&
         current.mouseNoticeSeen === DEFAULT_UI_STATE.mouseNoticeSeen) {

package/dist/diagnostics/doctor.js

@@ -17,9 +17,11 @@ import { getHomeResolutionWarning, getSessionsDir, getUserDataDir } from '../con
 import { readConfigFile } from '../config/store.js';
 import { loadConfig, makeGetApiKey } from '../config/load.js';
 import { isAdapterProvider, toRetryPolicy } from '../config/schema.js';
+import { MODE_TOGGLE_KEYS } from '../agent/agent-mode.js';
+import { supportsWindowsVtInput } from '../ui/win-vt-input.js';
 const MIN_NODE_MAJOR = 18;
 export async function runDoctorChecks(flags, opts = {}) {
-    const checks = [checkNode(), checkHome(), checkConfigFile()];
+    const checks = [checkNode(), ...checkVtInput(), checkHome(), checkConfigFile()];
     const config = loadConfig(flags);
     checks.push(checkProviderKey(config));
     checks.push(checkModel(config));
@@ -42,6 +44,44 @@ function checkNode() {
         remedy: `Install Node ${MIN_NODE_MAJOR} or newer.`,
     };
 }
+/**
+ * Whether this console can deliver `Shift+Tab`
+ * (shift-tab-mode-toggle-still-dead-on-windows, C3-2).
+ *
+ * `MIN_NODE_MAJOR` STAYS AT 18 and this is a separate check on purpose. The
+ * install floor is about whether aragon runs; this is about one key, and raising
+ * the floor to 22.17 would lock out a large, otherwise perfectly healthy Node 20
+ * population over it.
+ *
+ * `warn`, never `fail`: aragon turns the console bit on itself at startup, and
+ * `MODE_TOGGLE_KEYS.fallback` works whether or not that succeeded, so nothing
+ * here is actually broken - the exit code must not say it is.
+ *
+ * WHY IT EXISTS AT ALL: `checkNode` passes every version this bug affects, so a
+ * user whose mode toggle is dead ran the tool built to explain their machine and
+ * was told it was fine (analysis section 3.7). A diagnostic that is confidently
+ * wrong is worse than one that is silent - it ends the investigation.
+ *
+ * Returned as a list so the row simply does not exist off Windows, where there
+ * is no such thing as a console input mode to report on.
+ */
+function checkVtInput() {
+    if (process.platform !== 'win32')
+        return [];
+    if (supportsWindowsVtInput(process.platform, process.versions.node)) {
+        return [pass('vt-input', `v${process.versions.node} delivers Shift+Tab and mouse reports`)];
+    }
+    return [
+        {
+            name: 'vt-input',
+            verdict: 'warn',
+            detail: `Node v${process.versions.node} never enables ENABLE_VIRTUAL_TERMINAL_INPUT, so this ` +
+                'console reports Shift+Tab as a plain Tab and sends no mouse events',
+            remedy: `aragon turns that bit on at startup; if a policy blocks it, ${MODE_TOGGLE_KEYS.fallback} ` +
+                'and /plan toggle the mode too. Node 22.17+ (or 24.2+) removes the problem.',
+        },
+    ];
+}
 function checkHome() {
     const home = getUserDataDir();
     const warning = getHomeResolutionWarning();

package/dist/exec/events.d.ts

@@ -157,6 +157,55 @@ export interface ExecFastReviewEvent {
     model: string;
     text: string;
 }
+/**
+ * Context compaction (context-auto-compaction §4.6).
+ *
+ * ONE ADDITIVE EVENT TYPE, AND `EXEC_SCHEMA_VERSION` DOES NOT MOVE — the rule
+ * this file's header states in the same words: adding a field or an event type
+ * never bumps it; renaming or removing one does. A consumer that ignores event
+ * types it does not know is unaffected.
+ *
+ * THE SUMMARY TEXT IS DELIBERATELY ABSENT (D-18). It can be tens of thousands of
+ * characters, no wrapper needs it, and the transcript card and the log both have
+ * it. What a wrapper does need is the SHAPE of what happened, which is here.
+ */
+export interface ExecCompactionEvent {
+    type: 'compaction';
+    sessionId: string;
+    turn: number;
+    subtype: 'start' | 'end';
+    trigger: 'pressure' | 'overflow' | 'manual';
+    /** `end` only. */
+    applied?: boolean;
+    /**
+     * `relieved` means the RETAINED turns were clipped and nothing was dropped
+     * (context-auto-compaction-hardening §3.3 / W2).
+     *
+     * A NEW MEMBER OF AN EXISTING UNION, WHICH DOES NOT MOVE `EXEC_SCHEMA_VERSION`
+     * either - the rule this file's header states covers adding, not renaming or
+     * removing. A consumer switching on this field already has to handle a value it
+     * does not know, because `none` and `truncated` were both already possible.
+     */
+    mode?: 'summarized' | 'truncated' | 'relieved' | 'none';
+    reason?: string;
+    messagesBefore?: number;
+    messagesAfter?: number;
+    tokensBefore?: number;
+    tokensAfter?: number;
+    /**
+     * Present only when tail relief fired (§4.5).
+     *
+     * A BOUNDED, ANNOUNCED DATA LOSS INSIDE THE TURNS THE RUN CONTINUES FROM, and
+     * therefore something a wrapper is entitled to see. The clipped bodies
+     * themselves are not on the stream, for the same reason `summary` is not
+     * (D-18).
+     */
+    tailRelief?: {
+        messages: number;
+        charsRemoved: number;
+    };
+    durationMs?: number;
+}
 export interface ExecRetryEvent {
     type: 'retry';
     sessionId: string;
@@ -202,7 +251,7 @@ export interface ExecResultEvent {
     todos: ExecTodoCounts | null;
     error: ExecErrorInfo | null;
 }
-export type ExecEvent = ExecSystemInitEvent | ExecUserEvent | ExecTextDeltaEvent | ExecThinkingEvent | ExecAssistantEvent | ExecToolCallEvent | ExecToolResultEvent | ExecTodoEvent | ExecTeamEvent | ExecFastReviewEvent | ExecRetryEvent | ExecErrorEvent | ExecResultEvent;
+export type ExecEvent = ExecSystemInitEvent | ExecUserEvent | ExecTextDeltaEvent | ExecThinkingEvent | ExecAssistantEvent | ExecToolCallEvent | ExecToolResultEvent | ExecTodoEvent | ExecTeamEvent | ExecFastReviewEvent | ExecCompactionEvent | ExecRetryEvent | ExecErrorEvent | ExecResultEvent;
 /** Everything `system/init` needs that the runner cannot derive for itself. */
 export interface ExecInitParams {
     sessionId: string;

package/dist/exec/index.js

@@ -22,7 +22,7 @@ import process from 'node:process';
 import { runHeadless } from '../agent/headless.js';
 import { computeCost } from '../agent/usage.js';
 import { loadConfig } from '../config/load.js';
-import { latestSessionForCwd, readSessionFile, resolveSessionRef, sessionPathFor, tryAcquireSessionLock, writeSession, } from '../session/store.js';
+import { latestSessionForCwd, readSessionFile, resolveSessionRef, resumedSessionId, sessionPathFor, tryAcquireSessionLock, writeSession, } from '../session/store.js';
 import { createEmitter } from './emitter.js';
 import { resolveExecOptions } from './options.js';
 import { resolvePermission } from './permission.js';
@@ -352,11 +352,15 @@ function planSession(options, cwd, err) {
     if (options.resume !== undefined) {
         const path = resolveSessionRef(options.resume, cwd);
         const saved = path ? readSessionFile(path) : null;
-        if (!saved) {
+        if (!path || !saved) {
             err.write(`session_not_found: no readable session for --resume "${options.resume}".\n`);
             return null;
         }
-        return { id: saved.meta?.id ?? options.resume, saved, saving, cwd };
+        // NOT `options.resume` AND NOT `meta.id` UNCHECKED (R-7). The flag accepts
+        // `<id|path>`, so the value the caller typed is frequently a path, and
+        // `meta.id` comes out of a file - neither is usable as a filename without
+        // being checked. `resumedSessionId` is the one place that decision is made.
+        return { id: resumedSessionId(path, saved), saved, saving, cwd };
     }
     if (options.continueSession) {
         const entry = latestSessionForCwd(cwd);
@@ -365,7 +369,7 @@ function planSession(options, cwd, err) {
             err.write(`no_session_for_cwd: no previous aragon exec session for ${cwd}.\n`);
             return null;
         }
-        return { id: entry.id, saved, saving, cwd };
+        return { id: resumedSessionId(entry.path, saved), saved, saving, cwd };
     }
     if (options.sessionId !== undefined) {
         // THE UPSERT. A wrapper that mints its own id must not have to ask whether

package/dist/exec/runner.js

@@ -121,6 +121,48 @@ export class ExecRunner {
         });
         if (fast)
             this.unsubscribers.push(fast);
+        // Context compaction (context-auto-compaction §4.6). Usage is folded into the
+        // run's totals for the reason the team and fast branches above give: a
+        // summarization is real spend, and `result.usage` is the only cost readout a
+        // wrapper gets.
+        const compaction = controller.subscribeCompaction?.((event) => {
+            if (event.type === 'usage') {
+                this.usage.inputTokens += event.usage.inputTokens;
+                this.usage.outputTokens += event.usage.outputTokens;
+                return;
+            }
+            if (event.type === 'compaction_start') {
+                this.emit({
+                    type: 'compaction',
+                    sessionId: this.sessionId,
+                    turn: this.turns,
+                    subtype: 'start',
+                    trigger: event.trigger,
+                });
+                return;
+            }
+            if (event.type !== 'compaction_end')
+                return;
+            const r = event.record;
+            this.emit({
+                type: 'compaction',
+                sessionId: this.sessionId,
+                turn: this.turns,
+                subtype: 'end',
+                trigger: r.trigger,
+                applied: r.applied,
+                mode: r.mode,
+                ...(r.reason !== undefined ? { reason: r.reason } : {}),
+                messagesBefore: r.messagesBefore,
+                messagesAfter: r.messagesAfter,
+                tokensBefore: r.tokensBefore,
+                tokensAfter: r.tokensAfter,
+                ...(r.tailRelief ? { tailRelief: r.tailRelief } : {}),
+                durationMs: r.durationMs,
+            });
+        });
+        if (compaction)
+            this.unsubscribers.push(compaction);
         this.installTerminator();
     }
     /**
@@ -193,8 +235,8 @@ export class ExecRunner {
         const followThrough = this.opts.followThrough ?? 'notify';
         for (;;) {
             const next = await source.next();
-            // EXHAUSTION IS CHECKED BEFORE THE SOURCE, SO A RUN THAT ENDS ON ITS OWN
-            // TERMS IS NEVER MISREPORTED (IF-3). `next === null` first is what makes
+            // THE SOURCE IS POLLED BEFORE THE EXHAUSTION CHECK, SO A RUN THAT ENDS ON
+            // ITS OWN TERMS IS NEVER MISREPORTED (IF-3). `next === null` first is what makes
             // that true: a conversation of exactly `--max-turns` turns whose caller has
             // nothing more to say exits 0 with `end_turn`, not 3 with `max_turns`.
             if (next === null)

package/dist/input/mouse-events.d.ts

@@ -15,8 +15,10 @@
  * module exists so `stdin-mouse-filter.ts` can remove every byte of every
  * report before Ink ever sees the chunk (invariant I-1).
  *
- * Non-wheel reports (press / release / drag) are recognized and DISCARDED
- * rather than passed through, for the same reason.
+ * Every mouse report is CONSUMED here whatever it turns out to be; what changed
+ * with tui-selection-and-scroll-follow is that press / drag / release are now
+ * EMITTED as well as consumed, so `SelectionController` can build a selection
+ * out of them (§4.4.2). They were previously recognized and thrown away.
  */
 export interface WheelEvent {
     readonly kind: 'wheel';
@@ -29,14 +31,33 @@ export interface WheelEvent {
     readonly alt: boolean;
     readonly ctrl: boolean;
 }
+export interface ButtonEvent {
+    readonly kind: 'press' | 'drag' | 'release';
+    /** 0 = left, 1 = middle, 2 = right. Never 3 — see `decodeReport`. */
+    readonly button: 0 | 1 | 2;
+    /** 1-based terminal column, as reported. */
+    readonly x: number;
+    /** 1-based terminal row, as reported. */
+    readonly y: number;
+    readonly shift: boolean;
+    readonly alt: boolean;
+    readonly ctrl: boolean;
+}
+export type MouseEvent = WheelEvent | ButtonEvent;
 export interface MouseSplit {
-    /** Wheel events, in arrival order. Non-wheel reports are dropped, not returned. */
-    readonly events: WheelEvent[];
+    /** Mouse events, in arrival order. Unrecognized reports are dropped, not returned. */
+    readonly events: MouseEvent[];
     /** Everything that was not a mouse report — forward this to Ink verbatim. */
     readonly text: string;
     /** Trailing strict prefix of a possible report; feed it back in with the next chunk. */
     readonly pending: string;
 }
+/**
+ * Which wire encoding a report arrived in. It is a PARAMETER rather than a
+ * remembered rule because the rule it expresses is invariant I-11 and the cost
+ * of forgetting it is a permanently frozen viewport (see `decodeReport`).
+ */
+export type MouseEncoding = 'sgr' | 'x10';
 /**
  * Ceiling on the held-back tail. A malformed sequence that looks like a prefix
  * forever must never be able to wedge input: past this length the tail is
@@ -51,11 +72,16 @@ export declare const MAX_PENDING_MOUSE_CHARS = 32;
  */
 export declare function isMousePrefix(s: string): boolean;
 /**
- * Split a decoded stdin chunk into wheel events, passthrough text, and a
+ * Split a decoded stdin chunk into mouse events, passthrough text, and a
  * trailing prefix to carry into the next chunk.
  *
  * The caller is expected to feed `pending + nextChunk` back in; ConPTY does
  * split writes mid-sequence, and a report torn across two chunks would
  * otherwise leak its tail into the composer (R-6).
+ *
+ * ONE CHANNEL, NOT TWO (§4.4.2). Widening this list to carry buttons alongside
+ * wheel notches is what keeps ARRIVAL ORDER intact between them; a second
+ * channel would let a press overtake the notch that preceded it, and the
+ * selection would then be anchored against rows that had already scrolled.
  */
 export declare function splitMouseEvents(buffer: string): MouseSplit;