@aragon-agent/cli 0.6.7 → 0.6.8

package/dist/cli.js

@@ -45,6 +45,9 @@ import { createFrameDiffer } from './ui/frame-differ.js';
 import { wrapStdoutForFrames } from './ui/stdout-frame-writer.js';
 import { setFrameStatsProvider } from './commands/perf.js';
 import { tryCreateStdinFilter } from './input/stdin-filter.js';
+import { createScrollbarBridge } from './ui/scrollbar-controller.js';
+import { createPointerRouter } from './input/pointer-router.js';
+import { createFrameObserver } from './ui/frame-observer.js';
 import { enterAltScreen, writeExitTranscript } from './ui/screen.js';
 import { supportsWindowsVtInput } from './ui/win-vt-input.js';
 import { forceWindowsVtInput } from './ui/win-vt-force.js';
@@ -476,13 +479,14 @@ function runInteractive(flags, extras = {}) {
     const disposeStdinFilter = () => filter?.dispose();
     // --- Drag-select (tui-selection-and-scroll-follow §4.4). ------------------
     //
-    // ONE EXPRESSION, READ BY FOUR THINGS, and that is the same discipline
-    // `wantMouse` above follows for the same reason: the `?1002h` write, the
-    // controller, the differ's `decorate` hook and the startup notice must never
-    // disagree about whether drag-select is running. With it false the session is
-    // byte-identical to a pre-feature build — no extra escape on the wire (AC-8),
-    // no controller, no `decorate`, no mirror.
+    // Selection owns its controller, decoration and notice. Button motion follows
+    // mouseOn independently so --no-mouse-select still permits scrollbar dragging.
     const wantSelect = mouseOn && config.mouseSelect;
+    let mouseCaptured = mouseOn;
+    const scrollbar = createScrollbarBridge(() => mouseCaptured);
+    const pointerRouter = mouseOn && filter ? createPointerRouter({
+        source: filter.source, handle: (event) => scrollbar.controller?.handle(event) ?? false,
+    }) : null;
     const selectionBridge = {
         controller: null,
         onCopied: null,
@@ -535,7 +539,13 @@ function runInteractive(flags, extras = {}) {
     // than printing zeroes that read like a writer doing nothing (§5.4).
     if (frameWriter)
         setFrameStatsProvider(frameWriter.stats);
+    const frameObserver = mode === 'fullscreen' ? createFrameObserver({
+        stdout: frameWriter?.stdout ?? process.stdout, terminal: process.stdout, scrollbar,
+    }) : null;
     const disposeFrameWriter = () => {
+        frameObserver?.dispose();
+        pointerRouter?.dispose();
+        scrollbar.controller?.dispose();
         if (!frameWriter)
             return;
         setFrameStatsProvider(null);
@@ -574,7 +584,7 @@ function runInteractive(flags, extras = {}) {
         // keep their terminal's own selection.
         screen = enterAltScreen(process.stdout, {
             mouse: mouseOn,
-            motion: wantSelect,
+            motion: mouseOn,
             bracketedPaste: pasteOn && mode === 'fullscreen',
         });
         const restore = () => screen?.restore();
@@ -637,7 +647,7 @@ function runInteractive(flags, extras = {}) {
     // attempted. Naming the mechanism honestly is the entire reason that return
     // value exists (R-7), and a door that lies is worse than no door.
     const writeForeign = frameWriter
-        ? (text) => frameWriter.writeForeign(text)
+        ? (text) => { frameObserver?.invalidate(); frameWriter.writeForeign(text); }
         : process.stdout.isTTY
             ? (text) => {
                 try {
@@ -659,10 +669,9 @@ function runInteractive(flags, extras = {}) {
     // than inside `screen.ts`'s closure because `App` needs to READ it and the
     // handle's own flag is private (it has to be — `restore()` reads it, and
     // exposing a setter would be a second way to get the two out of step).
-    let mouseCaptured = mouseOn;
     if (wantSelect && filter) {
         selectionBridge.controller = createSelectionController({
-            source: filter.source,
+            source: pointerRouter?.selectionSource ?? filter.source,
             // The frame writer is absent under `--no-diff-render`, where there is no
             // cache to repaint from at all; the controller then falls back to asking
             // `App` for a React redraw on every drag flush, which is slower and
@@ -702,11 +711,14 @@ function runInteractive(flags, extras = {}) {
     const terminalBridge = mode === 'fullscreen' || writeForeign
         ? {
             mouseSelect: wantSelect,
+            ...(mode === 'fullscreen' ? { scrollbar } : {}),
             ...(mouseOn
                 ? {
                     setMouseCapture: (on) => {
                         screen?.setMouseCapture(on);
                         mouseCaptured = on;
+                        if (!on)
+                            scrollbar.controller?.cancel();
                         // A released mouse cannot be dragging, and a selection left
                         // painted over a screen the terminal is now selecting on its
                         // own would be two highlights claiming the same rows.
@@ -724,41 +736,67 @@ function runInteractive(flags, extras = {}) {
         : undefined;
     const updateBridge = { service: null, onAttach: null };
     let updateService = null;
+    let interactiveClosed = false;
+    const failInteractive = (error) => {
+        // Ink consumes render exceptions; retain failure even if a disposer throws.
+        process.exitCode = 1;
+        interactiveClosed = true;
+        logger.error('cli', 'render_failed', { error: String(error) });
+        for (const cleanup of [
+            () => screen?.restore(), disposeSelection, disposeStdinFilter, disposeFrameWriter,
+            () => controller.abort(), () => controller.dispose(), () => updateService?.dispose(),
+            () => { process.stdin.pause(); process.stdin.unref?.(); },
+        ]) {
+            try {
+                cleanup();
+            }
+            catch (cleanupError) {
+                logger.error('cli', 'render_cleanup_failed', { error: String(cleanupError) });
+            }
+        }
+    };
     const updateEligible = !!process.stdout.isTTY &&
         !!process.stdin.isTTY &&
         !process.env.CI &&
         config.update.mode !== 'off';
-    const instance = render(_jsx(App, { controller: controller, version: VERSION, mode: mode, confirmBridge: confirmBridge, humanInputBridge: humanInputBridge, initialPrompt: extras.initialPrompt, initialOverlay: extras.initialOverlay, 
-        // `mouseOn`, NOT the handle (I-11). `App.tsx:186-188` documents this
-        // prop's contract as "absent under `--no-mouse`, inline, or non-TTY", and
-        // it feeds `enabled: !!mouseSource` on a wheel subscription that would
-        // otherwise be a channel no event can ever arrive on.
-        mouseSource: mouseOn && filter ? filter.source : undefined, 
-        // Present ONLY when this console swallows `CSI Z` and mouse reports.
-        // Passed in rather than probed inside `App` so that every test renders
-        // the same tree on every machine — reading `process.versions.node` from
-        // a component would make the notice appear or vanish according to which
-        // Node the developer happened to have installed.
-        vtInputWarning: vtInputSupported ? undefined : { nodeVersion: process.versions.node }, updateBridge: updateEligible ? updateBridge : undefined, 
-        // Absent when nothing can refuse a paste, so a `--no-paste` tree is
-        // byte-identical to a build without this feature.
-        pasteBridge: pasteOn ? pasteBridge : undefined, terminal: terminalBridge }), 
-    // Full-screen owns console.* itself (I-4): Ink's patchConsole writes
-    // straight to stdout and permanently shifts the fixed frame's accounting.
-    {
-        exitOnCtrlC: false,
-        patchConsole: mode === 'inline',
-        // I-5: with mouse support off the REAL stdin is handed over unwrapped, so
-        // every existing path is provably unchanged.
-        stdin: filter?.stdin ?? process.stdin,
-        // SPREAD, not `frameWriter?.stdout ?? process.stdout`. This call passed no
-        // `stdout` at all before, and Ink defaults it to `process.stdout`; omitting
-        // the key entirely when the writer is off keeps the options object the same
-        // SHAPE it has always had, which is what makes AC-5 / AC-6 ("byte-identical
-        // with --no-diff-render, inline mode and `aragon -p`") a statement about
-        // the code rather than about Ink's defaulting.
-        ...(frameWriter ? { stdout: frameWriter.stdout } : {}),
-    });
+    let instance;
+    try {
+        instance = render(_jsx(App, { controller: controller, version: VERSION, mode: mode, confirmBridge: confirmBridge, humanInputBridge: humanInputBridge, initialPrompt: extras.initialPrompt, initialOverlay: extras.initialOverlay, 
+            // `mouseOn`, NOT the handle (I-11). `App.tsx:186-188` documents this
+            // prop's contract as "absent under `--no-mouse`, inline, or non-TTY", and
+            // it feeds `enabled: !!mouseSource` on a wheel subscription that would
+            // otherwise be a channel no event can ever arrive on.
+            mouseSource: mouseOn && filter ? filter.source : undefined, 
+            // Present ONLY when this console swallows `CSI Z` and mouse reports.
+            // Passed in rather than probed inside `App` so that every test renders
+            // the same tree on every machine — reading `process.versions.node` from
+            // a component would make the notice appear or vanish according to which
+            // Node the developer happened to have installed.
+            vtInputWarning: vtInputSupported ? undefined : { nodeVersion: process.versions.node }, updateBridge: updateEligible ? updateBridge : undefined, 
+            // Absent when nothing can refuse a paste, so a `--no-paste` tree is
+            // byte-identical to a build without this feature.
+            pasteBridge: pasteOn ? pasteBridge : undefined, terminal: terminalBridge }), 
+        // Full-screen owns console.* itself (I-4): Ink's patchConsole writes
+        // straight to stdout and permanently shifts the fixed frame's accounting.
+        {
+            exitOnCtrlC: false,
+            patchConsole: mode === 'inline',
+            // I-5: with mouse support off the REAL stdin is handed over unwrapped, so
+            // every existing path is provably unchanged.
+            stdin: filter?.stdin ?? process.stdin,
+            // SPREAD, not `frameWriter?.stdout ?? process.stdout`. This call passed no
+            // `stdout` at all before, and Ink defaults it to `process.stdout`; omitting
+            // the key entirely when the writer is off keeps the options object the same
+            // SHAPE it has always had, which is what makes AC-5 / AC-6 ("byte-identical
+            // with --no-diff-render, inline mode and `aragon -p`") a statement about
+            // the code rather than about Ink's defaulting.
+            ...(frameObserver ? { stdout: frameObserver.stdout } : {}),
+        });
+    }
+    catch (error) {
+        failInteractive(error);
+        throw error;
+    }
     // H1's primary disarm, and this is the earliest moment at which "this build
     // STARTS" is proven: the module graph loaded, config resolved, Ink mounted
     // (cli-auto-update-hardening section 5.1.4). It is what makes a long session
@@ -780,6 +818,8 @@ function runInteractive(flags, extras = {}) {
         // must degrade to "no updater", never to a crashed TUI.
         void import('./update/service.js')
             .then(({ UpdateService }) => {
+            if (interactiveClosed)
+                return;
             const service = new UpdateService({ config: config.update, currentVersion: VERSION });
             updateService = service;
             updateBridge.service = service;
@@ -810,6 +850,7 @@ function runInteractive(flags, extras = {}) {
     void instance
         .waitUntilExit()
         .then(() => {
+        interactiveClosed = true;
         screen?.restore();
         // BEFORE `disposeStdinFilter()`, which clears the listener set it subscribed to,
         // and after `restore()` for the reason that call records: the terminal must
@@ -838,18 +879,7 @@ function runInteractive(flags, extras = {}) {
         updateService?.dispose();
         replayTranscript();
     })
-        .catch(() => {
-        screen?.restore();
-        // BEFORE `disposeStdinFilter()`, which clears the listener set it subscribed to,
-        // and after `restore()` for the reason that call records: the terminal must
-        // stop reporting first, and anything already in flight is still consumed by
-        // a live filter.
-        disposeSelection();
-        disposeStdinFilter();
-        disposeFrameWriter();
-        controller.dispose();
-        updateService?.dispose();
-    });
+        .catch(failInteractive);
 }
 async function runOneShot(flags, prompt, quiet) {
     // Headless: no App is ever rendered, so there is no human to approve a skill

package/dist/commands/builtins.js

@@ -724,7 +724,9 @@ const COMMANDS = [
                 // slash history already has. Putting this canned paragraph under the
                 // composer's up-arrow as well would be the same event recorded twice, in
                 // the more verbose of the two forms (AC-17).
-                ctx.submit(buildContinuationMessage(snapshot), { userInitiated: false });
+                ctx.submit(buildContinuationMessage(snapshot), {
+                    userInitiated: false, todoPolicy: 'continue',
+                });
                 return;
             }
             ctx.notify('warn', `Unknown argument "${verb}" - use ` +

package/dist/commands/registry.d.ts

@@ -2,6 +2,7 @@
  * Slash-command registry + dispatcher (spec §5.2). A leading `/` in the prompt
  * input is routed here instead of to the agent; `//` is the literal-`/` escape.
  */
+import type { SubmitMessageOptions } from '../agent/prompt-options.js';
 import type { AgentController } from '../agent/controller.js';
 import type { AgentMode } from '../agent/agent-mode.js';
 import type { NoticeLevel, Overlay, ToastLevel, ViewAction, ViewState } from '../agent/reducer.js';
@@ -38,9 +39,7 @@ export interface CommandContext {
      * (P1-5): `builtins.ts` reaches `submitMessage` only through here, so
      * `/todo continue` cannot opt out of prompt history without it.
      */
-    submit: (text: string, opts?: {
-        userInitiated?: boolean;
-    }) => void;
+    submit: (text: string, opts?: SubmitMessageOptions) => void;
     /**
      * The live auto-continue budget, for `/todo status`'s `(2/25 used)` clause
      * (todo-plan-followthrough §4.3).

package/dist/input/interrupt-gesture.d.ts

@@ -0,0 +1,18 @@
+/** Confirmation window for two independent decoded Escape events. */
+export declare const INTERRUPT_CONFIRM_MS = 1500;
+export type InterruptGestureState = {
+    phase: 'ready';
+} | {
+    phase: 'armed';
+    armedAt: number;
+} | {
+    phase: 'stopping';
+};
+export interface InterruptGestureResult {
+    state: InterruptGestureState;
+    action: 'hint' | 'abort' | 'force-stop';
+}
+/** Advance using a monotonic clock; the caller owns the current run's lifetime. */
+export declare function advanceInterruptGesture(state: InterruptGestureState, now: number): InterruptGestureResult;
+/** Other input cancels confirmation, but cannot undo an already requested stop. */
+export declare function cancelInterruptConfirmation(state: InterruptGestureState): InterruptGestureState;

package/dist/input/interrupt-gesture.js

@@ -0,0 +1,19 @@
+/** Confirmation window for two independent decoded Escape events. */
+export const INTERRUPT_CONFIRM_MS = 1500;
+/** Advance using a monotonic clock; the caller owns the current run's lifetime. */
+export function advanceInterruptGesture(state, now) {
+    if (state.phase === 'stopping') {
+        return { state: { phase: 'ready' }, action: 'force-stop' };
+    }
+    if (state.phase === 'armed') {
+        const elapsed = now - state.armedAt;
+        if (elapsed >= 0 && elapsed <= INTERRUPT_CONFIRM_MS) {
+            return { state: { phase: 'stopping' }, action: 'abort' };
+        }
+    }
+    return { state: { phase: 'armed', armedAt: now }, action: 'hint' };
+}
+/** Other input cancels confirmation, but cannot undo an already requested stop. */
+export function cancelInterruptConfirmation(state) {
+    return state.phase === 'armed' ? { phase: 'ready' } : state;
+}

package/dist/input/pointer-router.d.ts

@@ -0,0 +1,11 @@
+import type { MouseEvent } from './mouse-events.js';
+import type { MouseSource } from './stdin-filter.js';
+export interface PointerRouter {
+    selectionSource: MouseSource;
+    dispose(): void;
+}
+/** Deliver each button gesture to the scrollbar before the selection source. */
+export declare function createPointerRouter(options: {
+    source: MouseSource;
+    handle(event: MouseEvent): boolean;
+}): PointerRouter;

package/dist/input/pointer-router.js

@@ -0,0 +1,14 @@
+/** Deliver each button gesture to the scrollbar before the selection source. */
+export function createPointerRouter(options) {
+    const listeners = new Set();
+    const unsubscribe = options.source.subscribe((event) => {
+        if (event.kind !== 'wheel' && options.handle(event))
+            return;
+        for (const listener of listeners)
+            listener(event);
+    });
+    return { selectionSource: { subscribe: (listener) => {
+                listeners.add(listener);
+                return () => { listeners.delete(listener); };
+            } }, dispose: () => { unsubscribe(); listeners.clear(); } };
+}

package/dist/todo/store.d.ts

@@ -9,15 +9,9 @@
  * is why `AgentController` can own this object as unconditionally as it owns
  * `TeamRuntime`.
  *
- * INVARIANT I-2 — the list is a PROJECTION OF WHAT THE MODEL BELIEVES, and
- * nothing that does not tell the model may change it — EXCEPT AN EXPLICIT USER
- * INSTRUCTION, which is the rule's standing exception and is marked
- * `TodoClearReason = 'user'`. Two commands come through that door: `/todo clear`
- * and `/clear`. Neither tells the model anything, and that is fine, because what
- * they leave behind is "panel absent, model still remembers" - the direction I-9
- * below calls safe, and one the model's next full-replacement write heals on its
- * own. `/reset` (reason `'reset'`) remains the only clear caused by the belief
- * itself being destroyed, because it clears `messages`.
+ * The list projects the current plan. Explicit clear/reset and a new TUI task
+ * may remove that projection while the model still remembers the old plan.
+ * Continuations preserve it; legacy callers retain completion/staleness rules.
  *
  * Every write is a FULL REPLACEMENT and every clear is a FULL REMOVAL - there is
  * no partial update anywhere, which is what makes I-9 ("the panel is never a
@@ -73,11 +67,12 @@ export declare class TodoStore {
      * asymmetry for free, which is the behaviour you want: a steer must not age
      * out the plan it is steering.
      *
-     * A FULLY-COMPLETED LIST IS DROPPED HERE rather than at `agent_end`. Ending
-     * the run is exactly when the user wants to see `7/7 done`; wiping it there
-     * would replace a moment of feedback with a blank column (D-6).
+     * A new TUI task drops the old plan here, while a continuation preserves it.
+     * With no policy, legacy callers retain completed/stale-plan expiration.
+     * Clearing at `agent_end` would erase the final progress before the user can
+     * inspect it and remove the plan that automatic continuation still needs.
      */
-    beginUserTurn(): void;
+    beginUserTurn(policy?: 'new-task' | 'continue'): void;
     /**
      * Report a refusal that never reached `write()` (§3.3 steps 1 and 2).
      *

package/dist/todo/store.js

@@ -9,15 +9,9 @@
  * is why `AgentController` can own this object as unconditionally as it owns
  * `TeamRuntime`.
  *
- * INVARIANT I-2 — the list is a PROJECTION OF WHAT THE MODEL BELIEVES, and
- * nothing that does not tell the model may change it — EXCEPT AN EXPLICIT USER
- * INSTRUCTION, which is the rule's standing exception and is marked
- * `TodoClearReason = 'user'`. Two commands come through that door: `/todo clear`
- * and `/clear`. Neither tells the model anything, and that is fine, because what
- * they leave behind is "panel absent, model still remembers" - the direction I-9
- * below calls safe, and one the model's next full-replacement write heals on its
- * own. `/reset` (reason `'reset'`) remains the only clear caused by the belief
- * itself being destroyed, because it clears `messages`.
+ * The list projects the current plan. Explicit clear/reset and a new TUI task
+ * may remove that projection while the model still remembers the old plan.
+ * Continuations preserve it; legacy callers retain completion/staleness rules.
  *
  * Every write is a FULL REPLACEMENT and every clear is a FULL REMOVAL - there is
  * no partial update anywhere, which is what makes I-9 ("the panel is never a
@@ -137,13 +131,18 @@ export class TodoStore {
      * asymmetry for free, which is the behaviour you want: a steer must not age
      * out the plan it is steering.
      *
-     * A FULLY-COMPLETED LIST IS DROPPED HERE rather than at `agent_end`. Ending
-     * the run is exactly when the user wants to see `7/7 done`; wiping it there
-     * would replace a moment of feedback with a blank column (D-6).
+     * A new TUI task drops the old plan here, while a continuation preserves it.
+     * With no policy, legacy callers retain completed/stale-plan expiration.
+     * Clearing at `agent_end` would erase the final progress before the user can
+     * inspect it and remove the plan that automatic continuation still needs.
      */
-    beginUserTurn() {
-        if (this.items.length === 0)
+    beginUserTurn(policy) {
+        if (this.items.length === 0 || policy === 'continue')
+            return;
+        if (policy === 'new-task') {
+            this.clear('turn');
             return;
+        }
         if (this.items.every((item) => item.status === 'completed')) {
             this.clear('turn');
             return;

package/dist/todo/types.d.ts

@@ -45,7 +45,8 @@ export interface TodoSnapshot {
  *   `user`  - `/todo clear`, or `/clear`. Both are an explicit user instruction,
  *             which is I-2's standing exception; neither touches `messages`.
  *   `reset` - `/reset`, or a `/resume` whose file carried no list (§3.13).
- *   `turn`  - every item was completed when the next user turn started.
+ *   `turn`  - a new TUI task started, or a legacy caller began a turn after
+ *             every item was completed.
  *   `stale` - unfinished, and unwritten for more than `TODO_LIMITS.staleTurns`
  *             consecutive turns (§3.2 / P1-7).
  */

package/dist/ui/App.d.ts

@@ -5,6 +5,7 @@
  * input / toast stack / status bar / overlays.
  */
 import React from 'react';
+import type { ScrollbarBridge } from './scrollbar-controller.js';
 import type { AgentController } from '../agent/controller.js';
 import type { ConfirmRequest } from '../tools/index.js';
 import { type Overlay, type ToastLevel } from '../agent/reducer.js';
@@ -109,6 +110,7 @@ export interface AppProps {
  * mounted. The effect below assigns both and clears them on unmount.
  */
 export interface TerminalBridge {
+    scrollbar?: ScrollbarBridge;
     /** Whether drag-select is on for this session (`mouseSelect` + a filter). */
     mouseSelect: boolean;
     /** Release the mouse to the terminal, or take it back (`/mouse`, G3). */