aiden-runtime 4.1.3 → 4.1.4

package/dist/cli/v4/callbacks.js

@@ -82,6 +82,15 @@ class CliCallbacks {
                     }
                     this.beforeFirstToolHook = undefined;
                 }
+                // v4.1.4 reply-quality polish — Part 1.6. Pause activity
+                // indicator BEFORE the tool row writes so the indicator's line
+                // is clean when the row lands. Fires for every tool, not just
+                // the first. Defensive try/catch — a misbehaving hook must not
+                // block tool dispatch.
+                try {
+                    this.beforeToolHook?.();
+                }
+                catch { /* defensive */ }
                 const handle = this.display.toolRow(call.name, call.arguments);
                 this.toolRows.set(call.id, handle);
                 this.toolStartTimes.set(call.id, Date.now());
@@ -92,14 +101,38 @@ class CliCallbacks {
             const startedAt = this.toolStartTimes.get(call.id);
             this.toolRows.delete(call.id);
             this.toolStartTimes.delete(call.id);
-            if (!handle || startedAt === undefined)
+            if (!handle || startedAt === undefined) {
+                // Even if we lost the handle, the indicator may still need to
+                // be re-armed so the next gap shows activity. Tool-name-aware
+                // verb selection happens in the hook itself.
+                try {
+                    this.afterEachToolHook?.(call.name);
+                }
+                catch { /* defensive */ }
                 return;
+            }
             const ms = Date.now() - startedAt;
             const err = result?.error;
             if (typeof err === 'string' && err.includes('URL provenance gate')) {
                 handle.blocked();
                 return;
             }
+            // v4.1.4 reply-quality polish — Part 1.6. Helper used by ALL
+            // outcome branches below so the activity indicator gets re-armed
+            // for the gap that follows this tool (next tool, or final reply).
+            // Tool-name-aware verb selection happens in the hook (chatSession
+            // wires it through `verbForActivity`).
+            const fireAfter = () => {
+                try {
+                    this.afterEachToolHook?.(call.name);
+                }
+                catch { /* defensive */ }
+            };
+            if (typeof err === 'string' && err.includes('URL provenance gate')) {
+                handle.blocked();
+                fireAfter();
+                return;
+            }
             if (err) {
                 handle.fail(ms);
                 // v4.1.3-essentials: when the tool's failure payload includes a
@@ -111,15 +144,18 @@ class CliCallbacks {
                 if (result?.capabilityCard) {
                     this.display.capabilityCard(result.capabilityCard);
                 }
+                fireAfter();
                 return;
             }
             // v4.1.3-repl-polish: degraded outcome — tool completed but with a
             // partial / best-effort result. Show in trail yellow instead of silent.
             if (result?.degraded) {
                 handle.degraded(ms, result.degradedReason);
+                fireAfter();
                 return;
             }
             handle.ok(ms);
+            fireAfter();
         };
         /** ApprovalEngine.callbacks.promptUser */
         this.promptApproval = async (req) => {
@@ -186,23 +222,29 @@ Reply with ONE word: safe, caution, or dangerous.`;
                 return false;
             }
         };
-        /** PlannerGuard sink. Quiet in compact mode. */
+        /**
+         * PlannerGuard sink. v4.1.4 Phase 3b' (Q-Planner): moved to
+         * verbose-only. The default `normal` mode previously emitted
+         * `[planner] kept N tools (reason)` mid-execution, which collided
+         * visually with the activity indicator's single-line paint and
+         * with streamed deltas. Users running with the default verbose
+         * level should see a clean execution surface — planner-guard
+         * decisions are useful for debugging but noise during normal use.
+         *
+         * `verbose` mode keeps the full breakdown for debugging. `compact`
+         * stays silent (unchanged).
+         */
         this.onPlannerGuardDecision = (decision) => {
             if (this.verboseMode === 'compact')
                 return;
-            if (decision.reason === 'no_filter')
+            if (this.verboseMode !== 'verbose')
                 return;
-            if (this.verboseMode === 'verbose') {
-                const conf = decision.confidence !== undefined
-                    ? ` (conf ${decision.confidence.toFixed(2)})`
-                    : '';
-                this.display.dim(`[planner] ${decision.reason}${conf}: kept ${decision.selectedTools.length} / dropped ${decision.excludedTools.length}`);
+            if (decision.reason === 'no_filter')
                 return;
-            }
-            // normal
-            if (decision.excludedTools.length > 0) {
-                this.display.dim(`[planner] kept ${decision.selectedTools.length} tools (${decision.reason})`);
-            }
+            const conf = decision.confidence !== undefined
+                ? ` (conf ${decision.confidence.toFixed(2)})`
+                : '';
+            this.display.dim(`[planner] ${decision.reason}${conf}: kept ${decision.selectedTools.length} / dropped ${decision.excludedTools.length}`);
         };
         /**
          * Phase v4.1-skill-mining — post-turn cue when the miner has
@@ -280,6 +322,21 @@ Reply with ONE word: safe, caution, or dangerous.`;
         this.beforeFirstToolHook = fn;
         this.firstToolFiredThisTurn = false;
     }
+    /**
+     * v4.1.4 reply-quality polish — Part 1.6.
+     *
+     * Register paired hooks so chatSession can pause the activity
+     * indicator while a tool row writes, and resume it (with a fresh
+     * verb derived from the just-completed tool) in the gap before the
+     * next tool fires or the final reply arrives.
+     *
+     * Both fire for EVERY tool, not just the first. Either can be
+     * omitted independently. Cleared between turns by passing `undefined`.
+     */
+    setActivityIndicatorHooks(opts) {
+        this.beforeToolHook = opts.beforeTool;
+        this.afterEachToolHook = opts.afterEachTool;
+    }
 }
 exports.CliCallbacks = CliCallbacks;
 // Tier-3.1 (v4.1-tier3.1): replaced 🟢/🟡/🔴 emoji badges with

package/dist/cli/v4/chatSession.js

@@ -70,6 +70,10 @@ exports.formatTokens = formatTokens;
 exports.formatDuration = formatDuration;
 exports.renderMemoryConfirmations = renderMemoryConfirmations;
 const display_1 = require("./display");
+// v4.1.4 Part 1.6 — per-turn token progress bar. Fed by `onProgress`
+// events from the streaming adapter; hidden when the adapter doesn't
+// emit progress (honest degradation).
+const progressBar_1 = require("./display/progressBar");
 const uiBuild_1 = require("./uiBuild");
 const sessionSummaryGate_1 = require("./sessionSummaryGate");
 const aidenPrompt_1 = __importDefault(require("./aidenPrompt"));
@@ -414,9 +418,22 @@ class ChatSession {
         // Tier-3-essentials: hard-clear the screen on terminal resize so
         // dropdown re-renders + previous prompt frames don't ghost into
         // the new viewport. No-op on non-TTY / MCP serve mode.
+        //
+        // v4.1.4 reply-quality polish: also drop the per-chunk stream row
+        // counter so a mid-stream resize doesn't try to erase rows that
+        // the hard-clear already removed. See `resetStreamFrameForResize`
+        // in display.ts for the rationale.
         const restoreResizeGuard = this.opts.promptApi
             ? () => { }
-            : (0, resizeGuard_1.installResizeGuard)();
+            : (0, resizeGuard_1.installResizeGuard)({
+                onCleared: () => {
+                    try {
+                        this.opts.display
+                            .resetStreamFrameForResize?.();
+                    }
+                    catch { /* defensive — never break the resize listener */ }
+                },
+            });
         try {
             while (iter < max) {
                 iter += 1;
@@ -885,40 +902,105 @@ class ChatSession {
         const baseHistory = newHistory.length > 0
             ? [...this.history, ...newHistory, userMsg]
             : [...this.history, userMsg];
-        // Phase 16c: streaming gated on display.streaming config (default off).
-        // Defensive: tests sometimes pass partial config stubs without the
-        // ConfigManager API; treat that as "streaming disabled".
+        // Phase 16c: streaming gated on display.streaming config.
+        // v4.1.4 Part 1.6: PRODUCTION DEFAULT FLIPPED FROM FALSE TO TRUE.
+        // Streaming delivers the activity indicator, tool-row live tick,
+        // and token progress bar that the user feedback ("after prompt i
+        // just see output") was specifically asking for. Users who
+        // explicitly set `display.streaming: false` in config still opt
+        // out; the change affects only the default for users who never
+        // touched the flag.
+        //
+        // Test-stub fallback (no ConfigManager) stays at `false` so
+        // existing tests that depended on the non-streaming code path
+        // don't have to be rewritten in this slice — they exercise the
+        // batch-call path that production users on Ollama / non-streaming
+        // adapters still hit naturally.
         const streamingEnabled = typeof this.opts.config?.getValue === 'function'
-            ? this.opts.config.getValue('display.streaming', false) === true
+            ? this.opts.config.getValue('display.streaming', true) === true
             : false;
-        // Phase 26.2.6 — random thinking phrase per turn, already wrapped
-        // in brand orange by Display.thinkingPhrase().
-        const spinner = this.opts.display.startSpinner(this.opts.display.thinkingPhrase());
-        let spinnerStopped = false;
+        // v4.1.4 reply-quality polish — Part 1.6. Activity indicator
+        // replaces the prior single-shot spinner. Pause/resume hooks make
+        // the indicator cooperate with tool rows: it pauses before each
+        // tool row writes and resumes (with a tool-aware verb) in the
+        // gap that follows, so the user always sees activity feedback
+        // during model-thinking time — not just the pre-first-token gap.
+        //
+        // Initial verb is "thinking" (pre-tools phase). After each tool
+        // completes, `verbForActivity(toolName, 'post-tool')` picks a
+        // category-aware verb (reading / searching / analyzing / drafting).
+        // When the first stream delta arrives OR the final agentTurn is
+        // about to write, the indicator stops permanently.
+        const indicator = this.opts.display.activityIndicator('thinking');
+        let indicatorStopped = false;
         let streamingActive = false;
-        const stopSpinnerOnce = () => {
-            if (spinnerStopped)
+        const stopIndicatorOnce = () => {
+            if (indicatorStopped)
                 return;
-            spinnerStopped = true;
-            spinner.stop();
+            indicatorStopped = true;
+            indicator.stop();
+            // Clear the per-turn pause/resume hooks so they don't fire
+            // against a stopped indicator on a subsequent turn. The next
+            // turn re-registers fresh hooks.
+            try {
+                this.opts.callbacks.setActivityIndicatorHooks?.({});
+            }
+            catch { /* defensive */ }
         };
-        // Phase 23.5: stop the "thinking…" spinner the moment the first
-        // tool row prints. The event rows are the user-facing indicator
-        // from that point on; a spinner painting `\r` over the same line
-        // would corrupt our row-overwrite when the row mutates to its
-        // final bracket state.
-        this.opts.callbacks.setBeforeFirstToolHook?.(stopSpinnerOnce);
+        // Phase 23.5 carried forward: stop the indicator the moment the
+        // first tool row prints — the row itself is the activity surface
+        // during a tool. Part 1.6 then resumes via `afterEachTool` so the
+        // post-tool gap has its own indicator paint.
+        this.opts.callbacks.setBeforeFirstToolHook?.(stopIndicatorOnce);
+        // Part 1.6: pause/resume hooks around every tool row. The
+        // `beforeTool` hook fires before EACH tool row writes (not just
+        // the first), so multi-tool sequences also keep the indicator
+        // off the tool-row line. `afterEachTool` resumes with a verb
+        // chosen from the just-completed tool's category — best guess
+        // for "what the model is doing next". `lastToolName` is captured
+        // for tests / observability; the verb decision happens inline.
+        this.opts.callbacks.setActivityIndicatorHooks?.({
+            beforeTool: () => {
+                if (indicatorStopped)
+                    return;
+                indicator.pause();
+                // v4.1.4 Part 1.6: hide the progress bar while the tool row
+                // owns the screen. The bar paints below the indicator, so
+                // it'd otherwise sit between the tool row and any subsequent
+                // stream output — visual clutter for tool-heavy turns. The
+                // bar is per-turn, not per-stream-segment; once hidden it
+                // stays hidden until the next turn's bar is created.
+                progressBar?.hide();
+            },
+            afterEachTool: (toolName) => {
+                if (indicatorStopped)
+                    return;
+                indicator.resume((0, display_1.verbForActivity)(toolName, 'post-tool'));
+            },
+        });
+        // v4.1.4 Part 1.6: per-turn progress bar. Created lazily on the
+        // first `onProgress` event from the streaming adapter so the bar
+        // line doesn't paint until there's something to show. Adapters
+        // that don't emit progress (Ollama, most OpenAI-compat) never
+        // trigger creation — honest degradation, no fake estimates.
+        let progressBar = null;
         try {
             const result = await this.opts.agent.runConversation(baseHistory, {
                 stream: streamingEnabled,
                 onFirstDelta: streamingEnabled
                     ? () => {
-                        stopSpinnerOnce();
+                        stopIndicatorOnce();
                         streamingActive = true;
                     }
                     : undefined,
                 onDelta: streamingEnabled
                     ? (text) => {
+                        // v4.1.4 Part 1.6: bar lives ABOVE streamed text. Hide
+                        // it before each delta writes so the stream output
+                        // doesn't land on the bar's line. The bar repaints on
+                        // the next `onProgress` event (which Anthropic emits
+                        // frequently enough that the bar stays usefully visible).
+                        progressBar?.hide();
                         this.opts.display.streamPartial(text);
                     }
                     : undefined,
@@ -927,8 +1009,30 @@ class ChatSession {
                         this.opts.display.streamToolIndicator(call.name);
                     }
                     : undefined,
+                onProgress: streamingEnabled
+                    ? (outputTokens, maxTokens) => {
+                        if (indicatorStopped === false)
+                            return;
+                        // Lazy-create on first event. The indicator must already
+                        // be stopped (first delta arrived) so the bar paints on
+                        // its own line below where the indicator was. If the
+                        // indicator is still up, skip — the bar would land on
+                        // the indicator line and get clobbered by the next tick.
+                        if (!progressBar) {
+                            progressBar = (0, progressBar_1.createProgressBar)(process.stdout, 
+                            // Display exposes its skin via getter on the
+                            // implementation; cast to any to avoid widening
+                            // the public Display surface for one-shot use.
+                            this.opts.display.skin);
+                        }
+                        progressBar.update(outputTokens, maxTokens);
+                    }
+                    : undefined,
             });
-            stopSpinnerOnce();
+            stopIndicatorOnce();
+            // Hide the progress bar before any post-stream content
+            // (statusFooter, the next prompt) lands on its line.
+            progressBar?.hide();
             if (streamingActive)
                 this.opts.display.streamComplete();
             this.history = result.messages;
@@ -966,7 +1070,11 @@ class ChatSession {
             this.renderStatusLine();
         }
         catch (err) {
-            stopSpinnerOnce();
+            stopIndicatorOnce();
+            // v4.1.4 Part 1.6: error path must also hide the progress bar
+            // so it doesn't leak across the boundary into the error chrome
+            // or the next prompt.
+            progressBar?.hide();
             if (streamingActive)
                 this.opts.display.streamComplete();
             const msg = err?.message ?? String(err);

package/dist/cli/v4/defaultSoul.js

@@ -30,7 +30,7 @@ exports.PREVIOUS_BUNDLED_SOULS = exports.DEFAULT_SOUL_MD = exports.BUNDLED_SOUL_
 // <act_dont_ask>. ensureSoulMdSeeded compares this against the user's
 // on-disk SOUL.md to decide whether to silent-replace (matches a prior
 // bundled default) or preserve+notify (user-edited).
-exports.BUNDLED_SOUL_VERSION = 'v4.1.2';
+exports.BUNDLED_SOUL_VERSION = 'v4.1.4';
 exports.DEFAULT_SOUL_MD = `You are Aiden — a local-first AI agent built by Taracod.
 
 Identity:
@@ -40,7 +40,8 @@ Identity:
 - You have 40 tools spanning files, browser, terminal, web, memory.
 
 Voice:
-- Direct. No fluff. Match the user's energy.
+- Match the user's energy. When the user asks a thoughtful question (opinion, exploration, comparison), engage thoughtfully. When the user asks transactionally, stay tight.
+- On thoughtful questions, share the reasoning before the answer — what you considered, what you discarded, why.
 - Honest above all — if you didn't do something, say so. If you're not sure, say so.
 - You never claim to "have run" a tool unless the trace shows it.
 
@@ -254,5 +255,71 @@ Limits:
 - You're a CLI agent in v4.0.0. No voice, no scheduled jobs, no messaging gateway yet — those are v4.1.
 - You can't bypass approval prompts for dangerous commands.
 - You don't lie to look smart. If you don't know, you say so.
+`,
+    // v4.1.2 default — shipped through v4.1.3 (no SOUL change in v4.1.3).
+    // v4.1.4 rewrites the Voice block to make conciseness conditional:
+    // thoughtful questions get thoughtful engagement, transactional
+    // questions stay tight. Adds an explicit reasoning-visibility line.
+    // Users on the v4.1.2 / v4.1.3 install have this verbatim text on
+    // disk; silent-upgrade picks them up here.
+    `You are Aiden — a local-first AI agent built by Taracod.
+
+Identity:
+- You run on the user's machine, native Windows/Linux/macOS (not WSL2).
+- You have 72 bundled skills + access to install more via skills.sh.
+- You remember past sessions via persistent storage.
+- You have 40 tools spanning files, browser, terminal, web, memory.
+
+Voice:
+- Direct. No fluff. Match the user's energy.
+- Honest above all — if you didn't do something, say so. If you're not sure, say so.
+- You never claim to "have run" a tool unless the trace shows it.
+
+Behavior:
+- Default to action over discussion. The user wants results.
+- When asked who you are, identify as Aiden. Not "a large language model."
+- When asked what you can do, mention specific skills/tools, not generic capabilities.
+- If user mentions trading/NSE/markets, you have specialized skills for that.
+
+<act_dont_ask>
+When a request has an obvious default interpretation, act on it
+immediately instead of asking for clarification. Examples:
+- "play me a popular song" / "play X on youtube" → load skill_view(media-search)
+  and follow it. Substitute fuzzy phrases ("popular song") with a specific
+  chart-topper BEFORE searching, then open_url a /watch?v= URL once.
+  NEVER search verbatim "popular song" — that returns articles, not music.
+- "what files are in my Downloads?" → file_list on Downloads. Don't ask
+  "which user?" — it's the current user.
+- "is port 443 open?" → check this machine. Don't ask "open where?"
+Only ask for clarification when the ambiguity genuinely changes which
+tool you would call.
+</act_dont_ask>
+
+<prerequisite_checks>
+Before acting, check whether prerequisite discovery, lookup, or
+context-gathering steps are needed. If a step depends on output from a
+prior step, resolve that dependency first. Don't skip prerequisite
+steps just because the final action seems obvious.
+</prerequisite_checks>
+
+<missing_context>
+If required context is missing, do NOT guess or hallucinate. Use the
+appropriate lookup tool when missing information is retrievable
+(file_read, file_list, web_search, fetch_url, session_search,
+system_info). Ask a clarifying question ONLY when no tool can resolve
+the ambiguity.
+</missing_context>
+
+<keep_going>
+Work autonomously until the task is fully resolved. Don't stop with a
+plan — execute it. Multi-step tasks (open browser → search → click
+result; or list files → read each → summarise) are expected; chain
+the tool calls within a single turn instead of returning halfway and
+asking the user what to do next.
+</keep_going>
+
+Limits:
+- You can't bypass approval prompts for dangerous commands.
+- You don't lie to look smart. If you don't know, you say so.
 `,
 ];

package/dist/cli/v4/display/frame.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/display/frame.ts — Phase v4.1.4 reply-quality polish (Part 1.5).
+ *
+ * Single source of truth for the reply-frame math: terminal width,
+ * left gutter, body width, indent-by-depth, and ANSI-aware soft wrap.
+ *
+ * Before this module the same width formula
+ * (`Math.min(out.columns ?? 80, 100)`) lived at 4 different sites with
+ * inconsistent offsets, no shared floor, and no actual wrap engine —
+ * `marked-terminal` has `reflowText: false` so long prose just spilled
+ * to terminal-natural wrap (continuation lines at column 0, not at the
+ * gutter). frame.ts replaces all four with one formula and one wrapper.
+ *
+ * Public surface:
+ *   - GUTTER             3-col left gutter (assistant body)
+ *   - BODY_WIDTH_MAX     100 (tunable cap; export so future skin/theme
+ *                        work can override without touching consumers)
+ *   - getTerminalCols()  live `process.stdout.columns` with 80 fallback
+ *   - getBodyWidth()     `max(20, cols - gutter - 2)` capped at
+ *                        `BODY_WIDTH_MAX - gutter - 2`
+ *   - getIndent(depth)   `' '.repeat(GUTTER + depth*2)` — gutter +
+ *                        depth-aware. depth=0 = bare gutter, depth=1 =
+ *                        gutter+2, etc.
+ *   - wrap(text, opts)   ANSI-aware soft wrap via wrap-ansi defaults
+ *                        `{ trim: false, hard: true }`. Returns string
+ *                        with embedded `\n` per wrap point.
+ *   - applyFrame(body)   convenience: indents every line of `body` by
+ *                        GUTTER. No wrap (caller pre-wraps to bodyWidth).
+ *
+ * Wrap engine: wrap-ansi@9 (ESM-only). Loaded via cached dynamic
+ * `import()` so a CJS TypeScript build can still consume it. Until the
+ * first wrap finishes resolving, `wrap()` falls back to a passthrough
+ * that preserves the input verbatim — wrong visual but never incorrect
+ * data. Boot-time prime via `primeFrameAsync()` (best-effort) so the
+ * first user-visible wrap call already has the module loaded.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BODY_WIDTH_MIN = exports.BODY_WIDTH_MAX = exports.GUTTER = void 0;
+exports.getTerminalCols = getTerminalCols;
+exports.getBodyWidth = getBodyWidth;
+exports.getIndent = getIndent;
+exports.primeFrameAsync = primeFrameAsync;
+exports.wrap = wrap;
+exports.applyFrame = applyFrame;
+exports._resetForTests = _resetForTests;
+exports._injectWrapForTests = _injectWrapForTests;
+// ── Tunable constants ─────────────────────────────────────────────────
+/**
+ * Left gutter for assistant body. 3 columns matches the visual rhythm
+ * established by the boot card, tool trail, and status footer once
+ * Part 1.5 lands. Was 2 before this slice — bumped one column so the
+ * body breathes against the left edge.
+ */
+exports.GUTTER = 3;
+/**
+ * Maximum body width before the visual frame stops growing. Wide
+ * terminals (150+ cols) get a body capped at this minus gutter+2
+ * because long lines (~120 chars) are harder to read than mid-length
+ * (~70-90 chars). Tunable: skin or theme code can override.
+ */
+exports.BODY_WIDTH_MAX = 100;
+/**
+ * Hard floor on body width. Below this we render at 20 cols and let
+ * the terminal-natural wrap pick up the rest — better than crashing
+ * with a negative-width wrap-ansi call on a 5-col terminal.
+ */
+exports.BODY_WIDTH_MIN = 20;
+// ── Width helpers ─────────────────────────────────────────────────────
+/**
+ * Live terminal column count. Reads `process.stdout.columns` on every
+ * call so resize events propagate without us needing a cache. Falls
+ * back to 80 when the stream is non-TTY or hasn't reported a size yet
+ * (pipes, CI logs, MCP serve).
+ *
+ * `out` override exists for testability — display.test.ts injects a
+ * fake stream with explicit `columns` to assert various widths.
+ */
+function getTerminalCols(out = process.stdout) {
+    const c = out.columns;
+    if (typeof c !== 'number' || !Number.isFinite(c) || c < 1)
+        return 80;
+    return c;
+}
+/**
+ * Computed body width — the safe horizontal space inside the frame.
+ * Math: `min(BODY_WIDTH_MAX, cols) - GUTTER - 2`. The trailing `-2`
+ * leaves visual breathing room on the right margin (mirrors the boot
+ * card / tool-row right-pad convention). Floored at BODY_WIDTH_MIN so
+ * pathological narrow terminals still get a usable wrap.
+ */
+function getBodyWidth(out = process.stdout) {
+    const cols = Math.min(getTerminalCols(out), exports.BODY_WIDTH_MAX);
+    const raw = cols - exports.GUTTER - 2;
+    return Math.max(exports.BODY_WIDTH_MIN, raw);
+}
+/**
+ * Indent string for the given nesting depth. Depth 0 = bare gutter
+ * (3 spaces). Each additional level adds 2 spaces. Used by list,
+ * blockquote, and code-block renderers so every element shares one
+ * indent algebra.
+ */
+function getIndent(depth = 0) {
+    const d = Math.max(0, Math.floor(depth));
+    return ' '.repeat(exports.GUTTER + d * 2);
+}
+let cachedWrap = null;
+let primePromise = null;
+/**
+ * Best-effort load of wrap-ansi. Idempotent. Safe to call from boot.
+ * Returns a promise that resolves once the module is loaded (or
+ * rejects silently — wrap() will just keep using the passthrough).
+ */
+function primeFrameAsync() {
+    if (cachedWrap)
+        return Promise.resolve();
+    if (primePromise)
+        return primePromise;
+    primePromise = (async () => {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const mod = await Promise.resolve().then(() => __importStar(require('wrap-ansi')));
+            const fn = (mod.default ?? mod);
+            if (typeof fn === 'function')
+                cachedWrap = fn;
+        }
+        catch {
+            // Swallow — fallback is a passthrough, never crashes.
+        }
+    })();
+    return primePromise;
+}
+// Kick off the import at module load. Best effort — if it fails (e.g.
+// missing dep, broken install) we degrade to passthrough.
+primeFrameAsync();
+/**
+ * ANSI-aware soft wrap. Defaults `{ trim: false, hard: true }`:
+ *   - trim: false → preserves leading/trailing whitespace on each
+ *     visual line (important for code-block indent + alignment).
+ *   - hard: true  → break extremely long words mid-character at width
+ *     instead of overflowing. Code blocks especially need this.
+ *
+ * Pure with respect to ANSI: escape sequences pass through wrap-ansi
+ * untouched and don't count toward the column budget.
+ *
+ * Synchronous. When wrap-ansi hasn't finished loading yet (the rare
+ * boot-race window), returns `text` unchanged. The user sees the
+ * un-wrapped paint exactly once; by the next render the cache is hot.
+ */
+function wrap(text, cols, options = {}) {
+    const w = cachedWrap;
+    if (!w)
+        return text;
+    const opts = { trim: options.trim ?? false, hard: options.hard ?? true };
+    try {
+        return w(text, cols, opts);
+    }
+    catch {
+        return text;
+    }
+}
+/**
+ * Indent every line of `body` by the bare gutter. Empty lines are
+ * passed through unindented so blank visual rows don't carry
+ * trailing whitespace into the transcript.
+ *
+ * Caller is responsible for pre-wrapping to `getBodyWidth()` — this
+ * function is purely the indent step, not the wrap step. Keeping them
+ * separate so callers that already have their own indent (lists,
+ * code blocks) can opt out of this and still consume `wrap()`.
+ */
+function applyFrame(body) {
+    const ind = getIndent(0);
+    return body
+        .split('\n')
+        .map((ln) => (ln.length === 0 ? '' : `${ind}${ln}`))
+        .join('\n');
+}
+/**
+ * Test reset — drops the cached wrap function so a fresh prime can be
+ * forced. Used by unit tests to exercise the fallback path AND to
+ * confirm post-prime behaviour.
+ */
+function _resetForTests() {
+    cachedWrap = null;
+    primePromise = null;
+}
+/**
+ * Test injection — set the wrap function explicitly. Used by tests
+ * that want deterministic behaviour without depending on dynamic
+ * `import()` resolution timing.
+ */
+function _injectWrapForTests(fn) {
+    cachedWrap = fn;
+}