@semalt-ai/code 1.8.5 → 1.20.0

package/test/images.test.js

@@ -0,0 +1,238 @@
+'use strict';
+
+// Unit tests for the multimodal image-input module (Task 5.4). Pure surface:
+// media-type detection per format, the read path (size cap + isPathSafe + format
+// guards), provider-specific content-part shaping (Anthropic vs OpenAI), the
+// format-selection precedence, vision-capability resolution (fail-loud), and the
+// message transform helpers.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const images = require('../lib/images');
+const { DEFAULT_IMAGE_MAX_BYTES } = require('../lib/constants');
+
+// Minimal buffers with the right magic bytes for each format (≥12 bytes so the
+// WebP offset check is in range).
+const PNG = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0, 0, 0, 13]);
+const JPEG = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0, 0, 0, 0, 0, 0, 0, 0]);
+const GIF = Buffer.from([0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0, 0, 0, 0, 0, 0]);
+const WEBP = Buffer.from([0x52, 0x49, 0x46, 0x46, 0, 0, 0, 0, 0x57, 0x45, 0x42, 0x50]);
+
+let tmp;
+function tmpdir() {
+  if (!tmp) tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'images-test-'));
+  return tmp;
+}
+function writeTmp(name, buf) {
+  const p = path.join(tmpdir(), name);
+  fs.writeFileSync(p, buf);
+  return p;
+}
+
+// ── media-type detection ────────────────────────────────────────────────────
+
+test('detectMediaType: PNG/JPEG/WebP/GIF by magic bytes', () => {
+  assert.strictEqual(images.detectMediaType(PNG, 'x.bin'), 'image/png');
+  assert.strictEqual(images.detectMediaType(JPEG, 'x.bin'), 'image/jpeg');
+  assert.strictEqual(images.detectMediaType(GIF, 'x.bin'), 'image/gif');
+  assert.strictEqual(images.detectMediaType(WEBP, 'x.bin'), 'image/webp');
+});
+
+test('detectMediaType: magic bytes win over a misleading extension', () => {
+  // A JPEG body named .png is classified as JPEG (authoritative header).
+  assert.strictEqual(images.detectMediaType(JPEG, 'photo.png'), 'image/jpeg');
+});
+
+test('detectMediaType: extension fallback when header is inconclusive', () => {
+  const blank = Buffer.alloc(12, 0);
+  assert.strictEqual(images.detectMediaType(blank, 'a.jpeg'), 'image/jpeg');
+  assert.strictEqual(images.detectMediaType(blank, 'a.gif'), 'image/gif');
+  assert.strictEqual(images.detectMediaType(blank, 'a.txt'), null);
+});
+
+// ── readImage: encode + guards ──────────────────────────────────────────────
+
+test('readImage: reads, detects type, base64-encodes', () => {
+  const p = writeTmp('ok.png', PNG);
+  const img = images.readImage(p, { isPathSafe: () => true });
+  assert.strictEqual(img.media_type, 'image/png');
+  assert.strictEqual(img.data, PNG.toString('base64'));
+  assert.strictEqual(img.bytes, PNG.length);
+  assert.strictEqual(img.path, p);
+});
+
+test('readImage: out-of-CWD path refused by isPathSafe (clear error)', () => {
+  const p = writeTmp('blocked.png', PNG);
+  assert.throws(
+    () => images.readImage(p, { isPathSafe: () => false }),
+    /outside allowed area/i,
+  );
+});
+
+test('readImage: oversize → clear error, not an opaque endpoint failure', () => {
+  const p = writeTmp('big.png', PNG);
+  assert.throws(
+    () => images.readImage(p, { isPathSafe: () => true, maxBytes: 4 }),
+    /too large/i,
+  );
+});
+
+test('readImage: unsupported format → clear error', () => {
+  const p = writeTmp('note.txt', Buffer.from('hello world, not an image'));
+  assert.throws(
+    () => images.readImage(p, { isPathSafe: () => true }),
+    /Unsupported image format/i,
+  );
+});
+
+test('readImage: missing file → clear error', () => {
+  assert.throws(
+    () => images.readImage(path.join(tmpdir(), 'nope.png'), { isPathSafe: () => true }),
+    /not found or unreadable/i,
+  );
+});
+
+test('readImage: default size cap is the documented constant', () => {
+  // A 1-byte over the default cap would error; under it is fine. We only assert
+  // the default is wired (no maxBytes passed uses DEFAULT_IMAGE_MAX_BYTES).
+  const p = writeTmp('small.png', PNG);
+  assert.doesNotThrow(() => images.readImage(p, { isPathSafe: () => true }));
+  assert.ok(DEFAULT_IMAGE_MAX_BYTES > 0);
+});
+
+test('readImages: order preserved; throws on first bad input', () => {
+  const a = writeTmp('a.png', PNG);
+  const b = writeTmp('b.jpeg', JPEG);
+  const out = images.readImages([a, b], { isPathSafe: () => true });
+  assert.strictEqual(out.length, 2);
+  assert.strictEqual(out[0].media_type, 'image/png');
+  assert.strictEqual(out[1].media_type, 'image/jpeg');
+});
+
+// ── provider-specific content-part shaping (constraint #1) ───────────────────
+
+test('buildImagePart: OpenAI-style image_url data URL', () => {
+  const part = images.buildImagePart({ media_type: 'image/png', data: 'AAAA' }, 'openai');
+  assert.deepStrictEqual(part, {
+    type: 'image_url',
+    image_url: { url: 'data:image/png;base64,AAAA' },
+  });
+});
+
+test('buildImagePart: Anthropic-style base64 source block', () => {
+  const part = images.buildImagePart({ media_type: 'image/jpeg', data: 'BBBB' }, 'anthropic');
+  assert.deepStrictEqual(part, {
+    type: 'image',
+    source: { type: 'base64', media_type: 'image/jpeg', data: 'BBBB' },
+  });
+});
+
+test('buildMultimodalContent: text part first, then image parts', () => {
+  const parts = images.buildMultimodalContent('hello', [{ media_type: 'image/png', data: 'AAAA' }], 'openai');
+  assert.strictEqual(parts.length, 2);
+  assert.deepStrictEqual(parts[0], { type: 'text', text: 'hello' });
+  assert.strictEqual(parts[1].type, 'image_url');
+});
+
+test('buildMultimodalContent: empty text → image-only content', () => {
+  const parts = images.buildMultimodalContent('', [{ media_type: 'image/png', data: 'AAAA' }], 'anthropic');
+  assert.strictEqual(parts.length, 1);
+  assert.strictEqual(parts[0].type, 'image');
+});
+
+// ── provider-format selection precedence ─────────────────────────────────────
+
+test('selectImageFormat: profile.image_format wins', () => {
+  const config = { api_base: 'http://x', models: [{ api_base: 'http://x', model: 'm', image_format: 'anthropic' }] };
+  assert.strictEqual(images.selectImageFormat(config, 'm'), 'anthropic');
+});
+
+test('selectImageFormat: top-level config.image_format next', () => {
+  assert.strictEqual(images.selectImageFormat({ image_format: 'anthropic' }, 'm'), 'anthropic');
+});
+
+test('selectImageFormat: heuristic — anthropic api_base → anthropic, else openai default', () => {
+  assert.strictEqual(images.selectImageFormat({ api_base: 'https://api.anthropic.com' }, 'claude-x'), 'anthropic');
+  assert.strictEqual(images.selectImageFormat({ api_base: 'http://127.0.0.1:8800' }, 'gpt-4o'), 'openai');
+  assert.strictEqual(images.selectImageFormat({}, 'whatever'), 'openai');
+});
+
+// ── vision capability (constraint #2: fail loud) ─────────────────────────────
+
+test('resolveVisionCapability: profile vision:false → false (fail-loud signal)', () => {
+  const config = { api_base: 'http://x', models: [{ api_base: 'http://x', model: 'm', vision: false }] };
+  assert.strictEqual(images.resolveVisionCapability(config, 'm'), false);
+});
+
+test('resolveVisionCapability: profile vision:true → true', () => {
+  const config = { api_base: 'http://x', models: [{ api_base: 'http://x', model: 'm', vision: true }] };
+  assert.strictEqual(images.resolveVisionCapability(config, 'm'), true);
+});
+
+test('resolveVisionCapability: known text-only family → false', () => {
+  assert.strictEqual(images.resolveVisionCapability({}, 'text-embedding-3-large'), false);
+  assert.strictEqual(images.resolveVisionCapability({}, 'whisper-1'), false);
+});
+
+test('resolveVisionCapability: known vision family → true', () => {
+  assert.strictEqual(images.resolveVisionCapability({}, 'gpt-4o'), true);
+  assert.strictEqual(images.resolveVisionCapability({}, 'claude-sonnet-4-6'), true);
+});
+
+test('resolveVisionCapability: unknown → null (proceed, endpoint decides)', () => {
+  assert.strictEqual(images.resolveVisionCapability({}, 'some-random-model'), null);
+});
+
+// ── message transform helpers ────────────────────────────────────────────────
+
+test('buildProviderMessages: only image-bearing turns become content arrays', () => {
+  const msgs = [
+    { role: 'system', content: 'sys' },
+    { role: 'user', content: 'see this', images: [{ media_type: 'image/png', data: 'AAAA' }] },
+    { role: 'assistant', content: 'ok' },
+  ];
+  const out = images.buildProviderMessages(msgs, 'openai');
+  assert.strictEqual(out[0].content, 'sys');
+  assert.ok(Array.isArray(out[1].content));
+  assert.strictEqual(out[1].images, undefined, 'internal images field stripped');
+  assert.strictEqual(out[2].content, 'ok');
+});
+
+test('buildProviderMessages: strips a stray empty images field', () => {
+  const out = images.buildProviderMessages([{ role: 'user', content: 'hi', images: [] }], 'openai');
+  assert.strictEqual(out[0].content, 'hi');
+  assert.ok(!('images' in out[0]));
+});
+
+test('attachImagesToLastUser: attaches to the most recent user message', () => {
+  const msgs = [
+    { role: 'user', content: 'first' },
+    { role: 'assistant', content: 'a' },
+    { role: 'user', content: 'second' },
+  ];
+  images.attachImagesToLastUser(msgs, [{ media_type: 'image/png', data: 'AAAA' }]);
+  assert.strictEqual(msgs[0].images, undefined);
+  assert.strictEqual(msgs[2].images.length, 1);
+});
+
+test('resolveImageInputs: accepts paths and pre-encoded records', () => {
+  const p = writeTmp('mix.png', PNG);
+  const out = images.resolveImageInputs(
+    [p, { media_type: 'image/jpeg', data: 'BBBB' }],
+    { isPathSafe: () => true },
+  );
+  assert.strictEqual(out.length, 2);
+  assert.strictEqual(out[0].media_type, 'image/png');
+  assert.strictEqual(out[1].data, 'BBBB');
+});
+
+test('resolveImageInputs: rejects an invalid inline media type', () => {
+  assert.throws(
+    () => images.resolveImageInputs([{ media_type: 'application/pdf', data: 'x' }], {}),
+    /Unsupported image media type/i,
+  );
+});

package/test/input-field-ctrl-o.test.js

@@ -0,0 +1,37 @@
+'use strict';
+
+// Ctrl+O (0x0f) is now an unmapped, inert key. The expand/collapse feature it
+// drove was removed (full viewing of large output is deferred to the planned
+// full-screen transcript viewer). Pressing Ctrl+O must emit NO 'expand' event,
+// insert no character into the buffer, and never crash — in both the active
+// (enabled) input state and the agent-running (disabled) state.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+process.stdout.isTTY = true;
+
+const { InputField } = require('../lib/ui/input-field');
+
+function makeField() {
+  const field = new InputField({ cols: 80 }, {}, () => {});
+  let expandCount = 0;
+  field.on('expand', () => { expandCount++; });
+  return { field, expands: () => expandCount };
+}
+
+test('Ctrl+O is inert while the input is active: no expand event, no char inserted, no crash', () => {
+  const { field, expands } = makeField();
+  assert.doesNotThrow(() => field._handleData(Buffer.from([0x0f])));
+  assert.strictEqual(expands(), 0, 'Ctrl+O emits no expand event');
+  assert.strictEqual(field._chars.length, 0, 'Ctrl+O inserts no character into the buffer');
+  try { field.destroy(); } catch {}
+});
+
+test('Ctrl+O is inert while the agent is running (input disabled): no expand event, no crash', () => {
+  const { field, expands } = makeField();
+  field.setDisabled(true);
+  assert.doesNotThrow(() => field._handleData(Buffer.from([0x0f])));
+  assert.strictEqual(expands(), 0, 'Ctrl+O emits no expand event while disabled');
+  try { field.destroy(); } catch {}
+});

package/test/live-height-physical.test.js

@@ -0,0 +1,281 @@
+'use strict';
+
+// Output Refactor · Phase 7a — wrap-aware physical-row live height (fix (B)).
+//
+// THE CHANGE: _liveHeight became a PHYSICAL-row total — the sum of
+// displayRows() over each EMITTED live entry at the current cols — instead of a
+// logical entry count (array.length). Today every emitted entry is pre-fitted
+// to ≤cols-1 by _fitOneRow, so displayRows == 1 per entry and the physical sum
+// EQUALS the old logical count → the erase math (`\x1b[{up}A\r\x1b[J`) emits the
+// identical cursor-up and every compound write is byte-identical. The wrap-aware
+// count only diverges once Phase 7b emits un-truncated multi-row detail.
+//
+// These tests gate that "zero visible change today" claim (byte-identity +
+// numeric no-op across widths), prove the height primitive actually consumes
+// displayRows (multi-row + resize counting), pin displayRows itself, and guard
+// the live-region no-leak invariant the prior phases established.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const writer = require('../lib/ui/writer');
+const { displayRows } = require('../lib/ui/utils');
+
+// ── Raw-byte capture harness ──────────────────────────────────────────────────
+//
+// Replaces process.stdout.write so we can assert the EXACT bytes the writer
+// emits for a compound write. The writer is a singleton; clearLive() resets its
+// module state between tests so each run starts from _liveHeight=0.
+function withWriter(fn) {
+  const out = process.stdout;
+  const prev = { isTTY: out.isTTY, columns: out.columns, rows: out.rows, write: out.write };
+  let buf = '';
+  out.isTTY = true;
+  out.columns = 80;
+  out.rows = 24;
+  out.write = (s) => { buf += String(s); return true; };
+  const cap = {
+    get: () => buf,
+    reset: () => { buf = ''; },
+    setCols: (n) => { out.columns = n; },
+  };
+  return (async () => {
+    try {
+      await fn(cap);
+    } finally {
+      await writer.clearLive();
+      await writer.flush();
+      out.isTTY = prev.isTTY;
+      out.columns = prev.columns;
+      out.rows = prev.rows;
+      out.write = prev.write;
+    }
+  })();
+}
+
+// A minimal ANSI terminal model (same vocabulary the writer emits) — used only
+// by the no-leak guard at the bottom. `rows.length` is the committed physical
+// footprint; an undercounting erase makes it GROW across repaints.
+function makeVT() {
+  const rows = [''];
+  let r = 0, c = 0;
+  function ensure(row) { while (rows.length <= row) rows.push(''); }
+  function put(ch) {
+    ensure(r);
+    const line = rows[r];
+    rows[r] = line.slice(0, c) + ch + line.slice(c + 1);
+    c++;
+  }
+  function write(s) {
+    let i = 0;
+    while (i < s.length) {
+      const ch = s[i];
+      if (ch === '\x1b' && s[i + 1] === '[') {
+        let j = i + 2;
+        let params = '';
+        while (j < s.length && /[0-9;?<>]/.test(s[j])) { params += s[j]; j++; }
+        const final = s[j];
+        const n = parseInt(params, 10) || 1;
+        if (final === 'A') r = Math.max(0, r - n);
+        else if (final === 'B') { r += n; ensure(r); }
+        else if (final === 'C') c += n;
+        else if (final === 'D') c = Math.max(0, c - n);
+        else if (final === 'J') { ensure(r); rows[r] = rows[r].slice(0, c); rows.length = r + 1; }
+        i = j + 1;
+        continue;
+      }
+      if (ch === '\x1b') { i += 1; continue; }
+      if (ch === '\n') { r++; c = 0; ensure(r); i++; continue; }
+      if (ch === '\r') { c = 0; i++; continue; }
+      put(ch); i++;
+    }
+  }
+  return { rows, write };
+}
+
+// ── Test 1 — byte-identity gate (THE gate) ────────────────────────────────────
+// Guards: every compound write is byte-for-byte what the pre-(B) logical-height
+// code emitted, because the cursor-up count (the only height-dependent byte)
+// equals the entry count while all entries are single-row.
+
+test('byte-identity: setLive emits exact bytes; erase cursor-up == entry count', () =>
+  withWriter(async (cap) => {
+    // Fresh region (_liveHeight=0) → nothing to erase, just hide + draw + LF.
+    await writer.setLive(['hi']);
+    await writer.flush();
+    assert.strictEqual(cap.get(), '\x1b[?25lhi\n', 'first draw: no erase');
+
+    // Second setLive erases exactly 1 physical row (== 1 logical) then redraws.
+    cap.reset();
+    await writer.setLive(['bye']);
+    await writer.flush();
+    assert.strictEqual(cap.get(), '\x1b[?25l\x1b[1A\r\x1b[Jbye\n', 'erase up=1');
+  }));
+
+test('byte-identity: a 3-row live region erases up=3 (logical==physical)', () =>
+  withWriter(async (cap) => {
+    await writer.setLive(['alpha', 'beta', 'gamma']);
+    await writer.flush();
+    assert.strictEqual(writer.getLiveHeight(), 3);
+    cap.reset();
+    await writer.setLive(['delta', 'epsilon', 'zeta']);
+    await writer.flush();
+    assert.strictEqual(cap.get(),
+      '\x1b[?25l\x1b[3A\r\x1b[Jdelta\nepsilon\nzeta\n');
+  }));
+
+test('byte-identity: scrollback erases the exact physical height then redraws', () =>
+  withWriter(async (cap) => {
+    await writer.setLive(['alpha', 'beta', 'gamma']);
+    await writer.flush();
+    cap.reset();
+    await writer.scrollback('note');
+    await writer.flush();
+    assert.strictEqual(cap.get(),
+      '\x1b[?25l\x1b[3A\r\x1b[Jnote\nalpha\nbeta\ngamma\n');
+  }));
+
+test('byte-identity: endActivity commits final line + redraws at exact height', () =>
+  withWriter(async (cap) => {
+    await writer.setLive(['status']);
+    // graceMs:0 → visible immediately; region = [activity, live] → height 2.
+    await writer.startActivity('t1', () => 'running tool', { graceMs: 0 });
+    await writer.flush();
+    assert.strictEqual(writer.getLiveHeight(), 2);
+    cap.reset();
+    await writer.endActivity('t1', 'done tool');
+    await writer.flush();
+    // Erase 2 physical rows, append the final line, redraw remaining live line.
+    assert.strictEqual(cap.get(),
+      '\x1b[?25l\x1b[2A\r\x1b[Jdone tool\nstatus\n');
+  }));
+
+test('byte-identity: identical bytes across terminal widths (short single-row)', () =>
+  withWriter(async (cap) => {
+    // A short entry fits at every width → displayRows==1 → erase up=1 always.
+    for (const cols of [120, 80, 40, 20]) {
+      cap.setCols(cols);
+      await writer.setLive(['x']);
+      await writer.flush();
+      cap.reset();
+      await writer.setLive(['y']);
+      await writer.flush();
+      assert.strictEqual(cap.get(), '\x1b[?25l\x1b[1A\r\x1b[Jy\n', `cols=${cols}`);
+    }
+  }));
+
+// ── Test 2 — numeric no-op proof (7a is a no-op today) ────────────────────────
+// Guards: for all-single-row content, _liveHeight === activity+modal+live entry
+// count (the OLD formula) — i.e. Σ displayRows == array.length for fitted rows.
+
+test('numeric no-op: physical height equals the old logical entry count', () =>
+  withWriter(async (cap) => {
+    for (const cols of [80, 40, 24, 120]) {
+      cap.setCols(cols);
+      await writer.setLive(['one', 'two', 'three']);
+      await writer.flush();
+      assert.strictEqual(writer.getLiveHeight(), 3, `cols=${cols}: live(3)`);
+    }
+    // activity(1) + modal(2) + live(3) = 6 — the full three-contributor sum.
+    await writer.setModal(['m1', 'm2']);
+    await writer.startActivity('a', () => 'act', { graceMs: 0 });
+    await writer.flush();
+    assert.strictEqual(writer.getLiveHeight(), 1 + 2 + 3,
+      'physical sum == activity+modal+live count');
+  }));
+
+// ── Test 3 — physical counting is wired (readiness for 7b) ────────────────────
+// Guards: the height source is Σ displayRows, NOT array.length — a wrapping
+// entry counts as its real physical rows. physicalRows() is the exact primitive
+// _drawLiveSeq calls to set _liveHeight.
+
+test('physical counting: physicalRows sums displayRows, counting wraps (not entry count)', () => {
+  // 50 visible cols at width 40 wraps to 2 physical rows; array.length says 1.
+  assert.strictEqual(writer.physicalRows(['x'.repeat(50)], 40), 2);
+  assert.strictEqual(writer.physicalRows(['y'.repeat(100)], 40), 3); // ceil(100/40)
+  // Mixed: short(1) + wrapping(3) = 4 — proves a SUM, not the 2-entry count.
+  assert.strictEqual(writer.physicalRows(['short', 'z'.repeat(90)], 40), 1 + 3);
+  // Empty array → 0; non-array → 0 (defensive).
+  assert.strictEqual(writer.physicalRows([], 40), 0);
+  assert.strictEqual(writer.physicalRows(null, 40), 0);
+});
+
+// ── Test 4 — resize recompute (the reason (B) exists) ─────────────────────────
+// Guards: the count is taken at the CURRENT cols, so a wrapping entry recomputes
+// to MORE physical rows as the terminal narrows — exactly the recompute
+// _drawLiveSeq performs on every redrawLive() so the next _eraseSeqForHeight()
+// cursor-ups by the correct physical total after a resize.
+
+test('resize recompute: a wrapping entry counts as MORE physical rows at narrower cols', () => {
+  const entry = 'w'.repeat(60);
+  assert.strictEqual(writer.physicalRows([entry], 80), 1); // fits → 1
+  assert.strictEqual(writer.physicalRows([entry], 40), 2); // ceil(60/40)
+  assert.strictEqual(writer.physicalRows([entry], 20), 3); // ceil(60/20)
+});
+
+test('resize recompute (real path): redrawLive recomputes _liveHeight at the new cols', () =>
+  withWriter(async (cap) => {
+    await writer.setLive(['a short line']);
+    await writer.flush();
+    assert.strictEqual(writer.getLiveHeight(), 1);
+    // Shrink the terminal and redraw: the fitted single-row entry stays 1 row,
+    // and the erase cursor-ups by exactly the recomputed physical height.
+    cap.setCols(20);
+    cap.reset();
+    await writer.redrawLive();
+    await writer.flush();
+    assert.strictEqual(writer.getLiveHeight(), 1);
+    assert.ok(cap.get().startsWith('\x1b[?25l\x1b[1A\r\x1b[J'),
+      `erase up == recomputed height: ${JSON.stringify(cap.get())}`);
+  }));
+
+// ── Test 5 — displayRows unit (the underlying primitive) ──────────────────────
+
+test('displayRows: cols-aware ceil, empty line = 1, ANSI-stripped width', () => {
+  assert.strictEqual(displayRows('', 80), 1);              // empty → 1 row
+  assert.strictEqual(displayRows('abc', 80), 1);
+  assert.strictEqual(displayRows('x'.repeat(80), 80), 1);  // exactly fills → 1
+  assert.strictEqual(displayRows('x'.repeat(81), 80), 2);  // one over → 2
+  assert.strictEqual(displayRows('a\nb', 80), 2);          // two logical lines
+  assert.strictEqual(displayRows('a\n\nb', 80), 3);        // blank middle = 1
+  // ANSI/SGR is stripped before width measurement → colored 80-col line is 1.
+  assert.strictEqual(displayRows('\x1b[31m' + 'x'.repeat(80) + '\x1b[0m', 80), 1);
+});
+
+// ── Test 6 — no-leak guard (scroll-fix invariant unchanged) ───────────────────
+// Guards: the live-region erase/redraw still strands ZERO rows in scrollback
+// across repaints. The full status-bar-{driver,pause,resync} and
+// output-heredoc-leak suites cover the anim-driver pause/resume + startup-resync
+// transitions; this re-checks the core no-growth invariant under the new
+// physical-height math directly.
+
+test('no-leak: repeated redraws of single-row content never grow the footprint', () => {
+  const vt = makeVT();
+  const out = process.stdout;
+  const prev = { isTTY: out.isTTY, columns: out.columns, rows: out.rows, write: out.write };
+  out.isTTY = true;
+  out.columns = 80;
+  out.rows = 24;
+  out.write = (s) => { vt.write(String(s)); return true; };
+  return (async () => {
+    try {
+      await writer.setLive(['⣯ Running shell: echo hello']);
+      await writer.flush();
+      const baseline = vt.rows.length;
+      assert.strictEqual(writer.getLiveHeight(), 1);
+      for (let i = 0; i < 12; i++) {
+        await writer.redrawLive();
+        await writer.flush();
+        assert.strictEqual(vt.rows.length, baseline,
+          `repaint ${i + 1}: footprint grew (${vt.rows.length} > ${baseline}) — leak`);
+      }
+    } finally {
+      await writer.clearLive();
+      await writer.flush();
+      out.isTTY = prev.isTTY;
+      out.columns = prev.columns;
+      out.rows = prev.rows;
+      out.write = prev.write;
+    }
+  })();
+});