@aragon-agent/cli 0.6.2 → 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,8 +32,32 @@ 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;
+    /**
+     * 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).
@@ -69,6 +93,9 @@ export declare function bumpSubmitCount(): number;
 export declare function getMouseNoticeSeen(): boolean;
 export declare function setMouseNoticeSeen(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;
 /**

package/dist/config/ui-state.js

@@ -35,6 +35,7 @@ const DEFAULT_UI_STATE = {
     schema: UI_STATE_SCHEMA,
     submitCount: 0,
     mouseNoticeSeen: false,
+    mouseNoticeVersion: 0,
     vtInputNoticeVersion: 0,
 };
 let memory = null;
@@ -66,6 +67,7 @@ function readFromDisk() {
             mouseNoticeSeen: typeof parsed.mouseNoticeSeen === 'boolean'
                 ? parsed.mouseNoticeSeen
                 : DEFAULT_UI_STATE.mouseNoticeSeen,
+            mouseNoticeVersion: coerceCount(parsed.mouseNoticeVersion, DEFAULT_UI_STATE.mouseNoticeVersion),
             vtInputNoticeVersion: coerceCount(parsed.vtInputNoticeVersion, DEFAULT_UI_STATE.vtInputNoticeVersion),
         };
     }
@@ -127,6 +129,13 @@ export function setMouseNoticeSeen(seen) {
     update({ mouseNoticeSeen: seen });
 }
 /** `0` on a file written before the field existed — see the field's comment. */
+export function getMouseNoticeVersion() {
+    return loadUiState().mouseNoticeVersion;
+}
+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;
 }

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/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();
     }
     /**

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;

package/dist/input/mouse-events.js

@@ -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.
  */
 /**
  * Ceiling on the held-back tail. A malformed sequence that looks like a prefix
@@ -38,34 +40,80 @@ const SGR_PREFIX = /^\x1b\[<[\d;]*$/;
 export function isMousePrefix(s) {
     return /^\x1B(\[(<[\d;]*|M[\s\S]{0,2})?)?$/.test(s);
 }
+function modifiers(b) {
+    return { shift: (b & 4) !== 0, alt: (b & 8) !== 0, ctrl: (b & 16) !== 0 };
+}
 /**
- * Decode an SGR button byte into a wheel event, or `null` when the report is
- * not a wheel notch we act on.
+ * Decode one report, or `null` when it is a report we consume without acting on.
  *
  * THE ORDER OF THESE TESTS IS THE SPECIFICATION, not a presentation choice.
  * Button 66 (wheel-left) has `b & 1 === 0` and would decode as `'up'`, so the
- * horizontal test has to precede the direction decode.
+ * horizontal test has to precede the direction decode; and `b & 32` (motion) has
+ * to precede the `final` test, because a drag is reported with `M` exactly as a
+ * press is.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * I-11 — BUTTON EVENTS COME FROM THE SGR PATH ONLY. X10 stays wheel-only, which
+ * is exactly the contract it has today.
+ *
+ * `matchX10` reconstructs a legacy report and hard-codes `final = 'M'`, because
+ * X10 HAS NO SEPARATE RELEASE FORM AT ALL — it encodes a release as button 3 of
+ * a press. Fed through the table below, an X10 release would become a `press`
+ * that is never followed by a `release`, whose `button` is 3 while the type says
+ * `0 | 1 | 2`, and whose consequence is a `hold` that is set and never cleared:
+ * content anchoring never lets go, the resume timer's third condition never
+ * passes, and the transcript is frozen for the rest of the session with nothing
+ * raised anywhere.
+ *
+ * This costs nothing real (D-16): we never REQUEST X10 — `?1006h` is over a
+ * decade old and every terminal that implements `?1000` implements it — and a
+ * terminal that ignored the SGR request also has no usable drag coordinates past
+ * column 223 (R-2). X10 exists in this parser only so a stray report cannot
+ * reach the user's draft.
+ * ═══════════════════════════════════════════════════════════════════════════
  */
-function decodeWheel(b, x, y, final) {
-    // 1. Not a wheel report at all (press / release / drag) — consume, emit nothing.
-    if ((b & 64) === 0)
-        return null;
-    // 2. Horizontal wheel (66 = left, 67 = right). Consumed and dropped (non-goal).
-    if ((b & 3) >= 2)
-        return null;
-    // 3. Wheel buttons are press-only; a terminal that ever sent a release for one
-    //    must not produce a second step for the same physical notch.
-    if (final !== 'M')
+function decodeReport(b, x, y, final, encoding) {
+    // 1. Wheel. Buttons 64-67 in both encodings.
+    if ((b & 64) !== 0) {
+        // Horizontal wheel (66 = left, 67 = right). Consumed and dropped (non-goal).
+        if ((b & 3) >= 2)
+            return null;
+        // Wheel buttons are press-only; a terminal that ever sent a release for one
+        // must not produce a second step for the same physical notch.
+        if (final !== 'M')
+            return null;
+        return { kind: 'wheel', dir: (b & 1) === 1 ? 'down' : 'up', x, y, ...modifiers(b) };
+    }
+    if (encoding !== 'sgr')
+        return null; // I-11
+    // 2. Motion while a button is held (`?1002h`). `3` is "no button", which
+    //    `?1002` should never send and `?1003` sends constantly — dropping it is
+    //    what keeps an any-event terminal from painting a selection with no button
+    //    down at all.
+    if ((b & 32) !== 0) {
+        const button = b & 3;
+        if (button === 3)
+            return null;
+        return { kind: 'drag', button: button, x, y, ...modifiers(b) };
+    }
+    // 3. Release. In SGR the final byte carries the transition, so this is
+    //    unambiguous — unlike X10, which is why step 1's guard exists.
+    //
+    //    A release whose button field reads `3` is a terminal saying "some button
+    //    came up" without naming it. It is mapped to button 0 rather than dropped:
+    //    the ONE thing a release must always do is let go of `hold`, and dropping
+    //    it would leave the viewport frozen — the exact failure I-11 is about. A
+    //    spurious button-0 release is harmless, because a selection can only exist
+    //    if button 0 was pressed in the first place.
+    if (final === 'm') {
+        const button = b & 3;
+        return { kind: 'release', button: (button === 3 ? 0 : button), x, y, ...modifiers(b) };
+    }
+    // 4. Press.
+    const button = b & 3;
+    if (button === 3)
         return null;
-    return {
-        kind: 'wheel',
-        dir: (b & 1) === 1 ? 'down' : 'up',
-        x,
-        y,
-        shift: (b & 4) !== 0,
-        alt: (b & 8) !== 0,
-        ctrl: (b & 16) !== 0,
-    };
+    return { kind: 'press', button: button, x, y, ...modifiers(b) };
 }
 /**
  * X10 legacy reports (`\x1b[M` + three chars, each `code - 32`).
@@ -84,7 +132,13 @@ function matchX10(s) {
     if (codes.some((c) => c < 32 || c > 255))
         return { kind: 'complete', length: 6, event: null };
     const [b, x, y] = codes;
-    return { kind: 'complete', length: 6, event: decodeWheel(b - 32, x - 32, y - 32, 'M') };
+    return {
+        kind: 'complete',
+        length: 6,
+        // `'x10'` is what makes I-11 a property of the code rather than of somebody's
+        // memory: this encoding yields wheel events or nothing, ever.
+        event: decodeReport(b - 32, x - 32, y - 32, 'M', 'x10'),
+    };
 }
 /** Classify the escape sequence starting at `s[0] === ESC`. */
 function matchReport(s) {
@@ -100,7 +154,7 @@ function matchReport(s) {
             const b = Number(m[1]);
             const x = Number(m[2]);
             const y = Number(m[3]);
-            return { kind: 'complete', length: m[0].length, event: decodeWheel(b, x, y, m[4]) };
+            return { kind: 'complete', length: m[0].length, event: decodeReport(b, x, y, m[4], 'sgr') };
         }
         return SGR_PREFIX.test(s) ? { kind: 'partial' } : { kind: 'none' };
     }
@@ -109,12 +163,17 @@ function matchReport(s) {
     return { kind: 'none' };
 }
 /**
- * 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 function splitMouseEvents(buffer) {
     const events = [];

package/dist/input/stdin-mouse-filter.d.ts

@@ -18,10 +18,15 @@
  * than the bug this feature fixes. `cli.tsx::runInteractive` is the only caller
  * and passes `filter !== null` to `enterAltScreen`.
  */
-import { type WheelEvent } from './mouse-events.js';
+import { type MouseEvent } from './mouse-events.js';
 export interface MouseSource {
-    /** Returns an unsubscribe function. Multiple subscribers are allowed. */
-    subscribe(listener: (event: WheelEvent) => void): () => void;
+    /**
+     * Returns an unsubscribe function. Multiple subscribers are allowed — the
+     * wheel router and (since tui-selection-and-scroll-follow) the selection
+     * controller both take this one channel, and each ignores the kinds it does
+     * not own.
+     */
+    subscribe(listener: (event: MouseEvent) => void): () => void;
 }
 export interface MouseFilter {
     /** Hand this to Ink: `render(<App/>, { stdin: filter.stdin })`. */