@aragon-agent/cli 0.6.1 → 0.6.3

package/dist/ui/transcript-text.js

@@ -111,6 +111,29 @@ function renderEntry(entry, glyphs) {
             const detail = entry.detail ? `: ${entry.detail}` : '';
             return [`${head} ${entry.status}${detail}`];
         }
+        case 'compaction': {
+            // A compaction is real spend AND a real, permanent loss of history, and an
+            // exported transcript that omitted it would be unaccountable for both —
+            // the argument the `team`, `retry` and `fast` cases above each make in
+            // their own words. It matters most here: this is the one entry kind whose
+            // presence explains why the messages the reader is looking for are gone.
+            const glyph = entry.applied ? glyphs.compaction : glyphs.toolError;
+            const duration = entry.durationMs === undefined ? '' : ` (${entry.durationMs}ms)`;
+            if (!entry.applied) {
+                const why = entry.reason ? `: ${entry.reason}` : '';
+                return [`${TOOL_INDENT}${glyph} context not compacted #${entry.index}${why}`];
+            }
+            const head = `${TOOL_INDENT}${glyph} context compacted #${entry.index} ` +
+                `${entry.messagesBefore} ${glyphs.arrowRight} ${entry.messagesAfter} messages, ` +
+                `${entry.tokensBefore} ${glyphs.arrowRight} ${entry.tokensAfter} tokens ` +
+                `[${entry.mode}] ${entry.model}${duration}`;
+            if (!entry.summary)
+                return [head];
+            return [
+                head,
+                ...entry.summary.split('\n').map((l) => `${TOOL_INDENT}${CONTINUATION_INDENT}${l}`),
+            ];
+        }
         case 'notice': {
             const glyph = entry.level === 'error'
                 ? glyphs.error

package/dist/ui/use-startup-notices.d.ts

@@ -12,11 +12,39 @@
  * not otherwise see — rather than belonging to the view.
  */
 import type { ViewAction } from '../agent/reducer.js';
+/**
+ * The revision of the mouse notice a user must have seen for it to stay quiet
+ * (`state.json::mouseNoticeVersion`, `0` when absent).
+ *
+ * BUMP IT WHENEVER THE ADVICE CHANGES, never for a rewording that leaves the
+ * recommended actions alone — the same rule `VT_INPUT_NOTICE_VERSION` below
+ * carries, and for the same reason.
+ *
+ * `1` = the first text that names DRAG-SELECT and `/mouse`. `0` = the 0.6.2 text
+ * that taught the Shift bypass, recorded back when this was a boolean.
+ */
+export declare const MOUSE_NOTICE_VERSION = 1;
+/**
+ * The revision of the text below that a user must have seen for this notice to
+ * stay quiet (`state.json::vtInputNoticeVersion`, `0` when absent).
+ *
+ * BUMP IT WHENEVER THE ADVICE CHANGES, and never for a rewording that leaves
+ * the recommended actions alone. The two failure modes sit on either side of
+ * this constant: leaving it alone after changing what the user is told to press
+ * makes the change inert for everyone who already ran the old build — which is
+ * the entire affected population, since the notice only appears on machines
+ * where the key has been broken all along — while dropping the gate altogether
+ * turns a one-shot into a banner on every launch.
+ *
+ * `1` = the first text naming `MODE_TOGGLE_KEYS.fallback`. `0` = the 0.6.1 text
+ * that offered only `/plan`, recorded back when this was a boolean.
+ */
+export declare const VT_INPUT_NOTICE_VERSION = 1;
 /**
  * The `shift-tab-and-mouse-wheel-dead-on-some-terminals` notice (F1'). Shown at
- * most once, ever, and only on a Windows console that cannot deliver either
- * input — see `ui/win-vt-input.ts` for why that is a property of the Node
- * version rather than of the terminal.
+ * most once per `VT_INPUT_NOTICE_VERSION`, and only on a Windows console that
+ * cannot deliver either input — see `ui/win-vt-input.ts` for why that is a
+ * property of the Node version rather than of the terminal.
  *
  * IT NAMES WHAT THE KEY DOES NOW, not merely that it is unavailable, and that
  * is the load-bearing half of the text. `Shift+Tab` on these machines is not
@@ -25,6 +53,16 @@ import type { ViewAction } from '../agent/reducer.js';
  * draft. A user told only "this key does not work" keeps pressing it and keeps
  * losing text without ever connecting the two.
  *
+ * THE FALLBACK KEY COMES BEFORE `/plan` IN BOTH BRANCHES, and it is named from
+ * `MODE_TOGGLE_KEYS` rather than spelled out, so the four consumers of that
+ * constant cannot drift apart. This notice is the last one of them to be wired
+ * up, and it is also the only channel that reaches the affected user without
+ * being asked to: the composer hint does not exist at all in inline mode and is
+ * switched off by a short terminal or `hints: false` in full-screen, and
+ * `/help` has to be typed by someone whose current belief is "the key does
+ * nothing" rather than "I should read the help". Ordering follows cost — one
+ * keystroke before four and a return.
+ *
  * `Shift+Up` / `Shift+Down` is the scroll workaround named here because it is
  * the only one PROVEN to survive: both Node versions emit `\x1b[1;2A` for it,
  * byte for byte, in the probe data. `PgUp` / `PgDn` is expected to work too but
@@ -74,7 +112,21 @@ export interface MouseNoticeOptions {
      * re-deriving either one here would put them back out of step.
      */
     enabled: boolean;
-    /** Record that it was shown (`state.json`). Called once, after dispatch. */
+    /**
+     * Whether DRAG-SELECT is running too, i.e. the resolved `mouseSelect`.
+     *
+     * A SECOND FLAG RATHER THAN AN INFERENCE, for the reason the field above
+     * records about its own two halves: "the mouse is captured" and "dragging
+     * selects text" are not the same claim, and a session that turned drag-select
+     * off must not be handed advice about a mode that is not running.
+     */
+    selectEnabled: boolean;
+    /**
+     * Record that `MOUSE_NOTICE_VERSION` was shown (`state.json`). Called once,
+     * after dispatch — and it must write that constant, not `true`: the gate
+     * compares against it, so a caller storing anything else either replays the
+     * notice forever or silences a future revision of the text.
+     */
     onSeen: () => void;
 }
 export interface VtInputNoticeOptions {
@@ -90,7 +142,12 @@ export interface VtInputNoticeOptions {
      * the renderer disagreeing about which mode is running.
      */
     fullscreen: boolean;
-    /** Record that it was shown (`state.json`). Called once, after dispatch. */
+    /**
+     * Record that `VT_INPUT_NOTICE_VERSION` was shown (`state.json`). Called once,
+     * after dispatch — and it must write that constant, not `true`: the gate
+     * below compares against it, so a caller storing anything else either replays
+     * the notice forever or silences a future revision of the text.
+     */
     onSeen: () => void;
 }
 export declare function useStartupNotices(dispatch: (action: ViewAction) => void, mouseNotice?: MouseNoticeOptions, retainNotice?: RetainNoticeOptions, vtInputNotice?: VtInputNoticeOptions): void;

package/dist/ui/use-startup-notices.js

@@ -12,19 +12,44 @@
  * not otherwise see — rather than belonging to the view.
  */
 import { useEffect, useRef } from 'react';
+import { MODE_TOGGLE_KEYS } from '../agent/agent-mode.js';
 import { readConfigFile } from '../config/store.js';
-import { getMouseNoticeSeen, getVtInputNoticeSeen } from '../config/ui-state.js';
+import { getMouseNoticeVersion, getVtInputNoticeVersion } from '../config/ui-state.js';
 import { getLogger } from '../logging/logger.js';
 /**
- * The §6.1 notice (mouse-wheel-region-routing). Shown at most once, ever.
+ * The revision of the mouse notice a user must have seen for it to stay quiet
+ * (`state.json::mouseNoticeVersion`, `0` when absent).
  *
- * R-3 is the only part of wheel region routing that reaches users who never
- * scroll, and it REMOVES a gesture — drag to select — that is used more often
- * than the one being added. A README is consulted only after the belief
- * "aragon broke copy/paste" has already formed.
+ * BUMP IT WHENEVER THE ADVICE CHANGES, never for a rewording that leaves the
+ * recommended actions alone — the same rule `VT_INPUT_NOTICE_VERSION` below
+ * carries, and for the same reason.
+ *
+ * `1` = the first text that names DRAG-SELECT and `/mouse`. `0` = the 0.6.2 text
+ * that taught the Shift bypass, recorded back when this was a boolean.
  */
-const MOUSE_SELECTION_NOTICE = 'Mouse wheel scrolls the transcript. Hold Shift to select text, ' +
-    'or turn it off with `aragon config set mouse false`.';
+export const MOUSE_NOTICE_VERSION = 1;
+/**
+ * The one-shot mouse notice (tui-selection-and-scroll-follow §5.2 row 29).
+ *
+ * IT NO LONGER TEACHES THE SHIFT WORKAROUND. That text was a workaround told
+ * once, in a line that scrolls away, naming a key that is not portable — Shift
+ * on xterm / VTE / Windows Terminal, Fn on macOS Terminal, a preference
+ * elsewhere — and it collided with our own Shift+wheel binding. The user report
+ * this feature exists for is the evidence that it was not enough (D-1).
+ *
+ * TWO TEXTS, because a `mouseSelect: false` session must not be told about a
+ * gesture that is not running — the same rule the vt-input notice follows below,
+ * and the reason `MouseNoticeOptions` carries the flag rather than this module
+ * re-deriving it.
+ */
+function mouseNoticeText(selectEnabled) {
+    if (!selectEnabled) {
+        return ('Mouse wheel scrolls the transcript. Drag-select is off (mouseSelect); ' +
+            '/mouse off hands the mouse back to your terminal for this session.');
+    }
+    return ('Mouse wheel scrolls the transcript, and dragging selects text - releasing ' +
+        'copies it. /mouse off hands the mouse back to your terminal for this session.');
+}
 /**
  * The §5.1 notice (tui-render-performance). Shown once per run, and only when
  * the user's own `transcriptRetain` was below `transcriptWindow`.
@@ -39,11 +64,27 @@ function retainRaisedNotice(requested, resolved) {
         'so the whole scroll horizon stays reachable. Lower transcriptWindow too if you meant ' +
         'to cap memory.');
 }
+/**
+ * The revision of the text below that a user must have seen for this notice to
+ * stay quiet (`state.json::vtInputNoticeVersion`, `0` when absent).
+ *
+ * BUMP IT WHENEVER THE ADVICE CHANGES, and never for a rewording that leaves
+ * the recommended actions alone. The two failure modes sit on either side of
+ * this constant: leaving it alone after changing what the user is told to press
+ * makes the change inert for everyone who already ran the old build — which is
+ * the entire affected population, since the notice only appears on machines
+ * where the key has been broken all along — while dropping the gate altogether
+ * turns a one-shot into a banner on every launch.
+ *
+ * `1` = the first text naming `MODE_TOGGLE_KEYS.fallback`. `0` = the 0.6.1 text
+ * that offered only `/plan`, recorded back when this was a boolean.
+ */
+export const VT_INPUT_NOTICE_VERSION = 1;
 /**
  * The `shift-tab-and-mouse-wheel-dead-on-some-terminals` notice (F1'). Shown at
- * most once, ever, and only on a Windows console that cannot deliver either
- * input — see `ui/win-vt-input.ts` for why that is a property of the Node
- * version rather than of the terminal.
+ * most once per `VT_INPUT_NOTICE_VERSION`, and only on a Windows console that
+ * cannot deliver either input — see `ui/win-vt-input.ts` for why that is a
+ * property of the Node version rather than of the terminal.
  *
  * IT NAMES WHAT THE KEY DOES NOW, not merely that it is unavailable, and that
  * is the load-bearing half of the text. `Shift+Tab` on these machines is not
@@ -52,6 +93,16 @@ function retainRaisedNotice(requested, resolved) {
  * draft. A user told only "this key does not work" keeps pressing it and keeps
  * losing text without ever connecting the two.
  *
+ * THE FALLBACK KEY COMES BEFORE `/plan` IN BOTH BRANCHES, and it is named from
+ * `MODE_TOGGLE_KEYS` rather than spelled out, so the four consumers of that
+ * constant cannot drift apart. This notice is the last one of them to be wired
+ * up, and it is also the only channel that reaches the affected user without
+ * being asked to: the composer hint does not exist at all in inline mode and is
+ * switched off by a short terminal or `hints: false` in full-screen, and
+ * `/help` has to be typed by someone whose current belief is "the key does
+ * nothing" rather than "I should read the help". Ordering follows cost — one
+ * keystroke before four and a return.
+ *
  * `Shift+Up` / `Shift+Down` is the scroll workaround named here because it is
  * the only one PROVEN to survive: both Node versions emit `\x1b[1;2A` for it,
  * byte for byte, in the probe data. `PgUp` / `PgDn` is expected to work too but
@@ -79,12 +130,13 @@ export function vtInputDeadNotice(nodeVersion, fullscreen) {
     const cause = `Node ${nodeVersion} on Windows does not turn on the console's VT input mode, so `;
     const cost = 'it will not switch mode, and with the / palette or an @ popup open it completes that ' +
         'instead, overwriting your draft. ';
+    const toggle = `Press ${MODE_TOGGLE_KEYS.fallback} to switch mode instead (or /plan)`;
     if (!fullscreen) {
         return (`${cause}Shift+Tab never arrives: it comes through as a PLAIN TAB - ${cost}` +
-            'Use /plan to switch mode instead. Node 22.17.0+ (or 24.2.0+) restores it.');
+            `${toggle}. Node 22.17.0+ (or 24.2.0+) restores it.`);
     }
     return (`${cause}two keys never arrive: the wheel sends nothing at all, and Shift+Tab arrives ` +
-        `as a PLAIN TAB - ${cost}Use /plan to switch mode and Shift+Up / Shift+Down to scroll. ` +
+        `as a PLAIN TAB - ${cost}${toggle}, and Shift+Up / Shift+Down to scroll. ` +
         'Node 22.17.0+ (or 24.2.0+) restores both.');
 }
 export function useStartupNotices(dispatch, mouseNotice, retainNotice, vtInputNotice) {
@@ -114,16 +166,24 @@ export function useStartupNotices(dispatch, mouseNotice, retainNotice, vtInputNo
     const noticeRef = useRef(mouseNotice);
     noticeRef.current = mouseNotice;
     const mouseEnabled = mouseNotice?.enabled ?? false;
+    const mouseSelectEnabled = mouseNotice?.selectEnabled ?? false;
     const mouseNoticeShown = useRef(false);
     useEffect(() => {
         if (!mouseEnabled || mouseNoticeShown.current)
             return;
-        if (getMouseNoticeSeen())
+        // A VERSION, NOT THE OLD BOOLEAN (P1-8 / AC-16). The audience for the
+        // corrected text is exactly the set of users who already have
+        // `mouseNoticeSeen: true` on disk from the text it replaces, so reading that
+        // flag would make this change inert for everyone it is for.
+        //
+        // `>=`, not `!==`: a state file written by a NEWER build (a downgrade, or a
+        // shared home directory) has already told this user everything below.
+        if (getMouseNoticeVersion() >= MOUSE_NOTICE_VERSION)
             return;
         mouseNoticeShown.current = true;
-        dispatch({ type: 'notice', level: 'info', text: MOUSE_SELECTION_NOTICE });
+        dispatch({ type: 'notice', level: 'info', text: mouseNoticeText(mouseSelectEnabled) });
         noticeRef.current?.onSeen();
-    }, [mouseEnabled, dispatch]);
+    }, [mouseEnabled, mouseSelectEnabled, dispatch]);
     // The R-1 notice. `warn`, not `info`: unlike the one above it reports a
     // capability the user was promised and does not have, plus a key that is
     // actively editing their draft.
@@ -132,6 +192,10 @@ export function useStartupNotices(dispatch, mouseNotice, retainNotice, vtInputNo
     // out on the retain effect below — `App` builds that literal during render.
     // Its one-shot key is checked only AFTER the presence test, so a machine that
     // is not affected never touches `state.json` at all.
+    //
+    // `>=`, not `!==`: a state file written by a NEWER build (a downgrade, or a
+    // shared home directory) has already told this user everything the text below
+    // says, so re-showing it would be noise rather than news.
     const vtNoticeRef = useRef(vtInputNotice);
     vtNoticeRef.current = vtInputNotice;
     const vtNodeVersion = vtInputNotice?.nodeVersion;
@@ -140,7 +204,7 @@ export function useStartupNotices(dispatch, mouseNotice, retainNotice, vtInputNo
     useEffect(() => {
         if (vtNodeVersion === undefined || vtNoticeShown.current)
             return;
-        if (getVtInputNoticeSeen())
+        if (getVtInputNoticeVersion() >= VT_INPUT_NOTICE_VERSION)
             return;
         vtNoticeShown.current = true;
         dispatch({

package/dist/ui/use-wheel-routing.js

@@ -84,6 +84,14 @@ export function useWheelRouting(options) {
         }
     }, [flush]);
     const route = useCallback((event) => {
+        // The channel now carries press / drag / release as well
+        // (tui-selection-and-scroll-follow §4.4.2). ONE LINE, AT THE TOP, and the
+        // rest of this module is untouched: widening the single channel rather
+        // than adding a second is what keeps arrival order intact between a wheel
+        // notch and a button, and each subscriber ignoring what it does not own is
+        // the price of that.
+        if (event.kind !== 'wheel')
+            return;
         const current = optionsRef.current;
         const overlay = current.getOverlay();
         // THE OVERLAY BRANCH IS EVALUATED FIRST AND RETURNS FOR EVERY OVERLAY IT

package/dist/ui/win-vt-force.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Turn `ENABLE_VIRTUAL_TERMINAL_INPUT` on for THIS console, from outside Node
+ * (shift-tab-mode-toggle-still-dead-on-windows, C1-M1).
+ *
+ * ASCII ONLY - this tree is inside the glyph scanner's scope.
+ *
+ * `win-vt-input.ts` answers "will this console ever deliver `CSI Z`?". This
+ * module answers "can we MAKE it deliver one?", and the measured answer is yes.
+ * The bit is a property of the console input buffer, not of Node, so any process
+ * attached to the same console can set it - and libuv's pre-22.17 translator
+ * forwards whatever characters the console generates, `ESC` `[` `Z` included.
+ * On Node 20.19.0, in one run, one injected `Shift+Tab` went from `09` to
+ * `1b 5b 5a` the instant an outside process OR-ed `0x0200` in (analysis section
+ * 3.2; raw probe data under `docs/diagnoses/.../repro/`).
+ *
+ * Node ships no FFI, so the outside process is `powershell.exe` calling
+ * `SetConsoleMode` through P/Invoke. Measured cost end to end: 722 ms, roughly
+ * 280 ms of process start plus 300 ms of `Add-Type` compiling C# at run time
+ * (analysis section 3.4). That is the whole price of not adding a native
+ * dependency, and it is paid ONCE, only on an affected Windows console.
+ *
+ * THREE TRAPS ARE ENCODED HERE, all of them measured rather than imagined:
+ *
+ *  1. `windowsHide: true` maps to `CREATE_NO_WINDOW`, which hands the child its
+ *     OWN console. The helper then reads, sets and reports success against a
+ *     console nobody is typing into: exit code 0, `SetConsoleMode` true, log
+ *     clean, and no effect whatsoever - indistinguishable from "the fix was
+ *     never written" (analysis section 3.5). Hence `windowsHide: false`.
+ *  2. The helper must open `CONIN$` with `CreateFileW`, never
+ *     `GetStdHandle(STD_INPUT_HANDLE)`: it is spawned with stdin `ignore`, so
+ *     its standard input is `NUL`. Sharing the real stdin instead is not an
+ *     option - that handle is being reconfigured underneath it.
+ *  3. The `before` mode is the ONLY signal that distinguishes trap 1 from
+ *     success, so the helper reports it and `decideVtForceOutcome` checks it.
+ *     The check is a POSITIVE bitmask ("is this console already in raw mode"),
+ *     not `before !== 0x01F7`: that number is one machine's default and varies
+ *     with QuickEdit, with the host, and with a user who already turned VT input
+ *     on. A magic-number comparison passes silently on the first machine whose
+ *     default happens to differ, which puts trap 1 straight back (review R-3).
+ *
+ * WHAT UNDOES IT: `setRawMode(false)`. libuv rewrites the whole console mode on
+ * every raw-mode transition and its pre-22.17 path does not know about this bit,
+ * so one transition clears it (analysis section 3.3). That is why the caller
+ * must raise raw mode BEFORE calling this, and it is also the entire restore
+ * path - the bit outlives the process otherwise, and neither Windows nor the
+ * console clears it (analysis section 3.5b).
+ *
+ * FAILURE IS ALWAYS GRACEFUL. Constrained Language Mode disables `Add-Type`
+ * outright, and enterprise fleets ship it by policy - exactly the "another PC"
+ * population this bug is about. Every failure returns `ok: false` with a reason
+ * for the log and nothing else happens; the alternate mode-toggle key
+ * (`MODE_TOGGLE_KEYS.fallback`) is the rung below that needs none of this.
+ */
+/** Console input mode bits (`consoleapi.h`). */
+export declare const ENABLE_PROCESSED_INPUT = 1;
+export declare const ENABLE_LINE_INPUT = 2;
+export declare const ENABLE_ECHO_INPUT = 4;
+export declare const ENABLE_WINDOW_INPUT = 8;
+export declare const ENABLE_VIRTUAL_TERMINAL_INPUT = 512;
+/**
+ * The three bits a cooked console has and a raw one does not.
+ *
+ * This is the fingerprint of "libuv has already put this console in raw mode",
+ * and it is what tells the two measured samples apart: `0x0008` (the CLI's own
+ * console, raw) versus `0x01F7` (a fresh `CREATE_NO_WINDOW` console, cooked).
+ */
+export declare const COOKED_INPUT_BITS: number;
+export declare function isRawConsoleMode(mode: number): boolean;
+export type VtForceFailure = 'not_windows' | 'spawn_failed' | 'helper_failed' | 'no_before' | 'wrong_console' | 'bit_not_set';
+export interface VtForceResult {
+    ok: boolean;
+    /** Absent on success; a stable machine token on failure, for the log. */
+    reason?: VtForceFailure;
+    before?: number;
+    after?: number;
+    /** Free-form context for the log line. Never shown to the user. */
+    detail?: string;
+}
+/**
+ * The PowerShell side, as a string.
+ *
+ * A LITERAL HERE-STRING (`@'` ... `'@`) around the C# so PowerShell expands
+ * nothing inside it, and `'CONIN$'` in single quotes for the same reason - the
+ * `$` is part of the device name, not a variable.
+ *
+ * Shipped inline rather than as a `.ps1` next to the build output, and that is a
+ * capability difference rather than tidiness: ExecutionPolicy blocks script
+ * FILES and does not apply to `-EncodedCommand`, so a locked-down machine - the
+ * population this bug keeps landing on - can still run it. It also removes the
+ * "where did my file go after packaging" class of failure entirely.
+ */
+export declare function buildHelperScript(): string;
+/** `-EncodedCommand` takes base64 of UTF-16LE, which needs no shell quoting. */
+export declare function encodePowerShellCommand(script: string): string;
+/**
+ * Prefer the absolute path so a sanitized or hijacked `PATH` cannot decide what
+ * runs; fall back to the bare name, which is still better than not trying.
+ */
+export declare function resolvePowerShellExe(env?: NodeJS.ProcessEnv): string;
+/** Pull `before=` / `after=` back out of the helper's stdout. */
+export declare function parseConsoleModes(stdout: string): {
+    before?: number;
+    after?: number;
+};
+/**
+ * PURE, and the reason this feature is testable without a Windows box: every
+ * interesting outcome - including the `0x01F7` wrong-console trap that returns
+ * exit code 0 - is decided here from two strings and a number.
+ */
+export declare function decideVtForceOutcome(run: {
+    status: number | null;
+    stdout: string;
+    stderr?: string;
+}): VtForceResult;
+export interface VtForceOptions {
+    platform?: string;
+    timeoutMs?: number;
+    /** Injected by the tests; defaults to a real `spawnSync`. */
+    run?: (exe: string, args: string[]) => {
+        status: number | null;
+        stdout: string;
+        stderr: string;
+    };
+}
+/**
+ * Set the bit on the console this process is attached to.
+ *
+ * SYNCHRONOUS on purpose. The caller has to know the answer before it decides
+ * whether the mouse can report and whether to warn the user, and at the one
+ * moment this runs - after raw mode is up, before Ink renders - there is nothing
+ * else for the event loop to do. An async version would buy nothing and would
+ * spread the ordering across two files.
+ *
+ * NEVER THROWS.
+ */
+export declare function forceWindowsVtInput(opts?: VtForceOptions): VtForceResult;