@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/use-render-governor.d.ts

@@ -1,39 +0,0 @@
-/**
- * Commit-cost timing for the render governor (tui-render-performance L4).
- *
- * `performance.now()` is taken at the TOP of the `App` render body (this hook
- * must therefore be called early, before any other work) and again in a layout
- * effect. Ink computes yoga layout in `onRender`, which React runs BEFORE layout
- * effects, so that span covers React reconciliation AND the Ink layout pass —
- * the same mechanism `ScrollViewport.tsx:87-88` and `AppShell.tsx:100-102`
- * already document and rely on.
- *
- * ONLY THE RUNG IS REACT STATE. The measured cost and the resolved interval live
- * in refs: putting a millisecond count in state would re-render the whole tree
- * on every frame to record how expensive rendering the whole tree was.
- */
-export interface RenderGovernorOptions {
-    /** `false` pins rung 0 forever (`--no-render-governor`, `ARAGON_RENDER_GOVERNOR=0`). */
-    enabled: boolean;
-    /** Ceiling of the ladder; `33` flattens it. */
-    maxIntervalMs: number;
-}
-export interface RenderGovernorHandle {
-    /**
-     * The coalescing interval to arm the next flush timer with.
-     *
-     * A REF, read at `setTimeout` time. The coalescer's callbacks are `useCallback`d
-     * with stable deps and must stay that way (the controller subscription effect
-     * never re-runs), so a plain value would be pinned to the mount render.
-     */
-    intervalMs: {
-        current: number;
-    };
-    /** Rendered as the `eco` chip when > 0 (I-L4-2). */
-    rung: number;
-    /** Most recent commit cost in ms, for `/perf`. Not state. */
-    lastCommitMs: () => number;
-    /** `/perf reset` — back to rung 0. */
-    reset: () => void;
-}
-export declare function useRenderGovernor(opts: RenderGovernorOptions): RenderGovernorHandle;

package/dist/ui/use-render-governor.js

@@ -1,57 +0,0 @@
-/**
- * Commit-cost timing for the render governor (tui-render-performance L4).
- *
- * `performance.now()` is taken at the TOP of the `App` render body (this hook
- * must therefore be called early, before any other work) and again in a layout
- * effect. Ink computes yoga layout in `onRender`, which React runs BEFORE layout
- * effects, so that span covers React reconciliation AND the Ink layout pass —
- * the same mechanism `ScrollViewport.tsx:87-88` and `AppShell.tsx:100-102`
- * already document and rely on.
- *
- * ONLY THE RUNG IS REACT STATE. The measured cost and the resolved interval live
- * in refs: putting a millisecond count in state would re-render the whole tree
- * on every frame to record how expensive rendering the whole tree was.
- */
-import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
-import { performance } from 'node:perf_hooks';
-import { GOVERNOR_LADDER, initialGovernor, intervalOf, stepGovernor, } from './render-governor.js';
-export function useRenderGovernor(opts) {
-    const { enabled, maxIntervalMs } = opts;
-    const stateRef = useRef(initialGovernor());
-    const intervalMs = useRef(GOVERNOR_LADDER[0]);
-    const lastCommit = useRef(0);
-    const startedAt = useRef(0);
-    const mounted = useRef(true);
-    const [rung, setRung] = useState(0);
-    // Stamped during render, which is the whole point of calling this hook first.
-    startedAt.current = performance.now();
-    useEffect(() => () => {
-        mounted.current = false;
-    }, []);
-    useLayoutEffect(() => {
-        const cost = performance.now() - startedAt.current;
-        lastCommit.current = cost;
-        if (!enabled) {
-            stateRef.current = initialGovernor();
-            intervalMs.current = Math.min(maxIntervalMs, GOVERNOR_LADDER[0]);
-            if (rung !== 0)
-                setRung(0);
-            return;
-        }
-        const next = stepGovernor(stateRef.current, cost, maxIntervalMs);
-        stateRef.current = next;
-        intervalMs.current = intervalOf(next, maxIntervalMs);
-        // React bails out when the value is unchanged, so this is a no-op on every
-        // frame that did not move the ladder — which is almost all of them.
-        if (mounted.current && next.rung !== rung)
-            setRung(next.rung);
-    });
-    const reset = useCallback(() => {
-        stateRef.current = initialGovernor();
-        intervalMs.current = Math.min(maxIntervalMs, GOVERNOR_LADDER[0]);
-        if (mounted.current)
-            setRung(0);
-    }, [maxIntervalMs]);
-    const lastCommitMs = useCallback(() => lastCommit.current, []);
-    return { intervalMs, rung, lastCommitMs, reset };
-}

package/dist/ui/use-wheel-routing.d.ts

@@ -1,57 +0,0 @@
-/**
- * Wheel routing (wheel-scrolls-transcript-only §4.1).
- *
- * Subscribes to the mouse source and dispatches every notch to THE ONE
- * SCROLLABLE REGION ON SCREEN — the transcript, or the controlled overlay
- * covering it. Lives outside `App.tsx` because the routing table is the most
- * testable part of this feature and a table wants to be readable on its own,
- * away from a large component (D-13).
- *
- * THE POINTER ROW IS NOT CONSULTED, and that is the requirement rather than a
- * simplification (§1). A wheel notch is a VIEWPORT gesture: the pointer in a
- * TUI rests wherever the user last left it — in a chat-shaped app, next to the
- * thing they type into — so routing by row meant the ordinary "scroll back to
- * see what the agent just did" gesture landed on the composer and replaced the
- * draft with an old prompt. Prompt history belongs to `↑` / `↓` alone (G1 / G3),
- * which is the contract Claude Code, Codex and every full-screen terminal app
- * the user brings muscle memory from already follow.
- *
- * Every notch is coalesced into one intent carrying `repeat`, no matter how fast
- * the wheel spins: one gesture, one `setState`, one render.
- */
-import type { Overlay } from '../agent/reducer.js';
-import type { MouseSource } from '../input/stdin-filter.js';
-import type { ScrollIntent } from './layout/scroll.js';
-export interface WheelRoutingOptions {
-    isPointerCaptured?: () => boolean;
-    isActive?: () => boolean;
-    /** Absent when mouse support is off, or on a non-TTY. */
-    mouseSource?: MouseSource;
-    /** Read at EVENT time for the routing branch, and again at FLUSH time (P1-3). */
-    getOverlay: () => Overlay | null;
-    onScroll: (kind: ScrollIntent, repeat: number) => void;
-    /** Signed row delta; the caller clamps at 0 the way the keyboard branch does. */
-    onOverlayScroll: (delta: number) => void;
-    /**
-     * Rows one Shift+wheel notch turns inside a controlled overlay (defect 11).
-     *
-     * A GETTER, read at event time for the same reason `getOverlay` is: the window
-     * height changes with the terminal, with `statusExpanded` and with the rail, and
-     * a value captured when the subscription was built is the value that goes stale.
-     * `App` answers with `overlayPageSize(...)`, the same function its keyboard
-     * branch uses, so the wheel and `PgDn` can never disagree.
-     */
-    getOverlayPage?: () => number;
-}
-export interface WheelRouting {
-    /**
-     * Drop any accumulated-but-unflushed transcript scroll.
-     *
-     * Called by `App` from its existing `state.overlay` effect rather than from a
-     * second subscriber to the same transition. This is guard #2 of the pair that
-     * has to ship together (§14 condition 3); guard #1 is the overlay re-check
-     * inside the flush, and guard #3 is `ScrollViewport`'s I-9 mount-skip.
-     */
-    clearCoalescer: () => void;
-}
-export declare function useWheelRouting(options: WheelRoutingOptions): WheelRouting;

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

@@ -1,152 +0,0 @@
-/**
- * Wheel routing (wheel-scrolls-transcript-only §4.1).
- *
- * Subscribes to the mouse source and dispatches every notch to THE ONE
- * SCROLLABLE REGION ON SCREEN — the transcript, or the controlled overlay
- * covering it. Lives outside `App.tsx` because the routing table is the most
- * testable part of this feature and a table wants to be readable on its own,
- * away from a large component (D-13).
- *
- * THE POINTER ROW IS NOT CONSULTED, and that is the requirement rather than a
- * simplification (§1). A wheel notch is a VIEWPORT gesture: the pointer in a
- * TUI rests wherever the user last left it — in a chat-shaped app, next to the
- * thing they type into — so routing by row meant the ordinary "scroll back to
- * see what the agent just did" gesture landed on the composer and replaced the
- * draft with an old prompt. Prompt history belongs to `↑` / `↓` alone (G1 / G3),
- * which is the contract Claude Code, Codex and every full-screen terminal app
- * the user brings muscle memory from already follow.
- *
- * Every notch is coalesced into one intent carrying `repeat`, no matter how fast
- * the wheel spins: one gesture, one `setState`, one render.
- */
-import { useCallback, useEffect, useRef } from 'react';
-/**
- * Page rows used ONLY when the host supplies no `getOverlayPage`.
- *
- * `App` always supplies one (defect 11): the step is the overlay's visible window
- * minus two rows of context, so `PgDn` in `/help` turns a page instead of 42% of
- * one. This fallback exists so a host that owns no overlay window - this module's
- * own routing tests are the only such host - still gets a page rather than
- * silently degrading a Shift+wheel to a three-row notch.
- */
-const FALLBACK_OVERLAY_PAGE = 8;
-/** Transcript rows per notch. The terminal's own convention. */
-const CONTENT_LINES_PER_NOTCH = 3;
-/** Overlay rows per notch. Overlay content is short; a page needs Shift. */
-const OVERLAY_LINES_PER_NOTCH = 3;
-/**
- * Coalescing window for transcript scrolling — one `setState`, one render, no
- * matter how fast the wheel spins (R-10). Deliberately tighter than the 33 ms
- * streaming coalescer: this one is in the direct path of a hand gesture.
- */
-const WHEEL_COALESCE_MS = 16;
-export function useWheelRouting(options) {
-    // Every mutable input reaches the subscription through this ref, so the
-    // effect below subscribes exactly once per `mouseSource` instead of tearing
-    // the listener down and rebuilding it on every parent render.
-    const optionsRef = useRef(options);
-    optionsRef.current = options;
-    const accumulator = useRef(null);
-    const timer = useRef(null);
-    const clearCoalescer = useCallback(() => {
-        if (timer.current) {
-            clearTimeout(timer.current);
-            timer.current = null;
-        }
-        accumulator.current = null;
-    }, []);
-    const flush = useCallback(() => {
-        if (timer.current) {
-            clearTimeout(timer.current);
-            timer.current = null;
-        }
-        const pending = accumulator.current;
-        accumulator.current = null;
-        if (!pending)
-            return;
-        if (optionsRef.current.isPointerCaptured?.() || optionsRef.current.isActive?.() === false)
-            return;
-        // P1-3: THE DECISION BELONGS AT FLUSH TIME, not at event time, because the
-        // event-time decision is the one that goes stale. `App` swaps
-        // `ScrollViewport` out for an overlay, and 16 ms is more than wide enough
-        // for an agent-raised `confirm` or an `ask_user` to land inside the window
-        // — the intent would then be applied on a component that is not there, and
-        // the transcript would jump by itself when the overlay closed.
-        if (optionsRef.current.getOverlay())
-            return;
-        optionsRef.current.onScroll(pending.kind, pending.repeat);
-    }, []);
-    const accumulate = useCallback((kind, repeat) => {
-        // A fast up-then-down must never cancel itself into a no-op, so a change
-        // of direction (or of granularity) flushes what is already held.
-        if (accumulator.current && accumulator.current.kind !== kind)
-            flush();
-        const held = accumulator.current;
-        accumulator.current = { kind, repeat: (held?.repeat ?? 0) + repeat };
-        if (!timer.current) {
-            timer.current = setTimeout(flush, WHEEL_COALESCE_MS);
-            timer.current.unref?.();
-        }
-    }, [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;
-        if (current.isPointerCaptured?.() || current.isActive?.() === false) {
-            clearCoalescer();
-            return;
-        }
-        const overlay = current.getOverlay();
-        // THE OVERLAY BRANCH IS EVALUATED FIRST AND RETURNS FOR EVERY OVERLAY IT
-        // RECOGNIZES — the same two ordering rules the keyboard handler follows,
-        // and for the same reason (R-P1-7).
-        if (overlay) {
-            // Modes A only. `model` / `confirm` / `question` own their own keys and
-            // scrolling them would leave an inconsistent cursor (R-11).
-            const controlled = overlay === 'help' || overlay === 'settings' || overlay === 'plan'
-                || overlay === 'queue' || overlay === 'kit'
-                // The prompt surfaces (quick-prompt-library appendix B-2). Missing this line
-                // makes the wheel fall through to the transcript BEHIND an open overlay,
-                // which reads as a frozen list and a jumping transcript at the same time.
-                || overlay === 'prompts' || overlay === 'prompt-pick'
-                // The Agents board (tui-subagent-panel §6.5). Missing this line makes the
-                // wheel fall through to the transcript BEHIND the open board, which reads
-                // as a frozen list and a jumping transcript at the same time.
-                || overlay === 'agents'
-                // The governance board pages through `overlayScroll` too (governance-mode 10.5).
-                || overlay === 'governance';
-            if (!controlled)
-                return;
-            // D-3: the row is not consulted here either. Behind an overlay the
-            // composer is inactive and the overlay is the only scrollable thing on
-            // screen, so a notch anywhere scrolls it.
-            const step = event.shift
-                ? current.getOverlayPage?.() ?? FALLBACK_OVERLAY_PAGE
-                : OVERLAY_LINES_PER_NOTCH;
-            current.onOverlayScroll(event.dir === 'up' ? -step : step);
-            return;
-        }
-        if (event.shift) {
-            accumulate(event.dir === 'up' ? 'pageUp' : 'pageDown', 1);
-            return;
-        }
-        accumulate(event.dir === 'up' ? 'lineUp' : 'lineDown', CONTENT_LINES_PER_NOTCH);
-    }, [accumulate]);
-    const { mouseSource } = options;
-    useEffect(() => {
-        if (!mouseSource)
-            return undefined;
-        const unsubscribe = mouseSource.subscribe(route);
-        return () => {
-            unsubscribe();
-            clearCoalescer();
-        };
-    }, [mouseSource, route, clearCoalescer]);
-    return { clearCoalescer };
-}

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

@@ -1,136 +0,0 @@
-/**
- * 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;