aiden-runtime 4.1.3 → 4.1.5

package/dist/cli/v4/display.js

@@ -18,13 +18,16 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_ROW_ARG_CAP = exports.TOOL_ROW_NAME_PAD = exports.Display = exports.SPINNER_PHRASES = exports.TOOL_ICONS = void 0;
+exports.TRAIL_HIDE_TOOLS = 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.makeNoOpToolRowHandle = makeNoOpToolRowHandle;
 exports.previewToolArgs = previewToolArgs;
+exports.verbForActivity = verbForActivity;
+exports.isPreFramedLine = isPreFramedLine;
 exports.countNewlines = countNewlines;
 exports.splitAtUnclosedBold = splitAtUnclosedBold;
 exports.formatToolDuration = formatToolDuration;
@@ -48,6 +51,12 @@ 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");
 /**
  * v4.1.3-repl-polish — category emoji icons for the tool-row trail.
  * Icons are ON by default (AIDEN_UI_ICONS !== '0'). Set
@@ -263,18 +272,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 +741,282 @@ 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.
+     */
+    /**
+     * v4.1.5 Issue K — wave-bar option.
+     *
+     * When `opts.waveBar === true` (DEFAULT), the indicator paints a
+     * second row BELOW the verb line — a 10-cell `▰▱` snake-scroll
+     * heartbeat that gives visible motion during long pre-first-token
+     * gaps even when the verb doesn't change. The bar is NOT progress:
+     * it's a constant-cadence heartbeat (250ms shared with the dot
+     * pulse), explicitly not a percentage indicator.
+     *
+     * Pass `{ waveBar: false }` for back-compat with v4.1.4 tests that
+     * assert single-row geometry. Production callers (chatSession) get
+     * the wave bar by default.
+     */
+    activityIndicator(initialVerb = 'thinking', opts = {}) {
+        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');
+        // v4.1.5 Issue K — wave-bar state. Snake-scroll: a 3-cell `▰`
+        // block slides across 10 cells, wrapping at the right edge. Same
+        // 250ms tick as the verb dot pulse — one timer drives both rows.
+        const waveBarEnabled = opts.waveBar !== false; // default true
+        const WAVE_CELLS = 10;
+        const WAVE_BLOCK = 3;
+        let waveFrame = 0;
+        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}`;
+        };
+        /**
+         * v4.1.5 Issue K — render the wave-bar row. A 3-cell `▰` block at
+         * positions `[waveFrame, waveFrame+1, waveFrame+2]` mod 10. The
+         * filled cells paint brand orange, empty cells paint warm-muted.
+         * Same width + glyph set as the token progress bar so the two
+         * rows feel like a coherent palette (one is heartbeat, the other
+         * is real progress).
+         *
+         * Heartbeat semantics: this is NOT progress. The wave moves at a
+         * constant 250ms cadence regardless of any backend metric. It
+         * exists purely so the user sees motion during the unobservable
+         * TTFT (time-to-first-token) wait. The verb row above carries
+         * any real lifecycle signal via `setVerb()`.
+         */
+        const buildWave = () => {
+            // v4.1.5 Phase 1d (Q-P1) — glyph palette switch. Was `▰`/`▱`
+            // (U+25B0/B1, Geometric Shapes) which legacy Windows console
+            // fonts render as tofu. Now `▓`/`░` (U+2593/91, Block Elements
+            // — in CP437, universally supported). Matches the existing
+            // statusFooter chrome that's shipped since v3 without ever
+            // being garbled.
+            const filled = new Set();
+            for (let i = 0; i < WAVE_BLOCK; i += 1) {
+                filled.add((waveFrame + i) % WAVE_CELLS);
+            }
+            // Render cells in order so the snake-scroll visually slides:
+            // we paint cell-by-cell with the right color, joined into one
+            // string. ANSI runs reset per cell — slight overhead but keeps
+            // glyph order true to position. Brand orange filled, warm-muted
+            // empty.
+            const cells = [];
+            for (let c = 0; c < WAVE_CELLS; c += 1) {
+                cells.push(filled.has(c)
+                    ? sk.applyColors('▓', 'brand')
+                    : sk.applyColors('░', 'muted'));
+            }
+            return cells.join('');
+        };
+        // v4.1.5 Part 1a — Issue M (Windows ConPTY buffering fix).
+        //
+        // Prior pattern wrote `\r\x1b[K{indicator}` with NO trailing
+        // newline. On Windows ConPTY, `process.stdout` buffers no-newline
+        // writes — none of the 60 indicator ticks during a 15s gap
+        // actually rendered. The final reply's `\n` chars eventually
+        // flushed the buffer, but by then the indicator's stop()-erase
+        // had also been buffered + flushed, so the user saw 15s of blank
+        // followed by the reply dumping all at once.
+        //
+        // Fix: indicator OWNS one terminal row. Every write that paints
+        // the indicator ends with `\n`, which forces a flush on every
+        // platform. The cursor sits on the LINE BELOW the indicator
+        // while it's running (one visible empty row gap). When the
+        // indicator stops/pauses, we walk back UP to the indicator's
+        // row and erase it — the cursor then sits at col 0 of that
+        // (now empty) row, ready for the caller to write whatever
+        // content follows (header, tool row, stream output).
+        //
+        // ANSI primitives:
+        //   `\x1b[1A` — cursor up 1 line
+        //   `\x1b[2K` — erase the whole current line
+        // Sequence on tick:    walk up → erase → paint → `\n` → cursor below.
+        // Sequence on erase:   walk up → erase (no newline). Cursor on the
+        //                      now-empty indicator row, ready for caller.
+        const ANSI_UP_ERASE = '\x1b[1A\x1b[2K';
+        const renderTick = () => {
+            if (stopped || paused || !isTty)
+                return;
+            dotFrame = (dotFrame + 1) % 4;
+            // v4.1.5 Issue K — wave snake-scroll advances 1 cell per tick.
+            // Same 250ms cadence as the dot pulse, so both rows move in
+            // visible lockstep. Modulo WAVE_CELLS wraps the leading block
+            // back to the left edge.
+            waveFrame = (waveFrame + 1) % WAVE_CELLS;
+            if (waveBarEnabled) {
+                // 2-row layout: walk up TWO rows (two separate up-1+erase
+                // sequences, which keeps the `\x1b[1A\x1b[2K` substring
+                // assertion-compatible), repaint both, drop newlines so the
+                // cursor lands on the row below the wave bar.
+                out.write(`${ANSI_UP_ERASE}${ANSI_UP_ERASE}` +
+                    `${buildLine()}\n` +
+                    `${buildWave()}\n`);
+            }
+            else {
+                // Single-row layout (back-compat with v4.1.4 tests).
+                out.write(`${ANSI_UP_ERASE}${buildLine()}\n`);
+            }
+        };
+        const startTick = () => {
+            if (stopped || !isTty || tickTimer !== null)
+                return;
+            tickTimer = setInterval(renderTick, TICK_MS);
+        };
+        const stopTick = () => {
+            if (tickTimer !== null) {
+                clearInterval(tickTimer);
+                tickTimer = null;
+            }
+        };
+        const eraseLine = () => {
+            // Walk up to the indicator's row(s) + erase. Cursor lands at
+            // col 0 of the (now empty) verb row. NO trailing newline here:
+            // the caller is about to write content on this row, and
+            // whatever they write will include their own `\n` to flush
+            // the buffer. If we emitted `\n` here, we'd leave a phantom
+            // blank row before the caller's content.
+            //
+            // v4.1.5 Issue K — with wave bar enabled, walk up 2 rows (two
+            // up-1+erase sequences). Without the bar, walk up 1 row.
+            if (!isTty || !printed)
+                return;
+            if (waveBarEnabled) {
+                out.write(`${ANSI_UP_ERASE}${ANSI_UP_ERASE}`);
+            }
+            else {
+                out.write(ANSI_UP_ERASE);
+            }
+        };
+        // Initial paint — only on TTY. Indicator + `\n` so the buffer
+        // flushes and the cursor sits on the row below, ready for the
+        // first tick to walk back up.
+        //
+        // v4.1.5 Issue K — when wave bar is enabled, paint TWO rows:
+        // verb row + wave row, each with trailing `\n`. Cursor lands on
+        // the row below the wave bar. The first tick will walk up 2.
+        if (isTty) {
+            if (waveBarEnabled) {
+                out.write(`${buildLine()}\n${buildWave()}\n`);
+            }
+            else {
+                out.write(`${buildLine()}\n`);
+            }
+            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. Paint the indicator + `\n` to claim the
+                // current row(s) and leave the cursor on the row below — same
+                // invariant the initial paint and tick maintain. Trailing `\n`
+                // also flushes Windows ConPTY buffering (Issue M).
+                //
+                // v4.1.5 Issue K — repaint BOTH rows when wave bar enabled.
+                if (waveBarEnabled) {
+                    out.write(`${buildLine()}\n${buildWave()}\n`);
+                }
+                else {
+                    out.write(`${buildLine()}\n`);
+                }
+                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
@@ -737,6 +1029,31 @@ class Display {
     // completion so each line in the log carries the final state — no
     // ANSI cursor games on a dumb sink.
     toolRow(name, args) {
+        // v4.1.5 Phase 1d (Q-Q2-a) — TRAIL_HIDE_TOOLS suppression.
+        //
+        // Some tools are pure agent plumbing — the model calls them to
+        // introspect its own registry, not to do user-visible work.
+        // `lookup_tool_schema` is the canonical case: during planning
+        // the agent may invoke it 30+ times to discover unfamiliar tool
+        // shapes. Each call is a sub-millisecond in-memory lookup, but
+        // they flood the visible trail with noise that obscures the
+        // actual user-relevant tool calls.
+        //
+        // Short-circuit: hidden tools get a NO-OP handle that satisfies
+        // the `ToolRowHandle` contract (ok/fail/degraded/retry/blocked/
+        // emptyRetry/emptyFail all defined but write nothing). The
+        // execution path itself is unaffected — the agent still calls
+        // the tool, the planner / skill-enforcement trackers still
+        // record it. Only the visual row is suppressed.
+        //
+        // CRITICAL invariant: `setBeforeFirstToolHook` is fired by
+        // callbacks.ts BEFORE `toolRow()` is called (see callbacks.ts
+        // onToolCall 'before' branch), so `turnHadTools` flips even for
+        // hidden tools. The separator logic stays correct regardless of
+        // whether ONLY hidden tools fired this turn.
+        if (exports.TRAIL_HIDE_TOOLS.has(name)) {
+            return makeNoOpToolRowHandle();
+        }
         const sk = this.skin;
         // ── Build the fixed left portion (icon + verb + detail) ────────────
         // v4.1.3-repl-polish: icons default ON; set AIDEN_UI_ICONS=0 to
@@ -838,8 +1155,31 @@ class Display {
                     writeFinal(`ok ${formatToolDuration(durationMs)} after ${retries} ${retries === 1 ? 'retry' : 'retries'}`, 'warn');
                 }
                 else {
-                    // Clean success — SILENT. Erase on TTY; emit nothing on non-TTY.
-                    eraseLast();
+                    // v4.1.5 Issue N — persistent tool trail in scrollback.
+                    //
+                    // Prior behaviour: silent erase on clean success (`eraseLast()`
+                    // with no replacement write). Tool rows for successful tools
+                    // vanished, leaving only the markdown reply visible afterward.
+                    // The user couldn't see WHAT actions Aiden took unless a tool
+                    // failed or degraded.
+                    //
+                    // Fix: replace the silent erase with a completed-state row
+                    // painted entirely in warm-muted (`#b8a89a` from v4.1.4). The
+                    // duration suffix replaces the live `running Ns…` chrome; the
+                    // whole row reads "done" via reduced visual weight. Failed /
+                    // degraded / retry outcomes keep their existing coloured paint
+                    // (error red, degraded yellow, warn amber) — only clean success
+                    // shifts from "silent" to "muted-persistent."
+                    //
+                    // The persistence mechanism is the existing `writeFinal` path:
+                    // it walks up + erases the running row, then writes the final
+                    // row with trailing `\n`. The row sits in scrollback because
+                    // `streamComplete` rerenders only the post-tool stream chunk
+                    // (via `streamLineCount` which was reset to 0 inside
+                    // `commitStreamChunk` before this row wrote). No additional
+                    // isolation machinery needed — already verified by 13/13
+                    // `smoke-stream-rerender.ts` regressions.
+                    writeFinal(formatToolDuration(durationMs), 'muted');
                 }
             },
             fail(durationMs, retries = 0) {
@@ -948,15 +1288,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.
@@ -1075,6 +1457,33 @@ class Display {
         }
         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
@@ -1099,12 +1508,83 @@ 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);
+    }
+    /**
+     * 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.
+     */
+    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
@@ -1161,10 +1641,13 @@ class Display {
             // \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 {
@@ -1398,6 +1881,56 @@ function renderRmsBar(rms) {
 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;
+/**
+ * v4.1.5 Phase 1d (Q-Q2-a) — names of tools that should be SUPPRESSED
+ * from the visible tool-trail row, even though they still execute
+ * normally through the agent loop.
+ *
+ * The canonical case is `lookup_tool_schema`: the agent calls it
+ * during planning to introspect tool registry entries (in-memory
+ * registry get, sub-millisecond per call). On complex prompts the
+ * model may fire it 30+ times in a row, flooding the visible trail
+ * with rows that don't represent user-meaningful work. Suppressing
+ * them keeps the trail focused on the tools that did real work
+ * (web_search, file_read, etc.).
+ *
+ * Suppression happens at `Display.toolRow()` entry — it returns a
+ * no-op handle that satisfies the `ToolRowHandle` contract but
+ * never writes to stdout. The agent's `callbacks.onToolCall`
+ * dispatch is unchanged: `setBeforeFirstToolHook` still fires (so
+ * `turnHadTools` flips for the separator-emission logic), and
+ * skill-enforcement / honesty-trace tracking still records the
+ * call. Only the visual row is hidden.
+ *
+ * Exported as a `Set` so callers can mutate at runtime if they
+ * need to hide additional tools (e.g. user customization, MCP
+ * plumbing tools). Mutation-of-shared-state is intentional — there's
+ * no per-session config plumbing for "trail hidden tools" yet, so
+ * the env-var pattern (`AIDEN_TRAIL_HIDE=tool1,tool2`) would be the
+ * v4.1.6 evolution.
+ */
+exports.TRAIL_HIDE_TOOLS = new Set([
+    'lookup_tool_schema',
+]);
+/**
+ * v4.1.5 Phase 1d helper — produces a `ToolRowHandle` that satisfies
+ * the contract but writes nothing. Used by hidden tools (see
+ * `TRAIL_HIDE_TOOLS`) and as a safe fallback. All methods are inert.
+ *
+ * Pure — no side effects, no closures over Display state. Safe to
+ * call from any thread / phase.
+ */
+function makeNoOpToolRowHandle() {
+    return {
+        ok: () => { },
+        fail: () => { },
+        degraded: () => { },
+        retry: () => { },
+        blocked: () => { },
+        emptyRetry: () => { },
+        emptyFail: () => { },
+    };
+}
 /**
  * Build a compact, single-line preview of the tool's arguments. Picks
  * the most informative scalar fields when the args are an object, then
@@ -1450,6 +1983,112 @@ function truncToolArg(s) {
         return flat;
     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