@semalt-ai/code 1.8.3 → 1.8.4

package/lib/ui/format.js

@@ -0,0 +1,247 @@
+'use strict';
+
+// Pure formatters for the tool-line chrome. Kept zero-dep and side-effect
+// free: every function maps inputs → string, does not touch stdout, and does
+// not read config or state. Consumed by:
+//   - commands.js — builds pending + final activity lines
+//   - writer.js   — nothing (writer is layout-only)
+//
+// Layout contract for a tool line (all four segments are " · "-joined):
+//
+//   <glyph> <category> · <operation> · <duration> · <meta>
+//
+//   glyph     ● pending (muted) / ✓ success / ✗ failure
+//   category  5-col padded short tag ("net  ", "file ", "shell", …)
+//   operation verb + target ("GET https://x", "write /tmp/x", "npm install")
+//   duration  formatDuration(ms), pending lines trail with "…"
+//   meta      type-specific tail — exit codes, byte counts, match counts, …
+
+const { RST, DIM } = require('./ansi');
+const { UI_THEME, UI_ICONS, TOOL_CATEGORIES } = require('./theme');
+
+// Adaptive precision. ms < 1s shows "Nms", under a minute shows "N.Ns"
+// (sub-10s) or "Ns", under an hour shows "MmSs", above uses "HhMm". Never
+// returns the empty string for a valid number — callers strip the value
+// when they want no duration rendered.
+function formatDuration(ms) {
+  if (ms == null || !Number.isFinite(ms)) return '';
+  const v = ms < 0 ? 0 : ms;
+  if (v < 1000) return `${Math.round(v)}ms`;
+  if (v < 60_000) {
+    const s = v / 1000;
+    return s < 10 ? `${s.toFixed(1)}s` : `${Math.round(s)}s`;
+  }
+  if (v < 3_600_000) {
+    const totalSec = Math.floor(v / 1000);
+    return `${Math.floor(totalSec / 60)}m${totalSec % 60}s`;
+  }
+  const totalMin = Math.floor(v / 60_000);
+  return `${Math.floor(totalMin / 60)}h${totalMin % 60}m`;
+}
+
+// Human-readable byte count. Single decimal below 10, none above. Scales
+// through KB/MB/GB. Rejects NaN/negative by returning '' so callers can
+// drop the meta fragment entirely.
+function formatBytes(n) {
+  if (n == null || !Number.isFinite(n) || n < 0) return '';
+  if (n < 1024) return `${Math.round(n)} B`;
+  const kb = n / 1024;
+  if (kb < 1024) return kb < 10 ? `${kb.toFixed(1)} KB` : `${Math.round(kb)} KB`;
+  const mb = kb / 1024;
+  if (mb < 1024) return mb < 10 ? `${mb.toFixed(1)} MB` : `${Math.round(mb)} MB`;
+  const gb = mb / 1024;
+  return gb < 10 ? `${gb.toFixed(1)} GB` : `${Math.round(gb)} GB`;
+}
+
+// Short tag for HTTP / network errors. Prefers Node's err.code when
+// available (authoritative) and falls back to substring matches against
+// err.message for non-Node-originated errors (our own "Request timeout"
+// sentinel, for example).
+function formatHttpErrorTag(err) {
+  if (!err) return 'error';
+  const code = err.code || '';
+  const msg = String(err.message || err).toLowerCase();
+  if (code === 'ETIMEDOUT' || /timed out|timeout/.test(msg)) return 'timeout';
+  if (code === 'ECONNREFUSED' || /refused/.test(msg)) return 'refused';
+  if (code === 'ENOTFOUND' || code === 'EAI_AGAIN' || /getaddrinfo|dns/.test(msg)) return 'dns';
+  if (code === 'ECONNRESET' || /reset by peer|econnreset/.test(msg)) return 'reset';
+  if (code === 'CERT_HAS_EXPIRED' || code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE' || /certificate|cert/.test(msg)) return 'cert';
+  if (code === 'EHOSTUNREACH' || /unreachable/.test(msg)) return 'unreachable';
+  return 'error';
+}
+
+// The XML-tag extractor and native-function mapper hand the agent loop
+// *action* names (read, write, append) that differ from the *tag* names
+// (read_file, write_file, append_file) indexed by TAG_REGISTRY and
+// TOOL_CATEGORIES. Normalize here so downstream category/label lookups
+// resolve regardless of which code path produced the call tuple.
+const ACTION_TO_TAG = {
+  read:   'read_file',
+  write:  'write_file',
+  append: 'append_file',
+  exec:   'shell',
+};
+
+function _normalizeTag(tag) {
+  return ACTION_TO_TAG[tag] || tag || 'tool';
+}
+
+// 5-column label. Wider than "net"/"file" so concurrent lines align their
+// operation columns; category names of 5 chars ("shell") fit exactly.
+const CATEGORY_WIDTH = 5;
+
+function _categoryLabel(tag) {
+  const cat = TOOL_CATEGORIES[_normalizeTag(tag)] || 'tool';
+  return cat.length >= CATEGORY_WIDTH ? cat.slice(0, CATEGORY_WIDTH) : cat.padEnd(CATEGORY_WIDTH);
+}
+
+function _truncate(text, max) {
+  if (text == null) return '';
+  const s = String(text);
+  if (s.length <= max) return s;
+  return s.slice(0, Math.max(0, max - 1)) + '…';
+}
+
+// Verb + target string. Never more than ~80 chars visible — longer URLs,
+// commands, paths are head-tail truncated so the line stays on one row
+// even in 120-col terminals with metadata appended.
+function _operation(tag, arg, attrs) {
+  const a = attrs || {};
+  const max = 80;
+  const pathOrArg = (k) => a[k] || arg || '';
+  switch (_normalizeTag(tag)) {
+    case 'http_get':         return _truncate(`GET ${a.url || arg || ''}`, max);
+    case 'download':         return _truncate(`download ${a.url || arg || ''}`, max);
+    case 'upload':           return _truncate(`upload ${a.path || arg || ''}`, max);
+    case 'shell':            return _truncate(a.command || arg || '', max);
+    case 'read_file':        return _truncate(`read ${pathOrArg('path')}`, max);
+    case 'write_file':       return _truncate(`write ${pathOrArg('path')}`, max);
+    case 'create_file':      return _truncate(`create ${pathOrArg('path')}`, max);
+    case 'append_file':      return _truncate(`append ${pathOrArg('path')}`, max);
+    case 'delete_file':      return _truncate(`delete ${pathOrArg('path')}`, max);
+    case 'list_dir':         return _truncate(`list ${pathOrArg('path') || '.'}`, max);
+    case 'make_dir':         return _truncate(`mkdir ${pathOrArg('path')}`, max);
+    case 'remove_dir':       return _truncate(`rmdir ${pathOrArg('path')}`, max);
+    case 'move_file':        return _truncate(`move ${a.src || ''} → ${a.dst || ''}`, max);
+    case 'copy_file':        return _truncate(`copy ${a.src || ''} → ${a.dst || ''}`, max);
+    case 'edit_file':        return _truncate(`edit ${a.path || ''}:${a.line || ''}`, max);
+    case 'search_files':     return _truncate(`search ${a.pattern || arg || ''}${a.dir && a.dir !== '.' ? ` in ${a.dir}` : ''}`, max);
+    case 'search_in_file':   return _truncate(`search-in ${a.path || arg || ''}`, max);
+    case 'replace_in_file':  return _truncate(`replace ${a.path || arg || ''}`, max);
+    case 'file_stat':        return _truncate(`stat ${pathOrArg('path')}`, max);
+    case 'get_env':          return _truncate(`get $${a.name || arg || ''}`, max);
+    case 'set_env':          return _truncate(`set $${a.name || ''}`, max);
+    case 'ask_user':         return _truncate(`ask ${a.question || arg || ''}`, max);
+    case 'store_memory':     return _truncate(`store ${a.key || ''}`, max);
+    case 'recall_memory':    return _truncate(`recall ${a.key || arg || ''}`, max);
+    case 'list_memories':    return 'list memories';
+    case 'system_info':      return 'system info';
+    default:                 return _truncate(arg ? `${tag} ${arg}` : tag, max);
+  }
+}
+
+// Type-specific meta tail. Split into sub-parts so the 4-segment joiner
+// renders e.g. "200 · 42 KB" with its own " · " between them. Returns an
+// array of strings; the caller joins them with " · ".
+function _metaParts(tag, meta, error) {
+  const out = [];
+  const normalized = _normalizeTag(tag);
+  if (error && (normalized === 'http_get' || normalized === 'download')) {
+    out.push(formatHttpErrorTag(error));
+    return out;
+  }
+  switch (normalized) {
+    case 'http_get':
+    case 'download':
+      if (meta && typeof meta.status_code === 'number') out.push(String(meta.status_code));
+      if (meta && typeof meta.bytes === 'number' && meta.bytes >= 0) out.push(formatBytes(meta.bytes));
+      break;
+    case 'shell':
+      if (meta && typeof meta.exit_code === 'number') out.push(`exit ${meta.exit_code}`);
+      break;
+    case 'read_file':
+    case 'write_file':
+    case 'create_file':
+    case 'append_file':
+    case 'upload':
+      if (meta && typeof meta.bytes === 'number' && meta.bytes >= 0) out.push(formatBytes(meta.bytes));
+      break;
+    case 'search_files':
+    case 'search_in_file':
+      if (meta && typeof meta.count === 'number') {
+        out.push(`${meta.count} ${meta.count === 1 ? 'match' : 'matches'}`);
+      }
+      break;
+    case 'replace_in_file':
+      if (meta && typeof meta.count === 'number') out.push(`${meta.count} replaced`);
+      break;
+    case 'list_dir':
+      if (meta && typeof meta.count === 'number') out.push(`${meta.count} ${meta.count === 1 ? 'entry' : 'entries'}`);
+      break;
+    case 'file_stat':
+      if (meta && typeof meta.bytes === 'number' && meta.bytes >= 0) out.push(formatBytes(meta.bytes));
+      if (meta && meta.kind) out.push(meta.kind);
+      break;
+  }
+  return out;
+}
+
+// Build the full styled 4-segment tool line. `status` is one of
+// 'pending' | 'success' | 'failure'. For 'failure', caller may pass an
+// Error-shaped `error` and/or partial `meta` — we format both when
+// present (e.g. a failed HTTP fetch that still yielded a status code).
+function formatToolLine(args) {
+  const {
+    status,
+    tag,
+    arg,
+    attrs,
+    durationMs,
+    meta,
+    error,
+  } = args || {};
+
+  let glyph;
+  let glyphColor;
+  if (status === 'pending') {
+    glyph = UI_ICONS.pending;
+    glyphColor = UI_THEME.muted;
+  } else if (status === 'failure' || error) {
+    glyph = UI_ICONS.error;
+    glyphColor = UI_THEME.error;
+  } else {
+    glyph = UI_ICONS.success;
+    glyphColor = UI_THEME.success;
+  }
+
+  const cat = _categoryLabel(tag);
+  const catColor = (UI_THEME.categories && UI_THEME.categories[_normalizeTag(tag) && (TOOL_CATEGORIES[_normalizeTag(tag)] || 'tool')]) || UI_THEME.accent;
+
+  const op = _operation(tag, arg, attrs);
+  const durStr = formatDuration(durationMs || 0) + (status === 'pending' ? '…' : '');
+  const metaParts = _metaParts(tag, meta, error);
+
+  // Segment-by-segment styling. Each fragment carries its own ANSI codes
+  // so the " · " separator — neutral DIM — can sit between them without
+  // leaking the surrounding color into the separator itself.
+  const sep = ` ${DIM}·${RST} `;
+
+  const durColor = status === 'failure' ? UI_THEME.error : UI_THEME.muted;
+  const metaColor = status === 'failure' ? UI_THEME.error : UI_THEME.subtle;
+
+  const segments = [];
+  segments.push(`  ${glyphColor}${glyph}${RST} ${catColor}${cat}${RST}`);
+  segments.push(`${UI_THEME.default}${op}${RST}`);
+  segments.push(`${durColor}${durStr}${RST}`);
+  for (const m of metaParts) {
+    if (m) segments.push(`${metaColor}${m}${RST}`);
+  }
+  return segments.join(sep);
+}
+
+module.exports = {
+  formatDuration,
+  formatBytes,
+  formatHttpErrorTag,
+  formatToolLine,
+};

package/lib/ui/input-field.js

@@ -4,6 +4,7 @@ const EventEmitter = require('events');
 const readline = require('readline');
 
 const { RST, DIM, FG_CYAN, FG_GREEN, FG_YELLOW } = require('./ansi');
+const { stripAnsi, termWidth } = require('./utils');
 const writer = require('./writer');
 
 const SLASH_CMDS = [
@@ -128,15 +129,15 @@ class InputField extends EventEmitter {
     this._historyIdx = -1;
     this._draft = '';
     this._selectCapture = null;
-    this._blink = true;
     this._idle = false;
     this._idleTimer = null;
-    this._cursorHidden = false;
-    this._blinkTimer = setInterval(() => {
-      if (this._idle || this._disabled) return;
-      this._blink = !this._blink;
-      if (!this._pasteMode) this._render();
-    }, 500);
+    // Caret position within the rendered input lines, consumed by the
+    // orchestrator to position the OS cursor after every live-region
+    // redraw. { line, col } in display columns, or null when the caret
+    // should stay hidden (disabled, navigation capture). The terminal's
+    // native blinking cursor IS the caret — no custom rendering effect
+    // is applied to the character under it.
+    this._caretPosition = null;
     this._escBuf = null;
     this._escTimer = null;
     this._utf8Buf = null;
@@ -158,6 +159,12 @@ class InputField extends EventEmitter {
     this._savedChars = null;
     this._savedCursor = 0;
 
+    // Bash-style exit-arm state: first Ctrl+C on empty input arms, second
+    // Ctrl+C within the window exits. Timer is unref'd so a lingering arm
+    // never keeps the process alive.
+    this._exitArmed = false;
+    this._exitArmTimer = null;
+
     this._onData = (chunk) => this._handleData(chunk);
     if (process.stdin.isTTY) {
       process.stdin.setRawMode(true);
@@ -166,6 +173,7 @@ class InputField extends EventEmitter {
       // land inside another task's compound write. Each is a tiny escape
       // that only toggles state — no display content.
       writer.enqueue(() => {
+        // audit: allowed — terminal-mode raw escapes inside writer.enqueue (sanctioned escape hatch).
         try {
           process.stdout.write('\x1b[?2004h');  // bracketed paste
           process.stdout.write('\x1b[>4;2m');   // xterm modifyOtherKeys level 2
@@ -198,22 +206,6 @@ class InputField extends EventEmitter {
     });
   }
 
-  hideCursor() {
-    if (!this._cursorHidden) {
-      this._cursorHidden = true;
-      // Serialize through writer so this can't interleave mid-frame with a
-      // bubble/scrollback write.
-      writer.enqueue(() => { try { process.stdout.write('\x1b[?25l'); } catch {} });
-    }
-  }
-
-  showCursor() {
-    if (this._cursorHidden) {
-      this._cursorHidden = false;
-      writer.enqueue(() => { try { process.stdout.write('\x1b[?25h'); } catch {} });
-    }
-  }
-
   captureNavigation(handler) {
     this._navCapture = handler;
     this._navSearchMode = false;
@@ -221,37 +213,33 @@ class InputField extends EventEmitter {
     this._deleteLine();
     this._renderHints();
     this._render();
-    this.hideCursor();
   }
 
   releaseNavigation() {
     this._navCapture = null;
     this._navSearchMode = false;
     this._navSearchQuery = '';
-    this.showCursor();
     this._renderHints();
     this._render();
   }
 
-  // Stop all periodic stdout writes so the terminal viewport can scroll freely.
+  // Pause status-bar ticking so the terminal viewport can scroll freely.
+  // The OS cursor is managed by the writer based on caret state, not here —
+  // it stays visible at the input caret whenever getCaretPosition() is
+  // non-null.
   _goIdle() {
     this._idle = true;
     clearTimeout(this._idleTimer);
     this._idleTimer = null;
-    this.hideCursor();
     this.emit('idle');
   }
 
-  // Resume periodic writes and restart the idle countdown.
   _goActive() {
     const wasIdle = this._idle;
     this._idle = false;
     clearTimeout(this._idleTimer);
     this._idleTimer = setTimeout(() => this._goIdle(), 0);
-    if (wasIdle) {
-      this.showCursor();
-      this.emit('active');
-    }
+    if (wasIdle) this.emit('active');
   }
 
   setSearchItems(items) {
@@ -767,6 +755,10 @@ class InputField extends EventEmitter {
 
     if (key !== 'tab') this._clearHint();
 
+    // Any non-Ctrl+C key cancels an armed exit — a letter, arrow, Tab,
+    // Backspace, or Enter all revert the hints row to normal.
+    if (key !== 'ctrl+c') this._clearExitArm();
+
     switch (key) {
       case 'shift+enter':  this._insertChar('\n'); this._render(); break;
       case 'enter': {
@@ -806,9 +798,9 @@ class InputField extends EventEmitter {
       case 'ctrl+l':       this._chatHistory.clearMessages(); break;
       case 'ctrl+r':       this._enterSearchMode(); break;
       case 'ctrl+o':       if (this._navCapture) this._navCapture('expand'); else this.emit('expand'); break;
-      case 'ctrl+g':
-      case 'ctrl+c':
-      case 'ctrl+d':       this.emit('interrupt'); break;
+      case 'ctrl+g':       this.emit('interrupt'); break;
+      case 'ctrl+c':       this._onCtrlC(); break;
+      case 'ctrl+d':       this._onCtrlD(); break;
       case 'ctrl+right':
       case 'alt+f':        this._jumpWordForward(); this._render(); break;
       case 'ctrl+left':
@@ -831,6 +823,58 @@ class InputField extends EventEmitter {
     }
   }
 
+  // ── Bash-style Ctrl+C / Ctrl+D ───────────────────────────────────────────────
+  //
+  // Ctrl+C is context-dependent. _handleKey is only reached when the agent is
+  // idle (agent-active Ctrl+C is handled directly in _handleData's disabled
+  // branch), so these helpers only cover the idle cases: clear a non-empty
+  // line, or arm/confirm exit on empty input. Ctrl+D mirrors readline: exit
+  // only when the line is empty, otherwise do nothing.
+  _onCtrlC() {
+    if (this._chars.length > 0) {
+      // Non-empty line: clear it and DO NOT arm. A subsequent Ctrl+C on the
+      // newly-empty line starts the arm sequence from scratch.
+      this._deleteLine();
+      this._clearExitArm();
+      this._render();
+      return;
+    }
+    if (this._exitArmed) {
+      this._clearExitArm();
+      this.emit('interrupt');
+      return;
+    }
+    this._armExit();
+  }
+
+  _onCtrlD() {
+    if (this._chars.length > 0) return;
+    this.emit('interrupt');
+  }
+
+  _armExit() {
+    this._exitArmed = true;
+    if (this._exitArmTimer) clearTimeout(this._exitArmTimer);
+    this._exitArmTimer = setTimeout(() => {
+      this._exitArmed = false;
+      this._exitArmTimer = null;
+      this._renderHints();
+    }, 2000);
+    // Don't let a pending arm keep the event loop alive.
+    if (this._exitArmTimer.unref) this._exitArmTimer.unref();
+    this._renderHints();
+  }
+
+  _clearExitArm() {
+    if (!this._exitArmed && !this._exitArmTimer) return;
+    this._exitArmed = false;
+    if (this._exitArmTimer) {
+      clearTimeout(this._exitArmTimer);
+      this._exitArmTimer = null;
+    }
+    this._renderHints();
+  }
+
   // ── Raw stdin byte handler ───────────────────────────────────────────────────
 
   _handleData(chunk) {
@@ -852,9 +896,12 @@ class InputField extends EventEmitter {
     if (this._navCapture) { this._processBuf(buf, false); return; }
     if (this._disabled) {
       if (buf[0] === 0x03) {
+        // Ctrl+C while agent is active: interrupt the operation and reset
+        // any pending exit-arm so the next idle Ctrl+C starts a fresh arm.
+        this._clearExitArm();
         this.emit('abort');
       } else if (buf[0] === 0x04) {
-        this.emit('interrupt');
+        // Ctrl+D while agent active: ignored (bash readline semantics).
       } else if (buf[0] === 0x0f) {
         this.emit('expand');
       } else if (buf[0] === 0x1b && buf.length === 1) {
@@ -991,6 +1038,10 @@ class InputField extends EventEmitter {
           if (cp !== undefined && cp >= 0x20) {
             const ch = String.fromCodePoint(cp);
             this._insertChar(ch);
+            // Printable chars bypass _handleKey — explicitly cancel an armed
+            // exit so typing a letter behaves like bash (any keystroke except
+            // a second Ctrl+C reverts the hint).
+            this._clearExitArm();
             if (!this._pasteMode) {
               this._clearHint();
               this._render();
@@ -1018,7 +1069,9 @@ class InputField extends EventEmitter {
 
   _renderHints() {
     let text;
-    if (this._searchMode) {
+    if (this._exitArmed) {
+      text = `${FG_YELLOW}Press Ctrl+C again to exit${RST}`;
+    } else if (this._searchMode) {
       text = `${FG_YELLOW}ctrl+r${RST}${DIM} next match  ${RST}${FG_YELLOW}esc${RST}${DIM} cancel search${RST}`;
     } else if (this._disabled) {
       text = `${FG_YELLOW}esc${RST}${DIM}/${RST}${FG_YELLOW}ctrl+c${RST}${DIM} interrupt${RST}`;
@@ -1045,9 +1098,12 @@ class InputField extends EventEmitter {
   // the UI orchestrator. Then _notify() — the orchestrator pulls the lines
   // and repaints the live region.
   //
-  // The "caret" is a printable inverted/underlined character embedded in
-  // the text; the OS cursor stays hidden for the whole TUI session so it
-  // never flickers during in-place redraws.
+  // The caret is the terminal's native blinking cursor, positioned by the
+  // writer after each redraw using this._caretPosition. Rendering here does
+  // not embed any visual cursor into the text — the inverted/underlined
+  // simulation was removed because it duplicated the native cursor and
+  // caused a phantom "below hints" blink when the OS cursor wasn't moved
+  // up to the input row after a frame.
 
   _render() {
     if (this._disabled) {
@@ -1056,6 +1112,7 @@ class InputField extends EventEmitter {
         this._layout.setInputHeight(1);
       }
       this._inputLines = [`${DIM}›${RST}`];
+      this._caretPosition = null;
       this._notify();
       return;
     }
@@ -1066,6 +1123,7 @@ class InputField extends EventEmitter {
         this._layout.setInputHeight(1);
       }
       this._inputLines = [`${DIM}›${RST}`];
+      this._caretPosition = null;
       this._notify();
       return;
     }
@@ -1098,7 +1156,13 @@ class InputField extends EventEmitter {
         displayMatch = matched;
       }
 
-      this._inputLines = [prefix + typeLabel + displayMatch];
+      const rendered = prefix + typeLabel + displayMatch;
+      this._inputLines = [rendered];
+      // Put the OS cursor at the end of the visible text so the user sees
+      // where their next keystroke will land (they're editing _searchQuery
+      // in the prefix, but by design the row gets rewritten with the match
+      // on every keystroke; trailing position is the least surprising).
+      this._caretPosition = { line: 0, col: termWidth(stripAnsi(rendered)) };
       this._notify();
       return;
     }
@@ -1136,20 +1200,7 @@ class InputField extends EventEmitter {
     const renderCount = Math.min(lines.length, this._inputHeight);
     for (let li = 0; li < renderCount; li++) {
       const lineChars = lines[li];
-
-      let lineStr;
-      if (li === cursorLine) {
-        const leftStr  = lineChars.slice(0, cursorCol).join('');
-        const cursorCh = cursorCol < lineChars.length ? lineChars[cursorCol] : ' ';
-        const afterStr = lineChars.slice(cursorCol + (cursorCol < lineChars.length ? 1 : 0)).join('');
-        const cursorEsc = this._blink
-          ? `\x1b[7m${cursorCh}\x1b[27m`
-          : `\x1b[4m${cursorCh}\x1b[24m`;
-        lineStr = leftStr + cursorEsc + afterStr;
-      } else {
-        lineStr = lineChars.join('');
-      }
-
+      const lineStr = lineChars.join('');
       const leadIn  = li === 0 ? PREFIX : ' '.repeat(PREFIX_LEN);
       const hintStr = (li === 0 && this._hint) ? `${DIM}${this._hint}${RST}` : '';
       out.push(leadIn + lineStr + hintStr);
@@ -1157,12 +1208,36 @@ class InputField extends EventEmitter {
 
     if (out.length === 0) out.push(PREFIX);
     this._inputLines = out;
+
+    // Caret sits at PREFIX_LEN + display-width of the chars on the caret
+    // line that precede it. termWidth handles double-width glyphs (CJK,
+    // emoji) so the column is correct even when the input contains them.
+    // If the caret row was dropped because _inputHeight clamped the render
+    // to fewer rows, keep the caret on the last rendered row at its end —
+    // the text that overflowed isn't visible anyway.
+    const caretLineIdx = Math.min(cursorLine, renderCount - 1);
+    const caretLineChars = lines[caretLineIdx] || [];
+    const beforeCaret = caretLineIdx === cursorLine
+      ? caretLineChars.slice(0, cursorCol).join('')
+      : caretLineChars.join('');
+    this._caretPosition = {
+      line: caretLineIdx,
+      col: PREFIX_LEN + termWidth(beforeCaret),
+    };
     this._notify();
   }
 
   // Expose the last-computed input lines for the orchestrator.
   renderInputLines() { return this._inputLines.slice(); }
 
+  // Expose the caret position inside the most recently rendered input rows:
+  // { line, col } — `line` is the 0-indexed input row and `col` is the
+  // 0-indexed display column (PREFIX width + termWidth of preceding chars).
+  // Returns null when no caret should appear (disabled / nav capture).
+  getCaretPosition() {
+    return this._caretPosition ? { ...this._caretPosition } : null;
+  }
+
   _notify() {
     try { this._onChange(); } catch {}
   }
@@ -1170,14 +1245,15 @@ class InputField extends EventEmitter {
   // ── Destroy ──────────────────────────────────────────────────────────────────
 
   destroy() {
-    if (this._blinkTimer) { clearInterval(this._blinkTimer); this._blinkTimer = null; }
-    if (this._escTimer)   { clearTimeout(this._escTimer);    this._escTimer = null; }
-    if (this._idleTimer)  { clearTimeout(this._idleTimer);   this._idleTimer = null; }
+    if (this._escTimer)     { clearTimeout(this._escTimer);    this._escTimer = null; }
+    if (this._idleTimer)    { clearTimeout(this._idleTimer);   this._idleTimer = null; }
+    if (this._exitArmTimer) { clearTimeout(this._exitArmTimer); this._exitArmTimer = null; }
     if (process.stdin.isTTY) {
       process.stdin.removeListener('data', this._onData);
       // Terminal-mode pops must run in queue order so they don't race with
       // a pending live-region redraw on shutdown.
       writer.enqueue(() => {
+        // audit: allowed — terminal-mode raw escapes inside writer.enqueue (sanctioned escape hatch).
         try {
           process.stdout.write('\x1b[?25h');   // show cursor
           process.stdout.write('\x1b[<u');     // pop kitty keyboard protocol
@@ -1185,7 +1261,6 @@ class InputField extends EventEmitter {
           process.stdout.write('\x1b[?2004l'); // disable bracketed paste
         } catch {}
       });
-      this._cursorHidden = false;
       process.stdin.setRawMode(false);    // restore cooked mode so mouse works again
     }
   }

package/lib/ui/layout.js

@@ -43,8 +43,6 @@ class LayoutManager {
     if (this._heightChangeCb) this._heightChangeCb();
   }
 
-  moveTo(row, col) { process.stdout.write(`\x1b[${row};${col || 1}H`); }
-
   destroy() {
     process.stdout.removeListener('resize', this._handler);
   }

package/lib/ui/messages.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// Thin wrappers over writer.scrollback for the four primary error categories
+// and three neutral system-line glyphs. All composition + colour comes from
+// theme.js so the palette stays consistent with the rest of the chrome. Each
+// helper returns the writer.scrollback promise so callers can `await` if
+// they need the line flushed before exit.
+
+const { UI_THEME, UI_ICONS } = require('./theme');
+const { RST } = require('./ansi');
+const writer = require('./writer');
+
+const ICON_ERROR   = `${UI_THEME.error}${UI_ICONS.error}${RST}`;
+const ICON_SUCCESS = `${UI_THEME.success}${UI_ICONS.success}${RST}`;
+const ICON_WARN    = `${UI_THEME.warning}${UI_ICONS.warn}${RST}`;
+const ICON_INFO    = `${UI_THEME.muted}${UI_ICONS.bullet}${RST}`;
+const SEP          = `${UI_THEME.muted}·${RST}`;
+
+function _cat(name) { return `${UI_THEME.accent}${name}${RST}`; }
+
+function agentError(msg) {
+  return writer.scrollback(`${ICON_ERROR} ${_cat('agent')} ${SEP} ${msg}${RST}`);
+}
+
+function toolError(tag, msg) {
+  return writer.scrollback(`${ICON_ERROR} ${_cat('tool')} ${SEP} ${UI_THEME.accent}${tag}${RST} ${SEP} ${msg}${RST}`);
+}
+
+function netError(msg) {
+  return writer.scrollback(`${ICON_ERROR} ${_cat('net')} ${SEP} ${msg}${RST}`);
+}
+
+function configError(msg) {
+  return writer.scrollback(`${ICON_ERROR} ${_cat('config')} ${SEP} ${msg}${RST}`);
+}
+
+function sysInfo(msg)    { return writer.scrollback(`${ICON_INFO} ${msg}${RST}`); }
+function sysSuccess(msg) { return writer.scrollback(`${ICON_SUCCESS} ${msg}${RST}`); }
+function sysWarn(msg)    { return writer.scrollback(`${ICON_WARN} ${msg}${RST}`); }
+
+module.exports = {
+  agentError, toolError, netError, configError,
+  sysInfo, sysSuccess, sysWarn,
+};