@semalt-ai/code 1.8.5 → 1.20.0

package/lib/ui/web-activity.js

@@ -0,0 +1,270 @@
+'use strict';
+
+// Web-activity process summary (Task W.3, Part 1).
+//
+// A web task runs `web_search` (find candidate pages) then targeted `http_get`
+// (read the relevant ones). By default each operation printed its own tool line
+// (one "tool · web_search" / "net · GET …" row per call), which reads as a noisy
+// list rather than one coherent process. This module collapses a run of
+// consecutive web operations into a SINGLE compact process-summary line —
+//
+//     ✓ web · search "коррупционные скандалы…" · 2 queries · 3 sources read · 1 blocked
+//
+// — while `--debug` keeps the full per-operation lines (in debug mode chat-turn.js
+// bypasses this collapser and renders each op the normal way).
+//
+// Display only: the audit log still records every individual operation (that
+// happens in the executors, untouched here), and NON-web tools render exactly as
+// before. Scope: `web_search` + `http_get`. `download` is a file-save, not a page
+// read for the search→fetch flow, so it keeps its own line.
+
+const { UI_THEME, UI_ICONS, resolveLineColors } = require('./theme');
+const { RST, DIM } = require('./ansi');
+const { formatDuration } = require('./format');
+
+// The tools collapsed into the web-activity summary.
+const WEB_TOOLS = new Set(['web_search', 'http_get']);
+
+function isWebTool(tag) { return WEB_TOOLS.has(tag); }
+
+function _truncate(text, max) {
+  const s = String(text == null ? '' : text).replace(/\s+/g, ' ').trim();
+  if (s.length <= max) return s;
+  return s.slice(0, Math.max(0, max - 1)) + '…';
+}
+
+// Whether a finished web op counts as a success. A `web_search` is ok unless the
+// executor flagged an error (backend down). An `http_get` is ok only when it both
+// avoided a transport error (timeout/DNS — surfaced as `op.error`) AND the server
+// answered < 400: a 403/406 is a real "blocked" even though the fetch itself
+// completed and returned a status code.
+function opSucceeded(op) {
+  if (!op) return false;
+  if (op.error) return false;
+  if (op.tag === 'http_get' && typeof op.status === 'number' && op.status >= 400) return false;
+  return true;
+}
+
+// ── Web-op persistence core (Output Refactor — Phase 6c-i) ───────────────────
+//
+// Web tools (`web_search`/`http_get`) are intercepted in chat-turn.js BEFORE
+// they become a normal ToolOperation descriptor (they collapse into the live
+// web-activity summary instead). So the per-call `_display` slot the agent loop
+// persists would be `null` for a web op, and on replay the whole turn drops to
+// the legacy summary. 6c-i closes that gap WITHOUT changing any pixel: the
+// interception now returns a dedicated web-op core (below) which is persisted
+// into the slot, while every replay reader is taught to treat a web-core as
+// "no descriptor → fallback" (see isWebCore + chat-history/chat-session). 6c-ii
+// will later flip the readers to aggregate these cores into a replayed summary.
+//
+// The core is a SEPARATE shape from serializeOperation's normal core, with a
+// MANDATORY `kind:'web'` discriminator: a normal core buries `query` in `attrs`
+// and `status` in `meta`, whereas aggregateWebOps reads `op.query/url/status/
+// bytes/error/tag` FLAT — so these cores can feed aggregateWebOps directly in
+// 6c-ii. `kind:'web'` is mandatory because descriptorFromStored accepts any
+// `v===1` object and would otherwise render a web-core as a broken descriptor.
+const WEB_DISPLAY_FORMAT_VERSION = 1;
+
+// Build a persistable web-op core from the tool ctx (NOT the tracker's mutable
+// ended[]/current state), mirroring exactly what web-activity.end() reads from
+// ctx (`:180-191`): query/url from ctx.attrs, status/bytes from ctx.meta, error
+// from ctx.error. Decoupling persistence from live-region state keeps the two
+// independent.
+function serializeWebOp(ctx, tag, durationMs) {
+  const meta = ctx && ctx.meta;
+  const attrs = ctx && ctx.attrs;
+  return {
+    v: WEB_DISPLAY_FORMAT_VERSION,
+    kind: 'web',
+    tag,
+    query: (attrs && attrs.query) || undefined,
+    url: (attrs && attrs.url) || undefined,
+    status: meta && typeof meta.status_code === 'number' ? meta.status_code : undefined,
+    bytes: meta && typeof meta.bytes === 'number' ? meta.bytes : undefined,
+    error: ctx && ctx.error ? (ctx.error.message || String(ctx.error)) : undefined,
+    durationMs: Number.isFinite(durationMs) ? durationMs : null,
+  };
+}
+
+// Predicate: a persisted display core is a web-op core (vs a normal descriptor
+// core). Replay readers use this to route web-cores to the legacy fallback so
+// 6c-i is invisible. Tolerant of any non-object input.
+function isWebCore(core) {
+  return !!core && typeof core === 'object' && core.v === WEB_DISPLAY_FORMAT_VERSION && core.kind === 'web';
+}
+
+// Pure: fold the recorded op list into the counts the summary needs.
+function aggregateWebOps(ops) {
+  const state = {
+    searchCount: 0, searchFailed: 0, queries: [],
+    fetchCount: 0, fetchOk: 0, fetchFailed: 0,
+  };
+  for (const op of (ops || [])) {
+    if (!op) continue;
+    const ok = opSucceeded(op);
+    if (op.tag === 'web_search') {
+      state.searchCount += 1;
+      if (!ok) state.searchFailed += 1;
+      if (op.query) state.queries.push(op.query);
+    } else if (op.tag === 'http_get') {
+      state.fetchCount += 1;
+      if (ok) state.fetchOk += 1; else state.fetchFailed += 1;
+    }
+  }
+  return state;
+}
+
+// Pure: the plain-text segments of the summary (no ANSI). Each segment is tagged
+// with a `kind` so the styled renderer can colour failures distinctly. Exposed
+// for tests and reused by the styled renderer. Failures (a blocked source / a
+// failed search) are ALWAYS represented so the compact view never silently drops
+// a source that didn't load.
+function webSummarySegments(state) {
+  const segs = [];
+  if (state.searchCount > 0) {
+    const q = state.queries[0] ? `"${_truncate(state.queries[0], 48)}"` : '';
+    segs.push({ kind: 'lead', text: `search ${q}`.trim() });
+    if (state.searchCount > 1) segs.push({ kind: 'count', text: `${state.searchCount} queries` });
+    if (state.searchFailed > 0) {
+      segs.push({ kind: 'fail', text: `${state.searchFailed} search${state.searchFailed === 1 ? '' : 'es'} failed` });
+    }
+  }
+  if (state.fetchCount > 0) {
+    segs.push({ kind: state.searchCount > 0 ? 'count' : 'lead', text: `${state.fetchOk} ${state.fetchOk === 1 ? 'source' : 'sources'} read` });
+    if (state.fetchFailed > 0) segs.push({ kind: 'fail', text: `${state.fetchFailed} blocked` });
+  }
+  if (segs.length === 0) segs.push({ kind: 'lead', text: 'web' });
+  return segs;
+}
+
+// Plain-text one-liner (no ANSI). The text the tests assert on.
+function webSummaryText(state) {
+  return webSummarySegments(state).map((s) => s.text).join(' · ');
+}
+
+// Styled, chrome-consistent line for the writer's activity region / scrollback.
+// Mirrors formatToolLine's "<glyph> <category> · <segments…>" layout so the
+// summary reads as a peer of the other tool lines, not a foreign widget.
+function formatWebSummaryLine(state, opts) {
+  const { pending = false, durationMs = 0 } = opts || {};
+  // Glyph/label/duration colour resolves through the single theme resolver so
+  // the web summary reads as a peer of the other tool lines (web → cyan 44,
+  // running glyph cyan not gray, duration subtle not muted).
+  const colors = resolveLineColors('web', pending ? 'pending' : 'success');
+  const glyph = pending ? UI_ICONS.pending : UI_ICONS.success;
+  const cat = 'web'.padEnd(5);
+  const sep = ` ${DIM}·${RST} `;
+
+  const out = [`  ${colors.glyph}${glyph}${RST} ${colors.label}${cat}${RST}`];
+  for (const seg of webSummarySegments(state)) {
+    let color = UI_THEME.subtle;
+    if (seg.kind === 'lead') color = colors.op;
+    else if (seg.kind === 'fail') color = UI_THEME.warning;
+    out.push(`${color}${seg.text}${RST}`);
+  }
+  if (pending) out.push(`${colors.dur}${formatDuration(durationMs)}…${RST}`);
+  return out.join(sep);
+}
+
+// Batch renderer / policy seam (used by tests, and documents the runtime split):
+//   debug   → one full per-operation tool line per op (nothing hidden), built
+//             with the SAME formatToolLine the runtime uses.
+//   default → a single collapsed summary line.
+function renderWebActivity(ops, opts) {
+  const { debug = false, formatToolLine } = opts || {};
+  if (debug) {
+    return (ops || []).map((op) => formatToolLine({
+      status: opSucceeded(op) ? 'success' : 'failure',
+      tag: op.tag,
+      arg: op.query || op.url || '',
+      attrs: op.tag === 'web_search' ? { query: op.query } : { url: op.url },
+      durationMs: op.durationMs,
+      meta: op.tag === 'http_get' ? { status_code: op.status, bytes: op.bytes } : null,
+      error: op.error ? { message: String(op.error) } : null,
+    }));
+  }
+  return [formatWebSummaryLine(aggregateWebOps(ops), { pending: false })];
+}
+
+// Stateful runtime collapser. Owns one writer "activity" entry per group of
+// consecutive web ops, updating it in place as ops complete and committing a
+// single final summary line to scrollback on flush(). Tools run sequentially in
+// the agent loop, so at most one group is ever open and there is no concurrency.
+function createWebActivityTracker(deps) {
+  const { writerModule } = deps || {};
+  let groupId = null;
+  let seq = 0;
+  let ended = [];
+  let current = null; // the in-flight op, shown in the pending line before it ends
+
+  function _render(durationMs) {
+    const state = aggregateWebOps(current ? ended.concat([current]) : ended);
+    return formatWebSummaryLine(state, { pending: true, durationMs });
+  }
+
+  function _refresh() {
+    if (groupId === null) return;
+    writerModule.updateActivity(groupId, (elapsedMs) => _render(elapsedMs));
+  }
+
+  return {
+    isWeb: isWebTool,
+    isOpen() { return groupId !== null; },
+
+    start(tag, input) {
+      current = {
+        tag,
+        query: tag === 'web_search' ? input : undefined,
+        url: tag === 'http_get' ? input : undefined,
+      };
+      if (groupId === null) {
+        groupId = `web-${seq++}`;
+        writerModule.startActivity(groupId, (elapsedMs) => _render(elapsedMs));
+      } else {
+        _refresh();
+      }
+    },
+
+    end(tag, result, durationMs, toolCtx) {
+      const meta = toolCtx && toolCtx.meta;
+      const attrs = toolCtx && toolCtx.attrs;
+      ended.push({
+        tag,
+        durationMs,
+        query: (attrs && attrs.query) || (current && current.query),
+        url: (attrs && attrs.url) || (current && current.url),
+        status: meta && typeof meta.status_code === 'number' ? meta.status_code : undefined,
+        bytes: meta && typeof meta.bytes === 'number' ? meta.bytes : undefined,
+        error: toolCtx && toolCtx.error ? (toolCtx.error.message || String(toolCtx.error)) : undefined,
+      });
+      current = null;
+      _refresh();
+    },
+
+    // Commit the collapsed summary for the current group to scrollback and reset.
+    // A no-op when no group is open.
+    flush() {
+      if (groupId === null) return;
+      const id = groupId;
+      const line = formatWebSummaryLine(aggregateWebOps(ended), { pending: false });
+      groupId = null;
+      ended = [];
+      current = null;
+      writerModule.endActivity(id, line);
+    },
+  };
+}
+
+module.exports = {
+  WEB_TOOLS,
+  isWebTool,
+  serializeWebOp,
+  isWebCore,
+  opSucceeded,
+  aggregateWebOps,
+  webSummarySegments,
+  webSummaryText,
+  formatWebSummaryLine,
+  renderWebActivity,
+  createWebActivityTracker,
+};

package/lib/ui/writer.js

@@ -15,8 +15,10 @@
 //   STATUS REGION— 1–N lines at the bottom of the viewport. Redrawn in
 //                  place whenever setLive() is called. Each live line is
 //                  truncated to (cols − 1) so it occupies exactly one
-//                  physical row; combined height is modalLines.length +
-//                  statusLines.length and precise.
+//                  physical row; combined height is the physical-row sum
+//                  (displayRows over each emitted entry) — equal to the entry
+//                  count while every entry stays single-row, wrap-aware once
+//                  Phase 7b emits multi-row detail.
 //
 // Invariant: after any operation resolves, the cursor is at column 0 of the
 // row immediately below the status region. Every operation erases the
@@ -28,12 +30,21 @@
 // synchronous, so each task's compound write is emitted in one burst and
 // can't interleave with another task's writes.
 
-const { stripAnsi, termWidth, truncateVisible } = require('./utils');
+const { stripAnsi, termWidth, truncateVisible, displayRows } = require('./utils');
 const dbg = require('../debug');
 
 let _queue = Promise.resolve();
 let _liveLines = [];
 let _modalLines = [];
+// Deferred-detail band (Output Refactor — Phase 7b). The redrawable pseudo-tail
+// at the TOP of the live region (below committed scrollback, above the activity
+// / modal / status rows) that holds the most-recent output-preview detail until
+// a turn boundary commits it. Emitted RAW — NOT through _fitOneRow — so the lines
+// held at op-end width wrap naturally to multiple physical rows on a narrower
+// terminal; physicalRows counts their real height so the erase math stays
+// correct. The band is installed once (setDetail) and committed once
+// (commitDetail moves it into scrollback atomically) — never redrawn in place.
+let _detailLines = [];
 // Activity region: currently-executing tools with live timers. Sits above
 // modal and status (scrollback | activity | modal | status). Entries keyed
 // by invocation id so concurrent tools each get their own slot.
@@ -67,17 +78,39 @@ let _caret = null;
 
 function _cols() { return process.stdout.columns || 80; }
 
+// Match embedded control chars that would break the one-logical=one-physical
+// invariant: a bare \n forces a second physical row, \r jumps to column 0
+// mid-row, \t and other C0/DEL controls move the cursor unpredictably. ESC
+// (0x1B) is deliberately EXCLUDED so legitimate ANSI/SGR sequences survive —
+// every other byte of an SGR sequence (`[`, digits, `m`) is printable, so
+// stripping the rest of the C0 range can't corrupt color chrome.
+const _CONTROL_CHARS = /[\x00-\x1A\x1C-\x1F\x7F]/g; // eslint-disable-line no-control-regex
+
 // ANSI-aware, display-width-aware truncate to (cols-1) visible columns so
 // each rendered live line occupies exactly one physical terminal row — no
-// wrap, no height mis-count. Wrap-induced row-count drift is the root cause
-// of stale-line residue in scrollback: if a single logical line wraps to
-// two physical rows, _liveHeight (which tracks logical lines) undercounts,
-// and the next _eraseLiveSeq leaves the top wrapped row behind. Using
+// wrap, no height mis-count. This keeps every single-row caller's emitted
+// entry at displayRows == 1, so the physical-row height (Phase 7a) equals the
+// entry count for them and the erase math stays byte-identical. Un-fitted
+// multi-row callers (Phase 7b) are counted by their real physical rows. Using
 // termWidth for column counting (rather than a raw char count that treats
 // wide chars and combining marks as 1) keeps the guarantee honest for
 // non-ASCII chrome.
+//
+// Structural guard (Phase 4 fix-A, Part 2): embedded control chars are
+// replaced with a space BEFORE width truncation, so a single fitted row is
+// guaranteed exactly one physical row regardless of caller discipline. No
+// future live-row source can desync the erase math by passing un-flattened
+// content (e.g. a heredoc command that slipped its newlines through).
 function _fitOneRow(line) {
   if (!line) return '';
+  // Sanitize control chars first — before the fast path, since control chars
+  // are ASCII (≤0x7F) and would otherwise ride through the ASCII fast path
+  // unchanged. truncateVisible treats \n as a width-1 char and copies it
+  // verbatim, so sanitizing here is the only place the invariant is enforced.
+  if (_CONTROL_CHARS.test(line)) {
+    _CONTROL_CHARS.lastIndex = 0; // reset; .test on a /g regex is stateful
+    line = line.replace(_CONTROL_CHARS, ' ');
+  }
   const max = Math.max(0, _cols() - 1);
   // Fast path: pure ASCII (and thus display width == stripped length) and
   // already within budget — skip the parse. The ASCII gate is important
@@ -94,7 +127,20 @@ function _fitOneRow(line) {
   return truncateVisible(line, max);
 }
 
-function _eraseLiveSeq() {
+// The single source of truth for the live-region erase sequence. Returns the
+// cursor-up + carriage-return + clear-to-end-of-screen string that lands the
+// cursor on the first live row (or below it when there is no region). Both the
+// per-frame erase (_eraseLiveSeq) and teardown call this — consolidated in
+// Phase 4 fix-A (Part 3) so the deferred (B) wrap-aware physical-row rewrite
+// changes ONE site instead of two divergent copies.
+//
+// NOTE: _liveHeight is now a PHYSICAL-row total (Phase 7a / fix (B)) — the sum
+// of displayRows() over each emitted live entry at the current cols (see
+// physicalRows + _drawLiveSeq). For today's all-single-row content (each entry
+// fitted to ≤cols-1 by _fitOneRow) that physical sum equals the old logical
+// line count, so this erase math is byte-identical to before; the wrap-aware
+// count only diverges once Phase 7b emits un-truncated multi-row detail.
+function _eraseSeqForHeight() {
   if (_liveHeight <= 0) return '';
   // When the previous frame repositioned the OS cursor up to the caret, the
   // cursor is sitting _caret.rowsFromBottom rows ABOVE "below-live-region".
@@ -106,6 +152,10 @@ function _eraseLiveSeq() {
   return `${up > 0 ? `\x1b[${up}A` : ''}\r\x1b[J`;
 }
 
+function _eraseLiveSeq() {
+  return _eraseSeqForHeight();
+}
+
 // Collect visible activity entries in insertion order. Entries whose grace
 // period hasn't elapsed are hidden and don't contribute to _liveHeight.
 function _visibleActivity() {
@@ -121,24 +171,57 @@ function _visibleActivity() {
   return rows;
 }
 
+// (B) wrap-aware physical-row height primitive. Sums displayRows() — the true
+// physical-row count at `cols` — over each ALREADY-EMITTED live entry, so an
+// entry that wraps to N physical rows contributes N (not 1). It MUST be fed the
+// exact strings written to the terminal: _drawLiveSeq passes the post-_fitOneRow
+// lines, each fitted to ≤cols-1 → displayRows == 1 → the sum equals the entry
+// count, i.e. numerically identical to the old logical `array.length` height for
+// all single-row content today. When Phase 7b emits an un-truncated multi-row
+// detail entry, this counts its real physical rows so _eraseSeqForHeight()
+// cursor-ups by the correct physical total (and recomputes on resize, since the
+// count is taken at the current `cols`). Exported for direct unit coverage.
+function physicalRows(lines, cols) {
+  if (!Array.isArray(lines)) return 0;
+  const c = cols || _cols();
+  let h = 0;
+  for (let i = 0; i < lines.length; i++) h += displayRows(lines[i], c);
+  return h;
+}
+
 function _drawLiveSeq() {
   const activityRows = _visibleActivity();
-  const total = activityRows.length + _modalLines.length + _liveLines.length;
+  const total = _detailLines.length + activityRows.length + _modalLines.length + _liveLines.length;
   if (total === 0) { _liveHeight = 0; return ''; }
+  // Collect each entry exactly as written, so the height is measured on the
+  // same bytes the terminal receives — the (B) correctness rule.
+  const cols = _cols();
+  const emitted = [];
   let out = '';
+  // Deferred-detail band first (Phase 7b): emitted RAW (no _fitOneRow) so a held
+  // op-end-width line wraps to its real physical rows on a narrower terminal;
+  // physicalRows() counts that wrap so _eraseSeqForHeight() cursor-ups by the
+  // correct physical total. Sits at the very top of the live region.
+  for (let i = 0; i < _detailLines.length; i++) {
+    emitted.push(_detailLines[i]);
+    out += _detailLines[i] + '\n';
+  }
   for (let i = 0; i < activityRows.length; i++) {
-    out += _fitOneRow(activityRows[i]);
-    out += '\n';
+    const fitted = _fitOneRow(activityRows[i]);
+    emitted.push(fitted);
+    out += fitted + '\n';
   }
   for (let i = 0; i < _modalLines.length; i++) {
-    out += _fitOneRow(_modalLines[i]);
-    out += '\n';
+    const fitted = _fitOneRow(_modalLines[i]);
+    emitted.push(fitted);
+    out += fitted + '\n';
   }
   for (let i = 0; i < _liveLines.length; i++) {
-    out += _fitOneRow(_liveLines[i]);
-    out += '\n';
+    const fitted = _fitOneRow(_liveLines[i]);
+    emitted.push(fitted);
+    out += fitted + '\n';
   }
-  _liveHeight = total;
+  _liveHeight = physicalRows(emitted, cols);
   return out;
 }
 
@@ -254,11 +337,51 @@ function clearLive() {
       if (entry.graceTimer) { try { clearTimeout(entry.graceTimer); } catch {} }
     }
     _activity.clear();
+    _detailLines = [];
     _liveHeight = 0;
     _caret = null;
   });
 }
 
+// Replace the deferred-detail band (Phase 7b) and redraw in place. The band sits
+// at the TOP of the live region and is emitted RAW (un-fitted, may wrap). Used to
+// install the held output-preview detail without touching scrollback. _caret is
+// left as-is (the band only exists while input is disabled, so the caret is null
+// anyway); this mirrors redrawLive rather than setModal (which suppresses the
+// caret).
+function setDetail(lines) {
+  return _enqueue(() => {
+    // Erase using the previous caret/liveHeight (the band's rows are part of the
+    // current _liveHeight) — see setLive() for why erase precedes the state swap.
+    const eraseSeq = _eraseLiveSeq();
+    _detailLines = Array.isArray(lines) ? lines.map((l) => (l == null ? '' : String(l))) : [];
+    _writeSync(_HIDE + eraseSeq + _drawLiveSeq() + _positionCaretSeq() + _caretShowSeq());
+  });
+}
+
+// Commit the deferred-detail band to scrollback and clear it, in ONE compound
+// write: erase the live region (the band's physical rows are included via the
+// current _liveHeight), append the held lines as immutable scrollback, then
+// redraw the live region with the band gone. Mirrors endActivity's atomic
+// erase+commit+redraw so there is no duplicate-band frame and no stranded rows
+// (the live-row race the discovery flagged). A no-op (plain erase+redraw) when
+// `text` is empty.
+function commitDetail(text) {
+  return _enqueue(() => {
+    let out = _HIDE + _eraseLiveSeq();
+    // Drop the band BEFORE _drawLiveSeq so the redraw omits it; the erase above
+    // already used the pre-clear _liveHeight (band included).
+    _detailLines = [];
+    if (text !== undefined && text !== null && text !== '') {
+      let t = String(text);
+      if (!t.endsWith('\n')) t += '\n';
+      out += t;
+    }
+    out += _drawLiveSeq() + _positionCaretSeq() + _caretShowSeq();
+    _writeSync(out);
+  });
+}
+
 // Replace the modal region with `lines`. Modal sits above status and below
 // scrollback. Used for permission pickers, confirm dialogs, text input
 // prompts, etc. — any widget that must redraw on every keystroke without
@@ -297,9 +420,11 @@ function hasModal() { return _modalLines.length > 0; }
 // the row without a scrollback commit (used by aborts where the final line
 // is already written elsewhere, or for tools that produced no output).
 //
-// refreshActivity() forces a redraw so the lazy `render(elapsedMs)` on
-// each entry picks up a new elapsed time. Called by the status-bar ticker;
-// a no-op when nothing is visible.
+// The lazy `render(elapsedMs)` on each entry picks up a fresh elapsed time on
+// every live-region repaint. Phase 3: those periodic repaints are driven by the
+// single animation driver (lib/ui/anim.js) via the status bar's coordinated
+// _notify → setLive, which re-runs each entry's render here — so the per-tool
+// elapsed meter + running glyph animate without a second timer of their own.
 
 const DEFAULT_ACTIVITY_GRACE_MS = 200;
 
@@ -381,23 +506,6 @@ function cancelActivity(id) {
   });
 }
 
-// Ticker hook: re-emit the live region so each activity entry's
-// `render(elapsedMs)` is re-invoked with a fresh elapsed time. No-op when
-// nothing is visible (avoids burning cycles when idle).
-function refreshActivity() {
-  if (_activity.size === 0) return _queue;
-  let anyVisible = false;
-  for (const entry of _activity.values()) { if (entry.visible) { anyVisible = true; break; } }
-  if (!anyVisible) return _queue;
-  return _enqueue(() => {
-    if (_destroyed) return;
-    let stillAnyVisible = false;
-    for (const entry of _activity.values()) { if (entry.visible) { stillAnyVisible = true; break; } }
-    if (!stillAnyVisible) return;
-    _writeSync(_HIDE + _eraseLiveSeq() + _drawLiveSeq() + _positionCaretSeq() + _caretShowSeq());
-  });
-}
-
 function hasActivity() {
   for (const entry of _activity.values()) { if (entry.visible) return true; }
   return false;
@@ -426,6 +534,7 @@ function enqueue(fn) {
 
 function getLiveHeight() { return _liveHeight; }
 function getLiveLines()  { return _liveLines.slice(); }
+function getDetailLines() { return _detailLines.slice(); }
 
 function destroy() { _destroyed = true; }
 
@@ -504,15 +613,16 @@ function teardown(opts) {
 
   // Erase the live region. The cursor may be sitting inside the region —
   // _caret.rowsFromBottom rows above the "below-live-region" baseline —
-  // because the last setLive positioned it at the input caret. Subtract
-  // that offset so cursor-up lands on the FIRST live row, not above the
-  // live region (which would erase scrollback). After \x1b[J the cursor
-  // sits at column 0 of the row immediately after the last scrollback
-  // line — exactly where new scrollback content should begin.
+  // because the last setLive positioned it at the input caret. The shared
+  // _eraseSeqForHeight() helper subtracts that offset so cursor-up lands on
+  // the FIRST live row, not above the live region (which would erase
+  // scrollback). After \x1b[J the cursor sits at column 0 of the row
+  // immediately after the last scrollback line — exactly where new
+  // scrollback content should begin. (Consolidated with _eraseLiveSeq in
+  // Phase 4 fix-A Part 3 so Phase 7a's (B) physical-row rewrite touched one
+  // site — _liveHeight is now that physical-row total.)
   if (_liveHeight > 0) {
-    const offset = _caret ? _caret.rowsFromBottom : 0;
-    const up = Math.max(0, _liveHeight - offset);
-    parts.push(up > 0 ? `\x1b[${up}A\r\x1b[J` : '\r\x1b[J');
+    parts.push(_eraseSeqForHeight());
   } else {
     // No live region active: ensure cursor is at column 0 so artifacts
     // (and any eventual shell prompt) don't print mid-line if some
@@ -564,6 +674,7 @@ function teardown(opts) {
     if (entry.graceTimer) { try { clearTimeout(entry.graceTimer); } catch {} }
   }
   _activity.clear();
+  _detailLines = [];
   _liveHeight = 0;
 
   try { process.stdout.write(parts.join('')); } catch {}
@@ -582,6 +693,8 @@ module.exports = {
   scrollback,
   setLive,
   clearLive,
+  setDetail,
+  commitDetail,
   setModal,
   clearModal,
   hasModal,
@@ -589,13 +702,14 @@ module.exports = {
   updateActivity,
   endActivity,
   cancelActivity,
-  refreshActivity,
   hasActivity,
   redrawLive,
   flush,
   enqueue,
   getLiveHeight,
   getLiveLines,
+  getDetailLines,
+  physicalRows,
   destroy,
   teardown,
 };

package/lib/ui.js

@@ -27,7 +27,7 @@ module.exports = {
   isPrintableKey: utils.isPrintableKey, approxTokens: utils.approxTokens,
 
   // Diff + Markdown
-  renderDiff: diff.renderDiff, renderMarkdown: diff.renderMarkdown,
+  renderDiff: diff.renderDiff, buildExecutionDiff: diff.buildExecutionDiff, renderMarkdown: diff.renderMarkdown,
 
   // Stream renderer
   StreamRenderer: stream.StreamRenderer,