@semalt-ai/code 1.19.0 → 1.20.0

package/test/replay-descriptor.test.js

@@ -0,0 +1,189 @@
+'use strict';
+
+// Output Refactor — Phase 6a: native-rail replay parity via a persisted descriptor.
+//
+// Replay (/history, /chats, --resume) historically rendered tool lines through
+// the lossy summarizeToolResult one-liner (no diff, no real duration, no real
+// status). Phase 6a persists the terminal-state descriptor core as a sibling
+// `_display` key on the native `{role:'tool'}` result message and replays it
+// through the SAME renderOperation a fresh turn uses. These tests pin:
+//   1. POSITIVE — a saved native tool message with `_display` replays byte-identical
+//      to a fresh renderOperation of the same descriptor (result line + diff body),
+//      across ok / error / diff cases.
+//   2. NEGATIVE — a legacy message (no `_display`) and an unknown-version `_display`
+//      both fall back to summarizeToolResult, unchanged from today, no crash.
+//   3. INV.1 — persisting `_display` leaves the model-facing `content` byte-identical
+//      and never feeds `_display` to the bound (model-facing) tool output.
+//   4. ANTI-PING-PONG — the Phase 1 fresh-render characterization bytes are unchanged.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+// Phase 2.5: colour is gated on `isTTY && !NO_COLOR`. Force a colour-capable env
+// so the byte comparisons below are stable regardless of how the runner wires
+// stdout (node:test runs each file in its own process — no leak to other suites).
+process.stdout.isTTY = true;
+delete process.env.NO_COLOR;
+
+const { buildToolOperation, serializeOperation, descriptorFromStored } = require('../lib/ui/tool-operation');
+const { renderOperation } = require('../lib/ui/render-operation');
+const { ChatHistory } = require('../lib/ui/chat-history');
+const { summarizeToolResult } = require('../lib/ui/format');
+
+const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
+
+// Mirror output-preview.test.js: intercept _commit to capture exactly what
+// addMessage commits to scrollback.
+function capture(ch) {
+  const out = [];
+  ch._commit = (t) => out.push(t);
+  return out;
+}
+
+// Representative COMPLETED operations spanning the fidelity dimensions that
+// summarizeToolResult drops: real duration, real exit/status meta, an error
+// state, and a file-edit diff body.
+const SHELL_OK = buildToolOperation({
+  id: 'tool-1', tag: 'shell', arg: 'npm test', attrs: { command: 'npm test' },
+  status: 'ok', durationMs: 2300, meta: { exit_code: 0 },
+});
+const SHELL_ERR = buildToolOperation({
+  id: 'tool-2', tag: 'shell', arg: 'npm test', attrs: { command: 'npm test' },
+  status: 'error', durationMs: 800, meta: { exit_code: 1 }, error: { message: 'exit 1', code: 1 },
+});
+const EDIT_DIFF = buildToolOperation({
+  id: 'tool-3', tag: 'edit_file', arg: 'lib/x.js', attrs: { path: 'lib/x.js' },
+  status: 'ok', durationMs: 12, diff: { before: 'a\nb\nc\n', after: 'a\nB\nc\n', path: 'lib/x.js' },
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// §3.1 backbone — the round-trip is the spine of test 1: a stored core rebuilds
+// a descriptor that renders byte-identical to the live one, for result + detail.
+// ───────────────────────────────────────────────────────────────────────────
+for (const [name, op] of [['shell ok', SHELL_OK], ['shell error', SHELL_ERR], ['edit diff', EDIT_DIFF]]) {
+  test(`round-trip: descriptorFromStored(serializeOperation(op)) renders == op — '${name}' (guards replay parity backbone)`, () => {
+    const restored = descriptorFromStored(serializeOperation(op));
+    assert.ok(restored, 'a v:1 core rebuilds a descriptor');
+    // result line (the default phase) — duration + meta + status preserved.
+    assert.strictEqual(
+      renderOperation(restored, { mode: 'ansi' }),
+      renderOperation(op, { mode: 'ansi' }),
+      'result line byte-identical after round-trip',
+    );
+    // detail body — the diff renders identically (empty for non-diff ops).
+    assert.strictEqual(
+      renderOperation(restored, { mode: 'ansi', phase: 'detail', maxLines: 50 }),
+      renderOperation(op, { mode: 'ansi', phase: 'detail', maxLines: 50 }),
+      'detail (diff) body byte-identical after round-trip',
+    );
+  });
+}
+
+test("round-trip: a real diff actually renders a non-empty body (the parity isn't vacuous)", () => {
+  const restored = descriptorFromStored(serializeOperation(EDIT_DIFF));
+  const body = renderOperation(restored, { mode: 'ansi', phase: 'detail', maxLines: 50 });
+  assert.ok(body.length > 0, 'the edit diff body is present, not empty');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 1. POSITIVE — native replay parity. A saved {role:'tool'} message carrying
+//    `_display` replays through addMessage byte-identical to a fresh render.
+// ───────────────────────────────────────────────────────────────────────────
+test('replay: native tool message with _display renders the result line == fresh renderOperation (ok, with duration/exit) (guards positive parity)', () => {
+  const ch = new ChatHistory();
+  const out = capture(ch);
+  ch.addMessage({ role: 'tool', tag: 'tool', content: 'Command `npm test`:\nExit code: 0\nok', _display: serializeOperation(SHELL_OK) });
+  const committed = out.join('');
+  const expected = renderOperation(descriptorFromStored(serializeOperation(SHELL_OK)), { mode: 'ansi' }) + '\n';
+  // The first committed line is the descriptor result line, verbatim (duration
+  // "2.3s" and "exit 0" present — both dropped by summarizeToolResult).
+  assert.ok(committed.startsWith(expected), 'replayed result line is byte-identical to a fresh render');
+  assert.match(stripAnsi(committed), /2\.3s/, 'real duration shown (not dropped)');
+  assert.match(stripAnsi(committed), /exit 0/, 'real exit meta shown');
+});
+
+test('replay: native tool message with _display shows the diff body and error styling (guards full fidelity)', () => {
+  // Error op: status must survive as an error glyph, not a generic ✓.
+  const chErr = new ChatHistory();
+  const outErr = capture(chErr);
+  chErr.addMessage({ role: 'tool', tag: 'tool', content: 'Command `npm test`:\nExit code: 1\nFAIL', _display: serializeOperation(SHELL_ERR) });
+  const errLine = renderOperation(descriptorFromStored(serializeOperation(SHELL_ERR)), { mode: 'ansi' }) + '\n';
+  assert.ok(outErr.join('').startsWith(errLine), 'error op replays byte-identical (error-styled)');
+  assert.match(stripAnsi(outErr.join('')), /exit 1/, 'error meta preserved');
+
+  // Diff op: the diff body must be replayed, not just the one-line header.
+  const chDiff = new ChatHistory();
+  const outDiff = capture(chDiff);
+  chDiff.addMessage({ role: 'tool', tag: 'tool', content: 'Updated lib/x.js', _display: serializeOperation(EDIT_DIFF), diffMaxLines: 50 });
+  const committed = outDiff.join('');
+  const resultLine = renderOperation(descriptorFromStored(serializeOperation(EDIT_DIFF)), { mode: 'ansi' });
+  const diffBody = renderOperation(descriptorFromStored(serializeOperation(EDIT_DIFF)), { mode: 'ansi', phase: 'detail', maxLines: 50 });
+  assert.ok(diffBody.length > 0, 'precondition: there is a diff body to show');
+  assert.strictEqual(committed, resultLine + '\n' + diffBody + '\n', 'replay commits result line + diff body, byte-identical to fresh');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 2. NEGATIVE / fallback guard — legacy (no _display) and unknown-version
+//    _display both take the summarizeToolResult path, unchanged, no crash.
+// ───────────────────────────────────────────────────────────────────────────
+test('replay: a legacy tool message (no _display) falls back to summarizeToolResult, unchanged (guards fallback)', () => {
+  const content = 'Command `npm test`:\nExit code: 0\nall good';
+  // Snapshot of today's behavior: the legacy path collapses via summarizeToolResult.
+  const expectedSummary = summarizeToolResult(content);
+  const ch = new ChatHistory();
+  const out = capture(ch);
+  ch.addMessage({ role: 'tool', tag: 'tool', content });
+  const text = stripAnsi(out.join(''));
+  assert.match(text, new RegExp(expectedSummary.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), 'legacy summary unchanged');
+  assert.doesNotMatch(text, /2\.3s/, 'legacy path carries no descriptor duration');
+});
+
+test('replay: an unknown-version _display (v:999) falls back, does not crash (guards version gate)', () => {
+  assert.strictEqual(descriptorFromStored({ v: 999, tag: 'shell', status: 'ok' }), null, 'unknown version → null descriptor');
+  const content = 'Command `npm test`:\nExit code: 0\nall good';
+  const ch = new ChatHistory();
+  const out = capture(ch);
+  // Must NOT throw, and must produce the same fallback as the legacy case.
+  ch.addMessage({ role: 'tool', tag: 'tool', content, _display: { v: 999, tag: 'shell', status: 'ok' } });
+  const text = stripAnsi(out.join(''));
+  assert.match(text, new RegExp(summarizeToolResult(content).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), 'unknown-version takes the same fallback path');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 3. INV.1 — content byte-identical; _display is additive and never fed to the
+//    model-facing bound output. We model the agent.js persist step: the result
+//    string handed to boundToolOutput becomes the message `content`; `_display`
+//    is attached as a sibling and must not alter `content`.
+// ───────────────────────────────────────────────────────────────────────────
+test('inv.1: attaching _display leaves content byte-identical and is additive only (guards the model-facing chokepoint)', () => {
+  const resultStr = 'Command `npm test`:\nExit code: 0\nall good';
+  // The persist site (agent.js): content = the exact bound result string; the
+  // descriptor core rides alongside as a sibling key.
+  const msg = { role: 'tool', tool_call_id: 'call_1', content: resultStr, _display: serializeOperation(SHELL_OK) };
+  assert.strictEqual(msg.content, resultStr, 'content equals the original bound result string, byte-for-byte');
+  // The bound (model-facing) value is `content`; nothing from `_display` leaks in.
+  assert.ok(!msg.content.includes('2.3s'), 'descriptor duration is NOT in the model-facing content');
+  assert.ok(!msg.content.includes('_display'), 'no descriptor framing in content');
+  // _display carries the display-only core, separate from content.
+  assert.strictEqual(msg._display.v, 1);
+  assert.strictEqual(msg._display.durationMs, 2300);
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 4. ANTI-PING-PONG — the Phase 1 fresh-render characterization bytes are still
+//    byte-identical (threading the descriptor through persistence changed
+//    nothing the live path renders).
+// ───────────────────────────────────────────────────────────────────────────
+test('anti-ping-pong: Phase 1 fresh-render bytes unchanged (guards no live-path regression)', () => {
+  // Re-pin a representative subset of the Phase 1 PINNED bytes (see
+  // render-operation.test.js). If descriptor threading altered the live render,
+  // these break.
+  const shellOk = renderOperation(
+    buildToolOperation({ status: 'success', tag: 'shell', arg: 'npm install', attrs: { command: 'npm install' }, durationMs: 2300, meta: { exit_code: 0 } }),
+    { mode: 'ansi', phase: 'result' },
+  );
+  assert.strictEqual(
+    shellOk,
+    '  \x1b[38;5;40m✓\x1b[0m \x1b[38;5;214mshell\x1b[0m \x1b[2m·\x1b[0m \x1b[38;5;214mnpm install\x1b[0m \x1b[2m·\x1b[0m \x1b[38;5;244m2.3s\x1b[0m \x1b[2m·\x1b[0m \x1b[38;5;244mexit 0\x1b[0m',
+  );
+});

package/test/replay-web-aggregate.test.js

@@ -0,0 +1,291 @@
+'use strict';
+
+// Output Refactor — Phase 6c-ii: two-rail web replay AGGREGATION.
+//
+// This is the only web commit with a VISIBLE replay change: replayed web activity
+// renders as the aggregated `✓ web · …` committed summary — byte-identical to the
+// LIVE committed output — on the native rail, the XML rail, and mixed sessions,
+// including multi-group interleaving and cross-iteration/cross-blob/cross-message
+// COALESCING into a single summary.
+//
+// THE ORACLE is the live committed output, NOT a bare aggregateWebOps re-call:
+// each test drives the real createWebActivityTracker (with a fake writerModule
+// that records endActivity(id, line)) through start()/end(), triggering flush()
+// exactly where the live runtime would — a non-web onToolStart (chat-turn.js:222),
+// a terminal onAssistantMessage with content (chat-turn.js:389-391), and the
+// turn-end `finally` (chat-turn.js:501). The recorded endActivity line(s), in
+// order, are the oracle. The SAME op sequence's persisted messages are then run
+// through chat-session.displayLoadedMessages against a fake writer, and the
+// committed scrollback lines must be byte-identical AND in the same order.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+// Stable colour env for byte comparisons (node:test isolates each file's process).
+process.stdout.isTTY = true;
+delete process.env.NO_COLOR;
+
+const { buildToolOperation, serializeOperation } = require('../lib/ui/tool-operation');
+const { renderOperation } = require('../lib/ui/render-operation');
+const { ChatHistory } = require('../lib/ui/chat-history');
+const { createChatSession } = require('../lib/commands/chat-session');
+const {
+  serializeWebOp,
+  createWebActivityTracker,
+} = require('../lib/ui/web-activity');
+
+const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
+const CFG = { diff_max_lines: 50, shell_preview_lines: 5 };
+
+// ── The live ORACLE driver ──────────────────────────────────────────────────
+// `ops` is a list of step objects describing the live runtime, in order:
+//   { web:  { tag, input, ctx, durationMs } }   → tracker.start()/end()
+//   { flush: 'tool' | 'assistant' | 'finally' } → tracker.flush() (a live trigger)
+// Returns the ordered list of committed summary LINES (each endActivity arg).
+function liveOracleLines(steps) {
+  const lines = [];
+  const tracker = createWebActivityTracker({ writerModule: {
+    startActivity: () => {}, updateActivity: () => {},
+    endActivity: (_id, line) => lines.push(line),
+  } });
+  for (const s of steps) {
+    if (s.web) {
+      tracker.start(s.web.tag, s.web.input);
+      tracker.end(s.web.tag, 'done', s.web.durationMs, s.web.ctx);
+    } else if (s.flush && tracker.isOpen()) {
+      tracker.flush();
+    }
+  }
+  return lines;
+}
+
+// ── The REAL replay path, capturing every committed scrollback chunk in order ──
+function replayCommits(loadedMessages, cfg) {
+  const ch = new ChatHistory();
+  const out = [];
+  ch._commit = (t) => out.push(t);
+  const session = createChatSession({ chatHistory: ch, getConfig: () => cfg || CFG });
+  session.displayLoadedMessages(loadedMessages);
+  return out;
+}
+
+// Faithful models of agent.js per-rail persistence (mirrors replay-web-persist):
+// native attaches `_display` only when truthy; XML pushes a `displayCore || null`
+// per slot into the {role:'user'} feedback blob's `_display[]`.
+function nativeToolMsg(content, core) {
+  const msg = { role: 'tool', content };
+  if (core) msg._display = core;
+  return msg;
+}
+function assistantMsg(content) { return { role: 'assistant', content }; }
+function xmlBlob(results, cores) {
+  const m = {
+    role: 'user',
+    content: `Tool execution results:\n\n${results.join('\n\n')}\n\nContinue with the task. If everything is done, summarize what was accomplished.`,
+  };
+  if (cores !== undefined) m._display = cores.map((c) => c || null);
+  return m;
+}
+
+// Op fixtures — ctx shape exactly as onToolEnd receives it ({ attrs, meta, error }).
+const SEARCH = {
+  input: 'коррупционные скандалы 2024',
+  ctx: { attrs: { query: 'коррупционные скандалы 2024' }, meta: { status_code: 200, bytes: 4096 }, error: null },
+};
+const FETCH_OK = {
+  input: 'https://example.com/article',
+  ctx: { attrs: { url: 'https://example.com/article' }, meta: { status_code: 200, bytes: 2048 }, error: null },
+};
+const EDIT_DIFF = buildToolOperation({
+  id: 'tool-1', tag: 'edit_file', arg: 'lib/x.js', attrs: { path: 'lib/x.js' },
+  status: 'ok', durationMs: 12, diff: { before: 'a\nb\nc\n', after: 'a\nB\nc\n', path: 'lib/x.js' },
+});
+
+// The committed web summaries among a replay's scrollback chunks (the ones the
+// web-activity summary produces — they carry the `web` category and no \n).
+function webLines(commits) {
+  return commits.filter((c) => / web /.test(stripAnsi(c)) && /[✓●]/.test(stripAnsi(c)));
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// 1. INTERLEAVING — web_search, edit_file, http_get → [web 1][edit][web 2], in
+//    order, each committed at its position (proves per-position commit; the
+//    non-web op breaks the run, so the two web ops do NOT coalesce).
+// ───────────────────────────────────────────────────────────────────────────
+test('interleaving: web · non-web · web commits two summaries straddling the edit line, byte-identical and in order', () => {
+  // Oracle: web_search opens; the edit's onToolStart flushes summary 1; http_get
+  // opens a new group; turn-end `finally` flushes summary 2.
+  const oracle = liveOracleLines([
+    { web: { tag: 'web_search', input: SEARCH.input, ctx: SEARCH.ctx, durationMs: 300 } },
+    { flush: 'tool' },
+    { web: { tag: 'http_get', input: FETCH_OK.input, ctx: FETCH_OK.ctx, durationMs: 120 } },
+    { flush: 'finally' },
+  ]);
+  assert.strictEqual(oracle.length, 2, 'live commits two separate web summaries');
+
+  // Native rail: tool(web) · tool(edit) · tool(web).
+  const commits = replayCommits([
+    nativeToolMsg('web search', serializeWebOp(SEARCH.ctx, 'web_search', 300)),
+    nativeToolMsg('edited', serializeOperation(EDIT_DIFF)),
+    nativeToolMsg('fetched', serializeWebOp(FETCH_OK.ctx, 'http_get', 120)),
+  ]);
+  const wl = webLines(commits);
+  assert.deepStrictEqual(wl, oracle, 'two web summaries replay byte-identical to the oracle, in order');
+  // Order proof: summary 1 lands BEFORE the edit line, summary 2 AFTER it.
+  const editLine = renderOperation(EDIT_DIFF, { mode: 'ansi', phase: 'result' });
+  const editIdx = commits.findIndex((c) => c.includes(editLine));
+  const s1 = commits.indexOf(oracle[0]);
+  const s2 = commits.lastIndexOf(oracle[1]);
+  assert.ok(s1 >= 0 && editIdx >= 0 && s2 >= 0, 'all three landmarks present');
+  assert.ok(s1 < editIdx && editIdx < s2, 'order is [web 1][edit][web 2]');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 2. CROSS-ITERATION COALESCING (the key test) — web_search(iter1) → http_get
+//    (iter2) → terminal answer commits ONE summary, on BOTH rails. The ops live
+//    in separate {role:'user'} blobs (XML) / separate {role:'tool'} messages
+//    (native); the intermediate iteration must not flush.
+// ───────────────────────────────────────────────────────────────────────────
+test('cross-iteration coalescing — XML rail (two separate {role:user} blobs) → ONE summary, byte-identical', () => {
+  // Oracle: both web ops in one open group; only the terminal assistant flushes.
+  const oracle = liveOracleLines([
+    { web: { tag: 'web_search', input: SEARCH.input, ctx: SEARCH.ctx, durationMs: 300 } },
+    { web: { tag: 'http_get', input: FETCH_OK.input, ctx: FETCH_OK.ctx, durationMs: 120 } },
+    { flush: 'assistant' },
+  ]);
+  assert.strictEqual(oracle.length, 1, 'live commits exactly one coalesced summary');
+
+  const commits = replayCommits([
+    assistantMsg(''),                                                   // iter1 tool-call-only (empty)
+    xmlBlob(['search results…'], [serializeWebOp(SEARCH.ctx, 'web_search', 300)]),
+    assistantMsg(''),                                                   // iter2 tool-call-only (empty)
+    xmlBlob(['page body…'], [serializeWebOp(FETCH_OK.ctx, 'http_get', 120)]),
+    assistantMsg('Here is the answer.'),                                // terminal answer
+  ]);
+  assert.deepStrictEqual(webLines(commits), oracle, 'XML rail coalesces two cross-blob iterations into one summary');
+});
+
+test('cross-iteration coalescing — native rail (two separate {role:tool} messages) → ONE summary, byte-identical', () => {
+  const oracle = liveOracleLines([
+    { web: { tag: 'web_search', input: SEARCH.input, ctx: SEARCH.ctx, durationMs: 300 } },
+    { web: { tag: 'http_get', input: FETCH_OK.input, ctx: FETCH_OK.ctx, durationMs: 120 } },
+    { flush: 'assistant' },
+  ]);
+  const commits = replayCommits([
+    assistantMsg(''),                                                   // iter1 tool-call-only
+    nativeToolMsg('web search', serializeWebOp(SEARCH.ctx, 'web_search', 300)),
+    assistantMsg(''),                                                   // iter2 tool-call-only
+    nativeToolMsg('fetched', serializeWebOp(FETCH_OK.ctx, 'http_get', 120)),
+    assistantMsg('Here is the answer.'),                                // terminal answer
+  ]);
+  assert.deepStrictEqual(webLines(commits), oracle, 'native rail coalesces two cross-message iterations into one summary');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 3. NO PREMATURE FLUSH ON INTERMEDIATE ASSISTANT — an empty-content assistant
+//    message sitting BETWEEN two web iterations must not split the group; still
+//    ONE summary. Guards the §1 flush condition (terminal-with-content only).
+// ───────────────────────────────────────────────────────────────────────────
+test('no premature flush: an empty-content assistant between two web iterations yields ONE summary', () => {
+  const oracle = liveOracleLines([
+    { web: { tag: 'web_search', input: SEARCH.input, ctx: SEARCH.ctx, durationMs: 300 } },
+    { web: { tag: 'http_get', input: FETCH_OK.input, ctx: FETCH_OK.ctx, durationMs: 120 } },
+    { flush: 'finally' },
+  ]);
+  const commits = replayCommits([
+    nativeToolMsg('web search', serializeWebOp(SEARCH.ctx, 'web_search', 300)),
+    assistantMsg('   '),  // whitespace-only / empty display content → MUST NOT flush
+    nativeToolMsg('fetched', serializeWebOp(FETCH_OK.ctx, 'http_get', 120)),
+  ]);
+  assert.deepStrictEqual(webLines(commits), oracle, 'the intermediate empty assistant does not split the group');
+  // And it really is a single line, not two.
+  assert.strictEqual(webLines(commits).length, 1);
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 4. GATE FAIL-SAFE — an XML blob with a null/unknown slot still drops to the
+//    legacy whole-blob summary (after flushing any open run); non-null slots are
+//    NOT partially rendered. Preserves the 6b/6c-i invariant.
+// ───────────────────────────────────────────────────────────────────────────
+test('gate fail-safe: a null slot still drops the whole blob to the legacy summary after flushing the open run', () => {
+  const results = ['edited lib/x.js', 'web search results…'];
+  const blob = xmlBlob(results, [serializeOperation(EDIT_DIFF), null]); // one null slot → gate fails
+  // A web run is open from a PRIOR native web op; the failing blob must flush it
+  // first, then render the legacy whole-blob summary (no per-slot render).
+  const commits = replayCommits([
+    nativeToolMsg('web search', serializeWebOp(SEARCH.ctx, 'web_search', 300)),
+    blob,
+  ]);
+  // The open run flushed → exactly one web summary committed (the prior op).
+  assert.strictEqual(webLines(commits).length, 1, 'the open web run is flushed before the fallback');
+  // Whole-blob legacy summary present; the normal slot's diff body is NOT rendered.
+  const body = blob.content
+    .replace(/^Tool execution results[^\n]*\n+/, '')
+    .replace(/\n+Continue with the task\.[\s\S]*$/, '')
+    .trim();
+  const ch = new ChatHistory();
+  const legacy = [];
+  ch._commit = (t) => legacy.push(t);
+  ch.addMessage({ role: 'tool', tag: 'tool', content: body });
+  const joined = commits.join('');
+  assert.ok(joined.includes(legacy.join('')), 'the whole-blob legacy summary is rendered');
+  const diffBody = renderOperation(EDIT_DIFF, { mode: 'ansi', phase: 'detail', maxLines: 50 });
+  assert.ok(diffBody.length > 0 && !joined.includes(diffBody), 'the non-web slot is NOT partially rendered');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 5. SCROLL-FIX SAFETY — the replay path NEVER instantiates the live web tracker
+//    and never calls a live-region method. Guards idle-pause/startup-resync/anim.
+// ───────────────────────────────────────────────────────────────────────────
+test('scroll-fix safety: replay never instantiates createWebActivityTracker nor calls a live-region method', () => {
+  const webMod = require('../lib/ui/web-activity');
+  const realTracker = webMod.createWebActivityTracker;
+  let trackerCalls = 0;
+  webMod.createWebActivityTracker = (...a) => { trackerCalls++; return realTracker(...a); };
+
+  // Spy the writer's ACTIVITY-REGION methods — the ones the live web tracker
+  // drives (startActivity/updateActivity/endActivity, plus cancelActivity). Replay
+  // must touch none of them. (redrawLive/setModal are general teardown — clearMessages
+  // calls redrawLive — and are NOT part of the web live region, so not spied.)
+  const writer = require('../lib/ui/writer');
+  const liveMethods = ['startActivity', 'updateActivity', 'endActivity', 'cancelActivity'];
+  const saved = {};
+  const hits = [];
+  for (const name of liveMethods) {
+    saved[name] = writer[name];
+    writer[name] = (...a) => { hits.push(name); if (saved[name]) return saved[name](...a); };
+  }
+  try {
+    const ch = new ChatHistory();
+    ch._commit = () => {};            // swallow scrollback; we only watch the live region
+    const session = createChatSession({ chatHistory: ch, getConfig: () => CFG });
+    session.displayLoadedMessages([
+      nativeToolMsg('web search', serializeWebOp(SEARCH.ctx, 'web_search', 300)),
+      assistantMsg(''),
+      nativeToolMsg('fetched', serializeWebOp(FETCH_OK.ctx, 'http_get', 120)),
+      assistantMsg('Here is the answer.'),
+    ]);
+    assert.strictEqual(trackerCalls, 0, 'replay does NOT instantiate the live web tracker');
+    assert.deepStrictEqual(hits, [], 'replay calls no live-region method');
+  } finally {
+    webMod.createWebActivityTracker = realTracker;
+    for (const name of liveMethods) writer[name] = saved[name];
+  }
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 6. ANTI-PING-PONG — fresh LIVE web display unchanged; the pure aggregator the
+//    replay path reuses is the SAME one the live tracker commits, so a single
+//    web op replays exactly as it renders live.
+// ───────────────────────────────────────────────────────────────────────────
+test('anti-ping-pong: a single web op replays byte-identical to its fresh LIVE committed summary', () => {
+  const oracle = liveOracleLines([
+    { web: { tag: 'web_search', input: SEARCH.input, ctx: SEARCH.ctx, durationMs: 300 } },
+    { flush: 'finally' },
+  ]);
+  const commits = replayCommits([nativeToolMsg('web search', serializeWebOp(SEARCH.ctx, 'web_search', 300))]);
+  assert.deepStrictEqual(webLines(commits), oracle, 'one web op replays identically to its live committed line');
+  // Live render is untouched by 6c-ii — the committed line still carries `web` + `search`.
+  assert.match(stripAnsi(oracle[0]), /web/);
+  assert.match(stripAnsi(oracle[0]), /search/);
+});