mixdog 0.9.0 → 0.9.2

package/src/tui/components/tool-output-format.mjs

@@ -18,9 +18,11 @@
  */
 import stringWidth from 'string-width';
 import stripAnsi from 'strip-ansi';
+import { displayWidth } from '../display-width.mjs';
 import {
   extraColorizers,
   highlightCodeLine,
+  highlightCodeBlockToLines,
   colorizeDiffLine,
   looksLikeUnifiedDiff,
   LANG_FAMILY,
@@ -35,13 +37,72 @@ const DEFAULT_MARKDOWN_WIDTH = 80;
 // Hard ceilings so a pathological tool result can never lock the render loop.
 // CC uses ~MAX_LINES*width*4 for the collapsed fold; for the EXPANDED body we
 // cap total characters processed and total lines kept, with an explicit marker.
-const MAX_EXPANDED_CHARS = 256 * 1024; // 256 KB of text gets per-line processing
-const MAX_EXPANDED_LINES = 80; // keep at most this many rendered lines
+export const MAX_EXPANDED_CHARS = 256 * 1024; // 256 KB of text gets per-line processing
+const MAX_EXPANDED_LINES = 4000; // logical-line safety ceiling; physical mount cap is separate
 const MAX_JSON_FORMAT_LENGTH = 10_000; // mirror CC's tryJsonFormatContent cap
 const MAX_HIGHLIGHT_LINE_CHARS = 2000; // skip token-scan on absurdly long lines
 // Lockstep with ToolExecution collapsed fit budget (MIN_RESULT_LINE_CHARS).
 const MIN_EXPANDED_BODY_COLS = 24;
 
+// Hard cap on the number of PHYSICAL (wrapped) rows a single expanded tool /
+// script body may mount. MAX_EXPANDED_LINES bounds LOGICAL lines, but a single
+// very long line with no newlines (minified JSON, a 256 KB single-line blob)
+// wraps into thousands of physical rows — and EACH physical row is a mounted
+// Ink <Text> node that ink re-serializes every frame even while clipped off-
+// screen (clipping only trims write coords, not the serialize pass). So a lone
+// huge expanded item could mount thousands of nodes and stall typing/drag even
+// though it is the only visible transcript item. This cap bounds the mounted
+// node count regardless of line shape; the omitted tail gets a clear marker.
+// It is set generously above what any viewport needs so normal multi-line
+// output (already capped at MAX_EXPANDED_LINES logical lines) is byte-for-byte
+// unchanged — only pathological wide/unwrapped blobs are trimmed. Env-tunable
+// via MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES (0 disables); legacy
+// MIXDOG_TUI_EXPANDED_MAX_ROWS is still honored when the primary var is unset.
+export function resolveToolOutputMaxRenderLines() {
+  const raw = process.env.MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES;
+  if (raw !== undefined && String(raw).trim() !== '') {
+    const v = Number(raw);
+    if (Number.isFinite(v) && v <= 0) return 0;
+    if (Number.isFinite(v) && v > 0) return Math.floor(v);
+  }
+  const legacy = process.env.MIXDOG_TUI_EXPANDED_MAX_ROWS;
+  if (legacy !== undefined && String(legacy).trim() !== '') {
+    const v = Number(legacy);
+    if (Number.isFinite(v) && v > 0) return Math.floor(v);
+  }
+  return 600;
+}
+
+function omittedPhysicalRowsMarker(omitted, isShell) {
+  if (isShell) {
+    const n = Math.max(1, Math.floor(Number(omitted) || 0));
+    return `\u2026 [${n} line${n === 1 ? '' : 's'} omitted above \u2014 showing newest output below]`;
+  }
+  return '\u2026 [output truncated for display \u2014 collapse (ctrl+o) or re-read a narrower range]';
+}
+
+function shellLogicalOmittedMarker({ omittedLines = 0, omittedChars = false }, c) {
+  if (omittedLines > 0) {
+    return c.synComment(omittedPhysicalRowsMarker(omittedLines, true));
+  }
+  if (omittedChars) {
+    return c.synComment('\u2026 [earlier output omitted above \u2014 showing newest output below]');
+  }
+  return null;
+}
+
+function finalizeShellPhysicalCap(buffer, omitted, maxRows) {
+  const bodySlots = Math.max(0, maxRows - 1);
+  if (omitted <= 0) {
+    return buffer.length > 0 ? buffer : [' '];
+  }
+  const tail = bodySlots > 0 ? buffer.slice(-bodySlots) : [];
+  const extraHidden = Math.max(0, buffer.length - bodySlots);
+  const totalOmitted = omitted + extraHidden;
+  const out = [omittedPhysicalRowsMarker(totalOmitted, true), ...tail];
+  return out.length > 0 ? out.slice(0, maxRows) : [' '];
+}
+
 // `<n>→<content>` (read) OR `<n>:<content>` / `<path>:<n>:<content>` (grep).
 const READ_LINE_RE = /^(\s*)(\d+)(\u2192)(.*)$/;
 // Gutter ends with `:<line>:`. Windows absolute paths use `X:\...` so the drive
@@ -54,6 +115,77 @@ const URL_RE = /https?:\/\/[^\s"'<>\x1b\\)\]]+/g;
 // eslint-disable-next-line no-control-regex
 const ANSI_ESCAPE_RE = /\x1b(?:\[[0-9;]*m|\][\s\S]*?(?:\x07|\x1b\\))/g;
 
+// Visible-text tab stop for expanded tool output (cosmetic; what matters is that
+// no raw \t survives the width math).
+const TOOL_OUTPUT_TAB_SIZE = 2;
+// Match ONE CSI-SGR or OSC sequence anchored at the string start (for the
+// ANSI-aware control normalizer below). Kept separate from the global
+// ANSI_ESCAPE_RE so neither one's lastIndex perturbs the other.
+// eslint-disable-next-line no-control-regex
+const ANSI_SEQ_AT_START_RE = /^\x1b(?:\[[0-9;]*m|\][\s\S]*?(?:\x07|\x1b\\))/;
+
+/**
+ * ANSI-aware control normalization for expanded tool output.
+ *
+ * Why: string-width counts a raw \t (and other C0 controls) as ZERO cells, so
+ * `wrapExpandedResultLines` under-wraps a tab-bearing line; the row then renders
+ * past the truncate width and the terminal EXPANDS the surviving tab to a tab
+ * stop, bleeding the line THROUGH the bottom prompt box on scroll. We must
+ * expand tabs / strip stray controls in the VISIBLE text — but tool output can
+ * also carry legitimate color (SGR) and OSC-8 hyperlink escapes, so those
+ * sequences are copied through verbatim (zero visible columns) instead of being
+ * mangled. CRLF/lone CR → LF; other C0 + DEL (except LF) → a single space.
+ */
+function normalizeToolOutputControls(text) {
+  const input = String(text ?? '');
+  if (input.length === 0) return input;
+  let out = '';
+  let col = 0;
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === '\x1b') {
+      // Copy a recognized SGR/OSC escape verbatim (no visible width); only a
+      // lone/unknown ESC falls through to the control-strip branch below.
+      const m = ANSI_SEQ_AT_START_RE.exec(input.slice(i));
+      if (m) {
+        out += m[0];
+        i += m[0].length;
+        continue;
+      }
+    }
+    if (ch === '\n') { out += '\n'; col = 0; i += 1; continue; }
+    if (ch === '\r') {
+      // CR or CRLF → a single LF.
+      out += '\n'; col = 0; i += 1;
+      if (input[i] === '\n') i += 1;
+      continue;
+    }
+    if (ch === '\t') {
+      const advance = TOOL_OUTPUT_TAB_SIZE - (col % TOOL_OUTPUT_TAB_SIZE);
+      out += ' '.repeat(advance);
+      col += advance;
+      i += 1;
+      continue;
+    }
+    const cp = input.codePointAt(i);
+    const step = cp > 0xffff ? 2 : 1;
+    if (cp <= 0x1f || cp === 0x7f) {
+      // Remaining C0 control / DEL (and lone ESC): a space so it cannot move the
+      // terminal cursor after ink has already accounted for the row.
+      out += ' ';
+      col += 1;
+      i += step;
+      continue;
+    }
+    const chr = String.fromCodePoint(cp);
+    out += chr;
+    col += stringWidth(chr);
+    i += step;
+  }
+  return out;
+}
+
 
 /** Infer a highlighter family from a read/grep path arg's extension. */
 export function inferLangFamily(pathArg) {
@@ -198,20 +330,31 @@ export function formatExpandedResult(text, { pathArg = '', isShell = false } = {
 
   // Oversized guard: slice before any O(n) per-line work, append a marker.
   let truncatedChars = false;
+  let shellOmittedLines = 0;
+  let shellOmittedChars = false;
   if (src.length > MAX_EXPANDED_CHARS) {
-    src = src.slice(0, MAX_EXPANDED_CHARS);
-    truncatedChars = true;
+    src = isShell ? src.slice(-MAX_EXPANDED_CHARS) : src.slice(0, MAX_EXPANDED_CHARS);
+    if (isShell) shellOmittedChars = true;
+    else truncatedChars = true;
   }
 
   const carriesAnsi = hasAnsi(src);
+  // Expand tabs / strip stray controls so a tab-bearing line cannot bleed
+  // through the bottom prompt box on scroll (string-width measures \t as zero
+  // cells; the terminal expands it after ink's row accounting). ANSI-aware:
+  // SGR/OSC escapes are preserved verbatim, so this runs unconditionally —
+  // colored shell output and OSC-8 links keep their escapes while their VISIBLE
+  // text is normalized.
+  src = normalizeToolOutputControls(src);
   // JSON pretty only when the text is not already colored (don't reflow ANSI).
   if (!carriesAnsi) src = tryFormatJson(src);
 
   let lines = src.split('\n');
   let truncatedLines = false;
   if (lines.length > MAX_EXPANDED_LINES) {
-    lines = lines.slice(0, MAX_EXPANDED_LINES);
-    truncatedLines = true;
+    if (isShell) shellOmittedLines = lines.length - MAX_EXPANDED_LINES;
+    lines = isShell ? lines.slice(-MAX_EXPANDED_LINES) : lines.slice(0, MAX_EXPANDED_LINES);
+    if (!isShell) truncatedLines = true;
   }
 
   const c = extraColorizers();
@@ -223,29 +366,31 @@ export function formatExpandedResult(text, { pathArg = '', isShell = false } = {
   if (shouldRenderExpandedMarkdown({ src, lines, carriesAnsi, isShell, diffMode, family })) {
     out = formatExpandedMarkdownLines(src);
     if (out.length > MAX_EXPANDED_LINES) {
-      out = out.slice(0, MAX_EXPANDED_LINES);
-      truncatedLines = true;
+      if (isShell) shellOmittedLines += out.length - MAX_EXPANDED_LINES;
+      out = isShell ? out.slice(-MAX_EXPANDED_LINES) : out.slice(0, MAX_EXPANDED_LINES);
+      if (!isShell) truncatedLines = true;
     }
   } else {
-    out = lines.map((line) => formatLine(line, { c, family, diffMode, carriesAnsi, isShell }));
+    if (family && family !== 'md' && !diffMode && !carriesAnsi && !isShell) {
+      out = formatSyntaxBlock(lines, { c, family });
+    } else {
+      out = lines.map((line) => formatLine(line, { c, family, diffMode, carriesAnsi, isShell }));
+    }
   }
 
+  if (isShell) {
+    const marker = shellLogicalOmittedMarker({ omittedLines: shellOmittedLines, omittedChars: shellOmittedChars }, c);
+    if (marker) return [marker, ...out];
+    return out;
+  }
   if (truncatedChars || truncatedLines) {
     out.push(c.synComment('… [output truncated for display — re-read a narrower range]'));
   }
   return out;
 }
 
-/** Format ONE line: split line-number gutter, then highlight/linkify the body. */
-function formatLine(line, { c, family, diffMode, carriesAnsi, isShell }) {
-  // Shell / already-colored output: keep ANSI verbatim, only fix underline leaks
-  // and linkify URLs. No gutter split (shell has no <n>→ prefix).
-  if (carriesAnsi || isShell) {
-    return linkifyUrls(stripUnderlineAnsi(line));
-  }
-
-  // Split a read (`<n>→`) or grep (`<file>:<n>:` / `<n>:`) gutter into a dim
-  // column so the body can be highlighted independently.
+/** Split read/grep line-number gutter from body (shared by per-line and block highlight). */
+function splitGutter(line) {
   let indent = '';
   let gutter = '';
   let body = line;
@@ -262,6 +407,35 @@ function formatLine(line, { c, family, diffMode, carriesAnsi, isShell }) {
       body = gm[4];
     }
   }
+  return { indent, gutter, body };
+}
+
+/** Block syntax highlight for non-diff code bodies (multi-line tokens color correctly). */
+function formatSyntaxBlock(lines, { c, family }) {
+  const parts = lines.map(splitGutter);
+  const bodies = parts.map((p) =>
+    p.body.length > MAX_HIGHLIGHT_LINE_CHARS ? '' : p.body,
+  );
+  const highlighted = highlightCodeBlockToLines(bodies.join('\n'), family, c);
+  return parts.map((p, i) => {
+    const rawBody = p.body;
+    const bodyOut = rawBody.length > MAX_HIGHLIGHT_LINE_CHARS
+      ? c.body(rawBody)
+      : (highlighted[i] ?? '');
+    const linked = linkifyUrls(bodyOut);
+    return p.gutter ? `${p.indent}${c.synComment(p.gutter)}${linked}` : linked;
+  });
+}
+
+/** Format ONE line: split line-number gutter, then highlight/linkify the body. */
+function formatLine(line, { c, family, diffMode, carriesAnsi, isShell }) {
+  // Shell / already-colored output: keep ANSI verbatim, only fix underline leaks
+  // and linkify URLs. No gutter split (shell has no <n>→ prefix).
+  if (carriesAnsi || isShell) {
+    return linkifyUrls(stripUnderlineAnsi(line));
+  }
+
+  const { indent, gutter, body } = splitGutter(line);
 
   const coloredBody = highlightBody(body, { c, family, diffMode });
   const linked = linkifyUrls(coloredBody);
@@ -300,21 +474,17 @@ function splitAnsiByPlainWidth(text, plainTarget) {
   while (i < src.length) {
     if (plain >= target) break;
     if (src[i] === '\x1b') {
-      const rest = src.slice(i);
-      const sgr = rest.match(/^\x1b\[[0-9;]*m/);
-      if (sgr) {
-        i += sgr[0].length;
-        continue;
-      }
-      const osc = rest.match(/^\x1b\]8;;[^\x07]*\x07/);
-      if (osc) {
-        i += osc[0].length;
+      // Recognize SGR + OSC-8 (BEL- OR ST-terminated) via the shared matcher so
+      // the split never lands inside an escape sequence for either terminator.
+      const m = ANSI_SEQ_AT_START_RE.exec(src.slice(i));
+      if (m) {
+        i += m[0].length;
         continue;
       }
     }
     const cp = src.codePointAt(i);
     const ch = String.fromCodePoint(cp);
-    plain += stringWidth(ch);
+    plain += displayWidth(ch);
     i += cp > 0xffff ? 2 : 1;
   }
   return [src.slice(0, i), src.slice(i)];
@@ -322,30 +492,88 @@ function splitAnsiByPlainWidth(text, plainTarget) {
 
 function leadingPrefixPlainWidth(plainLine) {
   const rm = READ_LINE_RE.exec(plainLine);
-  if (rm) return stringWidth(rm[1] + rm[2] + rm[3]);
+  if (rm) return displayWidth(rm[1] + rm[2] + rm[3]);
   const gm = GREP_LINE_RE.exec(plainLine);
-  if (gm) return stringWidth(gm[1] + gm[2] + gm[3]);
+  if (gm) return displayWidth(gm[1] + gm[2] + gm[3]);
   return 0;
 }
 
+/**
+ * Hard-cut an ANSI string so its VISIBLE (displayWidth) width is <= maxWidth.
+ * ANSI/OSC-8 escapes are preserved verbatim (zero visible width) and never cut
+ * mid-sequence. This is the final safety clamp: `wrapText` measures with
+ * string-width, so an arrow-bearing row it accepts as fitting can still render
+ * 1+ cells wider under the wide policy — this guarantees no emitted row can
+ * exceed maxWidth in real terminal cells and trigger terminal autowrap.
+ *
+ * Single forward pass: accumulate visible code points until the next one would
+ * overflow `max`, then drop the remaining VISIBLE glyphs while still copying
+ * every trailing escape (SGR resets, OSC-8 closers) verbatim — so a clamped
+ * colored/hyperlinked row can never leak an unbalanced/open sequence into later
+ * TUI cells. Escapes are zero-width, so keeping all of them can never push the
+ * result past `max`; the pass always terminates (i advances every iteration).
+ */
+function clampRowToDisplayWidth(row, maxWidth) {
+  const src = String(row ?? '');
+  const max = Math.max(0, Math.floor(Number(maxWidth) || 0));
+  if (max <= 0) return src;
+  if (displayWidth(src) <= max) return src;
+  let out = '';
+  let plain = 0;
+  let overflowed = false;
+  let i = 0;
+  while (i < src.length) {
+    if (src[i] === '\x1b') {
+      // Copy any recognized escape (SGR / OSC-8 BEL or ST) verbatim — including
+      // trailing resets/closers AFTER the visible cut point.
+      const m = ANSI_SEQ_AT_START_RE.exec(src.slice(i));
+      if (m) {
+        out += m[0];
+        i += m[0].length;
+        continue;
+      }
+    }
+    const cp = src.codePointAt(i);
+    const step = cp > 0xffff ? 2 : 1;
+    if (!overflowed) {
+      const ch = String.fromCodePoint(cp);
+      const w = displayWidth(ch);
+      if (plain + w > max) {
+        // This glyph would overflow: stop emitting visible text but keep
+        // scanning so trailing escapes are still preserved.
+        overflowed = true;
+      } else {
+        out += ch;
+        plain += w;
+      }
+    }
+    i += step;
+  }
+  return out;
+}
+
 function wrapOneExpandedLogicalLine(line, maxWidth) {
   const src = String(line ?? '');
   if (!src) return [' '];
-  if (stringWidth(src) <= maxWidth) return [src];
+  if (displayWidth(src) <= maxWidth) return [src];
 
   const prefixPlainW = leadingPrefixPlainWidth(stripAnsi(src));
   const [prefix, body] = prefixPlainW > 0
     ? splitAnsiByPlainWidth(src, prefixPlainW)
     : ['', src];
-  const prefixW = stringWidth(prefix);
+  const prefixW = displayWidth(prefix);
   const bodyBudget = Math.max(1, maxWidth - prefixW);
   const bodyPieces = wrapText(body, bodyBudget, { hard: true });
-  if (bodyPieces.length <= 1) return [src];
+  // wrapText measures with string-width, so even the single-piece fast path can
+  // exceed maxWidth under the wide policy — always run the display-width clamp.
+  if (bodyPieces.length <= 1) return [clampRowToDisplayWidth(src, maxWidth)];
 
   const out = [];
   for (let i = 0; i < bodyPieces.length; i++) {
-    if (i === 0) out.push(`${prefix}${bodyPieces[i]}`);
-    else out.push(`${padDisplaySpaces(prefixW)}${bodyPieces[i]}`);
+    const row = i === 0
+      ? `${prefix}${bodyPieces[i]}`
+      : `${padDisplaySpaces(prefixW)}${bodyPieces[i]}`;
+    out.push(clampRowToDisplayWidth(row, maxWidth));
   }
   return out;
 }
@@ -354,12 +582,56 @@ function wrapOneExpandedLogicalLine(line, maxWidth) {
  * Turn logical expanded lines into physical rows that fit the body column.
  * One output row per left-rail row in ToolExecution (lockstep with App row est.).
  */
-export function wrapExpandedResultLines(logicalLines, columns = 80) {
+export function wrapExpandedResultLines(logicalLines, columns = 80, { isShell = false } = {}) {
+  const maxRows = resolveToolOutputMaxRenderLines();
+  const capOn = maxRows > 0;
   const maxWidth = expandedResultBodyWidth(columns);
   const lines = Array.isArray(logicalLines) ? logicalLines : [];
   const out = [];
-  for (const line of lines) {
-    out.push(...wrapOneExpandedLogicalLine(line, maxWidth));
+
+  // Safety net: EVERY emitted row (including omitted/oversize markers that
+  // bypass wrapOneExpandedLogicalLine) must satisfy the display-width clamp so
+  // no physical row can exceed maxWidth and trigger terminal autowrap.
+  const clampAll = (rows) => rows.map((row) => clampRowToDisplayWidth(row, maxWidth));
+
+  if (!capOn) {
+    for (const line of lines) {
+      for (const row of wrapOneExpandedLogicalLine(line, maxWidth)) out.push(row);
+    }
+    return out.length > 0 ? clampAll(out) : [' '];
+  }
+
+  if (isShell) {
+    let omitted = 0;
+    for (const line of lines) {
+      for (const row of wrapOneExpandedLogicalLine(line, maxWidth)) {
+        out.push(row);
+        if (out.length > maxRows) {
+          out.shift();
+          omitted += 1;
+        }
+      }
+    }
+    return clampAll(finalizeShellPhysicalCap(out, omitted, maxRows));
+  }
+
+  // Non-shell surfaces keep the head of the expanded body (read/grep/json).
+  let truncated = false;
+  outer: for (const line of lines) {
+    for (const row of wrapOneExpandedLogicalLine(line, maxWidth)) {
+      if (out.length < maxRows) {
+        out.push(row);
+      } else {
+        truncated = true;
+        break outer;
+      }
+    }
+  }
+  if (truncated) {
+    const bodySlots = Math.max(0, maxRows - 1);
+    if (out.length > bodySlots) out.length = bodySlots;
+    if (maxRows > 0) out.push(omittedPhysicalRowsMarker(1, false));
+    return out.length > 0 ? clampAll(out.slice(0, maxRows)) : [' '];
   }
-  return out.length > 0 ? out : [' '];
+  return out.length > 0 ? clampAll(out) : [' '];
 }

package/src/tui/components/tool-output-format.test.mjs

@@ -10,9 +10,25 @@ import {
   tryFormatJson,
 } from './tool-output-format.mjs';
 import stringWidth from 'string-width';
+import { displayWidthWith } from '../display-width.mjs';
 
 const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '').replace(/\x1b\]8;;[^\x07]*\x07/g, '');
 
+function withRenderLineCap(cap, fn) {
+  const prev = process.env.MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES;
+  const legacy = process.env.MIXDOG_TUI_EXPANDED_MAX_ROWS;
+  process.env.MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES = String(cap);
+  delete process.env.MIXDOG_TUI_EXPANDED_MAX_ROWS;
+  try {
+    return fn();
+  } finally {
+    if (prev === undefined) delete process.env.MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES;
+    else process.env.MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES = prev;
+    if (legacy === undefined) delete process.env.MIXDOG_TUI_EXPANDED_MAX_ROWS;
+    else process.env.MIXDOG_TUI_EXPANDED_MAX_ROWS = legacy;
+  }
+}
+
 test('inferLangFamily maps known extensions, null otherwise', () => {
   assert.equal(inferLangFamily('src/x.mjs'), 'js');
   assert.equal(inferLangFamily('a.py'), 'py');
@@ -31,6 +47,57 @@ test('read line-number gutter is split into a dim column and body is highlighted
   assert.ok(out[0].includes('\x1b['), 'first line carries color escapes');
 });
 
+test('non-ANSI tool output expands tabs so width math matches the terminal', () => {
+  // A raw \t is ZERO-width to string-width, so wrapExpandedResultLines would
+  // under-wrap a tab-bearing line and the terminal-expanded tab would bleed
+  // the row through the bottom prompt box on scroll. formatExpandedResult must
+  // normalize tabs to spaces for non-ANSI output.
+  const out = formatExpandedResult('\tindented line', { pathArg: 'a.txt' });
+  const plain = stripAnsi(out.join('\n'));
+  assert.ok(!plain.includes('\t'), 'no raw tab survives non-ANSI tool output');
+  const body = plain.split('\n').find((l) => l.includes('indented line'));
+  assert.ok(body, 'body line present');
+  assert.equal(stringWidth(body), body.length, 'visible width equals char length');
+});
+
+test('shell ANSI output keeps raw control bytes (not normalized)', () => {
+  // ANSI/shell output legitimately carries control bytes in escape sequences;
+  // normalization must be skipped so those survive verbatim.
+  const sh = '\x1b[31mred\x1b[0m';
+  const out = formatExpandedResult(sh, { isShell: true });
+  assert.ok(out.join('').includes('\x1b['), 'escape sequences preserved');
+});
+
+test('colored shell output still expands visible tabs (ANSI-aware normalize)', () => {
+  // A colored line with a raw \t in its VISIBLE text: the SGR escapes must be
+  // preserved verbatim while the tab is expanded, so the visible width matches
+  // the terminal and the row cannot bleed through the prompt box on scroll.
+  const sh = '\x1b[32m\tgreen tabbed\x1b[0m';
+  const out = formatExpandedResult(sh, { isShell: true });
+  const joined = out.join('\n');
+  assert.ok(joined.includes('\x1b['), 'color escapes preserved');
+  assert.ok(!joined.includes('\t'), 'visible tab expanded even in colored output');
+  const body = stripAnsi(joined).split('\n').find((l) => l.includes('green tabbed'));
+  assert.ok(body, 'body line present');
+  assert.equal(stringWidth(body), body.length, 'visible width equals char length');
+});
+
+test('block syntax highlight skips tokenizer for over-long lines (index aligned)', () => {
+  // MAX_HIGHLIGHT_LINE_CHARS is 2000 in tool-output-format.mjs
+  const giant = 'x'.repeat(2001);
+  const read = `1\u2192const a = 1;\n2\u2192${giant}\n3\u2192const b = 2;`;
+  const out = formatExpandedResult(read, { pathArg: 'a.mjs' });
+  assert.equal(out.length, 3);
+  assert.ok(out[0].includes('\x1b['), 'short line before giant is highlighted');
+  assert.ok(out[2].includes('\x1b['), 'short line after giant is highlighted');
+  const plainMid = stripAnsi(out[1]);
+  assert.ok(plainMid.startsWith('2\u2192'), 'gutter preserved on giant line');
+  assert.ok(plainMid.endsWith(giant), 'giant body preserved');
+  const hljsSpans = (out[1].match(/\x1b\[[0-9;]*m/g) || []).length;
+  const shortSpans = (out[0].match(/\x1b\[[0-9;]*m/g) || []).length;
+  assert.ok(hljsSpans <= shortSpans + 2, 'giant line not fully tokenized like normal code');
+});
+
 test('grep file:line: gutter is split too', () => {
   const grep = 'src/a.mjs:5581:  value: foo,';
   const out = formatExpandedResult(grep, { pathArg: 'src/a.mjs' });
@@ -105,9 +172,13 @@ test('unified diff is colored by line class', () => {
 test('oversize output is capped with a truncation marker', () => {
   const many = Array.from({ length: 5000 }, (_, i) => `line${i}`).join('\n');
   const out = formatExpandedResult(many, {});
-  assert.ok(out.length <= 81);
+  assert.ok(out.length <= 4001, 'logical cap keeps at most MAX_EXPANDED_LINES plus marker');
   assert.ok(/truncated/.test(stripAnsi(out[out.length - 1])));
 
+  const sixHundred = Array.from({ length: 600 }, (_, i) => `row${i}`).join('\n');
+  const out600 = formatExpandedResult(sixHundred, {});
+  assert.equal(out600.length, 600, 'normal expanded output is not truncated at 80 logical lines');
+
   const huge = 'x'.repeat(300 * 1024);
   const out2 = formatExpandedResult(huge, {});
   assert.ok(/truncated/.test(stripAnsi(out2[out2.length - 1])));
@@ -218,3 +289,111 @@ test('read gutter lines skip markdown mode and keep syntax highlight', () => {
   assert.ok(visible.some((l) => l.includes('const y = 2;')), 'read body preserved');
   assert.ok(out.some((l) => stripAnsi(l).includes('const y = 2;') && l.includes('\x1b[')), 'code line still highlighted');
 });
+
+test('shell physical cap keeps newest rows across logical lines', () => {
+  withRenderLineCap(5, () => {
+    const long = 'W'.repeat(240);
+    const logical = formatExpandedResult(`${long}\nNEWEST_TAIL_LINE`, { isShell: true });
+    const physical = wrapExpandedResultLines(logical, 32, { isShell: true });
+    const visible = physical.map(stripAnsi);
+    assert.ok(visible.some((l) => l.includes('NEWEST_TAIL_LINE')), 'newest logical line survives rolling cap');
+    assert.ok(physical.length <= 5);
+    assert.ok(visible.some((l) => /omitted above/i.test(l)));
+  });
+});
+
+test('exact physical cap row count is not truncated', () => {
+  withRenderLineCap(10, () => {
+    const logical = Array.from({ length: 10 }, (_, i) => `row-${i}`).map((l) => formatExpandedResult(l, { isShell: true })[0]);
+    const physical = wrapExpandedResultLines(logical, 80, { isShell: true });
+    assert.equal(physical.length, 10);
+    assert.ok(!physical.some((l) => /omitted above/i.test(stripAnsi(l))));
+  });
+});
+
+test('physical cap of 1 never returns more than one row', () => {
+  withRenderLineCap(1, () => {
+    const physical = wrapExpandedResultLines(formatExpandedResult('a\nb\nc', { isShell: true }), 80, { isShell: true });
+    assert.ok(physical.length <= 1);
+    const physicalNonShell = wrapExpandedResultLines(formatExpandedResult('a\nb\nc', {}), 80, { isShell: false });
+    assert.ok(physicalNonShell.length <= 1);
+  });
+});
+
+test('shell physical cap omitted count includes marker slot', () => {
+  withRenderLineCap(5, () => {
+    const logical = ['r0', 'r1', 'r2', 'r3', 'r4', 'r5'].map((l) => formatExpandedResult(l, { isShell: true })[0]);
+    const physical = wrapExpandedResultLines(logical, 80, { isShell: true });
+    const visible = physical.map(stripAnsi);
+    assert.equal(physical.length, 5);
+    assert.match(visible[0], /2 lines omitted above/);
+    assert.deepEqual(visible.slice(1), ['r2', 'r3', 'r4', 'r5']);
+  });
+  withRenderLineCap(1, () => {
+    const logical = Array.from({ length: 6 }, (_, i) => `row${i}`).map((l) => formatExpandedResult(l, { isShell: true })[0]);
+    const physical = wrapExpandedResultLines(logical, 80, { isShell: true });
+    assert.equal(physical.length, 1);
+    assert.match(stripAnsi(physical[0]), /6 lines omitted above/);
+  });
+});
+
+test('shell logical truncation marker precedes retained tail', () => {
+  const many = Array.from({ length: 5000 }, (_, i) => `line${i}`).join('\n');
+  const out = formatExpandedResult(many, { isShell: true });
+  const visible = out.map(stripAnsi);
+  assert.ok(visible.length <= 4001);
+  assert.ok(/omitted above/i.test(visible[0]), 'shell marker is first row');
+  assert.ok(visible[visible.length - 1].includes('line4999'), 'newest logical line is last');
+  assert.ok(!visible[visible.length - 1].includes('re-read a narrower range'));
+});
+
+test('wide policy OFF: displayWidth is byte-for-byte identical to string-width for arrow lines', () => {
+  // Guards the "non-WT terminals unchanged" invariant: with the policy OFF
+  // (default in this test process — no WT_SESSION, no override), the arrow is
+  // still 1 cell, so wrap output must be identical to the string-width world.
+  const arrowLine = '  12\u2192const x = 1; \u2190 done';
+  assert.equal(displayWidthWith(arrowLine, false), stringWidth(arrowLine),
+    'policy OFF must equal plain string-width');
+  const logical = formatExpandedResult(arrowLine, { pathArg: 'a.mjs' });
+  const physical = wrapExpandedResultLines(logical, 40);
+  const maxW = expandedResultBodyWidth(40);
+  for (const row of physical) {
+    assert.ok(stringWidth(stripAnsi(row)) <= maxW,
+      `row width ${stringWidth(stripAnsi(row))} exceeds ${maxW} (policy OFF)`);
+  }
+});
+
+test('wide policy ON (forced): every emitted arrow row fits the display-width budget', async () => {
+  // The policy is resolved ONCE at module load, so forcing it requires a fresh
+  // process. Spawn a child with MIXDOG_TUI_AMBIGUOUS_WIDE=1 and assert that
+  // every wrapped read row (containing U+2192) measures <= expandedResultBodyWidth
+  // under the SAME wide policy the terminal will use. Without the clamp,
+  // string-width accepts arrow rows as fitting while the terminal renders them
+  // one cell wider, bleeding into the prompt box.
+  const { execFileSync } = await import('node:child_process');
+  const { fileURLToPath } = await import('node:url');
+  const modUrl = new URL('./tool-output-format.mjs', import.meta.url).href;
+  const dwUrl = new URL('../display-width.mjs', import.meta.url).href;
+  const script = `
+    import { formatExpandedResult, wrapExpandedResultLines, expandedResultBodyWidth } from ${JSON.stringify(modUrl)};
+    import { displayWidth, AMBIGUOUS_WIDE } from ${JSON.stringify(dwUrl)};
+    const strip = (s) => String(s).replace(/\\x1b\\[[0-9;]*m/g, '').replace(/\\x1b\\]8;;[^\\x07]*\\x07/g, '');
+    if (AMBIGUOUS_WIDE !== true) { console.log('POLICY_OFF'); process.exit(2); }
+    const columns = 30;
+    // Many arrows so a naive string-width fit accepts an over-wide row.
+    const body = 'x'.repeat(24) + ' ' + '\\u2192'.repeat(12) + ' tail';
+    const logical = formatExpandedResult('42\\u2192' + body, { pathArg: 'a.mjs' });
+    const physical = wrapExpandedResultLines(logical, columns);
+    const maxW = expandedResultBodyWidth(columns);
+    let bad = 0;
+    for (const row of physical) {
+      if (displayWidth(strip(row)) > maxW) bad++;
+    }
+    console.log(bad === 0 ? 'OK ' + physical.length : 'BAD ' + bad);
+  `;
+  const out = execFileSync(process.execPath, ['--input-type=module', '-e', script], {
+    env: { ...process.env, MIXDOG_TUI_AMBIGUOUS_WIDE: '1', WT_SESSION: '' },
+    encoding: 'utf8',
+  }).trim();
+  assert.ok(out.startsWith('OK'), `expected all rows within budget, got: ${out}`);
+});