aiden-runtime 4.1.2 → 4.1.4

package/dist/cli/v4/display.js

@@ -18,13 +18,17 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Display = exports.SPINNER_PHRASES = exports.TOOL_ICONS = void 0;
+exports.TOOL_ROW_ARG_CAP = exports.TOOL_ROW_NAME_PAD = exports.Display = exports.SPINNER_PHRASES = exports.TOOL_ICONS = void 0;
 exports.iconForTool = iconForTool;
 exports.detectConfiguredChannels = detectConfiguredChannels;
 exports.summarizeConfiguredChannels = summarizeConfiguredChannels;
 exports.summarizeChannelState = summarizeChannelState;
 exports.voiceIndicator = voiceIndicator;
 exports.previewToolArgs = previewToolArgs;
+exports.verbForActivity = verbForActivity;
+exports.isPreFramedLine = isPreFramedLine;
+exports.countNewlines = countNewlines;
+exports.splitAtUnclosedBold = splitAtUnclosedBold;
 exports.formatToolDuration = formatToolDuration;
 exports.formatCompactTokens = formatCompactTokens;
 exports.formatElapsedShort = formatElapsedShort;
@@ -36,6 +40,9 @@ const marked_1 = require("marked");
 const TerminalRenderer = require('marked-terminal').default ?? require('marked-terminal');
 const skinEngine_1 = require("./skinEngine");
 const box_1 = require("./box");
+const toolTrail_1 = require("./display/toolTrail");
+// v4.1.3-essentials — capability card renderer (auth/platform failures).
+const capabilityCard_1 = require("./display/capabilityCard");
 // Phase v4.1-reply-formatting: skin-aware markdown renderer that
 // replaces marked-terminal's defaults with structured headers, lists,
 // code blocks, blockquotes, and links.
@@ -43,71 +50,63 @@ const replyRenderer_1 = require("./replyRenderer");
 // Optional "Sources" footer when AIDEN_CITATIONS=1 (default off).
 const citationFooter_1 = require("./citationFooter");
 const toolPreview_1 = require("./toolPreview");
+// v4.1.4 reply-quality polish: shared frame math for width + indent.
+// `cols()`, `rule()`, `agentTurn`, and `tryRerenderInPlace` all route
+// through frame helpers so the visible left edge / right margin / wrap
+// targets are consistent across streaming, rerender, and one-shot
+// reply paths. See `cli/v4/display/frame.ts` for the math.
+const frame_1 = require("./display/frame");
 /**
- * Phase 26.2.7 — category emoji icons for the tool-row prefix when
- * `AIDEN_UI_ICONS=1` is set in the environment. Default OFF (the
- * row stays at `·`) because emoji width and font availability vary
- * across Windows Terminal / older Console hosts / SSH sessions.
+ * v4.1.3-repl-polish — category emoji icons for the tool-row trail.
+ * Icons are ON by default (AIDEN_UI_ICONS !== '0'). Set
+ * `AIDEN_UI_ICONS=0` to disable them (CI / dumb terminals).
  *
- * Categories — tool name is matched against keys in this map:
- *   1. exact-match first (lowercased toolName)
- *   2. then substring match in insertion order
- *   3. fall back to `default` (·)
+ * Kept as a flat Record for backward-compat with smoke tests that
+ * import it directly. The canonical lookup now lives in
+ * `./display/toolTrail` (supports verb too); this map is derived
+ * from it for legacy reference.
  *
- * Keep the map small and category-based, NOT one-per-tool.
+ * Matching order: exact lowercased name, then substring, then 'default'.
  */
 exports.TOOL_ICONS = {
-    // Observe / read / inspect
-    observe: '👁',
-    read: '👁',
-    file_read: '👁',
-    list: '👁',
-    // Think / analyze / plan
-    analyze: '🧠',
-    think: '🧠',
-    plan: '📋',
-    skills_list: '📋',
-    // Execute / write / run
-    execute: '⚡',
-    run: '⚡',
-    bash: '⚡',
-    powershell: '⚡',
-    code: '⚡',
-    skill_view: '⚡',
-    write: '✏',
-    edit: '✏',
+    // Observe / read
+    file_read: '👁', read_file: '👁', file_list: '👁', list_directory: '👁',
+    observe: '👁', read: '👁', list: '👁',
+    // Write / edit
+    file_write: '✏', write_file: '✏', edit_file: '✏',
+    write: '✏', edit: '✏', create: '✏',
+    // Execute / run
+    bash: '⚡', powershell: '⚡', execute_code: '⚡', skill_view: '⚡',
+    execute: '⚡', run: '⚡',
     // Web / browse
-    web_search: '🌐',
-    web_fetch: '🌐',
-    open_url: '🌐',
-    browser: '🌐',
-    // Memory
-    memory: '🧠',
-    recall: '🧠',
+    web_search: '🌐', web_fetch: '🌐', fetch_url: '🌐', open_url: '🌐',
+    navigate: '🌐', browser: '🌐', fetch: '🌐', search: '🌐',
+    // Memory / recall
+    recall_session: '🧠', session_search: '🧠', memory: '🧠', recall: '🧠',
+    // Think
+    session_summary: '🧠', analyze: '🧠', think: '🧠',
+    // Skills / catalog
+    skills_list: '📋', skill: '📋',
+    // Screen / capture
+    screenshot: '🖥', computer: '🖥',
+    // Media / launch
+    now_playing: '▶', app_launch: '▶', media: '▶',
+    // Deploy / build
+    deploy: '📦', build: '📦', push: '📦',
+    // Message / send
+    send: '💬', message: '💬', notify: '💬',
     // Verify / test
-    verify: '🛡',
-    test: '🛡',
-    // Default fallback (matches current behaviour).
+    verify: '🛡', test: '🛡', doctor: '🛡', health: '🛡',
+    // Default fallback
     default: '·',
 };
 /**
- * Phase 26.2.7 — return the category emoji for `toolName` from
- * `TOOL_ICONS`, or `·` when nothing matches. Lowercases the input
- * and tries exact match first, then substring match in the map's
- * insertion order. Pure — exported for smoke testing.
+ * Return the category emoji for `toolName`, or '·' when nothing matches.
+ * Delegates to the canonical toolTrail lookup (returns icon only).
+ * Exported for backward-compat with existing smoke / unit tests.
  */
 function iconForTool(toolName) {
-    const lc = toolName.toLowerCase();
-    const exact = exports.TOOL_ICONS[lc];
-    if (exact)
-        return exact;
-    for (const [key, glyph] of Object.entries(exports.TOOL_ICONS)) {
-        if (key === 'default')
-            continue;
-        if (lc.includes(key))
-            return glyph;
-    }
-    return exports.TOOL_ICONS.default;
+    return (0, toolTrail_1.iconForTool)(toolName).icon;
 }
 /**
  * Phase 26.2.6 — pool of fun spinner phrases that the chat REPL
@@ -241,6 +240,15 @@ class Display {
             // marked-terminal optional — markdown() falls back to raw text below
         }
     }
+    /**
+     * v4.1.3-repl-polish — public colour gate so callers (e.g. session-end
+     * card renderer) can colour text without importing SkinEngine directly.
+     * Delegates to the active skin's applyColors(). Monochrome mode is
+     * respected the same way as internal calls.
+     */
+    applyColors(text, kind) {
+        return this.skin.applyColors(text, kind);
+    }
     /**
      * Build the welcome banner string (does not write).
      *
@@ -263,18 +271,25 @@ class Display {
     // ── Phase 23.6 — v3 visual primitives ──────────────────────────────────
     // Pure renderers (return strings, don't write) so chatSession can
     // compose the boot card and turn rhythm without owning ANSI escapes.
-    /** Terminal column count clamped to 100 — matches v3 width discipline. */
+    /**
+     * Terminal column count. v4.1.4 reply-quality polish: delegates to
+     * `frame.getTerminalCols()` so all width math shares one formula.
+     * Retains the 100-col cap via `Math.min` so existing callers that
+     * paint full-width chrome (boot card, footer) keep their visual
+     * identity — `frame.BODY_WIDTH_MAX` is the tunable.
+     */
     cols() {
-        return Math.min(this.out.columns ?? 80, 100);
+        return Math.min((0, frame_1.getTerminalCols)(this.out), 100);
     }
     /**
-     * Thin horizontal rule (`──…──`) in muted colour, full visible width
-     * minus the 2-column indent the boot card / turn render uses.  Returns
-     * the line WITHOUT a trailing newline; caller adds one + the leading
-     * 2-space indent.
+     * Thin horizontal rule (`──…──`) in muted colour, full body width.
+     * v4.1.4 reply-quality polish: width sourced from `frame.getBodyWidth()`
+     * so the rule sits at the same right margin as wrapped prose and
+     * code blocks. Returns the line WITHOUT a trailing newline; caller
+     * adds one + the leading gutter.
      */
     rule(width) {
-        const w = Math.max(8, (width ?? this.cols()) - 2);
+        const w = Math.max(8, width ?? (0, frame_1.getBodyWidth)(this.out));
         return this.skin.applyColors('─'.repeat(w), 'muted');
     }
     /** Render `▲` (brand-orange filled triangle) — Aiden's identity motif. */
@@ -725,6 +740,148 @@ class Display {
             },
         };
     }
+    /**
+     * v4.1.4 reply-quality polish — Part 1.6 activity indicator.
+     *
+     * Renders `▲ {verb}{dots} (Ns)    ▸▸ Ctrl+C cancel` on a single
+     * line. `verb` is the activity label; the dots pulse 0→1→2→3→0
+     * every 400ms; elapsed time `(Ns)` appears only once N >= 1 (avoids
+     * the `(0s)` flash). The "▸▸ Ctrl+C cancel" hint is folded into the
+     * same line so cursor management stays simple (single-line write,
+     * single-line erase).
+     *
+     * Pause/resume semantics:
+     *   - `pause()` erases the line + stops the tick + sets paused=true.
+     *     Elapsed time keeps accumulating wall-clock — when a later
+     *     `resume()` re-renders, the indicator shows the TOTAL elapsed
+     *     since the original `activityIndicator()` call, not just since
+     *     the last resume.
+     *   - `resume(verb?)` re-renders on a fresh line below the current
+     *     cursor and restarts the tick. Optional `verb` swap is the
+     *     supported way to transition phases ("thinking" → "drafting").
+     *   - `stop()` is terminal — erases the line, marks stopped, refuses
+     *     further pause/resume.
+     *
+     * Non-TTY: completely silent. No initial paint, no ticks, no erases.
+     * Pipes / CI / MCP serve mode get clean output by default.
+     *
+     * Cursor invariant on render: the indicator OWNS one line. After
+     * each render the cursor sits at column 0 of the indicator line
+     * (NOT a new line below it) — that way the next render erases the
+     * line and rewrites in place. Callers that want to write OTHER
+     * content below MUST call `pause()` first; otherwise their content
+     * lands on the indicator line and the next tick clobbers it.
+     */
+    activityIndicator(initialVerb = 'thinking') {
+        const sk = this.skin;
+        const out = this.out;
+        const isTty = !!out.isTTY;
+        const startTime = Date.now();
+        let verb = initialVerb;
+        let dotFrame = 0;
+        let paused = !isTty; // non-TTY = effectively pre-paused (silent)
+        let stopped = false;
+        let printed = false;
+        let tickTimer = null;
+        // Tunable cadence. v4.1.4 Phase 3b' (Issue G): bumped from 400ms
+        // to 250ms after visual smoke — 400ms felt sluggish, made the
+        // indicator look static between seconds. 250ms gives ~4 dot
+        // updates per second so motion is always visible even when the
+        // (Ns) counter hasn't ticked. Slow enough not to flicker on SSH
+        // / slow ConPTY refresh.
+        const TICK_MS = 250;
+        // ▲ glyph in brand orange — the user's primary motif. Dots and
+        // elapsed counter paint muted to keep visual weight on the verb.
+        //
+        // v4.1.4 Phase 3b' (Issue F): the inline "▸▸ Ctrl+C cancel" hint
+        // shipped with Phase 3a was visually noisy on the activity line
+        // and collided with planner-debug dim writes. Dropped per user
+        // feedback; a separate bottom-of-screen footer can be added in
+        // v4.1.5 if wanted, but it must NOT be glued to the indicator.
+        const glyph = sk.applyColors('▲', 'brand');
+        const buildLine = () => {
+            const dots = '.'.repeat(dotFrame); // 0..3 dots
+            const elapsedSec = Math.floor((Date.now() - startTime) / 1000);
+            const elapsedStr = elapsedSec >= 1
+                ? ` ${sk.applyColors(`(${elapsedSec}s)`, 'muted')}`
+                : '';
+            // `▲ {verb}{dots-padded-to-3}{elapsed?}`
+            return `${glyph} ${verb}${dots.padEnd(3, ' ')}${elapsedStr}`;
+        };
+        const renderTick = () => {
+            if (stopped || paused || !isTty)
+                return;
+            dotFrame = (dotFrame + 1) % 4;
+            // `\r\x1b[K` — carriage return + clear line — then write the
+            // fresh indicator. No newline at end: cursor stays at end of
+            // the indicator line, ready for the next overwrite.
+            out.write(`\r\x1b[K${buildLine()}`);
+        };
+        const startTick = () => {
+            if (stopped || !isTty || tickTimer !== null)
+                return;
+            tickTimer = setInterval(renderTick, TICK_MS);
+        };
+        const stopTick = () => {
+            if (tickTimer !== null) {
+                clearInterval(tickTimer);
+                tickTimer = null;
+            }
+        };
+        const eraseLine = () => {
+            if (isTty && printed)
+                out.write('\r\x1b[K');
+        };
+        // Initial paint — only on TTY.
+        if (isTty) {
+            out.write(buildLine());
+            printed = true;
+            startTick();
+        }
+        return {
+            pause: () => {
+                if (stopped || paused)
+                    return;
+                paused = true;
+                stopTick();
+                eraseLine();
+                // After erase the cursor is at column 0 of the indicator's
+                // (now empty) line. Caller is expected to write its own
+                // content next; that content lands cleanly on this line.
+            },
+            resume: (newVerb) => {
+                if (stopped)
+                    return;
+                if (typeof newVerb === 'string' && newVerb.length > 0)
+                    verb = newVerb;
+                if (!paused)
+                    return;
+                paused = false;
+                if (!isTty)
+                    return;
+                // Caller has just finished writing its own content (typically
+                // ending with `\n`), so the cursor is on a fresh line below
+                // whatever was there. Render the indicator there and arm the
+                // tick again.
+                out.write(buildLine());
+                printed = true;
+                startTick();
+            },
+            setVerb: (newVerb) => {
+                if (typeof newVerb === 'string' && newVerb.length > 0)
+                    verb = newVerb;
+            },
+            stop: () => {
+                if (stopped)
+                    return;
+                stopped = true;
+                stopTick();
+                eraseLine();
+            },
+            isPaused: () => paused,
+            isStopped: () => stopped,
+        };
+    }
     // ── Phase 23.5 — tool event row ───────────────────────────────────────
     // One line per tool call: a "·" gutter, the keyword `tool`, the
     // tool name (soft cyan, padded), a brief truncated arg preview, and
@@ -738,55 +895,133 @@ class Display {
     // ANSI cursor games on a dumb sink.
     toolRow(name, args) {
         const sk = this.skin;
-        const argStr = previewToolArgs(args);
-        const padded = name.length > TOOL_ROW_NAME_PAD
-            ? name.slice(0, TOOL_ROW_NAME_PAD)
-            : name.padEnd(TOOL_ROW_NAME_PAD);
-        // Phase 26.2.7 — category emoji icon when AIDEN_UI_ICONS=1, else
-        // the default muted middle-dot. Read at call-time so toggling
-        // the env var doesn't require a restart. Emoji are rendered raw
-        // (no SGR wrap) because most terminals paint emoji glyphs in
-        // their native colour and ignore foreground ANSI anyway.
-        const useIcons = process.env.AIDEN_UI_ICONS === '1';
-        const glyph = useIcons ? iconForTool(name) : sk.applyColors('·', 'muted');
-        const left = `  ${glyph} ` +
-            `${sk.applyColors('tool', 'muted')} ` +
-            `${sk.applyColors(padded, 'tool')} ` +
-            `${sk.applyColors(argStr, 'muted')}`;
-        const renderBracket = (text, kind) => {
-            const colored = sk.applyColors(`[${text}]`, kind);
-            return `${left} ${colored}\n`;
+        // ── Build the fixed left portion (icon + verb + detail) ────────────
+        // v4.1.3-repl-polish: icons default ON; set AIDEN_UI_ICONS=0 to
+        // disable (CI / dumb terminals / narrow SSH sessions).
+        // Read at call-time so env changes take effect without restart.
+        const useIcons = process.env.AIDEN_UI_ICONS !== '0';
+        const { icon, verb } = (0, toolTrail_1.iconForTool)(name);
+        const glyph = useIcons ? icon : sk.applyColors('·', 'muted');
+        // Detail field: v4.1.4-media — consult `buildToolPreview` first so
+        // tools registered in `TOOL_PRIMARY_ARG` (media_transport → 'target',
+        // media_key → 'action', file_read → 'path', etc.) get their
+        // meaningful primary-arg preview instead of a JSON blob. Fall back
+        // to the generic `previewToolArgs` scan for tools the map doesn't
+        // know about so unregistered MCP tools etc. still render readably.
+        const mapped = (0, toolPreview_1.buildToolPreview)(name, args);
+        const detail = (0, toolTrail_1.truncDetail)(mapped ?? previewToolArgs(args));
+        // v4.1.3-essentials: live tool indicator. Capture wall-clock start
+        // so the running-row renderer can append an elapsed-time suffix
+        // ("running 3s…") after the first second. Sub-second tools render
+        // without the suffix — no flash of `running 0s` for fast paths.
+        const startedAt = Date.now();
+        // Running row — muted pipe, raw icon, tool-colored verb, muted detail.
+        // The optional `running Ns…` tail appears once the tool crosses the
+        // 1-second mark; the tick interval below redraws this row every 1s.
+        const runningRow = () => {
+            const elapsed = Date.now() - startedAt;
+            const liveSuffix = elapsed >= 1000
+                ? `  ${sk.applyColors(`running ${formatToolDuration(elapsed)}…`, 'muted')}`
+                : '';
+            return `${sk.applyColors(toolTrail_1.TRAIL_PIPE, 'muted')} ${glyph} ` +
+                `${sk.applyColors((0, toolTrail_1.padVerb)(verb), 'tool')} ` +
+                `${sk.applyColors(detail, 'muted')}${liveSuffix}\n`;
         };
-        const isTty = !!this.out.isTTY;
+        // Outcome row — entire line colored by outcome kind.
+        const outcomeRow = (suffix, kind) => {
+            const content = `${toolTrail_1.TRAIL_PIPE} ${glyph} ${(0, toolTrail_1.padVerb)(verb)} ${detail}` +
+                (suffix ? `  ${suffix}` : '');
+            return `${sk.applyColors(content, kind)}\n`;
+        };
+        // Capture stream reference so closures don't need `this`.
+        const out = this.out;
+        const isTty = !!out.isTTY;
         let printed = false;
-        const writeFinal = (text, kind) => {
-            if (isTty && printed) {
-                // Move up one line, clear it, then write the final row.
-                this.out.write('\x1b[1A\x1b[2K\r');
+        // v4.1.3-essentials: tick handle for the live-elapsed update. Set
+        // when we start the interval; cleared by every terminal method
+        // (ok / fail / degraded / blocked / emptyFail / emptyRetry) AND by
+        // `retry` (retry is a state announcement and should hold static
+        // until the next state change — race-free).
+        let tickTimer = null;
+        const stopTick = () => {
+            if (tickTimer !== null) {
+                clearInterval(tickTimer);
+                tickTimer = null;
             }
-            this.out.write(renderBracket(text, kind));
+        };
+        // Erase the last printed line (TTY only).
+        const eraseLast = () => {
+            if (isTty && printed)
+                out.write('\x1b[1A\x1b[2K\r');
+        };
+        const writeFinal = (suffix, kind) => {
+            stopTick();
+            eraseLast();
+            out.write(outcomeRow(suffix, kind));
             printed = true;
         };
         if (isTty) {
-            this.out.write(renderBracket('running', 'warn'));
+            // v4.1.3-essentials (replaces v4.1.3-repl-polish streamInterrupted
+            // flag pattern): if a stream is active, fence off the current
+            // chunk BEFORE the running row writes. `commitStreamChunk` does
+            // its own newline-fencing + in-place rerender of the just-streamed
+            // chunk so this row lands cleanly on its own line below.
+            this.commitStreamChunk();
+            out.write(runningRow());
             printed = true;
+            // v4.1.3-essentials: start the live-elapsed ticker. Fires every
+            // 1s; first tick at +1s, when `runningRow()` starts emitting the
+            // `running 1s…` suffix. Cleared by every terminal method via
+            // `stopTick()` — no leaked timers across the tool lifecycle.
+            // Tool dispatch in aidenAgent is sequential (one tool at a time
+            // per turn) so the assumption "running row is the last written
+            // line" holds for the whole tick lifetime; `eraseLast()` is safe.
+            tickTimer = setInterval(() => {
+                if (!printed)
+                    return;
+                eraseLast();
+                out.write(runningRow());
+            }, 1000);
         }
-        // On non-TTY we hold off entirely until the caller signals completion.
+        // Non-TTY: hold off until completion (log lines carry final state).
+        // No tick — non-TTY sinks (pipes, CI logs) get one line per call
+        // with the final state; live updates would be noise in scrollback.
         return {
             ok(durationMs, retries = 0) {
-                const text = retries > 0
-                    ? `ok ${formatToolDuration(durationMs)} after ${retries} ${retries === 1 ? 'retry' : 'retries'}`
-                    : `ok ${formatToolDuration(durationMs)}`;
-                writeFinal(text, 'success');
+                stopTick();
+                if (retries > 0) {
+                    // Showed retries — surface the eventual success in warn so the
+                    // user knows it took multiple attempts.
+                    writeFinal(`ok ${formatToolDuration(durationMs)} after ${retries} ${retries === 1 ? 'retry' : 'retries'}`, 'warn');
+                }
+                else {
+                    // Clean success — SILENT. Erase on TTY; emit nothing on non-TTY.
+                    eraseLast();
+                }
             },
             fail(durationMs, retries = 0) {
-                const text = retries > 0
+                const suffix = retries > 0
                     ? `fail ${formatToolDuration(durationMs)} after ${retries} ${retries === 1 ? 'retry' : 'retries'}`
                     : `fail ${formatToolDuration(durationMs)}`;
-                writeFinal(text, 'error');
+                writeFinal(suffix, 'error');
+            },
+            degraded(durationMs, reason) {
+                const suffix = reason
+                    ? `partial ${formatToolDuration(durationMs)} — ${reason}`
+                    : `partial ${formatToolDuration(durationMs)}`;
+                writeFinal(suffix, 'degraded');
             },
             retry(n, m) {
-                writeFinal(`retry ${n}/${m} …`, 'warn');
+                // v4.1.3-essentials: retry is a state-change announcement —
+                // freeze the row at the retry counter until next state change.
+                // Stopping the ticker prevents the next 1s tick from racing
+                // back over the retry counter with `running Ns…`.
+                stopTick();
+                // Update the running row with retry count.
+                eraseLast();
+                const content = `${toolTrail_1.TRAIL_PIPE} ${glyph} ${(0, toolTrail_1.padVerb)(verb)} ${detail}  retry ${n}/${m} …`;
+                out.write(sk.applyColors(content, 'warn') + '\n');
+                printed = true;
             },
             blocked() {
                 writeFinal('blocked', 'warn');
@@ -870,15 +1105,57 @@ class Display {
         const sk = this.skin;
         const useMd = opts.markdown !== false;
         const rawBody = useMd ? this.markdown(text).trimEnd() : text;
-        const indented = rawBody
-            .split('\n')
-            .map((ln) => (ln ? `  ${ln}` : ''))
-            .join('\n');
+        // v4.1.4 reply-quality polish — F1 detect-and-skip indent + wrap.
+        //
+        // Walks the rendered markdown line-by-line, but applies frame
+        // indent/wrap ONLY to plain prose lines. Lines that already carry
+        // structural chrome (code-block rail+bg, blockquote rail,
+        // pre-indented list bullets) pass through untouched — `renderCode-
+        // Block`, `renderBlockquote`, and the list override already own
+        // their own gutter + per-line wrap. Double-applying the gutter
+        // shifts content right by 3 cols; double-wrapping breaks the rail
+        // off the wrap-continuation row. See `isPreFramedLine` for the
+        // detection rules.
+        const indented = this.applyFrameToRendered(rawBody);
         const reasoning = opts.reasoning
-            ? `  ${sk.applyColors(opts.reasoning.trim(), 'muted')}\n`
+            ? `${(0, frame_1.getIndent)(0)}${sk.applyColors(opts.reasoning.trim(), 'muted')}\n`
             : '';
         return `${this.agentHeader()}${reasoning}${indented}\n`;
     }
+    /**
+     * v4.1.4 reply-quality polish — F1 shared helper.
+     *
+     * Apply frame indent + soft-wrap to the prose lines of a rendered
+     * markdown body, but pass structural lines (code-block rail+bg,
+     * blockquote rail, pre-indented list bullets) through unchanged.
+     *
+     * Shared by `agentTurn` (one-shot reply) and `tryRerenderInPlace`
+     * (post-stream rerender) so both paths produce identical output.
+     */
+    applyFrameToRendered(rawBody) {
+        const indent = (0, frame_1.getIndent)(0);
+        const bw = (0, frame_1.getBodyWidth)(this.out);
+        return rawBody
+            .split('\n')
+            .map((ln) => {
+            if (ln.length === 0)
+                return '';
+            // F1 detect-and-skip: pre-framed lines (code-block chrome, list
+            // bullets, blockquote rails) own their own gutter + wrap. Don't
+            // re-indent or re-wrap them — that double-applies the gutter
+            // and breaks the rail off wrap-continuation rows.
+            if (isPreFramedLine(ln))
+                return ln;
+            // Plain prose: indent + wrap to bodyWidth. wrap-ansi handles
+            // ANSI-aware width counting so bold/heading paint survives.
+            const wrapped = (0, frame_1.wrap)(ln, bw, { trim: false, hard: true });
+            return wrapped
+                .split('\n')
+                .map((vln) => `${indent}${vln}`)
+                .join('\n');
+        })
+            .join('\n');
+    }
     /**
      * Format a recoverable error with optional remediation suggestion.
      * Output goes through the caller (returned as string), not stderr.
@@ -973,6 +1250,57 @@ class Display {
     printError(message, suggestion) {
         this.out.write(this.error(message, suggestion));
     }
+    /**
+     * v4.1.3-essentials: render a structured capability card. Used when
+     * a tool fails because a capability is missing (platform unsupported,
+     * auth not present, key env-var unset) and a generic error wouldn't
+     * give the user enough signal. The card lists what the user CAN
+     * still do, what's blocked, and a one-line fix.
+     *
+     * Delegates the layout to the pure renderer in `./display/capability-
+     * Card.ts`. This method is the I/O boundary — caller passes data, we
+     * write lines to the configured stdout. Trailing newline ensures the
+     * card sits clean above whatever renders next (typically the prompt).
+     */
+    capabilityCard(data) {
+        // v4.1.3-essentials: fence off any active stream chunk before the
+        // card writes so the chunk gets rerendered as markdown and the
+        // card lands below it on its own line. Same pattern as toolRow /
+        // streamToolIndicator.
+        this.commitStreamChunk();
+        const lines = (0, capabilityCard_1.renderCapabilityCard)(data, (t, k) => this.applyColors(t, k));
+        for (const line of lines) {
+            this.out.write(line + '\n');
+        }
+        this.out.write('\n');
+    }
+    /**
+     * v4.1.4 reply-quality polish (Q-ResizeReflow Option B): zero the
+     * per-chunk row counter when the terminal resizes mid-stream.
+     *
+     * Why: the resize guard hard-clears the viewport (`\x1b[2J\x1b[H`)
+     * which removes ALL rows from the screen — but our `streamLineCount`
+     * still believes those rows are there. The next `tryRerenderInPlace`
+     * would walk the cursor back N rows that no longer exist, leaving a
+     * ghost gap at the top of the new viewport. Zeroing the count makes
+     * the next eraser a no-op (which is correct — there's nothing left
+     * to erase).
+     *
+     * Idempotent: no-op when no stream is active. Safe to call from a
+     * resize callback that fires unconditionally on every viewport
+     * change. Also resets `streamBuffer` so the next commit doesn't try
+     * to rerender content that was already wiped.
+     */
+    resetStreamFrameForResize() {
+        if (!this.streamHeaderShown)
+            return;
+        this.streamLineCount = 0;
+        this.streamBuffer = '';
+        // Header was wiped by the hard-clear too — let the next
+        // streamPartial / agentTurn write a fresh one.
+        this.streamHeaderShown = false;
+        this.streamLastEndedNewline = false;
+    }
     /**
      * Append a streamed text fragment. Writes a styled "Aiden" header on
      * the first call of a turn, then writes raw text directly via the
@@ -997,72 +1325,270 @@ class Display {
         this.out.write(text);
         this.streamLastEndedNewline = text.endsWith('\n');
         // Phase v4.1-reply-formatting: track buffer + line count for the
-        // post-stream re-render. We count newlines in the OUTGOING bytes
-        // so the eraser later knows how many rows to clear.
+        // post-stream re-render.
         this.streamBuffer += text;
-        for (let i = 0; i < text.length; i += 1)
-            if (text[i] === '\n')
-                this.streamLineCount += 1;
+        // v4.1.4 reply-quality polish — F-B1 wrap-aware row count.
+        //
+        // Prior counter just `streamLineCount += text.match(/\n/g)?.length`
+        // — counted `\n` chars only. When the model emits a long single
+        // line (e.g. a 100-char bullet on an 80-col terminal), the terminal
+        // naturally wraps it across multiple screen rows, but the old
+        // counter would still think it's 1 row. At streamComplete the
+        // eraser walked back N rows that didn't match the wrapped row
+        // count → raw `**markup**` from the streaming phase remained
+        // visible above the rerendered output.
+        //
+        // Confirmed undercount via scripts/smoke-stream-wrap-count.ts:
+        // 3 long bullets on 80-col counted 3, actually 6. Multi-chunk
+        // preamble + bullets on 40-col counted 4, actually 8.
+        //
+        // Fix: count `ceil(visibleWidth / cols)` rows per `\n`-delimited
+        // segment, then add 1 for the `\n` itself (cursor advances to
+        // next row when newline is emitted). Visible width strips ANSI.
+        this.streamLineCount += this.countStreamRows(text);
     }
     /**
-     * Mark the end of a streaming turn. Adds a trailing newline if the
-     * stream didn't end with one so the next CLI line doesn't visually
-     * butt up against the model's last token. Resets the per-turn state
-     * so the next `streamPartial` re-emits the header.
+     * v4.1.4 reply-quality polish — F-B1 helper.
+     *
+     * Estimate how many screen rows `text` consumes when written to a
+     * terminal of width `this.out.columns`. Counts terminal-natural-wrap
+     * rows for each logical line, plus one row per `\n`.
+     *
+     * Falls back to a sane count when columns is undefined (non-TTY or
+     * pre-resize): in that case the eraser won't fire anyway
+     * (`tryRerenderInPlace` gates on `out.isTTY`), so the count is
+     * effectively ignored. We still compute a defensible value so any
+     * future TTY-detection change doesn't silently regress.
+     *
+     * Pure with respect to ANSI: escape sequences pass through
+     * `visibleLength` and don't inflate the row count.
+     *
+     * Edge cases:
+     *   - Empty text → 0 rows (consistent with the prior counter).
+     *   - Text without `\n` → ceil(visibleLen / cols) rows.
+     *   - Trailing `\n` → counts the prior content row + 1 for the
+     *     newline. Cursor is now at the start of the next row, which is
+     *     correct screen-state — the next streamPartial extends from
+     *     col 0 of that row.
      */
-    streamComplete() {
-        if (!this.streamHeaderShown)
-            return;
-        if (!this.streamLastEndedNewline)
-            this.out.write('\n');
-        // Phase v4.1-reply-formatting: re-render the buffered stream as
-        // structured markdown — but ONLY when stdout is a TTY and the
-        // buffer actually contains markdown structure worth rendering.
-        // Plain prose with no headers / lists / fences gets left alone
-        // (no flicker, identical output). Otherwise we erase the raw
-        // streamed body via cursor-up + erase-line and reprint via the
-        // skin-aware renderer.
-        const buffered = this.streamBuffer;
-        const lines = this.streamLineCount;
-        this.streamBuffer = '';
-        this.streamLineCount = 0;
-        this.streamHeaderShown = false;
-        this.streamLastEndedNewline = false;
+    countStreamRows(text) {
+        if (text.length === 0)
+            return 0;
+        const cols = (typeof this.out.columns === 'number' && this.out.columns >= 1)
+            ? this.out.columns
+            : 80;
+        // Semantics: counter tracks ROW BOUNDARIES CROSSED during
+        // emission, not "rows occupied". The eraser uses `\x1b[<N>F`
+        // which moves the cursor up N rows; if N matches the number of
+        // boundaries crossed from start-of-stream to current-cursor, the
+        // eraser lands at the start row and `\x1b[J` clears the rest.
+        //
+        // For a segment of visible width V on a terminal of width C:
+        //   - V == 0       → 0 wrap boundaries
+        //   - V <= C       → 0 wrap boundaries (single row)
+        //   - C < V <= 2C  → 1 wrap boundary
+        //   - General      → floor((V - 1) / C) wrap boundaries
+        //
+        // Each `\n` between segments crosses one boundary regardless of
+        // visible width — that's the newline advancing the cursor.
+        let rows = 0;
+        const segments = text.split('\n');
+        for (let i = 0; i < segments.length; i += 1) {
+            const seg = segments[i] ?? '';
+            const visible = (0, box_1.visibleLength)(seg);
+            if (visible > 0)
+                rows += Math.floor((visible - 1) / cols);
+            if (i < segments.length - 1)
+                rows += 1;
+        }
+        return rows;
+    }
+    /**
+     * v4.1.3-essentials: rerender a buffered stream chunk in place. Walks
+     * the cursor back `lines` rows, erases to end-of-screen, and reprints
+     * the chunk as skin-aware markdown.
+     *
+     * Pure side-effect; returns nothing. Used by:
+     *   - `commitStreamChunk()`        — when a tool row interrupts the
+     *                                    stream, render the pre-tool
+     *                                    chunk before the row writes.
+     *   - `streamComplete()`           — final chunk at end of turn.
+     *
+     * Heuristic gate avoids flicker on plain prose (no structure → no
+     * rerender, no eraser fires). The catch block writes the RAW buffered
+     * text as a fallback if `marked` throws — without this the eraser
+     * would already have run and the body would silently vanish.
+     * v4.1.3-essentials raw-text fallback per "make state legible" thesis.
+     */
+    tryRerenderInPlace(buffered, lines) {
         if (!this.out.isTTY)
             return;
         if (process.env.AIDEN_NO_REFORMAT === '1')
             return;
-        // Cheap heuristic: only re-render when there's structure that
-        // benefits from formatting. Avoids flicker on short prose replies.
+        if (lines === 0)
+            return;
+        // Cheap structural heuristic — only re-render when formatting
+        // actually helps. Plain prose chunks stay raw (no flicker).
+        //
+        // v4.1.3-essentials post-ship: inline `**bold**` and `` `code` ``
+        // added to the heuristic. Before this, a chunk that contained ONLY
+        // inline markdown (no headings / lists / code blocks) skipped
+        // rerender entirely, leaving the literal `**bold**` asterisks in
+        // user-visible output. The `paintBoldWhite` strong renderer was
+        // never invoked for those chunks.
+        //
+        // Patterns:
+        //   - `**bold**`: requires non-space immediately after the opening
+        //     `**` so `2 ** 3` math expressions don't false-positive.
+        //     Tolerates multi-line bold via `[\s\S]*?`.
+        //   - `` `code` ``: negative-lookarounds for the triple-backtick
+        //     fence so we don't double-trigger when ``` lines are present
+        //     (those already match the fence pattern above).
         const hasStructure = /^#{1,6}\s/m.test(buffered) ||
             /^\s*[-*+]\s/m.test(buffered) ||
             /^\s*\d+\.\s/m.test(buffered) ||
             /^>\s/m.test(buffered) ||
-            /```/.test(buffered);
+            /```/.test(buffered) ||
+            /\*\*\S[\s\S]*?\*\*/.test(buffered) ||
+            /(?<![`])`[^`\n]+`(?![`])/.test(buffered);
         if (!hasStructure)
             return;
         try {
-            // Erase the raw streamed body in place. We wrote `lines + 1`
-            // rows (header + body) — the header (`┃ Aiden`) stays, so we
-            // walk back `lines` rows and clear each.
-            // `\x1b[<n>F` = cursor-up-and-to-column-0 N times.
-            // `\x1b[J`    = erase from cursor to end of screen.
-            if (lines > 0) {
-                this.out.write(`\x1b[${lines}F\x1b[J`);
-            }
+            // \x1b[<n>F = cursor-up-and-to-column-0 N times.
+            // \x1b[J   = erase from cursor to end of screen.
+            this.out.write(`\x1b[${lines}F\x1b[J`);
             const formatted = this.markdown(buffered).trimEnd();
-            const indented = formatted
-                .split('\n')
-                .map((ln) => (ln ? `  ${ln}` : ''))
-                .join('\n');
+            // v4.1.4 reply-quality polish: same detect-and-skip indent + wrap
+            // as agentTurn so streamed and one-shot replies share the visible
+            // frame. wrap-ansi handles ANSI-aware width counting for prose;
+            // structural lines (code-block chrome, list bullets, blockquote
+            // rails) pass through unchanged so their own gutter + wrap stays
+            // intact.
+            const indented = this.applyFrameToRendered(formatted);
             this.out.write(indented + '\n');
         }
         catch {
-            // If anything goes wrong with the re-render, leave the raw
-            // streamed text in place — graceful degradation beats flicker
-            // + corrupted output.
+            // Eraser already ran. v4.1.3-essentials: write the raw buffered
+            // text back so the body doesn't vanish silently. The user sees
+            // unformatted markdown rather than a missing reply — the honest
+            // failure mode.
+            this.out.write(buffered);
+            if (!buffered.endsWith('\n'))
+                this.out.write('\n');
         }
     }
+    /**
+     * v4.1.3-essentials: fence off the current stream chunk before a
+     * non-stream write (tool row, tool indicator, capability card) lands.
+     *
+     * Replaces the v4.1.3-repl-polish `streamInterrupted` flag pattern.
+     * Old pattern: set flag mid-stream → on streamComplete, check flag
+     * and SKIP rerender entirely (lost markdown on every tool-using
+     * turn). New pattern: at each interrupt point, eagerly rerender THIS
+     * chunk in place, then reset the per-chunk window so the next
+     * streamPartial starts a fresh count. The cursor is at the end of
+     * this chunk when commit fires, so `streamLineCount` is correct for
+     * the eraser — tool rows write below without being clobbered.
+     *
+     * Multi-chunk turns (model says X, calls tool, says Y, calls tool,
+     * says Z) get all three chunks rerendered as markdown.
+     *
+     * Idempotent: no-op when no stream cycle is active or when the buffer
+     * is empty (consecutive tool calls). Always ensures the cursor sits
+     * at start-of-line before returning so the caller can write its own
+     * row cleanly.
+     */
+    commitStreamChunk() {
+        if (!this.streamHeaderShown)
+            return;
+        // Ensure the streamed chunk ends with a newline so the interrupt
+        // row doesn't stick to mid-token text from the prior delta.
+        if (!this.streamLastEndedNewline) {
+            this.out.write('\n');
+            this.streamLastEndedNewline = true;
+            // The trailing newline we just wrote DOES bump the cursor's row,
+            // but only by 1 — and `streamLineCount` should reflect physical
+            // rows of the chunk. Add it so the eraser walks back the right
+            // amount.
+            this.streamLineCount += 1;
+        }
+        // v4.1.3-essentials boldwrap-fix: if the chunk ends mid-bold-pair
+        // (e.g. tool fired between the model emitting `**` and the closing
+        // `**`), splitting here would leave literal asterisks in the
+        // rerendered output and a matching orphan in the next chunk.
+        // `splitAtUnclosedBold` finds the last unmatched `**` and carves
+        // the buffer into two parts: the closed-bold prefix we CAN
+        // rerender now, and the carry tail that we keep for the next
+        // chunk (where the closing `**` will eventually arrive).
+        //
+        // Code-fence safety (carried in the helper): if the would-be
+        // unmatched `**` is inside an open ``` fence, we defer the whole
+        // chunk — bold-syntax inside code blocks isn't markdown bold and
+        // splitting there would corrupt the fence.
+        const split = splitAtUnclosedBold(this.streamBuffer);
+        if (split.carry === '') {
+            // Common case: buffer is balanced (or has no `**` at all).
+            // Same behavior as before — rerender the whole chunk in place
+            // and reset the per-chunk window.
+            this.tryRerenderInPlace(this.streamBuffer, this.streamLineCount);
+            this.streamBuffer = '';
+            this.streamLineCount = 0;
+            return;
+        }
+        // Split path: erase the WHOLE chunk (because the cursor is at the
+        // end of the full buffer), rerender the closed prefix, then
+        // re-emit the carry as raw text. The carry visibly stays on
+        // screen as raw `**Live tool indi`-style text — ugly for the
+        // ~milliseconds until the next streamPartial extends it past the
+        // closing `**`, at which point the next commit will rerender
+        // cleanly.
+        const rerenderableLines = countNewlines(split.rerenderable);
+        const carryLines = this.streamLineCount - rerenderableLines;
+        if (this.out.isTTY && this.streamLineCount > 0) {
+            // \x1b[<n>F = cursor-up-and-to-column-0 N times.
+            // \x1b[J   = erase from cursor to end of screen.
+            this.out.write(`\x1b[${this.streamLineCount}F\x1b[J`);
+        }
+        // Rerender the closed prefix (handles its own heuristic gate
+        // internally — a prefix without structure stays raw, which is
+        // identical to the pre-split behavior).
+        this.tryRerenderInPlace(split.rerenderable, rerenderableLines);
+        // Re-emit the carry verbatim. It's intentionally raw because the
+        // unmatched `**` can't be rendered without its closing pair.
+        this.out.write(split.carry);
+        // Reset the per-chunk window to the carry only. Next streamPartial
+        // extends it; when the closing `**` lands, the next commit (or
+        // streamComplete) rerenders cleanly.
+        this.streamBuffer = split.carry;
+        this.streamLineCount = carryLines;
+        this.streamLastEndedNewline = split.carry.endsWith('\n');
+    }
+    /**
+     * Mark the end of a streaming turn. Adds a trailing newline if the
+     * stream didn't end with one so the next CLI line doesn't visually
+     * butt up against the model's last token. Rerenders the FINAL chunk
+     * (post-last-tool prose, or the whole body if no tools fired this
+     * turn) and resets the per-turn state so the next `streamPartial`
+     * re-emits the header.
+     */
+    streamComplete() {
+        if (!this.streamHeaderShown)
+            return;
+        if (!this.streamLastEndedNewline) {
+            this.out.write('\n');
+            this.streamLineCount += 1;
+        }
+        // Final chunk: same in-place rerender path as commitStreamChunk
+        // (factored shared helper). Tool-row interrupts have already
+        // committed their preceding chunks; what's left in the buffer here
+        // is the post-final-tool prose — typically the bulk of the
+        // user-visible body in well-behaved turns.
+        this.tryRerenderInPlace(this.streamBuffer, this.streamLineCount);
+        this.streamBuffer = '';
+        this.streamLineCount = 0;
+        this.streamHeaderShown = false;
+        this.streamLastEndedNewline = false;
+    }
     /**
      * Phase v4.1-reply-formatting: render the optional "Sources"
      * footer when AIDEN_CITATIONS=1 and the trace has fetch-class
@@ -1085,10 +1611,15 @@ class Display {
      * newline if the prior delta ran past column N without one.
      */
     streamToolIndicator(name) {
+        // v4.1.3-essentials (replaces v4.1.3-repl-polish streamInterrupted
+        // flag pattern): fence off the streamed chunk before the indicator
+        // writes. `commitStreamChunk` handles the newline-or-not and
+        // in-place rerenders the pre-indicator chunk so this row lands
+        // below well-formed markdown rather than below raw streamed text.
+        this.commitStreamChunk();
         const sk = this.skin;
         const arrow = sk.getActive().glyphs?.arrow ?? '>';
-        const prefix = this.streamLastEndedNewline ? '' : '\n';
-        this.out.write(`${prefix}${sk.applyColors(`${arrow} ${name}…`, 'tool')}\n`);
+        this.out.write(`${sk.applyColors(`${arrow} ${name}…`, 'tool')}\n`);
         this.streamLastEndedNewline = true;
     }
 }
@@ -1144,11 +1675,29 @@ function renderRmsBar(rms) {
     const filled = Math.round((safe / BAR_FULL_RMS) * BAR_WIDTH);
     return '▌'.repeat(filled) + ' '.repeat(BAR_WIDTH - filled);
 }
-// ── Phase 23.5 — tool row helpers ─────────────────────────────────────
-/** Width the tool name is padded to so brackets line up across rows. */
-const TOOL_ROW_NAME_PAD = 16;
-/** Args preview cap. Args longer than this get truncated with "…". */
-const TOOL_ROW_ARG_CAP = 40;
+// ── Phase 23.5 / v4.1.3-repl-polish — tool row helpers ────────────────
+//
+// v4.1.3 changes the row format from:
+//   "  {glyph} tool {name:16} {args}  [{state}]"
+// to the compact trail format:
+//   "┊ {icon} {verb:12} {detail:40}"
+//
+// Outcome semantics:
+//   ok()        → SILENT — running row is erased; nothing persists.
+//   fail()      → row persists in error (red).
+//   degraded()  → row persists in degraded (yellow). NEW in v4.1.3.
+//   blocked()   → row persists in warn.
+//   retry()     → running row is updated with retry counter.
+//   emptyFail() → treated as fail (error colour).
+//   emptyRetry()→ treated as retry.
+/**
+ * Kept for reference / smoke-test backward compat. New code should use
+ * TRAIL_VERB_PAD / TRAIL_DETAIL_CAP from toolTrail.ts instead.
+ * @deprecated
+ */
+exports.TOOL_ROW_NAME_PAD = toolTrail_1.TRAIL_VERB_PAD;
+/** @deprecated Use TRAIL_DETAIL_CAP. */
+exports.TOOL_ROW_ARG_CAP = toolTrail_1.TRAIL_DETAIL_CAP;
 /**
  * Build a compact, single-line preview of the tool's arguments. Picks
  * the most informative scalar fields when the args are an object, then
@@ -1184,13 +1733,202 @@ function previewToolArgs(args) {
     catch {
         serialized = String(obj);
     }
+    // v4.1.4-media: an empty object serializes to '{}'. Rendering that
+    // literal in the trail row is honest but ugly and reads as "buggy
+    // empty args". When the model legitimately passes an empty args
+    // object (e.g. `media_sessions({})`, `system_info()`), show nothing
+    // rather than the braces — `buildToolPreview` already does this for
+    // tools mapped in `TOOL_PRIMARY_ARG`; here we extend the same UX to
+    // any unmapped-tool fallback that bottoms out at `{}`.
+    if (serialized === '{}')
+        return '';
     return truncToolArg(serialized);
 }
 function truncToolArg(s) {
     const flat = s.replace(/\s+/g, ' ').trim();
-    if (flat.length <= TOOL_ROW_ARG_CAP)
+    if (flat.length <= exports.TOOL_ROW_ARG_CAP)
         return flat;
-    return flat.slice(0, TOOL_ROW_ARG_CAP - 1) + '…';
+    return flat.slice(0, exports.TOOL_ROW_ARG_CAP - 1) + '…';
+}
+/**
+ * v4.1.4 reply-quality polish — Part 1.6 tool-aware verb mapper.
+ *
+ * Picks the activity-indicator verb for the gap that follows a given
+ * tool's completion. The verb reflects "what the model is likely doing
+ * next" rather than "what just happened" — so a `file_read` completing
+ * leads to "reading" (model is digesting the contents) rather than
+ * "drafted" (which would imply done). Tested in display.test.ts.
+ *
+ * Categories (matches against the tool-name substring, lowercased):
+ *   - read/list/view/get/inspect    → 'reading'
+ *   - search/web/fetch_url/scrape   → 'searching'
+ *   - shell/exec/run/compute/system → 'analyzing'
+ *   - write/edit/patch/save         → 'drafting'
+ *   - everything else (or undefined) → 'thinking'
+ *
+ * Special caller-supplied phase override:
+ *   - When the caller knows "all tools are done, reply about to start"
+ *     they pass `phase: 'post-all'` → verb defaults to 'drafting'
+ *     regardless of the last tool name.
+ *
+ * Pure; exported for unit-test access.
+ */
+function verbForActivity(toolName, phase = 'post-tool') {
+    if (phase === 'pre-tools')
+        return 'thinking';
+    if (phase === 'post-all')
+        return 'drafting';
+    const t = (toolName ?? '').toLowerCase();
+    if (t.length === 0)
+        return 'thinking';
+    // Match in priority order so 'web_search' hits 'searching' (search)
+    // before 'reading' (a hypothetical 'web_search_read' would still
+    // map to 'searching' since search hits first).
+    if (/(^|_)(search|web|fetch_url|scrape|crawl)(_|$)/.test(t))
+        return 'searching';
+    if (/(^|_)(read|list|view|get|inspect|info|status)(_|$)/.test(t))
+        return 'reading';
+    if (/(^|_)(write|edit|patch|save|create|append|delete|remove)(_|$)/.test(t))
+        return 'drafting';
+    if (/(^|_)(shell|exec|execute|run|compute|process|system|launch)(_|$)/.test(t))
+        return 'analyzing';
+    return 'thinking';
+}
+/**
+ * v4.1.4 reply-quality polish — F1 detect-and-skip predicate.
+ *
+ * Returns true when `line` is a structural / pre-framed line emitted
+ * by replyRenderer (code-block chrome, blockquote rail, indented list
+ * bullet, fence rules). These lines OWN their own gutter and per-line
+ * wrap; `agentTurn` and `tryRerenderInPlace` MUST pass them through
+ * unchanged so the post-render indent+wrap pass doesn't:
+ *   - Double the gutter (content drifts 3 cols right per pass)
+ *   - Re-wrap an already-wrapped code line (rail/bg breaks across
+ *     the new wrap continuation row)
+ *
+ * Detection rules (all on the ANSI-bearing line as emitted by marked
+ * via our renderer overrides):
+ *   - Contains `\x1b[48;` anywhere → 24-bit bg paint = code-block
+ *     line. Always pre-framed (renderCodeBlock applies gutter + rail).
+ *   - Starts with `   │ ` or `   ┃ ` → explicit pre-framed rail
+ *     (code or blockquote at the frame gutter).
+ *   - Matches `^\s{2,}(•|▸|\d+\.)\s` (depth-indented list bullet) →
+ *     the list override already applied the per-depth indent.
+ *   - Matches `^\s{0,4}─{8,}` (horizontal-rule run or fence) → render-
+ *     specific divider already styled.
+ *
+ * Pure; exported for unit-test access.
+ */
+function isPreFramedLine(line) {
+    if (line.length === 0)
+        return false;
+    // eslint-disable-next-line no-control-regex
+    const stripped = line.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+    // v4.1.4 reply-quality polish — Fix D (tightened predicate).
+    //
+    // Code-block body lines start with the frame gutter + rail. The
+    // 24-bit bg paint (`\x1b[48;…`) also appears on these lines, but
+    // we MUST NOT use bg-presence alone as the trigger: the `codespan`
+    // renderer wraps inline `` `code` `` with the same bg envelope, so
+    // any prose line containing inline code would be wrongly classified
+    // as a code-block line and would bypass the indent + wrap pass
+    // (Issue D from visual smoke — prose with inline codespans
+    // terminal-natural-wrapped past bodyWidth).
+    //
+    // Rail prefix (after ANSI strip) is the reliable signal: only
+    // `renderCodeBlock` emits `   │ ` and only `renderBlockquote` emits
+    // `┃ ` at line start (with display-layer gutter prepended).
+    if (/^   │ /.test(stripped))
+        return true;
+    if (/^   ┃ /.test(stripped) || /^┃ /.test(stripped))
+        return true;
+    // Depth-indented list bullets emitted by the renderer.list override:
+    //   `  • prose…`        (depth 1, 2-space indent)
+    //   `    ▸ prose…`      (depth 2, 4-space indent)
+    //   `  1. prose…`       (numbered, depth 1)
+    if (/^\s{2,}(•|▸|\d+\.)\s/.test(stripped))
+        return true;
+    // Code-block fence rules (long runs of `─` with optional leading
+    // gutter + optional language label from renderCodeBlock). Match
+    // ANYWHERE in the line so the language-tagged top rule
+    // (`   ── lang ──────…──`) trips alongside the unlabeled bottom rule.
+    if (/─{8,}/.test(stripped))
+        return true;
+    return false;
+}
+/**
+ * v4.1.3-essentials boldwrap-fix: count `\n` occurrences in `s`.
+ * Used by `commitStreamChunk` to recompute `streamLineCount` after
+ * splitting a buffer at an unclosed-bold boundary. Pure helper —
+ * exported for unit-test access.
+ */
+function countNewlines(s) {
+    let n = 0;
+    for (let i = 0; i < s.length; i += 1)
+        if (s[i] === '\n')
+            n += 1;
+    return n;
+}
+/**
+ * v4.1.3-essentials boldwrap-fix: split a streamed-chunk buffer at the
+ * last unmatched `**` so the closed-bold prefix can be rerendered now
+ * and the open-bold tail can be carried into the next chunk.
+ *
+ * Returns `{ rerenderable, carry }`:
+ *   - rerenderable: the prefix with all `**` pairs balanced
+ *   - carry:        the suffix starting at the last unmatched `**`
+ *
+ * `carry === ''` signals "balanced — render the whole buffer". Caller
+ * uses this as the fast-path discriminator.
+ *
+ * Code-fence safety: if the buffer contains an UNCLOSED fenced code
+ * block (` ``` ` count is odd), defer the entire chunk by returning
+ * `{ rerenderable: '', carry: buffer }`. Bold-syntax inside code
+ * blocks is literal text — splitting there would corrupt the fence
+ * AND likely produce nonsensical rerender output. Trade-off: a chunk
+ * that ends mid-code-block doesn't rerender at all until the closing
+ * ``` arrives; acceptable because code blocks have their own
+ * styling (dark bg + left rail) that doesn't depend on the markdown
+ * rerender step.
+ *
+ * Pure function. Tested via `tests/v4/cli/display.test.ts`.
+ */
+function splitAtUnclosedBold(buffer) {
+    // Fast path: no `**` at all → balanced.
+    if (!buffer.includes('**'))
+        return { rerenderable: buffer, carry: '' };
+    // Code-fence safety: count triple-backtick fences. Odd = open fence,
+    // defer the whole buffer.
+    const fenceMatches = buffer.match(/```/g);
+    if (fenceMatches && fenceMatches.length % 2 === 1) {
+        return { rerenderable: '', carry: buffer };
+    }
+    // Count `**` occurrences. Even → balanced. Odd → there's an
+    // unmatched `**` — find the LAST one (the open).
+    const positions = [];
+    for (let i = 0; i < buffer.length - 1; i += 1) {
+        if (buffer[i] === '*' && buffer[i + 1] === '*') {
+            positions.push(i);
+            i += 1; // skip the second `*` so `***` doesn't double-count
+        }
+    }
+    if (positions.length % 2 === 0) {
+        return { rerenderable: buffer, carry: '' };
+    }
+    const lastUnmatched = positions[positions.length - 1];
+    // Inline-backtick safety: if the unmatched `**` sits inside an
+    // open single-backtick span on the same line, the `**` is literal
+    // code, not a bold marker. Defer the whole chunk.
+    const lineStart = buffer.lastIndexOf('\n', lastUnmatched) + 1;
+    const lineUpToBold = buffer.slice(lineStart, lastUnmatched);
+    const backticksOnLine = (lineUpToBold.match(/`/g) ?? []).length;
+    if (backticksOnLine % 2 === 1) {
+        return { rerenderable: '', carry: buffer };
+    }
+    return {
+        rerenderable: buffer.slice(0, lastUnmatched),
+        carry: buffer.slice(lastUnmatched),
+    };
 }
 /**
  * Render a tool-call duration in the bracket cluster. Sub-second