@aragon-agent/cli 0.6.8 → 0.6.10

package/dist/input/enter-sequences.js

@@ -0,0 +1,151 @@
+/**
+ * Enter-family sequence recognition (tui-shift-enter-copy-queue §3.3) -- pure,
+ * stream-free, no node/React imports, callable from any test environment.
+ *
+ * WHY THIS LIVES BELOW INK. Ink 5's `parse-keypress.js` calls `parseKeypress`
+ * ONCE per stdin chunk and hard-codes `shift: false` for the exact string
+ * `'\r'`, so a component can never see `key.return && key.shift` -- the
+ * `PromptInput` branch for it is dead code. Worse, terminals that DO encode a
+ * distinct Shift+Enter send CSI-u (`\x1b[13;2u`), which Ink's `fnKeyRe` does
+ * not match: the ESC is stripped by `use-input.js` and `'[13;2u'` falls through
+ * to the PRINTABLE branch, typing garbage into the draft. The only layer that
+ * sees the bytes before Ink mangles them is the stdin filter, which is where
+ * the mouse-report and paste-marker dialects are already translated.
+ *
+ * THE CONTRACT: rewrite every recognized sequence to ONE normalized token --
+ * `ENTER_NEWLINE_FRAME` for "this was a modified Enter, the user wants a
+ * newline" and `'\r'` for the unmodified CSI-u Enter some other program left
+ * behind. No state, no partial-output: `rewriteEnterSequences` is idempotent
+ * because its output contains none of its inputs.
+ */
+import { ENTER_NEWLINE_FRAME } from './limits.js';
+/**
+ * The recognition table (§3.3). CSI-u modifiers 2-8 cover Shift(2), Alt(3),
+ * Shift+Alt(4), Ctrl(5), Ctrl+Shift(6), Ctrl+Alt(7), Ctrl+Alt+Shift(8) as
+ * emitted by kitty/WezTerm keyboard-enhancement mode and by
+ * `modifyOtherKeys=2`; every one of them means "Enter with a modifier", and a
+ * modified Enter must NEVER submit the draft. `\x1b\r` / `\x1b\n` are the
+ * classic Alt+Enter encodings. `\x1b[13u` (no modifier field) is what a
+ * leftover kitty mode sends for a PLAIN Enter: it must submit, so it maps to
+ * `'\r'` rather than to a newline.
+ */
+export const ENTER_SEQUENCES = [
+    {
+        seq: '\x1b[13;2u',
+        meaning: 'shift+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;3u',
+        meaning: 'alt+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;4u',
+        meaning: 'shift+alt+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;5u',
+        meaning: 'ctrl+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;6u',
+        meaning: 'ctrl+shift+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;7u',
+        meaning: 'ctrl+alt+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13;8u',
+        meaning: 'ctrl+alt+shift+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b\r',
+        meaning: 'alt+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b\n',
+        meaning: 'alt+enter',
+        to: ENTER_NEWLINE_FRAME,
+    },
+    {
+        seq: '\x1b[13u',
+        meaning: 'enter',
+        to: '\r',
+    },
+];
+/**
+ * Longest strict prefix any recognized sequence can have. Derived from the
+ * table rather than hard-coded so adding a sequence can never leave the hold
+ * ceiling behind: the longest sequence is 7 bytes, so a torn sequence can hold
+ * up to 6 of them.
+ */
+const MAX_ENTER_PREFIX = Math.max(...ENTER_SEQUENCES.map((s) => s.seq.length)) - 1;
+/** `\x1b[13;2u` .. `\x1b[13;8u`, or `\x1b[13u` when the modifier is absent. */
+const CSI_U_ENTER = /\x1b\[13(?:;[2-8])?u/g;
+/**
+ * Rewrite every recognized Enter-family sequence to its normalized token.
+ *
+ * ONE ANCHORED REGEX, not a per-sequence scan and not a state machine: the
+ * CSI-u family shares one shape and the two literal Alt+Enter encodings cannot
+ * nest inside it, so a single left-to-right pass is unambiguous. `\x1b[13;9u`
+ * and other unknown modifiers are deliberately left untouched -- rewriting an
+ * unrecognized sequence would be guessing at a terminal dialect we have not
+ * seen.
+ */
+export function rewriteEnterSequences(text) {
+    if (!text.includes('\x1b'))
+        return text;
+    // ONE PASS, TWO TARGETS: a MODIFIED Enter is a newline intent, while the
+    // modifier-less CSI-u Enter a leftover kitty mode emits is a PLAIN Enter
+    // and must still submit (`\r`). The `;` is the discriminator the table
+    // above records in each entry's `to` field.
+    let out = text.replace(CSI_U_ENTER, (seq) => (seq.includes(';') ? ENTER_NEWLINE_FRAME : '\r'));
+    // Only the two literal Alt+Enter encodings remain. `\x1b\n` is checked
+    // before `\x1b\r` is replaced; they share no bytes, so order is free, but
+    // splitting the escapes keeps each replacement self-evident.
+    if (out.includes('\x1b\n'))
+        out = out.split('\x1b\n').join(ENTER_NEWLINE_FRAME);
+    if (out.includes('\x1b\r'))
+        out = out.split('\x1b\r').join(ENTER_NEWLINE_FRAME);
+    return out;
+}
+/** True when `s` is a PROPER prefix of some recognized sequence (never whole). */
+function isEnterPrefix(s) {
+    if (s.length === 0 || s.length > MAX_ENTER_PREFIX)
+        return false;
+    for (const spec of ENTER_SEQUENCES) {
+        // `length >`, not `startsWith` alone: `startsWith` accepts the WHOLE
+        // sequence too, and holding a complete sequence back would add 12 ms
+        // of latency to a key that is ready to be rewritten right now.
+        if (spec.seq.length > s.length && spec.seq.startsWith(s))
+            return true;
+    }
+    return false;
+}
+/**
+ * Length of the trailing run of `text` that is a proper prefix of an
+ * Enter-family sequence, or 0.
+ *
+ * LONGEST MATCH, not shortest: unlike the mouse and paste families, a torn
+ * CSI-u sequence diverges from its siblings only at the LAST byte
+ * (`\x1b[13;` + `2u`), so every byte before the divergence point must be held
+ * back for the next chunk or the sequence is destroyed a byte early. Feeding
+ * the result into the filter's `keep = max(...)` alongside the other two
+ * families keeps every family's hold intact.
+ */
+export function trailingEnterPrefixLength(text) {
+    const max = Math.min(text.length, MAX_ENTER_PREFIX);
+    for (let k = max; k >= 1; k -= 1) {
+        if (isEnterPrefix(text.slice(text.length - k)))
+            return k;
+    }
+    return 0;
+}

package/dist/input/limits.d.ts

@@ -53,6 +53,17 @@ export declare const PASTE_ASSEMBLY_MAX_MS = 2000;
  */
 export declare const PASTE_OPEN = "\0[";
 export declare const PASTE_CLOSE = "\0]";
+/**
+ * The inline frame that carries ONE newline intent from the stdin filter to the
+ * composer (tui-shift-enter-copy-queue 3.2).
+ *
+ * SAME FAMILY AS `PASTE_OPEN`, with the same guarantee and for the same reason:
+ * NUL is the delimiter because no terminal delivers it for any key, and because
+ * `sanitisePaste` strips every NUL out of every payload -- so pasted text can
+ * never forge this frame either. A newline intent is single, atomic and carries
+ * no payload, so one constant replaces the OPEN/CLOSE pair.
+ */
+export declare const ENTER_NEWLINE_FRAME = "\0n";
 /**
  * The one channel from the stdin filter to `App`'s notice dispatch (P1-3 / I-15).
  *

package/dist/input/limits.js

@@ -53,6 +53,17 @@ export const PASTE_ASSEMBLY_MAX_MS = 2_000;
  */
 export const PASTE_OPEN = '\u0000[';
 export const PASTE_CLOSE = '\u0000]';
+/**
+ * The inline frame that carries ONE newline intent from the stdin filter to the
+ * composer (tui-shift-enter-copy-queue 3.2).
+ *
+ * SAME FAMILY AS `PASTE_OPEN`, with the same guarantee and for the same reason:
+ * NUL is the delimiter because no terminal delivers it for any key, and because
+ * `sanitisePaste` strips every NUL out of every payload -- so pasted text can
+ * never forge this frame either. A newline intent is single, atomic and carries
+ * no payload, so one constant replaces the OPEN/CLOSE pair.
+ */
+export const ENTER_NEWLINE_FRAME = '\u0000n';
 /** Human-readable byte size for the refusal toast (`4.1 MB`, `812.0 KB`, `7 B`). */
 export function formatPasteSize(bytes) {
     if (bytes >= 1024 * 1024)

package/dist/input/stdin-filter.js

@@ -35,6 +35,7 @@ import { PassThrough } from 'node:stream';
 import { MAX_PENDING_MOUSE_CHARS, splitMouseEvents, isMousePrefix, } from './mouse-events.js';
 import { PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
 import { PASTE_BEGIN_MARK, PASTE_END_MARK, classifyChunk, sanitisePaste, trailingPastePrefixLength, } from './paste-parse.js';
+import { rewriteEnterSequences, trailingEnterPrefixLength } from './enter-sequences.js';
 /**
  * How long a possible-prefix tail is held before being flushed as text.
  *
@@ -192,6 +193,17 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     const handleOutsidePaste = (text, holdTail) => {
         if (text.length === 0)
             return;
+        // ENTER-FAMILY REWRITE, AND IT IS FIRST FOR A REASON
+        // (tui-shift-enter-copy-queue 3.4). The Alt+Enter encoding contains a CR,
+        // and `classifyChunk`'s primary rule -- "longer than one character AND
+        // contains a line break" -- would buffer that two-byte key as a Tier 2
+        // paste body whose sanitiser then strips the ESC, silently swallowing the
+        // keystroke. After the rewrite the frame is NUL-led and classifies as
+        // `keys` under both rules. The cost is that an UNBRACKETED paste whose
+        // body happens to contain the literal Alt+Enter bytes loses that one
+        // pair's newline; a bracketed body never reaches this function at all
+        // (I-3), and losing two bytes of a heuristic tier beats eating the key.
+        text = rewriteEnterSequences(text);
         if (paste.kind === 'burst') {
             paste = { kind: 'burst', body: paste.body + text, bytes: paste.bytes + byteLength(text) };
             burstTimer = clearTimer(burstTimer);
@@ -266,7 +278,13 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             const strayEnd = rest.indexOf(PASTE_END_MARK);
             const first = begin === -1 ? strayEnd : strayEnd === -1 ? begin : Math.min(begin, strayEnd);
             if (first === -1) {
-                const keep = Math.max(trailingPastePrefixLength(rest), features.mouse ? trailingMousePrefixLength(rest) : 0);
+                // THIRD PREFIX FAMILY: a torn CSI-u Enter sequence
+                // (tui-shift-enter-copy-queue 3.4). `keep = max(...)` holds the longest
+                // tail any family might still complete; the three families share only
+                // the ESC / ESC-[ head bytes, which the max keeps for whoever needs
+                // them. The existing 12 ms flush and the 32-char ceiling bound the
+                // hold, so no new timer is needed.
+                const keep = Math.max(trailingPastePrefixLength(rest), features.mouse ? trailingMousePrefixLength(rest) : 0, trailingEnterPrefixLength(rest));
                 const tail = rest.slice(rest.length - keep);
                 handleOutsidePaste(rest.slice(0, rest.length - keep), true);
                 pending += tail;

package/dist/logging/install.d.ts

@@ -25,7 +25,7 @@
  *       Adding a listener suppresses it, turning a crash into a silent hang.
  *
  *   `SIGINT` / `SIGTERM` / `SIGHUP` — the handlers in `runInteractive()` exist
- *       ONLY in its full-screen branch, so inline mode, `-p`, and every
+ *       ONLY in its full-screen branch, so `-p` and every
  *       subcommand had no handler at all and took Node's default termination,
  *       which does not run `'exit'` listeners: the whole queue was lost. But a
  *       signal listener registered here runs BEFORE the one `runInteractive`
@@ -45,7 +45,7 @@ import { Logger, type LogScope } from './logger.js';
 export declare function setScreenRestore(fn: () => void): void;
 /**
  * Replace what a signal does after the flush. The default (a bare
- * `exit(128 + signo)`) is correct for headless, inline and every subcommand;
+ * `exit(128 + signo)`) is correct for headless and every subcommand;
  * full-screen substitutes one that restores the terminal first.
  *
  * A TERMINATOR MAY NOW RETURN WITHOUT EXITING, AND THAT IS A CONTRACT CHANGE

package/dist/logging/install.js

@@ -25,7 +25,7 @@
  *       Adding a listener suppresses it, turning a crash into a silent hang.
  *
  *   `SIGINT` / `SIGTERM` / `SIGHUP` — the handlers in `runInteractive()` exist
- *       ONLY in its full-screen branch, so inline mode, `-p`, and every
+ *       ONLY in its full-screen branch, so `-p` and every
  *       subcommand had no handler at all and took Node's default termination,
  *       which does not run `'exit'` listeners: the whole queue was lost. But a
  *       signal listener registered here runs BEFORE the one `runInteractive`
@@ -63,7 +63,7 @@ export function setScreenRestore(fn) {
 }
 /**
  * Replace what a signal does after the flush. The default (a bare
- * `exit(128 + signo)`) is correct for headless, inline and every subcommand;
+ * `exit(128 + signo)`) is correct for headless and every subcommand;
  * full-screen substitutes one that restores the terminal first.
  *
  * A TERMINATOR MAY NOW RETURN WITHOUT EXITING, AND THAT IS A CONTRACT CHANGE

package/dist/session/persist.js

@@ -193,6 +193,26 @@ export function normalizeLoadedEntries(entries) {
             (entry.status === 'starting' || entry.status === 'ready' || entry.status === 'running')) {
             return { ...entry, status: 'stopped', rows: [] };
         }
+        // THE SEVENTH CLAUSE (tui-shift-enter-copy-queue 5.2.5). Core's steering
+        // queue is memory-only, so a `queued` entry on disk is a promise this
+        // process can no longer keep: the message was never accepted into any
+        // conversation. Downgrade to a WARN NOTICE carrying the first line
+        // rather than to a `user` entry -- pretending it was sent is the lie
+        // that loses the user's words with a straight face.
+        //
+        // THE ID IS KEPT: `restoreEntries` splices these positions into the
+        // live transcript, and a fresh id here would collide with the next
+        // `e<n>` the reducer allocates.
+        if (entry.kind === 'queued') {
+            const firstLine = entry.text.split('\n', 1)[0] ?? '';
+            const downgraded = {
+                id: entry.id,
+                kind: 'notice',
+                level: 'warn',
+                text: `Queued but never sent: ${firstLine}`,
+            };
+            return downgraded;
+        }
         return entry;
     });
 }

package/dist/todo/follow-through.d.ts

@@ -84,10 +84,6 @@ export type FollowThroughDecision = {
 };
 /** The zero budget. A fresh App, a fresh headless run, and every cleared list. */
 export declare function emptyBudget(): FollowThroughBudget;
-/**
- * The decision. EVALUATED IN THIS ORDER, AND THE ORDER IS SEMANTICS, NOT STYLE —
- * the same sentence `decideRenderMode` carries.
- */
 export declare function decideFollowThrough(input: FollowThroughInput): FollowThroughDecision;
 /**
  * Fold a finished run into the budget. Called BEFORE `decideFollowThrough`, on

package/dist/todo/follow-through.js

@@ -36,10 +36,6 @@ function legacyUnfinishedNotice(left) {
 function advise(interactive, text) {
     return interactive ? ` ${text}` : '';
 }
-/**
- * The decision. EVALUATED IN THIS ORDER, AND THE ORDER IS SEMANTICS, NOT STYLE —
- * the same sentence `decideRenderMode` carries.
- */
 export function decideFollowThrough(input) {
     const { mode, snapshot, runEnd, budget, interactive } = input;
     // 1. Nothing is unfinished. `beginUserTurn` already drops a fully-completed

package/dist/todo/limits.d.ts

@@ -38,16 +38,6 @@ export declare const TODO_LIMITS: {
     readonly panelFullRows: 6;
     /** Below this many terminal columns the status-bar counter degrades to `[3/7]`. */
     readonly statusCompactCols: 100;
-    /**
-     * Below this many columns the inline strip drops its `+N done` suffix
-     * (todo-plan-followthrough §3.7 / D-19).
-     *
-     * NAMED RATHER THAN INLINED, and the reason is that it sits between two other
-     * real bounds — `statusCompactCols` (100) above and `MIN_FULLSCREEN_COLS` (40)
-     * in `frame.ts` — with nothing to tell a reader whether a bare `80` in the
-     * component was a third policy or a typo for one of them.
-     */
-    readonly stripDoneCols: 80;
     /**
      * Consecutive user turns an UNFINISHED list survives without a `todo_write`
      * before `beginUserTurn()` drops it (§3.2 / P1-7). Three keeps the common

package/dist/todo/limits.js

@@ -38,16 +38,6 @@ export const TODO_LIMITS = {
     panelFullRows: 6,
     /** Below this many terminal columns the status-bar counter degrades to `[3/7]`. */
     statusCompactCols: 100,
-    /**
-     * Below this many columns the inline strip drops its `+N done` suffix
-     * (todo-plan-followthrough §3.7 / D-19).
-     *
-     * NAMED RATHER THAN INLINED, and the reason is that it sits between two other
-     * real bounds — `statusCompactCols` (100) above and `MIN_FULLSCREEN_COLS` (40)
-     * in `frame.ts` — with nothing to tell a reader whether a bare `80` in the
-     * component was a third policy or a typo for one of them.
-     */
-    stripDoneCols: 80,
     /**
      * Consecutive user turns an UNFINISHED list survives without a `todo_write`
      * before `beginUserTurn()` drops it (§3.2 / P1-7). Three keeps the common

package/dist/todo/prompt.d.ts

@@ -22,21 +22,6 @@
 import { TODO_BLOCK_VERSION } from './limits.js';
 export { TODO_BLOCK_VERSION };
 export interface TodoBlockParams {
-    /**
-     * Whether this session can actually render the rail.
-     *
-     * FOUR SUPPORTED PATHS HAVE THE TOOL AND NO PANEL — `-p` (§3.12), inline mode
-     * (non-goal 4), `--no-todo-panel` (§4.3), and a terminal under 80 columns or 6
-     * viewport rows (§6.4) — and in the first three the answer is fixed for the
-     * whole session, before the prompt is composed. Telling the model about a
-     * panel the user does not have is the same error `composeSystemPrompt` already
-     * guards against for team mode with its TWO flags (P1-6 / D-24).
-     *
-     * Dropping the block instead would be wrong: the planning discipline is worth
-     * having without the column, which is precisely why `enabled` and `panel` are
-     * separate config keys, and a screen-reader user is the case that argument was
-     * written for.
-     */
     panelVisible: boolean;
 }
 /**

package/dist/ui/ActivityLine.d.ts

@@ -41,6 +41,8 @@
 import React from 'react';
 import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
+import { pickGlyphs } from './glyphs.js';
+import type { RunActivity } from './run-status-row.js';
 /**
  * The animated spinner this row draws while it is live, or `null` when it would
  * be STATIC — an ASCII terminal, or a user who asked for stillness.
@@ -57,42 +59,32 @@ import type { TermCapabilities } from './capabilities.js';
  * reader has to reason about; one more caller of this function is not.
  */
 export declare function liveSpinner(reducedMotion: boolean, caps: TermCapabilities): React.ReactElement | null;
-export interface ActivityLineProps {
-    /** Epoch ms the current run began — the phrase sequence's seed. */
-    startedAt: number;
-    /** `Date.now() - startedAt`, already computed by App's 200 ms ticker. */
-    elapsedMs: number;
-    reducedMotion: boolean;
-    /**
-     * The name of the tool currently in flight, or `undefined`
-     * (agent-activity-presentation-live L4 / D-31).
-     *
-     * `status === 'running'` covers the WHOLE turn, including the minutes the
-     * model is idle and a child process is doing the work. Round 1 chose the
-     * thinking vocabulary deliberately for the gap before the first token, and it
-     * is right for that gap; a UI that says "Pondering" while `npm test` runs is
-     * not calm, it is wrong.
-     */
-    runningTool?: string;
+/**
+ * The label ladder, MOST SPECIFIC FIRST: `Compacting context` outranks a tool name
+ * because compaction can be the only thing happening, and the tool name outranks
+ * the rotating phrase for the reason `runningTool` exists at all. One
+ * implementation, because the fixed bottom row and the run status row above the
+ * input must never disagree about what the agent is doing.
+ *
+ * `Running ${name}` rather than a per-tool verb table: a table would be a SECOND
+ * registry of tool names, and `toolGlyph` is already the one place that knows
+ * them. ASCII only, and the ellipsis comes from `pickGlyphs` like every other one.
+ */
+export declare function resolveActivityLabel(activity: RunActivity, glyphs: ReturnType<typeof pickGlyphs>): string;
+export interface ActivityLabelProps extends RunActivity {
     /**
-     * A context compaction is in flight (context-auto-compaction §6.1).
-     *
-     * HIGHEST PRECEDENCE IN THE LABEL LADDER, above `runningTool` and above the
-     * rotating phrase. Compaction happens BEFORE `turn_start`, i.e. at a moment
-     * when `status` is `'running'` but no tool is in flight — precisely the window
-     * in which the phrase rotation would say something false, and it can last
-     * tens of seconds. `runningTool` already established the principle one step
-     * back: a UI that says "Pondering" while `npm test` runs is not calm, it is
-     * wrong, and one that says it while a 30 k-token summarization runs is the same
-     * error.
-     *
-     * STILL NO SECOND SPINNER. `single-spinner-while-running`'s D-1 stands: this
-     * row owns the only animation while it is mounted, and the compaction card
-     * follows `FastCard` in taking a `reducedMotion` that `App` has already
-     * widened.
+     * False draws the STATIC glyph even when motion is allowed. The run status row
+     * uses it when it has scrolled out of the viewport (the fixed bottom row owns
+     * the animation then) or an overlay covers the chat. The phrase still rotates
+     * from the RAW `reducedMotion`, so a still icon never freezes the wording.
      */
-    compacting?: boolean;
+    spinnerLive?: boolean;
+    /** Prefix one space (the fixed bottom row's indent); the run row indents itself. */
+    leadingSpace?: boolean;
     theme: Theme;
     caps: TermCapabilities;
 }
-export declare function ActivityLine({ startedAt, elapsedMs, reducedMotion, runningTool, compacting, theme, caps, }: ActivityLineProps): React.ReactElement;
+/** `<spinner> <label>` as ONE truncating `<Text>`; the only place that composes them. */
+export declare function ActivityLabel({ spinnerLive, leadingSpace, theme, caps, ...activity }: ActivityLabelProps): React.ReactElement;
+export type ActivityLineProps = Omit<ActivityLabelProps, 'spinnerLive' | 'leadingSpace'>;
+export declare function ActivityLine(props: ActivityLineProps): React.ReactElement;

package/dist/ui/ActivityLine.js

@@ -21,32 +21,43 @@ import { pickActivityPhrase } from './activity-phrases.js';
 export function liveSpinner(reducedMotion, caps) {
     return caps.unicode && !reducedMotion ? _jsx(Spinner, { type: "dots" }) : null;
 }
-export function ActivityLine({ startedAt, elapsedMs, reducedMotion, runningTool, compacting, theme, caps, }) {
-    const glyphs = pickGlyphs(caps);
+/**
+ * The label ladder, MOST SPECIFIC FIRST: `Compacting context` outranks a tool name
+ * because compaction can be the only thing happening, and the tool name outranks
+ * the rotating phrase for the reason `runningTool` exists at all. One
+ * implementation, because the fixed bottom row and the run status row above the
+ * input must never disagree about what the agent is doing.
+ *
+ * `Running ${name}` rather than a per-tool verb table: a table would be a SECOND
+ * registry of tool names, and `toolGlyph` is already the one place that knows
+ * them. ASCII only, and the ellipsis comes from `pickGlyphs` like every other one.
+ */
+export function resolveActivityLabel(activity, glyphs) {
+    if (activity.compacting)
+        return `Compacting context${glyphs.ellipsis}`;
+    if (activity.runningTool)
+        return `Running ${activity.runningTool}`;
     // PURE AND DERIVED FROM `(startedAt, now)`, so the sequence does not need to
     // keep rotating underneath the tool label: when the tool settles the phrase
     // resumes at the position the clock implies, with no state anywhere.
-    const phrase = pickActivityPhrase(startedAt, startedAt + elapsedMs, !reducedMotion);
-    // `Running ${name}` rather than a per-tool verb table: a table would be a
-    // SECOND registry of tool names, and `toolGlyph` is already the one place that
-    // knows them. Everything round 1 legislated for this row survives — one row,
-    // no digits, no `esc abort`, no width ladder, ASCII only.
-    // THREE RUNGS, MOST SPECIFIC FIRST. `Compacting context` outranks a tool name
-    // because compaction can be the only thing happening, and it outranks the
-    // phrase for the reason `runningTool` does. ASCII only, and the ellipsis comes
-    // from `pickGlyphs` like every other one on this row.
-    const label = compacting
-        ? `Compacting context${glyphs.ellipsis}`
-        : runningTool
-            ? `Running ${runningTool}`
-            : `${phrase}${glyphs.ellipsis}`;
+    const phrase = pickActivityPhrase(activity.startedAt, activity.startedAt + activity.elapsedMs, !activity.reducedMotion);
+    return `${phrase}${glyphs.ellipsis}`;
+}
+/** `<spinner> <label>` as ONE truncating `<Text>`; the only place that composes them. */
+export function ActivityLabel({ spinnerLive = true, leadingSpace = false, theme, caps, ...activity }) {
+    const glyphs = pickGlyphs(caps);
+    const label = resolveActivityLabel(activity, glyphs);
     // The IDENTICAL branch `Transcript.tsx` uses for the assistant role marker, and
     // it must stay identical: braille dots are both an animation AND a Unicode-only
     // glyph, so reduced motion and an ASCII terminal fall back to the same marker.
     //
     // Through `liveSpinner` rather than inline, so this row and the glyph
     // `BottomStatusRow` composes beside a toast can never disagree about WHEN the
-    // spinner is live — the same reason `App` names its mount condition once.
-    const spinner = liveSpinner(reducedMotion, caps) ?? glyphs.spinnerStill;
-    return (_jsx(Box, { flexShrink: 0, children: _jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [' ', spinner, " ", label] }) }));
+    // spinner is live - the same reason `App` names its mount condition once.
+    const spinner = (spinnerLive ? liveSpinner(activity.reducedMotion, caps) : null) ??
+        glyphs.spinnerStill;
+    return (_jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [leadingSpace ? ' ' : '', spinner, " ", label] }));
+}
+export function ActivityLine(props) {
+    return (_jsx(Box, { flexShrink: 0, children: _jsx(ActivityLabel, { ...props, leadingSpace: true }) }));
 }

package/dist/ui/App.d.ts

@@ -10,7 +10,6 @@ import type { AgentController } from '../agent/controller.js';
 import type { ConfirmRequest } from '../tools/index.js';
 import { type Overlay, type ToastLevel } from '../agent/reducer.js';
 import type { UpdateBridge } from '../update/types.js';
-import { type RenderMode } from './layout/frame.js';
 import type { MouseSource } from '../input/stdin-filter.js';
 import type { PasteBridge } from '../input/limits.js';
 import type { SelectionBridge } from './selection/selection-controller.js';
@@ -43,15 +42,11 @@ export interface AppProps {
     controller: AgentController;
     version: string;
     /** Decided once in `cli.tsx::runInteractive()`; never switched at run time. */
-    mode: RenderMode;
     initialOverlay?: Overlay;
     initialPrompt?: string;
     confirmBridge?: ConfirmBridge;
     /** The plan-mode human channel; absent in tests that do not exercise it. */
     humanInputBridge?: HumanInputBridge;
-    /** Wheel events, already stripped out of stdin. Absent whenever mouse support
-     *  is off: inline mode, `--no-mouse`, a non-TTY, or a filter that failed to
-     *  build (mouse-wheel-region-routing §4.2). */
     mouseSource?: MouseSource;
     /**
      * Present ONLY on a console that can deliver neither `CSI Z` nor a mouse
@@ -87,28 +82,8 @@ export interface AppProps {
      * on a non-TTY, and in every test that does not exercise it.
      */
     pasteBridge?: PasteBridge;
-    /**
-     * The terminal-facing services `cli.tsx` owns and this component cannot build
-     * (tui-selection-and-scroll-follow §4.4).
-     *
-     * ONE PROP RATHER THAN FOUR, and every FIELD of it is independently optional,
-     * so `--no-mouse`, `--no-diff-render` and inline mode each drop exactly the
-     * services they do not have. Absent altogether on a non-TTY and in every test
-     * that does not exercise selection, which is what keeps those trees
-     * byte-identical.
-     */
     terminal?: TerminalBridge;
 }
-/**
- * Terminal-level services, almost all of which exist only in a full-screen TTY
- * session — `writeForeign` is the exception, because `/copy` is available in
- * inline mode too and OSC 52 is what makes it work over SSH (§4.4.5).
- *
- * `selection` is a LATE-BOUND BRIDGE for the reason `updateBridge` above is one:
- * the controller is constructed before `render()` and must not hold React state,
- * while the toast sink and the redraw nonce only exist once this component has
- * 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). */
@@ -117,22 +92,7 @@ export interface TerminalBridge {
     setMouseCapture?: (on: boolean) => void;
     /** Whether the mouse is captured right now — read at command time. */
     isMouseCaptured?: () => boolean;
-    /**
-     * Write bytes that are ours but are not a frame (OSC 52).
-     *
-     * IT MUST NOT BE `stdout.write` WITH THE DIFFER IN FRONT OF STDOUT (P1-6):
-     * that goes through the frame-writer proxy, which does not recognise an OSC 52
-     * chunk, counts it as a foreign write and prints `FRAME_FALLBACK_NOTICE` at
-     * the user the first time they copy anything. Without a differ — inline mode,
-     * `--no-diff-render` — stdout IS the real stream and `cli.tsx` supplies a
-     * direct write instead.
-     *
-     * Absent only when there is no terminal to accept it at all. It is never a
-     * function that writes nowhere: `copyText` reports `'osc52'` whenever its door
-     * took the text, so a no-op door would make the toast name a mechanism that
-     * was never attempted.
-     */
     writeForeign?: (text: string) => void;
     selection?: SelectionBridge;
 }
-export declare function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, }: AppProps): React.ReactElement;
+export declare function App({ controller, version, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, }: AppProps): React.ReactElement;