@aiwayds/dsh-tui-pi 0.1.1 → 0.3.0

package/lib/keymap.d.ts

@@ -0,0 +1,177 @@
+/**
+ * App-level keybinding decisions — the pi interrupt chain, kept pure.
+ *
+ * pi (badlogic/pi-mono) routes terminal key presses through an app-level
+ * handler before the focused component sees them. This module is the
+ * dsh-tui-pi equivalent: `tui.ts` composes the live state and calls
+ * `resolveKeyAction`, `index.ts` executes the returned action. Keeping the
+ * decision PURE makes the whole chain unit-testable without a terminal.
+ *
+ * Esc chain (mirrors pi's `app.interrupt`, verified on pi 0.84.2):
+ *   1. popup/selector overlay open  → let the popup's own Esc handle it —
+ *                                     Esc NEVER touches the running task
+ *                                     from inside a popup (the subagent
+ *                                     viewer, pickers and dialogs close
+ *                                     themselves and leave the turn alone)
+ *   2. editor autocomplete showing  → let the editor close the list only
+ *   3. agent mid-turn (running)     → 1st press arms the stop window, 2nd
+ *                                     press within `DOUBLE_PRESS_MS` cancels
+ *                                     the whole task (parent + subagents) —
+ *                                     stopping is a deliberate double-press
+ *   4. editor non-empty (idle)      → NO-OP — pi's anti-misfire core
+ *   5. editor empty (idle)          → 1st press arms, 2nd press within
+ *                                     `DOUBLE_PRESS_MS` triggers the mapped
+ *                                     action (pi defaults to /tree; dsh has
+ *                                     no /tree, so we map to /session — the
+ *                                     closest non-invasive analogue). The
+ *                                     running-stop and idle windows own
+ *                                     SEPARATE clocks (`lastRunningEscPress`
+ *                                     vs `lastEscPress`) so an Esc that armed
+ *                                     a stop never pops /session after the
+ *                                     turn settles, and vice versa.
+ *
+ * Ctrl+C chain (dsh convention, windowed): first press cancels a running
+ * turn — or clears the editor while idle — and a second press within
+ * `DOUBLE_PRESS_MS` quits. This keeps dsh's "first cancels / second quits"
+ * while requiring a deliberate double-press before an idle exit. Held-key
+ * auto-repeat never counts: repeats inside `MIN_DOUBLE_PRESS_GAP_MS` resolve
+ * to `key-repeat` (consumed, inert — and the executor aborts a pending quit
+ * confirmation on one, since a repeat betrays a held key; see index.ts).
+ *
+ * Ctrl+D chain (pi `app.exit`): only quits on an EMPTY editor; with text it
+ * is left alone so the pi-tui Editor's existing `tui.editor.deleteCharForward`
+ * binding (delete, ctrl+d) deletes a character forward — exactly pi's
+ * context distinction.
+ *
+ * Ctrl+L chain (pi `app.model.select`): opens the model/think picker — the
+ * dsh analogue of pi's model selector. Like every app key here it yields to
+ * an open overlay first, so a popup that is on screen keeps its own keys.
+ *
+ * Ctrl+G chain (dsh's subagent viewer): opens the subagent picker only while
+ * a subagent runs (`runningAgents > 0`) — idle it falls through untouched.
+ * Same overlay-yields-first rule as the other app keys.
+ */
+import { type KeyId } from '@earendil-works/pi-tui';
+/** Double-press window (ms) for ctrl+c quit and empty-editor double-Esc. */
+export declare const DOUBLE_PRESS_MS = 500;
+/**
+ * Minimum gap (ms) between two presses of the same key for the second to
+ * count as a deliberate press rather than terminal auto-repeat. A held key is
+ * re-sent every ~30-50ms after the OS repeat delay (183ms-2s) and terminals
+ * report no key-up, so gap alone is the discriminator: anything closer than
+ * this floor is auto-repeat (see `key-repeat`). Human double-presses are
+ * rarely faster than ~100ms; common repeat rates (20-33/s) sit well under it.
+ */
+export declare const MIN_DOUBLE_PRESS_GAP_MS = 80;
+/**
+ * The key identifiers resolved for each app-level binding. Injectable so a
+ * future `~/.dsh/keybindings.json` override can remap the app keys without
+ * touching the decision logic (see README "Keyboard shortcuts").
+ */
+export interface KeyBindings {
+    /** Stop the current task (pi app.interrupt). */
+    escape: KeyId;
+    /** Cancels the running turn / clears the editor; double-press quits. */
+    ctrlC: KeyId;
+    /** Quit, but only when the editor is empty (pi app.exit). */
+    ctrlD: KeyId;
+    /** Open the model picker (pi app.model.select). */
+    modelPicker: KeyId;
+    /** Open the subagent picker / viewer (running children). */
+    subagentViewer: KeyId;
+}
+export declare const DEFAULT_KEYBINDINGS: KeyBindings;
+/** Live snapshot of everything the decision needs — composed by tui.ts. */
+export interface KeyPressState {
+    /** Agent mid-turn (`bridge.isRunning()`). */
+    running: boolean;
+    /** An overlay/popup is open and focused (`tui.hasOverlay()`). */
+    overlayOpen: boolean;
+    /** Editor buffer is non-empty. */
+    editorHasText: boolean;
+    /** Editor autocomplete dropdown is currently showing. */
+    autocompleteOpen: boolean;
+    /** Live (not settled) subagent count; 0 = nothing for ctrl+g to open. */
+    runningAgents: number;
+    /** Timestamp (ms) of the last handled escape press; 0 = none. */
+    lastEscPress: number;
+    /** Timestamp (ms) of the last handled escape press that armed the
+     *  running-stop window (branch 3 above); 0 = none. Own clock: independent
+     *  of `lastEscPress` so the two Esc windows never bleed into each other. */
+    lastRunningEscPress: number;
+    /** Timestamp (ms) of the last handled ctrl+c press; 0 = none. */
+    lastCtrlCPress: number;
+}
+/**
+ * One resolved app-level key action. `consumes` mirrors pi-tui's
+ * `TuiInputListenerResult.consume`: true stops the key from reaching the
+ * focused component, false lets it through (the popup / the editor handle
+ * it — e.g. Esc-close, ctrl+d delete-char, drop of an unbound key).
+ */
+export type KeyAction = {
+    kind: 'overlay';
+    consumes: false;
+} | {
+    kind: 'autocomplete-close';
+    consumes: false;
+} | {
+    kind: 'noop';
+    consumes: false;
+} | {
+    kind: 'interrupt-arm-stop';
+    consumes: true;
+} | {
+    kind: 'interrupt-cancel';
+    consumes: true;
+} | {
+    kind: 'interrupt-arm';
+    consumes: true;
+} | {
+    kind: 'interrupt-double';
+    consumes: true;
+} | {
+    kind: 'ctrl-c-cancel';
+    consumes: true;
+} | {
+    kind: 'ctrl-c-clear';
+    consumes: true;
+} | {
+    kind: 'ctrl-c-quit';
+    consumes: true;
+} | {
+    kind: 'ctrl-d-quit';
+    consumes: true;
+} | {
+    kind: 'model-picker';
+    consumes: true;
+} | {
+    kind: 'subagent-viewer';
+    consumes: true;
+}
+/**
+ * Auto-repeat of a windowed key (Ctrl+C / armed Esc) — the key is being
+ * held. Consumed so the editor never sees it, but no action fires and the
+ * double-press clock does NOT advance (a repeat must never arm or complete
+ * a double press). The executor can use the `key` to cancel a pending
+ * quit confirmation (a repeat betrays a held key).
+ */
+ | {
+    kind: 'key-repeat';
+    key: 'ctrl-c' | 'escape';
+    consumes: true;
+};
+/**
+ * Resolve one raw terminal input sequence into an app-level action.
+ * `data` is the single decoded key sequence `addInputListener` receives
+ * (e.g. "\x1b" for Escape, "\x03" for Ctrl+C); see keys.js for the
+ * normalization: Escape is `\x1b`, and legacy Ctrl+[ collapses to the same
+ * byte, so both are recognized as `escape`.
+ *
+ * `keys` may be a PARTIAL override — every missing binding falls back to the
+ * default. That is the shape a future `~/.dsh/keybindings.json` loader will
+ * feed in: remap one key, keep the rest.
+ *
+ * Any key outside the app bindings yields `noop` (not consumed — the focused
+ * component, normally the editor, processes it).
+ */
+export declare function resolveKeyAction(data: string, state: KeyPressState, now: number, keys?: Partial<KeyBindings>): KeyAction;

package/lib/keymap.js

@@ -0,0 +1,189 @@
+/**
+ * App-level keybinding decisions — the pi interrupt chain, kept pure.
+ *
+ * pi (badlogic/pi-mono) routes terminal key presses through an app-level
+ * handler before the focused component sees them. This module is the
+ * dsh-tui-pi equivalent: `tui.ts` composes the live state and calls
+ * `resolveKeyAction`, `index.ts` executes the returned action. Keeping the
+ * decision PURE makes the whole chain unit-testable without a terminal.
+ *
+ * Esc chain (mirrors pi's `app.interrupt`, verified on pi 0.84.2):
+ *   1. popup/selector overlay open  → let the popup's own Esc handle it —
+ *                                     Esc NEVER touches the running task
+ *                                     from inside a popup (the subagent
+ *                                     viewer, pickers and dialogs close
+ *                                     themselves and leave the turn alone)
+ *   2. editor autocomplete showing  → let the editor close the list only
+ *   3. agent mid-turn (running)     → 1st press arms the stop window, 2nd
+ *                                     press within `DOUBLE_PRESS_MS` cancels
+ *                                     the whole task (parent + subagents) —
+ *                                     stopping is a deliberate double-press
+ *   4. editor non-empty (idle)      → NO-OP — pi's anti-misfire core
+ *   5. editor empty (idle)          → 1st press arms, 2nd press within
+ *                                     `DOUBLE_PRESS_MS` triggers the mapped
+ *                                     action (pi defaults to /tree; dsh has
+ *                                     no /tree, so we map to /session — the
+ *                                     closest non-invasive analogue). The
+ *                                     running-stop and idle windows own
+ *                                     SEPARATE clocks (`lastRunningEscPress`
+ *                                     vs `lastEscPress`) so an Esc that armed
+ *                                     a stop never pops /session after the
+ *                                     turn settles, and vice versa.
+ *
+ * Ctrl+C chain (dsh convention, windowed): first press cancels a running
+ * turn — or clears the editor while idle — and a second press within
+ * `DOUBLE_PRESS_MS` quits. This keeps dsh's "first cancels / second quits"
+ * while requiring a deliberate double-press before an idle exit. Held-key
+ * auto-repeat never counts: repeats inside `MIN_DOUBLE_PRESS_GAP_MS` resolve
+ * to `key-repeat` (consumed, inert — and the executor aborts a pending quit
+ * confirmation on one, since a repeat betrays a held key; see index.ts).
+ *
+ * Ctrl+D chain (pi `app.exit`): only quits on an EMPTY editor; with text it
+ * is left alone so the pi-tui Editor's existing `tui.editor.deleteCharForward`
+ * binding (delete, ctrl+d) deletes a character forward — exactly pi's
+ * context distinction.
+ *
+ * Ctrl+L chain (pi `app.model.select`): opens the model/think picker — the
+ * dsh analogue of pi's model selector. Like every app key here it yields to
+ * an open overlay first, so a popup that is on screen keeps its own keys.
+ *
+ * Ctrl+G chain (dsh's subagent viewer): opens the subagent picker only while
+ * a subagent runs (`runningAgents > 0`) — idle it falls through untouched.
+ * Same overlay-yields-first rule as the other app keys.
+ */
+import { matchesKey } from '@earendil-works/pi-tui';
+/** Double-press window (ms) for ctrl+c quit and empty-editor double-Esc. */
+export const DOUBLE_PRESS_MS = 500;
+/**
+ * Minimum gap (ms) between two presses of the same key for the second to
+ * count as a deliberate press rather than terminal auto-repeat. A held key is
+ * re-sent every ~30-50ms after the OS repeat delay (183ms-2s) and terminals
+ * report no key-up, so gap alone is the discriminator: anything closer than
+ * this floor is auto-repeat (see `key-repeat`). Human double-presses are
+ * rarely faster than ~100ms; common repeat rates (20-33/s) sit well under it.
+ */
+export const MIN_DOUBLE_PRESS_GAP_MS = 80;
+export const DEFAULT_KEYBINDINGS = {
+    escape: 'escape',
+    ctrlC: 'ctrl+c',
+    ctrlD: 'ctrl+d',
+    modelPicker: 'ctrl+l',
+    subagentViewer: 'ctrl+g',
+};
+/** True when a second press within the window follows `lastPress`. */
+function isDoublePress(lastPress, now) {
+    return lastPress > 0 && now - lastPress <= DOUBLE_PRESS_MS;
+}
+/** True when this press is auto-repeat of a held key (gap under the floor). */
+function isKeyRepeat(lastPress, now) {
+    return lastPress > 0 && now - lastPress < MIN_DOUBLE_PRESS_GAP_MS;
+}
+/** The Esc chain — pi app.interrupt, popup and autocomplete first. */
+function resolveEscape(state, now) {
+    // 1. An open overlay owns Esc: the popup (subagent viewer, pickers,
+    //    dialogs) closes itself and the running task is NEVER touched by that
+    //    press — Esc is a per-popup cancel, not the global stop.
+    if (state.overlayOpen)
+        return { kind: 'overlay', consumes: false };
+    if (state.autocompleteOpen)
+        return { kind: 'autocomplete-close', consumes: false };
+    // 2. Agent mid-turn: stopping the whole task (parent + subagents) is a
+    //    deliberate double-press — the first Esc only arms the stop window, so
+    //    a stray Esc (e.g. one aimed at a just-closed popup) can never kill a
+    //    running turn. Its clock is the separate `lastRunningEscPress`; held
+    //    auto-repeat never arms or fires it.
+    if (state.running) {
+        if (isKeyRepeat(state.lastRunningEscPress, now))
+            return { kind: 'key-repeat', key: 'escape', consumes: true };
+        return isDoublePress(state.lastRunningEscPress, now)
+            ? { kind: 'interrupt-cancel', consumes: true }
+            : { kind: 'interrupt-arm-stop', consumes: true };
+    }
+    // 3. Idle: a non-empty editor is untouched (pi's anti-misfire core).
+    if (state.editorHasText)
+        return { kind: 'noop', consumes: false };
+    // 4. Empty editor, idle: first press arms, second within the window fires
+    //    the double action (/session — dsh has no pi /tree). Auto-repeat of the
+    //    armed key never fires the double action.
+    if (isKeyRepeat(state.lastEscPress, now))
+        return { kind: 'key-repeat', key: 'escape', consumes: true };
+    return isDoublePress(state.lastEscPress, now)
+        ? { kind: 'interrupt-double', consumes: true }
+        : { kind: 'interrupt-arm', consumes: true };
+}
+/**
+ * Ctrl+C — dsh's "first cancels / second quits", windowed against misfires.
+ * Auto-repeat (a held key) is swallowed: it neither cancels again nor ever
+ * completes the quit double press.
+ */
+function resolveCtrlC(state, now) {
+    if (state.overlayOpen)
+        return { kind: 'overlay', consumes: false };
+    if (isKeyRepeat(state.lastCtrlCPress, now))
+        return { kind: 'key-repeat', key: 'ctrl-c', consumes: true };
+    if (state.running) {
+        if (isDoublePress(state.lastCtrlCPress, now))
+            return { kind: 'ctrl-c-quit', consumes: true };
+        return { kind: 'ctrl-c-cancel', consumes: true };
+    }
+    if (isDoublePress(state.lastCtrlCPress, now))
+        return { kind: 'ctrl-c-quit', consumes: true };
+    return { kind: 'ctrl-c-clear', consumes: true };
+}
+/** Ctrl+D — pi app.exit: quit only on an empty editor, else let it delete. */
+function resolveCtrlD(state) {
+    if (state.overlayOpen)
+        return { kind: 'overlay', consumes: false };
+    if (state.editorHasText)
+        return { kind: 'noop', consumes: false };
+    return { kind: 'ctrl-d-quit', consumes: true };
+}
+/** Ctrl+L — pi app.model.select: open the model picker (overlay yields). */
+function resolveModelPicker(state) {
+    if (state.overlayOpen)
+        return { kind: 'overlay', consumes: false };
+    return { kind: 'model-picker', consumes: true };
+}
+/** Ctrl+G — open the subagent picker only while children run (overlay yields). */
+function resolveSubagentViewer(state) {
+    if (state.overlayOpen)
+        return { kind: 'overlay', consumes: false };
+    if (state.runningAgents > 0)
+        return { kind: 'subagent-viewer', consumes: true };
+    // No subagents to watch: let the key fall through to the focused component.
+    return { kind: 'noop', consumes: false };
+}
+/**
+ * Resolve one raw terminal input sequence into an app-level action.
+ * `data` is the single decoded key sequence `addInputListener` receives
+ * (e.g. "\x1b" for Escape, "\x03" for Ctrl+C); see keys.js for the
+ * normalization: Escape is `\x1b`, and legacy Ctrl+[ collapses to the same
+ * byte, so both are recognized as `escape`.
+ *
+ * `keys` may be a PARTIAL override — every missing binding falls back to the
+ * default. That is the shape a future `~/.dsh/keybindings.json` loader will
+ * feed in: remap one key, keep the rest.
+ *
+ * Any key outside the app bindings yields `noop` (not consumed — the focused
+ * component, normally the editor, processes it).
+ */
+export function resolveKeyAction(data, state, now, keys = DEFAULT_KEYBINDINGS) {
+    const bindings = { ...DEFAULT_KEYBINDINGS };
+    for (const id of Object.keys(keys)) {
+        const value = keys[id];
+        if (value !== undefined)
+            bindings[id] = value;
+    }
+    if (matchesKey(data, bindings.escape))
+        return resolveEscape(state, now);
+    if (matchesKey(data, bindings.ctrlC))
+        return resolveCtrlC(state, now);
+    if (matchesKey(data, bindings.ctrlD))
+        return resolveCtrlD(state);
+    if (matchesKey(data, bindings.modelPicker))
+        return resolveModelPicker(state);
+    if (matchesKey(data, bindings.subagentViewer))
+        return resolveSubagentViewer(state);
+    return { kind: 'noop', consumes: false };
+}
+//# sourceMappingURL=keymap.js.map

package/lib/keymap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keymap.js","sourceRoot":"","sources":["../src/keymap.ts"],"names":[],"mappings":"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"}

package/lib/live-widgets.d.ts

@@ -9,13 +9,12 @@
  *    renders zero rows while empty and grows to its content while the model
  *    has todos.
  *  - `activityDoc` — the lastRequest container below the editor
- *    (`ui.lastRequest`): the ` ↳ <last request>` line (persisting across
+ *    (`ui.lastRequest`): the ` ● <last request>` line (persisting across
  *    agent churn) followed by one compact line PER RUNNING agent. NO box
- *    chrome, NO `● Agents` header, NO connector and NO provider — just
- *    `  ↳ ⠋ <name> · ↻N≤M · 562 token (4%) · 13.6s`, the `  ↳ ` prefix
- *    nesting one column right of the request line's ` ↳ ` (a tree level
- *    under the last request) so the agent NAMES align under that level.
- *    Auto height — it
+ *    chrome, NO `● Agents` header, NO provider — just
+ *    `├─ ⠋ <name> · ↻N≤M · 21k/1m · 13.6s · <latest output>`, the `├─ ` /
+ *    `└─ ` prefix in the same column as the todo rows and the request ` ● `
+ *    (the last running agent closes the list with `└─ `). Auto height — it
  *    collapses to zero rows when both the last-request line is cleared and no
  *    agent runs.
  *
@@ -37,6 +36,11 @@ import { type TuiTheme } from './theme/index.ts';
 export declare const AGENT_TICK_MS = 100;
 /** Braille spinner cycle; the frame index advances once per tick. */
 export declare const AGENT_SPINNER_FRAMES: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/**
+ * Compact human-readable size: 1_500_000 → `1.5m`, 20_965 → `20k`, 999 → `999`.
+ * Millions keep one decimal (a trailing `.0` dropped), thousands floor to `k`.
+ */
+export declare function fmtCompact(n: number): string;
 export declare class LiveWidgets {
     private readonly todosDoc;
     private readonly activityDoc;
@@ -50,7 +54,7 @@ export declare class LiveWidgets {
     private todosText;
     /** The merged running-agent Text in `activityDoc`, replaced on rebuild. */
     private agentsText;
-    /** The ` ↳ <last request>` Text in `activityDoc` (persists across churn). */
+    /** The ` ● <last request>` Text in `activityDoc` (persists across churn). */
     private requestText;
     /** Plain clipped last-request text backing `requestText` (for setTheme). */
     private requestDisplay;
@@ -59,12 +63,12 @@ export declare class LiveWidgets {
     /**
      * @param todosDoc The dock slot ABOVE the chat input — the Todos boxed
      *   panel lives here.
-     * @param activityDoc The lastRequest container BELOW the editor — the ` ↳ `
+     * @param activityDoc The lastRequest container BELOW the editor — the ` ● `
      *   last-request line plus the compact running-agent lines live here.
      */
     constructor(todosDoc: Container, activityDoc: Container, theme: TuiTheme, requestRender: () => void);
     /**
-     * Render the ` ↳ <text>` last-request line in `activityDoc`, UNDER which the
+     * Render the ` ● <text>` last-request line in `activityDoc`, UNDER which the
      * running-agent lines appear. `undefined` (or blank) removes the line. Same
      * styling as before the merge: `fgMuted` prefix, but the text is clipped to
      * the terminal width (`columns - 5`) so it ALWAYS renders on one row and
@@ -84,21 +88,21 @@ export declare class LiveWidgets {
      * — the activity area then holds its final (empty) state.
      */
     tickLive(): void;
-    /** Recolor the widget (Todos panel, ↳ line and agent lines) under a theme
+    /** Recolor the widget (Todos panel, ● line and agent lines) under a theme
      * hot-switch (no-op on the same bundle). */
     setTheme(theme: TuiTheme): void;
     /**
      * Drop everything except the last-request echo (`/new`): clears the Todos
-     * panel and the running-agent lines, keeps the ` ↳ ` line. The bridge also
+     * panel and the running-agent lines, keeps the ` ● ` line. The bridge also
      * fires `renderAgents([])`.
      */
     clear(): void;
     /**
      * Rebuild the two live surfaces:
      *  - `todosDoc`: one bordered Todos panel (or nothing when all completed).
-     *  - `activityDoc`: the ` ↳ ` line (managed separately, persists) followed
+     *  - `activityDoc`: the ` ● ` line (managed separately, persists) followed
      *    by ONE Text holding the compact running-agent lines joined by '\n'
-     *    (or nothing when no agent runs — the slot collapses to the ↳ line).
+     *    (or nothing when no agent runs — the slot collapses to the ● line).
      * Clear-when-done: the Todos panel hides once every todo is completed (the
      * model writes the whole-list snapshot and rarely clears it — an
      * all-completed list is the end-of-work signal); the agent lines hide once
@@ -117,17 +121,18 @@ export declare class LiveWidgets {
      */
     private todoLines;
     /**
-     * One compact running-agent line for the last-request area: `  ↳ ` prefix
-     * (nesting one column right of the ` ↳ ` request text, like a tree level
-     * under the last request) + spinner + the agent NAME
-     * (`view.label`, matching the boxed panel's main line) + the exact meta that
-     * main line showed (`↻retries≤max`, `N token (%)`, elapsed). NO box chrome,
-     * NO connector, NO provider — the name is the prominent element. The label
-     * is the only unbounded field; it is clipped against a budget measured from
-     * the terminal width so the whole plain line (prefix included) fits, then
-     * the assembled plain line is clipped to the terminal width BEFORE any ANSI
-     * is applied (clipToWidth counts SGR fragments as visible columns — style
-     * last). The provider (`view.provider`) is dropped from this line.
+     * One compact running-agent line for the last-request area, todo-style:
+     * `├─ `/`└─ ` connector (same column as the todo rows and the request
+     * ` ● `) + spinner + the agent NAME (`view.label`, matching the boxed
+     * panel's main line) + the exact meta that main line showed (`↻retries≤max`,
+     * compact `tokens[/contextWindow]`, elapsed) + the child's latest output
+     * line when one exists (` · <tail>`, so the user sees it is alive). NO box
+     * chrome, NO provider — the name is the prominent element; the last running
+     * agent closes the list with `└─ `. The label is the only unbounded field;
+     * it is clipped against a budget measured from the terminal width so the
+     * whole plain line (prefix included) fits, then the assembled plain line is
+     * clipped to the terminal width BEFORE any ANSI is applied (clipToWidth
+     * counts SGR fragments as visible columns — style last).
      */
     private compactAgentLine;
 }