aiden-runtime 4.8.0 → 4.8.1

package/dist/cli/v4/chatSession.js

@@ -907,13 +907,15 @@ class ChatSession {
         // Phase 22 Task 4: status bar reflects the live phase. Set on
         // entry, cleared in both success and error paths below.
         this.setStatusState({ kind: 'generating', sinceMs: Date.now() });
-        // Tier-3.1a: dim full-width rule between the user input echo and
-        // the agent reply for clean visual rhythm.
-        this.opts.display.write(`  ${this.opts.display.rule()}\n`);
-        // Phase 26.2.3 — blank line between the user-input echo and the
-        // spinner / response so the eye sees user → agent as separate
-        // beats instead of butting together.
-        this.opts.display.write('\n');
+        // v4.8.1 Slice 2 hotfix #3 — removed the prior Tier-3.1a dim
+        // rule between the user input echo and the agent reply. The dim
+        // colour read as a near-blank row in live smoke, and stacked
+        // with the indicator's erase-blank residue produced two visible
+        // separator rows above `▎ Aiden`. With the rule gone, the layout
+        // is:
+        //   user input → [indicator paints, erases — 1 blank row] → ▎ Aiden
+        // = exactly one blank row between user input and Aiden header,
+        // matching the rhythm Shiva flagged in smoke.
         const turnStartedAt = Date.now();
         const userMsg = { role: 'user', content: userInput };
         // Apply any queued system prompts (from skill slash commands) by

package/dist/cli/v4/commands/update.js

@@ -78,14 +78,26 @@ async function runInstall(ctx) {
         return;
     }
     ctx.display.write(`Installing aiden-runtime v${status.latest} (current: v${status.installed})…\n`);
-    const result = await (0, executeInstall_1.executeInstall)();
+    // v4.8.1 Slice 2 — reuse the v4.8.0 sliding-block shimmer indicator
+    // so the user sees motion while npm install runs (typically 5–15s
+    // on a warm cache, longer on cold). The indicator paints to a TTY
+    // only — non-TTY callers (CI, pipes) see the static "Installing…"
+    // line above and the result row below, no shimmer.
+    const indicator = ctx.display.activityIndicator('updating');
+    let result;
+    try {
+        result = await (0, executeInstall_1.executeInstall)();
+    }
+    finally {
+        indicator.stop();
+    }
     if (result.success) {
         const v = result.installedVersion ?? status.latest;
         ctx.display.write(`\n  ✓ aiden-runtime v${v} installed.\n`);
         ctx.display.dim('Restart Aiden to apply: type /quit then re-run `aiden`.');
         return;
     }
-    ctx.display.warn(result.error ?? 'Install failed (no error message).');
+    ctx.display.write(`\n  ✗ Update failed: ${result.error ?? 'no error message'}\n`);
 }
 // ── v4.5 update system — skip + auto subcommands ───────────────────────────
 async function runSkip(ctx) {

package/dist/cli/v4/display.js

@@ -658,10 +658,16 @@ class Display {
             segments = [provModel, ctxSegFull, turnSeg, sessionSeg, stateDot];
         }
         else if (cols >= 100 && turnSeg) {
-            segments = [provModel, ctxSegFull, turnSeg, elapsed];
+            // v4.8.1 Slice 2 hotfix — was `elapsed` (bare); now uses
+            // `sessionSeg` which includes the ⌛ timer glyph. The previous
+            // mid-tier dropped the glyph for "denser" packing, but Shiva's
+            // smoke at 80–110 cols showed only ` 5.1s` (leading space, no
+            // glyph). The glyph is single-cell, cheap, and load-bearing as
+            // the timer's identity affordance.
+            segments = [provModel, ctxSegFull, turnSeg, sessionSeg || elapsed];
         }
         else {
-            segments = [provModel, ctxSegCompact, elapsed];
+            segments = [provModel, ctxSegCompact, sessionSeg || elapsed];
         }
         return `  ${segments.join(SEP)}`;
     }
@@ -892,6 +898,13 @@ class Display {
         let stopped = false;
         let printed = false;
         let tickTimer = null;
+        // v4.8.1 Slice 2 hotfix #4 — true once the indicator has paused
+        // and resumed at least once (i.e. a tool row interrupted it). When
+        // false at stop() time, the indicator is still in its initial-paint
+        // row immediately below the leading blank, so stop()'s erase can
+        // safely consume BOTH rows. When true, the leading blank is far
+        // above and stop() erases only the current indicator row.
+        let movedFromInitial = false;
         // 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
@@ -951,7 +964,12 @@ class Display {
                 : '';
             // Shimmer prefix (or none, when opts.waveBar === false).
             const prefix = shimmerEnabled ? `${buildShimmer()} ` : '';
-            return `${prefix}${verb}${dots.padEnd(3, ' ')}${elapsedStr}`;
+            // v4.8.1 Slice 2 hotfix #4 — 2-space leading indent so the
+            // indicator line aligns at col 2, matching `▎ Aiden`, the
+            // user-prompt `  ▲ `, the panel `  │ ` bar, and every other
+            // structured surface. Prior buildLine started at col 0 which
+            // read as misaligned against the rest of the v4.8 chrome.
+            return `  ${prefix}${verb}${dots.padEnd(3, ' ')}${elapsedStr}`;
         };
         // v4.1.5 Part 1a — Issue M (Windows ConPTY buffering fix).
         //
@@ -1014,12 +1032,16 @@ class Display {
                 return;
             out.write(`${ANSI_UP_ERASE}\n`);
         };
-        // Initial paint — only on TTY. v4.8.0 Slice 11 — prepend a blank
-        // `\n` so the indicator gets one visible row of breathing space
-        // above it. Prior behaviour butted the indicator flush against
-        // the user-prompt row, which read as cramped. The trailing `\n`
-        // on the verb row sits the cursor below the indicator, ready
-        // for the first tick to walk back up.
+        // Initial paint — only on TTY.
+        //
+        // v4.8.1 Slice 2 hotfix #4 — leading `\n` restored to give one
+        // blank row between the user-input row and the indicator (hotfix
+        // #3 dropped the dim rule that previously provided that gap).
+        // To keep the post-stop layout at "exactly one blank between
+        // user input and ▎ Aiden", stop() now walks up TWO rows when
+        // the indicator never moved (no pause/resume), consuming both
+        // the indicator row AND the leading blank. The `movedFromInitial`
+        // flag below tracks that state.
         if (isTty) {
             out.write(`\n${buildLine()}\n`);
             printed = true;
@@ -1031,6 +1053,12 @@ class Display {
                     return;
                 paused = true;
                 stopTick();
+                // v4.8.1 Slice 2 hotfix #4 — mark the indicator as "moved" so
+                // a subsequent stop() does NOT walk up 2 rows. The leading
+                // blank from initial paint is now far above the current row
+                // and shouldn't be consumed; doing so would erase tool-row
+                // content instead.
+                movedFromInitial = true;
                 eraseLine();
                 // After erase the cursor is at column 0 of the indicator's
                 // (now empty) line. Caller is expected to write its own
@@ -1071,7 +1099,20 @@ class Display {
                     return;
                 stopped = true;
                 stopTick();
-                eraseLine();
+                // v4.8.1 Slice 2 hotfix #4 — when the indicator never moved
+                // (no pause/resume happened during the turn), walk up TWO
+                // rows: erase the indicator row AND the leading blank above
+                // it. The trailing `\n` then lands the cursor exactly one
+                // row below the user-input echo, so the next writer
+                // (agentHeader → ▎ Aiden) produces a clean single-blank gap.
+                if (!printed || !isTty)
+                    return;
+                if (movedFromInitial) {
+                    out.write(`${ANSI_UP_ERASE}\n`);
+                }
+                else {
+                    out.write(`${ANSI_UP_ERASE}${ANSI_UP_ERASE}\n`);
+                }
             },
             isPaused: () => paused,
             isStopped: () => stopped,
@@ -2051,23 +2092,25 @@ class Display {
         this.out.write(this.uiTrailRow(`${ok ? '✓' : '✗'} ${framework}: ${parts.join(', ')}${dur}`, ok ? 'success' : 'error'));
         this.streamLastEndedNewline = true;
     }
-    renderUiApprovalRequest(args) {
-        const prompt = typeof args.prompt === 'string' ? args.prompt : '';
-        if (!prompt)
-            return;
-        const riskTier = typeof args.risk_tier === 'string' ? args.risk_tier : 'medium';
-        const reason = typeof args.reason === 'string' ? args.reason : '';
-        this.commitStreamChunk();
-        const kind = riskTier === 'low' ? 'success'
-            : (riskTier === 'high' || riskTier === 'critical') ? 'error' : 'warn';
-        const shortP = prompt.length > 160 ? prompt.slice(0, 159) + '…' : prompt;
-        let out = this.uiTrailRow(`⚠ Approval needed: ${shortP}`, kind);
-        if (reason) {
-            const shortR = reason.length > 200 ? reason.slice(0, 199) + '…' : reason;
-            out += this.uiTrailRow(`  ${shortR}`, 'muted');
-        }
-        this.out.write(out);
-        this.streamLastEndedNewline = true;
+    renderUiApprovalRequest(_args) {
+        // v4.8.1 Slice 1 — silent no-op. The Phase 2.5 wiring fires both
+        // `ui_approval_request` (this method) AND `callbacks.promptApproval`
+        // (which paints the framed approval panel via `renderApprovalBox`)
+        // for every single approval request. The intent was complementary —
+        // succinct event row above, structured kv panel below — but in live
+        // smoke the two surfaces stack as a visual duplicate ("Approval
+        // needed: file_write {...}" event row + "│ tool / │ reason / │ args"
+        // panel). The panel is the canonical, information-rich surface; this
+        // event-row paint is redundant.
+        //
+        // Behavioural change is renderer-side only: `approvalEngine` still
+        // fires `onUiEvent('ui_approval_request', ...)` so any future
+        // telemetry / daemon-side run_events subscriber will still see the
+        // event. Nothing paints to the chat surface from this method.
+        //
+        // The `_args` parameter is retained for the dispatch signature
+        // contract (`renderUiEvent` calls it positionally) and for the day
+        // we re-introduce a single-paint surface keyed off args.risk_tier.
     }
     renderUiToast(args) {
         const message = typeof args.message === 'string' ? args.message : '';

package/dist/cli/v4/pasteIntercept.js

@@ -6,19 +6,52 @@
  * Aiden — local-first agent.
  */
 /**
- * cli/v4/pasteIntercept.ts — Tier-3.1a (v4.1-tier3.1a)
+ * cli/v4/pasteIntercept.ts — stdin pre-tap for bracketed paste.
  *
- * Stdin pre-tap that handles bracketed paste sequences before
- * @inquirer/prompts sees them. Modern inquirer treats any internal
- * `\n` as Enter and resolves early, so a multi-line paste auto-
- * submits before the user has a chance to review. This module
- * intercepts paste boundaries (CSI 2004), captures the content,
- * persists it via the existing pasteCompression manifest, and
- * substitutes a `[paste #<id>: <N> lines, <KB>]` label on stdin.
+ * Modern @inquirer/prompts treats any embedded `\n` as Enter and
+ * resolves early, so a multi-line paste would auto-submit one line
+ * at a time. This module intercepts paste payloads BEFORE inquirer
+ * sees them, persists them to a manifest, and substitutes a
+ * `[paste #<id>: <N> lines, <bytes>]` label on stdin. The user sees
+ * the label inside inquirer's input buffer, edits it like any other
+ * text, then presses Enter to submit; `chatSession.readUserInput`
+ * swaps the label back for the original via `getPasteOriginal(id)`
+ * before handing to the agent.
  *
- * The user sees the label in inquirer's input buffer, presses Enter
- * to submit, and chatSession.readUserInput swaps the label for the
- * original via getPasteOriginal(id) before handing to the agent.
+ * v4.8.1 Slice 2 hotfix #6 — robustness rebuild for terminal-
+ * environment diversity:
+ *
+ *   • State machine survives reads split across chunk boundaries.
+ *     The begin or end marker can arrive partially in one chunk
+ *     and be completed by the next; the parser keeps state in `buf`
+ *     until a full marker is observed.
+ *
+ *   • 800ms watchdog flushes a stuck `in_marker_paste` state if
+ *     the terminal never delivers PASTE_END (mosh/tmux/SSH paths
+ *     have all been observed to drop end markers under load).
+ *
+ *   • Degraded marker forms get normalised to canonical at the
+ *     intercept boundary. Visible-escape variants (`^[[200~`) are
+ *     the common case from terminals that escape control sequences
+ *     for display.
+ *
+ *   • CRLF/CR → LF normalisation is applied universally on every
+ *     incoming chunk, not just inside marker payloads. Some
+ *     clipboard payloads carry CR-only line endings.
+ *
+ *   • 30ms timing accumulation catches line-by-line paste delivery
+ *     — the failure mode that surfaced after hotfix #5. When a
+ *     terminal delivers a paste as N small `"<line>\n"` chunks
+ *     instead of one bulk chunk, each chunk has a single trailing
+ *     `\n` and would otherwise pass through as an Enter keystroke.
+ *     The accumulator holds candidate chunks (`length > 1` so the
+ *     bare Enter keystroke `"\n"` is never held) for a 30ms window;
+ *     if another candidate arrives, both are accumulated as a
+ *     multi-line paste and substituted with the placeholder before
+ *     any `\n` reaches inquirer. If no follow-up arrives within the
+ *     window, the held chunk is emitted unchanged (normal Enter).
+ *     30ms is imperceptible to humans and well below sustained
+ *     keystroke timing.
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -33,7 +66,16 @@ const node_path_1 = __importDefault(require("node:path"));
 const paths_1 = require("../../core/v4/paths");
 const PASTE_BEGIN = '\x1b[200~';
 const PASTE_END = '\x1b[201~';
-/** id → original text (in-memory swap table). */
+/**
+ * Degraded marker patterns observed in the wild. Each is rewritten
+ * to canonical at the normalisation boundary so the parser only
+ * needs to know about one form.
+ */
+const DEGRADED_BEGIN = /\^\[\[200~/g;
+const DEGRADED_END = /\^\[\[201~/g;
+const ACCUMULATION_MS = 30;
+const WATCHDOG_MS = 800;
+/** id → original text (in-memory swap table). Disk has /pastes/paste_<id>.txt as source of truth for /show. */
 const originals = new Map();
 function pastesDir() {
     return node_path_1.default.join((0, paths_1.resolveAidenPaths)().root, 'pastes');
@@ -74,18 +116,17 @@ function compressSync(text) {
 }
 /**
  * Look up the original text for a paste id. Returns undefined if the
- * id was never seen by this process (e.g. the user typed a label by
- * hand). Disk is the source of truth for /show <id>; this map is the
- * fast path for the in-flight prompt swap.
+ * id was never seen by this process. Disk (/pastes/paste_<id>.txt)
+ * is the source of truth for /show <id>; this map is the fast path
+ * for the in-flight prompt swap.
  */
 function getPasteOriginal(id) {
     return originals.get(id);
 }
 /**
  * Replace `[paste #N: …]` patterns in `input` with the corresponding
- * original text from the in-process map. Patterns whose id we don't
- * know are left intact (might be user-typed). Returns the swapped
- * string.
+ * original text. Patterns whose id we don't know are left intact
+ * (might be user-typed by hand).
  */
 function expandPasteLabels(input) {
     return input.replace(/\[paste #(\d+):[^\]]*\]/g, (m, id) => {
@@ -93,6 +134,38 @@ function expandPasteLabels(input) {
         return orig !== undefined ? orig : m;
     });
 }
+/**
+ * Universal normalisation applied at the intercept boundary:
+ * CRLF + bare CR → LF, then degraded marker variants → canonical.
+ */
+function normalize(text) {
+    let t = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    t = t.replace(DEGRADED_BEGIN, PASTE_BEGIN);
+    t = t.replace(DEGRADED_END, PASTE_END);
+    return t;
+}
+/**
+ * Decide whether `payload` should emit inline (small single-line) or
+ * be funnelled through the disk-backed placeholder system. Same
+ * thresholds for marker-wrapped and timing-accumulated paths so the
+ * user sees identical chrome regardless of how the paste arrived.
+ */
+function payloadToEmission(payload) {
+    const trimmed = payload.replace(/\n+$/, '');
+    if (!trimmed.includes('\n') && trimmed.length <= 500) {
+        return trimmed;
+    }
+    try {
+        const { id, label } = compressSync(trimmed);
+        originals.set(id, trimmed);
+        return label;
+    }
+    catch {
+        // Disk failure: collapse newlines so the auto-submit we're
+        // preventing doesn't fire downstream.
+        return trimmed.replace(/\n/g, ' ');
+    }
+}
 let installed = null;
 /**
  * Install the stdin pre-tap. Wraps `process.stdin.emit('data', …)`
@@ -103,72 +176,140 @@ let installed = null;
  * MCP serve mode: never call this — `aiden mcp serve` doesn't run
  * the REPL.
  */
-function installPasteInterceptor(stdin) {
+function installPasteInterceptor(stdin, opts = {}) {
     if (installed)
         return installed.restore;
+    const accumulationMs = opts.accumulationMs ?? ACCUMULATION_MS;
+    const watchdogMs = opts.watchdogMs ?? WATCHDOG_MS;
     const origEmit = stdin.emit.bind(stdin);
-    const state = { inPaste: false, buf: '' };
-    function processChunk(text) {
-        let out = '';
+    // State machine —
+    //   normal           : default; chunks pass through or accumulate
+    //   in_marker_paste  : between PASTE_BEGIN and PASTE_END; buf accumulates payload
+    let mode = 'normal';
+    let buf = '';
+    let markerTimer = null;
+    let pendingChunk = null;
+    let pendingTimer = null;
+    function emitDownstream(text) {
+        if (text.length === 0)
+            return;
+        origEmit('data', Buffer.from(text, 'utf8'));
+    }
+    function clearMarkerWatchdog() {
+        if (markerTimer) {
+            clearTimeout(markerTimer);
+            markerTimer = null;
+        }
+    }
+    function armMarkerWatchdog() {
+        clearMarkerWatchdog();
+        markerTimer = setTimeout(() => {
+            // PASTE_END never arrived. Flush whatever we have and reset.
+            const payload = buf;
+            buf = '';
+            mode = 'normal';
+            markerTimer = null;
+            emitDownstream(payloadToEmission(payload));
+        }, watchdogMs);
+    }
+    function clearPending() {
+        if (pendingTimer) {
+            clearTimeout(pendingTimer);
+            pendingTimer = null;
+        }
+        pendingChunk = null;
+    }
+    function flushPendingAsIs() {
+        if (pendingChunk === null)
+            return;
+        const chunk = pendingChunk;
+        clearPending();
+        // Pending was a normal Enter — emit as-is, don't placeholder.
+        emitDownstream(chunk);
+    }
+    function flushPendingAsPaste() {
+        if (pendingChunk === null)
+            return;
+        const chunk = pendingChunk;
+        clearPending();
+        emitDownstream(payloadToEmission(chunk));
+    }
+    function processNormalised(text) {
         let cursor = 0;
         while (cursor < text.length) {
-            if (state.inPaste) {
+            if (mode === 'in_marker_paste') {
                 const endIdx = text.indexOf(PASTE_END, cursor);
                 if (endIdx === -1) {
-                    state.buf += text.slice(cursor);
+                    buf += text.slice(cursor);
                     cursor = text.length;
+                    // Watchdog stays armed — extending the buf without an end
+                    // marker doesn't restart the clock; we still want to flush
+                    // if the entire turn never produces PASTE_END.
                 }
                 else {
-                    state.buf += text.slice(cursor, endIdx);
+                    buf += text.slice(cursor, endIdx);
                     cursor = endIdx + PASTE_END.length;
-                    // Tier-3.1c: terminals (and some clipboard payloads) emit a
-                    // trailing CR/LF immediately after PASTE_END. Without this
-                    // swallow the bytes pass through to readline, where they
-                    // become an Enter event and auto-submit the prompt before
-                    // the user has reviewed the paste. Eat at most one CR + one
-                    // LF (in either order) right after PASTE_END.
-                    if (text[cursor] === '\r')
-                        cursor += 1;
+                    // Swallow a trailing newline that some terminals emit
+                    // immediately after PASTE_END.
                     if (text[cursor] === '\n')
                         cursor += 1;
-                    state.inPaste = false;
-                    const original = state.buf.replace(/\r\n/g, '\n');
-                    state.buf = '';
-                    // Strip a single trailing newline (Enter at end of paste).
-                    const trimmed = original.replace(/\n+$/, '');
-                    if (!trimmed.includes('\n') && trimmed.length <= 500) {
-                        // Single-line, small — emit as-is so user can edit.
-                        out += trimmed;
-                    }
-                    else {
-                        // Multi-line or large — disk-back + emit label.
-                        try {
-                            const { id, label } = compressSync(trimmed);
-                            originals.set(id, trimmed);
-                            out += label;
-                        }
-                        catch {
-                            // Disk failure: fall back to a single-space substitute
-                            // so internal newlines don't trigger auto-submit.
-                            out += trimmed.replace(/\n/g, ' ');
-                        }
-                    }
+                    mode = 'normal';
+                    clearMarkerWatchdog();
+                    const payload = buf;
+                    buf = '';
+                    emitDownstream(payloadToEmission(payload));
                 }
+                continue;
             }
-            else {
-                const beginIdx = text.indexOf(PASTE_BEGIN, cursor);
-                if (beginIdx === -1) {
-                    out += text.slice(cursor);
-                    cursor = text.length;
+            // mode === 'normal'
+            const beginIdx = text.indexOf(PASTE_BEGIN, cursor);
+            if (beginIdx !== -1) {
+                // Pre-marker content: flush any pending and emit inline so
+                // it lands in inquirer's buffer ahead of the placeholder
+                // (preserves typed prefix when the user pastes after typing).
+                flushPendingAsIs();
+                if (beginIdx > cursor)
+                    emitDownstream(text.slice(cursor, beginIdx));
+                cursor = beginIdx + PASTE_BEGIN.length;
+                mode = 'in_marker_paste';
+                armMarkerWatchdog();
+                continue;
+            }
+            // No marker in the remainder.
+            const remainder = text.slice(cursor);
+            cursor = text.length;
+            const nlCount = (remainder.match(/\n/g) ?? []).length;
+            const hasInternalNl = nlCount > 1 || (nlCount === 1 && !remainder.endsWith('\n'));
+            if (hasInternalNl) {
+                // Single bulk chunk with internal newlines — instant
+                // placeholder. Flush pending first so any prior single-line
+                // candidate isn't lost.
+                flushPendingAsIs();
+                emitDownstream(payloadToEmission(remainder));
+                continue;
+            }
+            // Candidate paste-line: non-empty content ending in `\n` with
+            // length > 1 (excludes bare Enter keystroke `"\n"`).
+            const isCandidate = remainder.endsWith('\n') && remainder.length > 1;
+            if (isCandidate) {
+                if (pendingChunk !== null) {
+                    // Already pending — append, restart the window.
+                    pendingChunk += remainder;
+                    if (pendingTimer)
+                        clearTimeout(pendingTimer);
+                    pendingTimer = setTimeout(flushPendingAsPaste, accumulationMs);
                 }
                 else {
-                    out += text.slice(cursor, beginIdx);
-                    cursor = beginIdx + PASTE_BEGIN.length;
-                    state.inPaste = true;
+                    pendingChunk = remainder;
+                    pendingTimer = setTimeout(flushPendingAsIs, accumulationMs);
                 }
+                continue;
             }
+            // Non-candidate (bare Enter, or non-`\n`-terminated keystroke).
+            // Flush pending first since this chunk closes the window.
+            flushPendingAsIs();
+            emitDownstream(remainder);
         }
-        return out;
     }
     const wrappedEmit = function (event, ...args) {
         if (event !== 'data')
@@ -176,19 +317,22 @@ function installPasteInterceptor(stdin) {
         const chunk = args[0];
         if (chunk == null)
             return origEmit(event, ...args);
-        const text = Buffer.isBuffer(chunk)
+        const raw = Buffer.isBuffer(chunk)
             ? chunk.toString('utf8')
             : (typeof chunk === 'string' ? chunk : String(chunk));
-        const processed = processChunk(text);
-        if (processed.length === 0)
-            return true; // suppress entirely
-        const nextArgs = [Buffer.from(processed, 'utf8'), ...args.slice(1)];
-        return origEmit(event, ...nextArgs);
+        const normalised = normalize(raw);
+        processNormalised(normalised);
+        // We always claim to have handled the emit. Downstream listeners
+        // fire from `emitDownstream` immediately on the same tick OR
+        // from a deferred timer in the accumulation case.
+        return true;
     };
     stdin.emit = wrappedEmit;
     const restore = () => {
         if (!installed)
             return;
+        clearPending();
+        clearMarkerWatchdog();
         stdin.emit = origEmit;
         installed = null;
     };

package/dist/cli/v4/replyRenderer.js

@@ -39,6 +39,7 @@ const tokens_1 = require("./design/tokens");
 // callsites in this file with `getBodyWidth()` and adds soft-wrap for
 // code-block lines that previously overflowed the viewport.
 const frame_1 = require("./display/frame");
+const box_1 = require("./box");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const TerminalRenderer = require('marked-terminal').default ?? require('marked-terminal');
 function paint(kind) {
@@ -638,6 +639,144 @@ function getReplyRenderer() {
         const out = lines.join('\n');
         return proto._listDepth === 0 ? out + '\n' : out + '\n';
     };
+    // ── v4.8.1 Slice 2 — markdown table override ──────────────────────────
+    //
+    // Why: marked-terminal's default table renderer (cli-table3) auto-
+    // wraps cells but doesn't keep wrap-continuation lines aligned to
+    // the original row — wide tables with 5+ columns fragment into
+    // vertical pipe rails that don't read as rows. The narrow 2-col
+    // tables that smoke-tested fine were within the no-wrap budget.
+    //
+    // Strategy: own the entire render from the marked v15 token object.
+    // Use `parser.parseInline(cell.tokens)` to get ANSI-painted cell
+    // text, then proportionally distribute the terminal-width budget
+    // across columns (clamping to natural max width), wrap each cell
+    // to its column width, and render the box with the same row
+    // height for every cell in the row so visual rows stay tight.
+    //
+    // Token-source the box chars from `glyphs.chrome.*` so a single
+    // glyph swap propagates here automatically (consistent with the
+    // rest of v4.8.x chrome).
+    renderer.table = function (header, body) {
+        // marked v15 token: { header: [cellTok], rows: [[cellTok]] }.
+        // Older string-based API: (headerHtml, bodyHtml) — we fall back
+        // to a naive concatenation so the reply isn't lost entirely.
+        if (typeof header !== 'object' || header === null) {
+            return String(header ?? '') + (body !== undefined ? String(body) : '') + '\n';
+        }
+        const tok = header;
+        const parser = this.parser;
+        const renderCell = (c) => {
+            if (c.tokens && parser?.parseInline) {
+                try {
+                    return parser.parseInline(c.tokens).trim();
+                }
+                catch {
+                    return (c.text ?? '').trim();
+                }
+            }
+            return (c.text ?? '').trim();
+        };
+        const headers = (tok.header ?? []).map(renderCell);
+        const rows = (tok.rows ?? []).map((r) => r.map(renderCell));
+        const cols = headers.length;
+        if (cols === 0)
+            return '';
+        // Layout budget. Reply chrome family lives at col 2.
+        const indent = '  ';
+        const termCols = process.stdout.columns ?? 100;
+        const innerBudget = Math.max(40, Math.min(termCols, 110) - indent.length);
+        // Chrome per row = `│ ` (2) per col + trailing `│` (1) + 1 trailing
+        // space per cell already absorbed in the budget below.
+        const chromeCost = 3 * cols + 1;
+        const contentBudget = Math.max(cols * 4, innerBudget - chromeCost);
+        // Natural width = max(header, body) visible width per column.
+        const naturalW = headers.map((h, i) => {
+            const hw = (0, box_1.visibleLength)(h);
+            const cw = rows.reduce((m, r) => Math.max(m, (0, box_1.visibleLength)(r[i] ?? '')), 0);
+            return Math.max(hw, cw, 1);
+        });
+        // v4.8.1 Slice 2 hotfix #2 — header-floor + proportional allocation.
+        //
+        // Each column's minimum is `max(headerWidth, MIN_COL_W)` so column
+        // headers NEVER wrap — they are the column identifier; wrapping
+        // them ("Framework" → "Framew/ork") fragments scanability worse
+        // than wrapping body cells. Body content above the header width
+        // is what gets compressed under width pressure.
+        //
+        // Algorithm:
+        //   1. Compute `minPerCol = max(headerW[i], MIN_COL_W)` per column.
+        //   2. If sum(minPerCol) >= contentBudget (very narrow terminal),
+        //      use minPerCol as-is — body cells will wrap to fit, headers
+        //      stay intact.
+        //   3. Else if sum(naturalW) <= contentBudget, use natural widths
+        //      (no wrap needed anywhere).
+        //   4. Else: floor at minPerCol, distribute remaining budget
+        //      proportionally to each column's "extra need above min",
+        //      then hand rounding leftover to widest-natural cols first.
+        const MIN_COL_W = 4;
+        const headerW = headers.map((h) => (0, box_1.visibleLength)(h));
+        const minPerCol = naturalW.map((_, i) => Math.max(headerW[i], MIN_COL_W));
+        const totalMin = minPerCol.reduce((a, b) => a + b, 0);
+        const totalNatW = naturalW.reduce((a, b) => a + b, 0);
+        let colWidths;
+        if (totalMin >= contentBudget) {
+            colWidths = minPerCol.slice();
+        }
+        else if (totalNatW <= contentBudget) {
+            colWidths = naturalW.slice();
+        }
+        else {
+            colWidths = minPerCol.slice();
+            const extraNeed = naturalW.map((w, i) => Math.max(0, w - minPerCol[i]));
+            const totalNeed = extraNeed.reduce((a, b) => a + b, 0);
+            const pool = contentBudget - totalMin;
+            if (totalNeed > 0) {
+                for (let i = 0; i < cols; i += 1) {
+                    colWidths[i] += Math.floor((extraNeed[i] * pool) / totalNeed);
+                }
+            }
+            let leftover = contentBudget - colWidths.reduce((a, b) => a + b, 0);
+            const order = naturalW.map((_, i) => i).sort((a, b) => naturalW[b] - naturalW[a]);
+            for (let k = 0; leftover > 0 && k < cols * 2; k += 1) {
+                const idx = order[k % cols];
+                if (colWidths[idx] < naturalW[idx]) {
+                    colWidths[idx] += 1;
+                    leftover -= 1;
+                }
+            }
+        }
+        // ANSI-aware cell wrap. frameWrap handles colour-code-aware width.
+        const wrapCell = (text, w) => w <= 0 ? [''] : (0, frame_1.wrap)(text, w, { trim: false, hard: true }).split('\n');
+        const sk = (0, skinEngine_1.getSkinEngine)();
+        const ch = tokens_1.glyphs.chrome;
+        const rule = (l, m, r) => indent + sk.applyColors(l + colWidths.map((w) => ch.hLine.repeat(w + 2)).join(m) + r, 'muted');
+        const vBar = sk.applyColors(ch.vLine, 'muted');
+        const renderRow = (cells) => {
+            const height = Math.max(...cells.map((c) => c.length), 1);
+            const out = [];
+            for (let line = 0; line < height; line += 1) {
+                const cellLines = cells.map((cellLines2, ci) => {
+                    const cellLine = cellLines2[line] ?? '';
+                    const pad = Math.max(0, colWidths[ci] - (0, box_1.visibleLength)(cellLine));
+                    return ' ' + cellLine + ' '.repeat(pad) + ' ';
+                });
+                out.push(indent + vBar + cellLines.join(vBar) + vBar);
+            }
+            return out.join('\n');
+        };
+        const wrappedHeader = headers.map((h, i) => wrapCell(h, colWidths[i]));
+        const wrappedRows = rows.map((r) => r.map((c, i) => wrapCell(c, colWidths[i])));
+        const lines = [rule(ch.topLeft, ch.teeDown, ch.topRight)];
+        if (headers.length > 0) {
+            lines.push(renderRow(wrappedHeader));
+            lines.push(rule(ch.teeRight, ch.cross, ch.teeLeft));
+        }
+        for (const row of wrappedRows)
+            lines.push(renderRow(row));
+        lines.push(rule(ch.botLeft, ch.teeUp, ch.botRight));
+        return lines.join('\n') + '\n';
+    };
     cachedRenderer = {
         render(text) {
             try {

package/dist/core/v4/promptBuilder.js

@@ -166,6 +166,12 @@ const UI_EVENTS_GUIDANCE = [
     'Markdown text in your reply is for explanation, not status. Status goes',
     'through events. Skip events entirely on single-shot queries that aren\'t',
     'multi-step work.',
+    '',
+    '## Comparison formatting',
+    '',
+    'For comparison requests, prefer sectioned lists or narrow tables (3 cols max).',
+    'Wide tables (4+ columns or cells over ~30 chars) render imperfectly in the',
+    'CLI grid — break long content into sections with headers + bullets instead.',
 ].join('\n');
 /**
  * Llama-3.3-specific tool-call format guard. Adapter-side recovery picks

package/dist/core/v4/update/executeInstall.js

@@ -66,17 +66,21 @@ async function executeInstall(opts = {}) {
     const platform = opts.platform ?? process.platform;
     return new Promise((resolve) => {
         const args = ['install', '-g', packageSpec];
-        // shell: true on Windows so npm.cmd is found via PATHEXT; on
-        // POSIX we spawn npm directly. Either way the args are validated
-        // (only npm + install + a hardcoded spec by default) — no user
-        // input flows into argv.
+        // v4.8.1 Slice 2 — drop `shell: true`. Node 20+ emits
+        // `DeprecationWarning: Passing args to a child process with shell
+        // option true can lead to security vulnerabilities` whenever
+        // shell:true is paired with an args array. We don't need the
+        // shell either — on Windows we spawn `npm.cmd` explicitly (the
+        // shim that PATHEXT would otherwise resolve to); on POSIX we
+        // spawn `npm` directly. No user input flows into argv on either
+        // path so the prior shell-resolution wasn't load-bearing.
+        const cmd = platform === 'win32' ? 'npm.cmd' : 'npm';
         const spawnOpts = {
-            shell: platform === 'win32',
             stdio: ['ignore', 'pipe', 'pipe'],
         };
         let child;
         try {
-            child = spawn('npm', args, spawnOpts);
+            child = spawn(cmd, args, spawnOpts);
         }
         catch (err) {
             resolve({

package/dist/core/v4/update/installMethodDetect.js

@@ -37,6 +37,13 @@ const NPM_GLOBAL_HINTS = [
     /[/\\]npm-global[/\\]/,
     /[/\\]\.nvm[/\\]versions[/\\]node[/\\][^/\\]+[/\\]lib[/\\]node_modules\b/,
     /Program Files[/\\]nodejs[/\\]node_modules[/\\]aiden-runtime\b/i,
+    // v4.8.1 Slice 2 — Windows user-mode `npm install -g` lands in
+    // `C:\Users\<u>\AppData\Roaming\npm\node_modules\aiden-runtime\`.
+    // The leading `[/\\]npm[/\\]node_modules` hint above usually catches
+    // it, but tests on a non-default `npm config prefix` setup
+    // (Cmder, Scoop, etc.) can land outside the canonical path. The
+    // extra hint here is a belt-and-suspenders explicit AppData match.
+    /[/\\]AppData[/\\]Roaming[/\\]npm[/\\]/i,
 ];
 function inferDirs(input) {
     return {

package/dist/core/version.js

@@ -1,5 +1,70 @@
 "use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/version.ts — runtime version reader.
+ *
+ * v4.8.1 Slice 2 — switched from build-time injection to a runtime
+ * `package.json` walk. The previous design relied on
+ * `scripts/inject-version.js` (a `prebuild:cli` / `prebuild:api` hook)
+ * to write a hardcoded VERSION constant into this file. That design
+ * had a subtle ordering bug:
+ *
+ *   `npm run build` ran `tsc --outDir dist` BEFORE `inject-version.js`.
+ *   tsc compiled `core/version.ts` (still at the previously-committed
+ *   value) into `dist/core/version.js`. Inject then mutated the
+ *   source, but only the esbuild bundle (`dist-bundle/cli.js`) picked
+ *   up the fresh value. The `bin` entry uses the tsc tree
+ *   (`dist/cli/v4/aidenCLI.js`), so the globally-installed CLI
+ *   reported the stale version.
+ *
+ * Fix: read the version at module-load time by walking up from
+ * `__dirname` and parsing the first `package.json` we find whose
+ * `name` is `aiden-runtime`. This works for:
+ *
+ *   - the tsc tree   (`dist/core/version.js` → walk to `<install>/package.json`)
+ *   - the esbuild bundle (`dist-bundle/cli.js` → walk to root)
+ *   - source / tsx dev runs (`core/version.ts` → walk to repo root)
+ *   - tests (any `__dirname` inside the repo lands on the right pkg)
+ *
+ * Failure mode: returns `'0.0.0-unknown'` if no aiden-runtime
+ * package.json is found within 6 parent directories. End-user
+ * deployments always have one within 3 levels; the 6-level budget
+ * keeps the function defensive without scanning the whole filesystem.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-// AUTO-GENERATED by scripts/inject-version.js — do not edit by hand
-exports.VERSION = '4.8.0';
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function readVersion() {
+    let dir = __dirname;
+    for (let i = 0; i < 6; i += 1) {
+        const candidate = (0, node_path_1.join)(dir, 'package.json');
+        if ((0, node_fs_1.existsSync)(candidate)) {
+            try {
+                const pkg = JSON.parse((0, node_fs_1.readFileSync)(candidate, 'utf8'));
+                if (pkg.name === 'aiden-runtime' && typeof pkg.version === 'string') {
+                    return pkg.version;
+                }
+            }
+            catch {
+                /* unreadable / non-JSON → keep walking */
+            }
+        }
+        const parent = (0, node_path_1.dirname)(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return '0.0.0-unknown';
+}
+/**
+ * Resolved at module-load time. Idempotent — multiple imports share
+ * the cached value. Re-reading on every access would be wasteful;
+ * the package.json version doesn't change during a process lifetime.
+ */
+exports.VERSION = readVersion();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-runtime",
-  "version": "4.8.0",
+  "version": "4.8.1",
   "publishConfig": {
     "access": "public"
   },
@@ -60,9 +60,7 @@
   "scripts": {
     "dev": "electron electron/main.js",
     "build": "tsc --outDir dist && npm run build:cli && npm run build:api",
-    "prebuild:cli": "node scripts/inject-version.js",
     "build:cli": "esbuild cli/aiden.ts --bundle --platform=node --target=node18 --outfile=dist-bundle/cli.js --external:electron --external:cpu-features --external:ssh2 --external:bcrypt --external:playwright --external:playwright-core --external:@aws-sdk/client-s3",
-    "prebuild:api": "node scripts/inject-version.js",
     "build:api": "esbuild api/entry.ts --bundle --platform=node --target=node18 --outfile=dist-bundle/index.js --external:electron --external:cpu-features --external:ssh2 --external:bcrypt --external:playwright --external:playwright-core --external:@aws-sdk/client-s3",
     "prepublishOnly": "npm run typecheck && npm run build",
     "typecheck": "tsc --noEmit",