@semalt-ai/code 1.8.3 → 1.8.5

package/lib/ui/chat-history.js

@@ -3,6 +3,7 @@
 const { RST, DIM, BOLD, FG_CYAN, FG_GREEN, FG_YELLOW, FG_RED, FG_DARK, FG_GRAY } = require('./ansi');
 const { getCols, stripAnsi } = require('./utils');
 const { UI_THEME, UI_ICONS, TOOL_CATEGORIES } = require('./theme');
+const { summarizeToolResult } = require('./format');
 const writer = require('./writer');
 
 
@@ -142,14 +143,41 @@ class ChatHistory {
       }
       out += '\n';
     } else if (msg.role === 'tool') {
-      const indicator = msg.isError
-        ? `${UI_THEME.error}${UI_ICONS.error}${RST}`
-        : `${UI_THEME.success}${UI_ICONS.success}${RST}`;
-      const category = TOOL_CATEGORIES[msg.tag] || msg.tag || 'tool';
-      const head = `${UI_THEME.accent}${category}${UI_THEME.muted}:${RST}`;
-      const desc = _dimPaths(content);
-      out = `  ${indicator} ${head} ${desc}\n`;
-      lineCount = 1;
+      // Tool summary header. The writer's activity region now commits the
+      // primary "glyph · category · op · duration · meta" line directly to
+      // scrollback via endActivity — when a caller supplies an empty
+      // `content` they're signalling that the header is already present
+      // and only the expandable output body should render here.
+      //
+      // History-loaded tool messages arrive with the raw stored payload as
+      // `content` and no `output` — collapse them through summarizeToolResult
+      // to a single live-activity-style line. Callers that pass `output`
+      // (debug blocks, live-activity error pass-through) keep the legacy
+      // header chrome.
+      if (msg.content && !msg.output) {
+        const summary = safeContent(summarizeToolResult(msg.content));
+        if (summary) {
+          const indicator = msg.isError
+            ? `${UI_THEME.error}${UI_ICONS.error}${RST}`
+            : `${UI_THEME.success}${UI_ICONS.success}${RST}`;
+          const sep = ` ${DIM}·${RST} `;
+          const styled = summary.split(' · ').map((p) => _dimPaths(p)).join(sep);
+          out = `  ${indicator} ${styled}\n`;
+          lineCount = 1;
+        }
+      } else if (content) {
+        const indicator = msg.isError
+          ? `${UI_THEME.error}${UI_ICONS.error}${RST}`
+          : `${UI_THEME.success}${UI_ICONS.success}${RST}`;
+        const category = TOOL_CATEGORIES[msg.tag] || msg.tag || 'tool';
+        const head = `${UI_THEME.accent}${category}${UI_THEME.muted}:${RST}`;
+        const desc = _dimPaths(content);
+        out = `  ${indicator} ${head} ${desc}\n`;
+        lineCount = 1;
+      } else {
+        out = '';
+        lineCount = 0;
+      }
       if (msg.output) {
         const wrapAt = Math.max(60, getCols() - 8);
         const outLines = [];
@@ -309,6 +337,7 @@ class ChatHistory {
     // the clear can't land inside a pending scrollback burst, then redraw
     // the live region under the new cursor.
     writer.enqueue(() => {
+      // audit: allowed — viewport clear inside writer.enqueue (sanctioned escape hatch).
       try { process.stdout.write('\x1b[3J\x1b[2J\x1b[H'); } catch {}
     });
     writer.redrawLive();

package/lib/ui/create-ui.js

@@ -2,7 +2,7 @@
 
 const readline = require('readline');
 
-const { RST, DIM, FG_YELLOW, FG_CYAN, FG_GRAY, BG_SELECTED } = require('./ansi');
+const { RST, FG_YELLOW, FG_CYAN, FG_GRAY } = require('./ansi');
 const { ChatHistory } = require('./chat-history');
 const writer = require('./writer');
 const { registerTerminalCleanup } = require('./terminal');
@@ -10,9 +10,11 @@ const { registerTerminalCleanup } = require('./terminal');
 function _createNoOpUI() {
   const chatHistory = {
     addMessage: (msg) => {
+      // audit: allowed — non-TUI no-op UI fallback, no live region to protect.
       if (msg.role === 'assistant' || msg.role === 'user')
         process.stdout.write(`[${msg.role}] ${msg.content || ''}\n`);
     },
+    // audit: allowed — non-TUI no-op UI fallback, no live region to protect.
     streamToken: (token) => process.stdout.write(token),
     clearStreamingContent: () => {},
     finalizeLastMessage: () => {},
@@ -25,8 +27,9 @@ function _createNoOpUI() {
   };
   const statusBar = {
     update: () => {}, updateMetrics: () => {}, onToken: () => {},
-    drawSeparator: () => {}, liveUpdate: () => {}, _renderBar: () => {},
-    setModel: () => {}, destroy: () => {},
+    drawSeparator: () => {}, _renderBar: () => {},
+    setModel: () => {}, setContextLimit: () => {}, setReportedContext: () => {},
+    addPendingTokens: () => {}, destroy: () => {},
   };
   let _submitCb = null;
   const inputField = {
@@ -59,7 +62,7 @@ function createUI(opts) {
   const { LayoutManager } = require('./layout');
   const { FullStatusBar } = require('./status-bar');
   const { InputField } = require('./input-field');
-  const { interactiveSelect } = require('./legacy');
+  const { interactiveSelect } = require('./select');
 
   const layout = new LayoutManager();
   const chatHistory = new ChatHistory();
@@ -93,24 +96,38 @@ function createUI(opts) {
     // chrome has a visible top edge.
     if (_sb) lines.push(_sb.renderSeparator());
 
-    // Status bar.
-    if (_sb) {
-      const statusLine = _sb.renderLine();
-      if (statusLine !== null && statusLine !== undefined) {
-        lines.push(statusLine);
-      }
-    }
+    // Status bar. ALWAYS pushed — the row is a permanent fixture of the
+    // live region so the input and hint rows below it keep a stable
+    // vertical position. `renderLine()` is contractually non-null; missing
+    // data (model, tokens) renders as a short placeholder inside the row.
+    if (_sb) lines.push(_sb.renderLine());
 
     // Input row(s).
+    let caret = null;
     if (_inputField) {
-      for (const row of _inputField.renderInputLines()) {
+      const inputLines = _inputField.renderInputLines();
+      for (const row of inputLines) {
         lines.push(row);
       }
       // Hints row.
       lines.push(_inputField.renderHintsLine());
+
+      // Caret: translate the input-local { line, col } into the live
+      // region's "rows up from the cursor's post-draw position". The
+      // post-draw cursor lands one row below the final hints row, so:
+      //   rowsFromBottom = 1 (for hints) + (inputLines.length - caret.line)
+      // Leaving caret null keeps the OS cursor hidden — used while input
+      // is disabled or a navigation capture is active.
+      const inCaret = _inputField.getCaretPosition && _inputField.getCaretPosition();
+      if (inCaret && inputLines.length > 0) {
+        caret = {
+          rowsFromBottom: 1 + (inputLines.length - inCaret.line),
+          col: inCaret.col,
+        };
+      }
     }
 
-    writer.setLive(lines);
+    writer.setLive(lines, caret);
   }
 
   _sb = new FullStatusBar(layout, _updateLive);
@@ -136,31 +153,34 @@ function createUI(opts) {
 
   // ── captureSelect (modal menu) ───────────────────────────────────────────────
   //
-  // Interactive menus need to take over the bottom of the screen. Clear
-  // the live region, let interactiveSelect draw into scrollback-like space,
-  // then rebuild live on resume.
+  // Numbered-options picker for tools like ask_user. interactiveSelect
+  // renders each frame into the writer's modal region (above status,
+  // below scrollback) and routes keys through the input field's
+  // captureNavigation API — so the menu cohabits with the live region
+  // instead of taking over the screen, and Enter/Esc resolve in place.
   inputField.captureSelect = (menu) => new Promise((resolve) => {
     if (!process.stdin.isTTY) {
       resolve(menu.options[0]);
       return;
     }
-    inputField.suspend();
-    writer.clearLive().then(() => {
-      interactiveSelect(
-        menu.options,
-        (opt, isSelected, isFinal) => {
-          if (isSelected && !isFinal)
-            return `  ${FG_YELLOW}❯${RST} ${BG_SELECTED}${FG_CYAN}${opt}${RST}`;
-          if (isSelected)
-            return `  ${FG_YELLOW}❯${RST} ${FG_CYAN}${opt}${RST}`;
-          return `   ${FG_GRAY}${opt}${RST}`;
+    interactiveSelect(
+      menu.options,
+      (opt, isSelected) => isSelected
+        ? `  ${FG_YELLOW}❯${RST} ${FG_CYAN}${opt}${RST}`
+        : `   ${FG_GRAY}${opt}${RST}`,
+      {
+        initialIndex: 0,
+        onExpand: () => chatHistory.toggleLastExpand(),
+        captureNavigation: (handler) => {
+          inputField.captureNavigation(handler);
+          return () => inputField.releaseNavigation();
         },
-        { initialIndex: 0, onExpand: () => chatHistory.toggleLastExpand() }
-      ).then((idx) => {
-        inputField.resume();
-        _updateLive();
-        resolve(idx === null ? menu.options[menu.options.length - 1] : menu.options[idx]);
-      });
+      }
+    ).then((idx) => {
+      // Cancel returns null. Match the prior contract: pick the last
+      // option (typically "No"/decline) so callers don't need to
+      // special-case cancellation.
+      resolve(idx === null ? menu.options[menu.options.length - 1] : menu.options[idx]);
     });
   });
 
@@ -181,6 +201,7 @@ function createUI(opts) {
   // starts in a known state, then paint the first live frame below a fresh
   // cursor position.
   writer.enqueue(() => {
+    // audit: allowed — terminal-mode raw escape inside writer.enqueue (sanctioned escape hatch).
     try { process.stdout.write('\x1b[2J\x1b[3J\x1b[H\x1b[?25l'); } catch {}
   });
   // Pre-render both input and hints so the first _updateLive has valid
@@ -198,17 +219,21 @@ function createUI(opts) {
   // ── Destroy ──────────────────────────────────────────────────────────────────
   // Stop timers + stdin listeners FIRST so no further writes can be queued,
   // then run writer.teardown(). teardown is a single synchronous stdout
-  // write that erases the live region and resets terminal state. After it
-  // returns, the cursor sits at column 0 of the row immediately below the
-  // last scrollback line — so any subsequent console.log (goodbye banner,
-  // metrics summary, resume hint) lands cleanly under the session content.
-  function destroy() {
+  // write that erases the live region, emits any end-of-session artifacts
+  // passed in (session summary, resume hint, goodbye) as regular scrollback
+  // content, and resets terminal state. After it returns, the cursor sits
+  // at column 0 of the row immediately below those artifacts — ready for
+  // the shell prompt. Callers that want artifacts emitted at exit must
+  // pass them here rather than console.log-ing after destroy(); doing it
+  // after destroy races with terminal-mode restoration and can leave
+  // artifacts overlaid on scrollback with the cursor drifting mid-viewport.
+  function destroy(teardownOpts) {
     if (_destroyCalled) return;
     _destroyCalled = true;
     try { inputField.destroy(); } catch {}
     try { sb.destroy(); } catch {}
     try { layout.destroy(); } catch {}
-    writer.teardown();
+    writer.teardown(teardownOpts);
   }
 
   return { chatHistory, statusBar: sb, inputField, layout, destroy, redrawFixed: _updateLive };

package/lib/ui/diff.js

@@ -3,6 +3,7 @@
 const { FG_DARK, FG_RED, FG_GREEN, FG_GRAY, FG_YELLOW, FG_TEAL, RST, THEME, EL, hasTruecolor } = require('./ansi');
 const { getCols, stripAnsi, termWidth } = require('./utils');
 const { DIFF_THEME, UI_THEME } = require('./theme');
+const writer = require('./writer');
 
 function diffLines(oldLines, newLines) {
   const m = oldLines.length, n = newLines.length;
@@ -206,7 +207,7 @@ function _mdInline(text) {
 }
 
 function renderMarkdown(text) {
-  if (!process.stdout.isTTY) { process.stdout.write(text); return; }
+  if (!process.stdout.isTTY) { writer.scrollback(text); return; }
   const { loadConfig } = require('../config');
   const maxLines = (loadConfig().max_output_lines) || 50;
   const cols = getCols();
@@ -248,8 +249,8 @@ function renderMarkdown(text) {
   }
   let overflow = 0, printLines = output;
   if (output.length > maxLines) { overflow = output.length - maxLines; printLines = output.slice(0, maxLines); }
-  for (const l of printLines) process.stdout.write(l + '\n');
-  if (overflow > 0) process.stdout.write(THEME.dim + '[... ' + overflow + ' more lines]' + THEME.reset + '\n');
+  if (printLines.length > 0) writer.scrollback(printLines.join('\n'));
+  if (overflow > 0) writer.scrollback(THEME.dim + '[... ' + overflow + ' more lines]' + THEME.reset);
 }
 
 module.exports = { renderDiff, renderMarkdown, _mdInline };

package/lib/ui/format.js

@@ -0,0 +1,321 @@
+'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);
+}
+
+// Display-only normalizer for tool argument text. Collapses every run of
+// whitespace (including \n from heredocs and `\<NL>` line continuations)
+// to a single space and trims the ends, so the summary line never spills
+// across multiple physical rows. Pure: never mutates the value used for
+// execution or sent to the model.
+function normalizeCmdForDisplay(text) {
+  if (text == null) return '';
+  return String(text).replace(/\s+/g, ' ').trim();
+}
+
+// Truncate to fit `max` visible chars, normalizing first so a multi-line
+// command becomes a single visual line. When the cut would land mid-word,
+// back up to the nearest space — but only if it doesn't sacrifice more
+// than ~30% of the available width (otherwise prefer the harder cut).
+function _truncate(text, max) {
+  const s = normalizeCmdForDisplay(text);
+  if (s.length <= max) return s;
+  const cap = Math.max(0, max - 1);
+  let cut = s.slice(0, cap);
+  const lastSpace = cut.lastIndexOf(' ');
+  if (lastSpace > cap * 0.7) cut = cut.slice(0, lastSpace);
+  return cut + '…';
+}
+
+// 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,
+    noDuration,
+  } = 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 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}`);
+  if (!noDuration) {
+    const durStr = formatDuration(durationMs || 0) + (status === 'pending' ? '…' : '');
+    segments.push(`${durColor}${durStr}${RST}`);
+  }
+  for (const m of metaParts) {
+    if (m) segments.push(`${metaColor}${m}${RST}`);
+  }
+  return segments.join(sep);
+}
+
+// Collapse a stored tool-result string to a single-line summary in the same
+// shape as the live activity bubble ("net · GET https://x · 200 · 256 KB").
+// Pure: no ANSI, no IO, no allocation beyond the returned string. Idempotent
+// — a value that already looks like a summary is returned untouched so the
+// helper survives double-application once a separate display field lands in
+// storage.
+function summarizeToolResult(content) {
+  if (typeof content !== 'string' || !content) return '';
+  const trimmed = content.trim();
+  if (!trimmed) return '';
+
+  if (!trimmed.includes('\n') && trimmed.includes(' · ') && trimmed.length < 200) {
+    return trimmed;
+  }
+
+  // HTTP: agent.js formats as `HTTP <VERB> <url> (<status>):\n<body>`.
+  const httpMatch = content.match(/^HTTP\s+(\w+)\s+(\S+)\s+\((\d+)\)/);
+  if (httpMatch) {
+    const parts = ['net', `${httpMatch[1]} ${httpMatch[2]}`, httpMatch[3]];
+    const bytes = formatBytes(Buffer.byteLength(content, 'utf8'));
+    if (bytes) parts.push(bytes);
+    return parts.join(' · ');
+  }
+
+  // Exec: `Command \`<cmd>\`:\nExit code: <N>\n<output>`. The cmd may span
+  // multiple lines if the user passed a heredoc — non-greedy capture stops
+  // at the first `\`:` boundary, then we collapse whitespace for the preview.
+  const cmdMatch = content.match(/^Command `([\s\S]+?)`:/);
+  const exitMatch = content.match(/^Exit code: (-?\d+)$/m);
+  if (cmdMatch && exitMatch) {
+    const cmd = cmdMatch[1].replace(/\s+/g, ' ').trim();
+    const preview = cmd.length > 60 ? cmd.slice(0, 59) + '…' : cmd;
+    return `exec · ${preview} · exit ${exitMatch[1]}`;
+  }
+
+  const lines = content.split('\n');
+  if (lines.length <= 3 && /^(Wrote|Read|Created|Deleted|Moved|Renamed)\b/.test(lines[0])) {
+    return lines[0];
+  }
+
+  if (lines.length > 1 || content.length > 120) {
+    const firstLine = lines[0] || '';
+    const preview = firstLine.length > 100 ? firstLine.slice(0, 99) + '…' : firstLine;
+    const parts = ['tool', preview];
+    const bytes = formatBytes(Buffer.byteLength(content, 'utf8'));
+    if (bytes) parts.push(bytes);
+    return parts.join(' · ');
+  }
+
+  return trimmed;
+}
+
+module.exports = {
+  formatDuration,
+  formatBytes,
+  formatHttpErrorTag,
+  formatToolLine,
+  summarizeToolResult,
+  normalizeCmdForDisplay,
+};