dsh-better-display 0.3.8 → 0.3.9

package/tests/rewind-cut.test.ts

@@ -0,0 +1,1090 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { test } from 'vitest';
+import { fileURLToPath } from 'node:url';
+import {
+  anchorSeqOf,
+  coalesceCutSpans,
+  cutContains,
+  hiddenRewindSeqs,
+  rewindCutSpans,
+  rewindTargetOfArgs,
+  visibleChatKeys,
+  visibleChatSignature,
+  type CutChatNode
+} from '../src/client/rewind-cut.js';
+import { reconcileTurnSlots } from '../src/client/turn-slots.js';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+// Baseline first: the pure rule must go RED on the reported symptom before the
+// Reader is wired to it, and the wiring/bundle assertions stay RED until then.
+
+/** The pre-fix rule the Reader used: only the host's own hidden flag filtered rows. */
+function legacyVisibleKeys(chat: {
+  order: readonly string[];
+  nodes: { get(key: string): CutChatNode | undefined };
+}): readonly string[] {
+  return chat.order.filter(key => chat.nodes.get(key)?.visibility !== 'hidden');
+}
+
+function chatOf(nodes: readonly CutChatNode[]): {
+  order: readonly string[];
+  nodes: { get(key: string): CutChatNode | undefined };
+} {
+  const map = new Map(nodes.map(node => [node.key, node]));
+  return { order: nodes.map(node => node.key), nodes: map };
+}
+
+/**
+ * A command node as the chat snapshot carries it (`commandFromDone`).
+ *
+ * `name` defaults to the spelling the client projection actually publishes —
+ * `rewind-plugin`, the plugin's registered command id — because that is what
+ * the live chat snapshot carries. The shorter `rewind` is what older session
+ * logs recorded; both must be recognised.
+ */
+function rewindCommand(
+  key: string,
+  seq: number,
+  args: string | null,
+  marker: number | undefined,
+  outcomeKind = 'success',
+  name = 'rewind-plugin'
+): CutChatNode {
+  return {
+    key,
+    kind: 'command',
+    anchorSeq: seq,
+    visibility: 'visible',
+    data: {
+      kind: 'command',
+      seq,
+      time: 1,
+      commandId: key,
+      name,
+      args,
+      outcome: {
+        kind: outcomeKind,
+        ...(marker === undefined ? {} : { sourceEventSeq: marker })
+      }
+    }
+  };
+}
+
+function message(
+  key: string,
+  kind: 'user' | 'steering' | 'assistant-step' | 'tool-call' | 'turn-tail',
+  seq: number
+): CutChatNode {
+  return {
+    key,
+    kind,
+    anchorSeq: seq,
+    visibility: 'visible',
+    data: { seq, time: 1, content: [] }
+  };
+}
+
+/**
+ * The reported scenario: user@1, assistant@2, tool@3, then `/rewind @1 chat`
+ * executed at seq 5 with marker seq 6. Everything from the target onward must
+ * disappear from the Reader, including the `/rewind` command row itself.
+ */
+function rewoundSession() {
+  return chatOf([
+    message('user-1', 'user', 1),
+    message('assistant-2', 'assistant-step', 2),
+    message('tool-3', 'tool-call', 3),
+    rewindCommand('command-5', 5, '@1 chat', 6),
+    message('turn-tail-4', 'turn-tail', 4)
+  ]);
+}
+
+test('a rewind withdraws the target and every row after it, command row included', () => {
+  const chat = rewoundSession();
+  const visible = visibleChatKeys(chat);
+  assert.deepEqual(visible, []);
+  assert.deepEqual(rewindCutSpans(chat), [{ start: 1, end: 6 }]);
+  for (const seq of [1, 2, 3, 4, 5])
+    assert.equal(hiddenRewindSeqs(chat).has(seq), true, `seq ${seq} must be withdrawn`);
+});
+
+test('the pre-fix visibility rule reproduces the reported defect', () => {
+  // Regression evidence for the fix, not a wish: with only the host's hidden
+  // flag honoured, the withdrawn answer, tool row and `/rewind` command row all
+  // survived — the exact symptom reported (the command is recorded, no rollback).
+  const chat = rewoundSession();
+  assert.deepEqual(legacyVisibleKeys(chat), [
+    'user-1',
+    'assistant-2',
+    'tool-3',
+    'command-5',
+    'turn-tail-4'
+  ]);
+  assert.notDeepEqual(legacyVisibleKeys(chat), visibleChatKeys(chat));
+});
+
+test('a row before the target is never withdrawn', () => {
+  const chat = chatOf([
+    message('user-0', 'user', 1),
+    message('user-1', 'user', 2),
+    message('assistant-2', 'assistant-step', 3),
+    rewindCommand('command-4', 4, '@2 chat', 5)
+  ]);
+  assert.deepEqual(visibleChatKeys(chat), ['user-0']);
+});
+
+test('only a successful, marker-carrying rewind cuts; failures and previews stay readable', () => {
+  const failed = chatOf([
+    message('user-1', 'user', 1),
+    rewindCommand('command-2', 2, '@1 chat', undefined, 'error')
+  ]);
+  assert.deepEqual(rewindCutSpans(failed), []);
+  assert.deepEqual(visibleChatKeys(failed), ['user-1', 'command-2']);
+
+  // A success without the marker seq (older host output) must not cut a guessed range.
+  const markerless = chatOf([
+    message('user-1', 'user', 1),
+    rewindCommand('command-2', 2, '@1 chat', undefined)
+  ]);
+  assert.deepEqual(rewindCutSpans(markerless), []);
+  assert.deepEqual(visibleChatKeys(markerless), ['user-1', 'command-2']);
+});
+
+test('preview and candidate probe rows never surface in the transcript', () => {
+  const chat = chatOf([
+    message('user-1', 'user', 1),
+    rewindCommand('preview-2', 2, 'preview @1 both', undefined),
+    rewindCommand('candidates-3', 3, '__candidates', undefined)
+  ]);
+  assert.deepEqual(visibleChatKeys(chat), ['user-1']);
+});
+
+test('separate rewinds keep separate spans so later traffic is not swallowed', () => {
+  // rewind#1 cut [1, 4]; new user@5 survives; rewind#2 cut [5, 8].
+  const spans = coalesceCutSpans([
+    { start: 1, end: 4 },
+    { start: 5, end: 8 }
+  ]);
+  assert.deepEqual(spans, [
+    { start: 1, end: 4 },
+    { start: 5, end: 8 }
+  ]);
+  assert.equal(cutContains(spans, 4), true);
+  assert.equal(cutContains(spans, 5), true);
+  // A gap between spans must not be collapsed into one range.
+  assert.deepEqual(
+    coalesceCutSpans([
+      { start: 1, end: 4 },
+      { start: 7, end: 9 }
+    ]),
+    [
+      { start: 1, end: 4 },
+      { start: 7, end: 9 }
+    ]
+  );
+  assert.equal(
+    cutContains(
+      coalesceCutSpans([
+        { start: 1, end: 4 },
+        { start: 7, end: 9 }
+      ]),
+      5
+    ),
+    false
+  );
+  // The cut stops at the marker. 4.1 is past end 4; the next turn's process
+  // row lives in that gap (`startSeq - 0.1`).
+  const gapped = coalesceCutSpans([
+    { start: 1, end: 4 },
+    { start: 7, end: 9 }
+  ]);
+  assert.equal(cutContains(gapped, 4), true);
+  assert.equal(cutContains(gapped, 4.1), false);
+  assert.equal(cutContains(gapped, 5.0), false);
+  assert.equal(cutContains(gapped, 6.9), false);
+  assert.equal(cutContains(gapped, 7.0), true);
+  // Overlapping spans still merge.
+  assert.deepEqual(
+    coalesceCutSpans([
+      { start: 1, end: 6 },
+      { start: 4, end: 9 }
+    ]),
+    [{ start: 1, end: 9 }]
+  );
+});
+
+test('malformed command payloads are skipped instead of throwing', () => {
+  const chat = chatOf([
+    { key: 'broken', kind: 'command', anchorSeq: 1, data: 'not an object' },
+    {
+      key: 'no-name',
+      kind: 'command',
+      anchorSeq: 2,
+      data: {
+        args: '@1 chat',
+        outcome: { kind: 'success', sourceEventSeq: 3 }
+      }
+    },
+    {
+      key: 'bad-marker',
+      kind: 'command',
+      anchorSeq: 3,
+      data: {
+        name: 'rewind-plugin',
+        args: '@1 chat',
+        outcome: { kind: 'success', sourceEventSeq: 'x' }
+      }
+    },
+    {
+      key: 'bad-args',
+      kind: 'command',
+      anchorSeq: 4,
+      data: {
+        name: 'rewind',
+        args: null,
+        outcome: { kind: 'success', sourceEventSeq: 9 }
+      }
+    },
+    message('user-1', 'user', 1)
+  ]);
+  assert.deepEqual(rewindCutSpans(chat), []);
+  // bad-args succeeded and carries a marker, so the command row itself leaves
+  // (same as the plugin). It still opens no span: user-1 stays.
+  assert.deepEqual(visibleChatKeys(chat), ['broken', 'no-name', 'bad-marker', 'user-1']);
+});
+
+test('anchorSeq falls back to the payload seq and target parsing is locale-independent', () => {
+  assert.equal(anchorSeqOf({ key: 'k', kind: 'user', data: { seq: 7 } }), 7);
+  assert.equal(anchorSeqOf({ key: 'k', anchorSeq: 9, data: { seq: 7 } }), 9);
+  assert.equal(anchorSeqOf({ key: 'k', anchorSeq: -1, data: {} }), undefined);
+  assert.equal(rewindTargetOfArgs('@12 chat'), 12);
+  assert.equal(rewindTargetOfArgs('preview @3 both'), 3);
+  assert.equal(rewindTargetOfArgs('chat'), undefined);
+  assert.equal(rewindTargetOfArgs(undefined), undefined);
+});
+
+test('an unfiltered snapshot keeps its original order reference', () => {
+  const chat = chatOf([message('user-1', 'user', 1), message('assistant-2', 'assistant-step', 2)]);
+  assert.equal(visibleChatKeys(chat), chat.order);
+});
+
+test('the Reader renders from the rewind cut instead of the raw snapshot order', () => {
+  // The seam that was missing: the pure rule above is useless unless the Reader
+  // actually filters its rows with it. Pin the wiring so a refactor cannot drop
+  // it and silently restore the reported defect.
+  const source = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  assert.match(source, /visibleChatKeys/);
+  // Quote-agnostic: the source is formatted by the project's own toolchain, so a
+  // double-quoted import is still the same wiring.
+  assert.ok(source.includes("from './rewind-cut.js'") || source.includes('from "./rewind-cut.js"'));
+});
+
+test('the Reader no longer drives its groups and waiting clock from the raw order', () => {
+  // The raw snapshot order still feeds the pending-submission de-dup (a withdrawn
+  // message is still *durable*, so its echo must not reappear as a local one),
+  // but every render-facing consumer reads the filtered key list.
+  const source = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  assert.match(source, /groupNodes\(\s*renderKeys,/);
+  // The call may be formatted across lines, so match the argument rather than
+  // the argument-plus-comma.
+  assert.match(source, /waitingAnchor\(\s*renderKeys/);
+  assert.doesNotMatch(source, /groupNodes\(order,/);
+  assert.doesNotMatch(source, /waitingAnchor\(order,/);
+  assert.match(source, /observedInputIds\(order,/);
+});
+
+test('the client entry the bundle is built from still mounts the rewind cut', () => {
+  // lib/ is rebuilt at integration, so this pins the source the bundler reads
+  // rather than a stale prebuilt client.js.
+  const index = readFileSync(resolve(root, 'src/client/index.tsx'), 'utf8');
+  assert.match(index, /from ['"]\.\/Reader\.js['"]/);
+  const reader = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  assert.match(reader, /visibleChatKeys/);
+  assert.match(reader, /visibleChatSignature/);
+  assert.match(reader, /chatSeatProps\(/);
+});
+
+test('the Reader subscribes to the visible set instead of reference-stable snapshot fields', () => {
+  // The subscription seam: a rewind upserts an EXISTING command row in place, so
+  // `snapshot.order` and `snapshot.nodes` keep their identity and a selector on
+  // either never fires. The Reader must depend on the value-compared signature.
+  const source = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  // Matched across formatting: the formatter breaks the arrow onto its own line.
+  assert.match(source, /useChat\([\s\S]{0,40}?visibleChatSignature\(snapshot\)/);
+  assert.ok(source.includes('[order, nodes, rewindSignature]'));
+});
+
+test('a string signature is stable enough for an Object.is-compared selector', () => {
+  const chat = chatOf([message('user-1', 'user', 1)]);
+  assert.equal(typeof visibleChatSignature(chat), 'string');
+  assert.equal(visibleChatSignature(chat), visibleChatSignature(chat));
+  assert.equal(visibleChatSignature(chat), 'user-1');
+});
+
+test('the signature flips the moment the rewind marker lands', () => {
+  // Before the marker the command row is an ordinary record; after it, the cut
+  // exists and the same row must be gone. Nothing about the row's KEY changes,
+  // which is exactly why the memo needed a value signal rather than an identity.
+  const before = chatOf([
+    message('user-1', 'user', 1),
+    rewindCommand('command-2', 2, '@1 chat', undefined)
+  ]);
+  const after = chatOf([message('user-1', 'user', 1), rewindCommand('command-2', 2, '@1 chat', 3)]);
+  assert.equal(visibleChatSignature(before), 'user-1' + '\u0000' + 'command-2');
+  assert.equal(visibleChatSignature(after), '');
+  assert.notEqual(visibleChatSignature(before), visibleChatSignature(after));
+});
+
+test('a withdrawn turn retires its own synthetic rows, which the host anchors before the cut', () => {
+  // Measured live on the host (session 92667917, turn 1): the turn opens at 5,
+  // its user message lands at 9, and its process row is anchored at
+  // `controlAnchorSeq - 0.1` = 4.9 — BELOW the rewind target. Containment alone
+  // therefore kept the stopped-turn notice on screen even after every content
+  // row had been withdrawn: the second reported symptom.
+  const turn = {
+    turn: 1,
+    start: { seq: 5 },
+    end: { seq: 18 },
+    status: 'closed'
+  };
+  const chat = chatOf([
+    {
+      key: 'input-message',
+      kind: 'user',
+      anchorSeq: 9,
+      visibility: 'visible',
+      location: { kind: 'step', turn, step: 1 },
+      data: { seq: 9 }
+    },
+    {
+      key: 'turn-process1',
+      kind: 'turn-process',
+      anchorSeq: 4.9,
+      visibility: 'visible',
+      location: { kind: 'turn', turn },
+      data: { controlAnchorSeq: 5, processStartSeq: 5 }
+    },
+    {
+      key: 'turn-tail1',
+      kind: 'turn-tail',
+      anchorSeq: 18.1,
+      visibility: 'visible',
+      location: { kind: 'turn', turn },
+      data: { turn: 1, seq: 18 }
+    },
+    {
+      key: 'preview',
+      kind: 'command',
+      anchorSeq: 20,
+      visibility: 'visible',
+      location: { kind: 'session' },
+      data: {
+        kind: 'command',
+        seq: 20,
+        name: 'rewind-plugin',
+        args: ' preview @9 both',
+        outcome: { kind: 'success' }
+      }
+    },
+    {
+      key: 'executed',
+      kind: 'command',
+      anchorSeq: 22,
+      visibility: 'visible',
+      location: { kind: 'session' },
+      data: {
+        kind: 'command',
+        seq: 22,
+        name: 'rewind-plugin',
+        args: ' @9 chat',
+        outcome: { kind: 'success', sourceEventSeq: 23 }
+      }
+    }
+  ]);
+  assert.deepEqual(rewindCutSpans(chat), [{ start: 9, end: 23 }]);
+  assert.deepEqual(visibleChatKeys(chat), []);
+  assert.equal(visibleChatSignature(chat), '');
+});
+
+test('a later turn keeps its rows even though it shares the withdrawn turn number', () => {
+  // Guard against over-reach: the turn rule reads a turn IDENTITY, and a row of
+  // a different turn must survive no matter where it sits relative to the cut.
+  const withdrawnTurn = {
+    turn: 1,
+    start: { seq: 5 },
+    end: { seq: 18 },
+    status: 'closed'
+  };
+  const openTurn = {
+    turn: 2,
+    start: { seq: 30 },
+    end: { seq: 40 },
+    status: 'closed'
+  };
+  const chat = chatOf([
+    {
+      key: 'user-1',
+      kind: 'user',
+      anchorSeq: 9,
+      visibility: 'visible',
+      location: { kind: 'step', turn: withdrawnTurn, step: 1 },
+      data: { seq: 9 }
+    },
+    {
+      key: 'process-2',
+      kind: 'turn-process',
+      anchorSeq: 29.9,
+      visibility: 'visible',
+      location: { kind: 'turn', turn: openTurn },
+      data: { controlAnchorSeq: 30 }
+    },
+    rewindCommand('command-22', 22, ' @9 chat', 23)
+  ]);
+  assert.deepEqual(visibleChatKeys(chat), ['process-2']);
+});
+
+/**
+ * Genuine host records, copied verbatim from a real session log
+ * (`.../session-0be7b55b.../session.v4.jsonl.zstd`, two `/rewind` runs at
+ * 2026-10-14). The synthetic cases above encode our reading of the contract;
+ * this one refuses to drift from what the host actually writes.
+ */
+interface RealEventData {
+  readonly commandId?: string;
+  readonly name?: string;
+  readonly args?: string | null;
+  readonly kind?: string;
+  readonly text?: string;
+  readonly sourceEventSeq?: number;
+  readonly source?: {
+    readonly kind: string;
+    readonly rpcId?: string;
+    readonly clientTimeZone?: string;
+  };
+  readonly role?: string;
+  readonly id?: string;
+  readonly content?: readonly {
+    readonly type: string;
+    readonly text: string;
+  }[];
+}
+
+interface RealEvent {
+  readonly type: 'command/run' | 'command/done' | 'user/message';
+  readonly seq: number;
+  readonly time: number;
+  readonly data: RealEventData;
+  readonly surfaceOp?:
+    | 'append'
+    | {
+        readonly op: string;
+        readonly startSeq: number;
+        readonly endSeq: number;
+      };
+  readonly sourceEventSeqs?: readonly number[];
+}
+
+const REAL_REWIND_EVENTS: readonly RealEvent[] = [
+  {
+    type: 'command/run',
+    seq: 821,
+    time: 1791938178593,
+    data: {
+      commandId: 'cmd-8c119757-12',
+      name: 'rewind',
+      args: ' preview @802 both',
+      source: { kind: 'user' }
+    }
+  },
+  {
+    type: 'command/done',
+    seq: 822,
+    time: 1791938178678,
+    data: {
+      commandId: 'cmd-8c119757-12',
+      kind: 'success',
+      text: 'Rewind to seq 802, removing 2 node(s) from the model context (conversation log kept).\nNo restorable changes after the target.\nimpact=0'
+    }
+  },
+  {
+    type: 'command/run',
+    seq: 823,
+    time: 1791938179674,
+    data: {
+      commandId: 'cmd-8c119757-13',
+      name: 'rewind',
+      args: ' @802 chat',
+      source: { kind: 'user' }
+    }
+  },
+  {
+    type: 'user/message',
+    seq: 824,
+    time: 1791938179739,
+    data: {
+      content: [{ type: 'text', text: '(empty message)' }],
+      source: { kind: 'dsh-rewind' },
+      role: 'user',
+      id: '6b05f62f-f478-45fb-8cb8-50dcda7759b7'
+    },
+    sourceEventSeqs: [802, 803],
+    surfaceOp: { op: 'replace', startSeq: 802, endSeq: 803 }
+  },
+  {
+    type: 'command/done',
+    seq: 825,
+    time: 1791938179740,
+    data: {
+      commandId: 'cmd-8c119757-13',
+      kind: 'success',
+      text: 'Withdrawn seq 802 and everything after it (conversation returned to earlier).',
+      sourceEventSeq: 824
+    }
+  },
+  {
+    type: 'user/message',
+    seq: 830,
+    time: 1791938231664,
+    data: {
+      content: [{ type: 'text', text: '继续' }],
+      source: {
+        kind: 'user',
+        rpcId: '9a813c7f-1613-405b-a37e-57b25086b3ec',
+        clientTimeZone: 'Asia/Shanghai'
+      },
+      role: 'user',
+      id: '2c5e83ac-55cf-4a84-9daa-f25af2546614'
+    },
+    surfaceOp: 'append'
+  },
+  {
+    type: 'command/run',
+    seq: 850,
+    time: 1791938272620,
+    data: {
+      commandId: 'cmd-8c119757-18',
+      name: 'rewind',
+      args: ' preview @830 both',
+      source: { kind: 'user' }
+    }
+  },
+  {
+    type: 'command/done',
+    seq: 851,
+    time: 1791938272691,
+    data: {
+      commandId: 'cmd-8c119757-18',
+      kind: 'success',
+      text: 'Rewind to seq 830, removing 1 node(s) from the model context (conversation log kept).\nNo restorable changes after the target.\nimpact=0'
+    }
+  },
+  {
+    type: 'command/run',
+    seq: 852,
+    time: 1791938273661,
+    data: {
+      commandId: 'cmd-8c119757-19',
+      name: 'rewind',
+      args: ' @830 chat',
+      source: { kind: 'user' }
+    }
+  },
+  {
+    type: 'user/message',
+    seq: 853,
+    time: 1791938273719,
+    data: {
+      content: [{ type: 'text', text: '(empty message)' }],
+      source: { kind: 'dsh-rewind' },
+      role: 'user',
+      id: '2ce7c1c6-0c54-451c-864c-7026fd5bb92d'
+    },
+    sourceEventSeqs: [830],
+    surfaceOp: { op: 'replace', startSeq: 830, endSeq: 830 }
+  },
+  {
+    type: 'command/done',
+    seq: 854,
+    time: 1791938273720,
+    data: {
+      commandId: 'cmd-8c119757-19',
+      kind: 'success',
+      text: 'Withdrawn seq 830 and everything after it (conversation returned to earlier).',
+      sourceEventSeq: 853
+    }
+  }
+] as const;
+
+/** Project the real records the way the host's command definition does. */
+function chatFromRealEvents(events: typeof REAL_REWIND_EVENTS): {
+  order: readonly string[];
+  nodes: { get(key: string): CutChatNode | undefined };
+} {
+  const nodes: CutChatNode[] = [];
+  const started = new Map<
+    string,
+    { seq: number; time: number; name: string; args: string | null }
+  >();
+  for (const event of events) {
+    const commandId = event.data.commandId;
+    if (commandId === undefined) continue;
+    if (event.type === 'command/run') {
+      started.set(commandId, {
+        seq: event.seq,
+        time: event.time,
+        name: event.data.name ?? '',
+        args: event.data.args ?? null
+      });
+      nodes.push({
+        key: `command:${commandId}`,
+        kind: 'command',
+        anchorSeq: event.seq,
+        visibility: 'visible',
+        data: {
+          kind: 'command',
+          seq: event.seq,
+          time: event.time,
+          commandId,
+          name: event.data.name,
+          args: event.data.args ?? null,
+          outcome: null
+        }
+      });
+      continue;
+    }
+    if (event.type === 'command/done') {
+      // `commandFromDone` keeps the RUN seq as the node's seq/anchorSeq.
+      const previous = started.get(commandId);
+      const marker = 'sourceEventSeq' in event.data ? event.data.sourceEventSeq : undefined;
+      nodes.push({
+        key: `command:${commandId}`,
+        kind: 'command',
+        anchorSeq: previous?.seq ?? event.seq,
+        visibility: 'visible',
+        data: {
+          kind: 'command',
+          seq: previous?.seq ?? event.seq,
+          time: previous?.time ?? event.time,
+          commandId,
+          name: previous?.name ?? null,
+          args: previous?.args ?? null,
+          outcome: {
+            kind: event.data.kind,
+            ...(marker === undefined ? {} : { sourceEventSeq: marker })
+          }
+        }
+      });
+      continue;
+    }
+    // Only an append surface event materialises as a chat node; the replace marker does not.
+    if (event.surfaceOp === 'append') {
+      nodes.push({
+        key: `user:${event.seq}`,
+        kind: 'user',
+        anchorSeq: event.seq,
+        visibility: 'visible',
+        data: { seq: event.seq, time: event.time, content: event.data.content }
+      });
+    }
+  }
+  return chatOf(nodes);
+}
+
+test('the genuine host records from a real session produce the expected two cuts', () => {
+  const chat = chatFromRealEvents(REAL_REWIND_EVENTS);
+  // rewind#1 withdrew 802; the later user message at 830 survived it; rewind#2
+  // then withdrew 830 itself.
+  assert.deepEqual(rewindCutSpans(chat), [
+    { start: 802, end: 824 },
+    { start: 830, end: 853 }
+  ]);
+  // Every row in this window is inside one of the two cuts.
+  assert.deepEqual(visibleChatKeys(chat), []);
+  // The preview commands (821, 850) are not executed rewinds: they contribute
+  // no span of their own, and the two `command/done` successes with no marker
+  // (822, 851) are not cut sources either.
+  const previewOnly = chatFromRealEvents(
+    REAL_REWIND_EVENTS.filter(
+      event =>
+        event.seq !== 823 &&
+        event.seq !== 824 &&
+        event.seq !== 825 &&
+        event.seq !== 852 &&
+        event.seq !== 853 &&
+        event.seq !== 854
+    ) as typeof REAL_REWIND_EVENTS
+  );
+  assert.deepEqual(rewindCutSpans(previewOnly), []);
+  // The replace markers (824, 853) never materialise as chat nodes, but they are
+  // the cuts' upper bounds — which is exactly what swallows the `/rewind` rows
+  // anchored just before them.
+  const cuts = rewindCutSpans(chat);
+  assert.equal(cutContains(cuts, 824), true);
+  assert.equal(cutContains(cuts, 853), true);
+});
+
+/**
+ * The name the LIVE chat snapshot carries. The session log records
+ * `command/run.name: "rewind"`, but the plugin registers its command as
+ * `rewind-plugin` (`ENGINE_COMMANDS = new Set(["rewind-plugin", "rewind"])` in
+ * dsh-rewind-plugin's `src/client/hidden.ts`), and that is what the client
+ * projection publishes. Reading only the log spelling is the defect this test
+ * pins: the cut silently computed to nothing on every real session.
+ */
+test('the command name the live snapshot publishes (rewind-plugin) still cuts', () => {
+  const chat = chatOf([
+    message('user-1', 'user', 1),
+    message('assistant-2', 'assistant-step', 2),
+    rewindCommand('command-3', 3, ' @1 chat', 4)
+  ]);
+  assert.equal(
+    (chat.nodes.get('command-3')?.data as { name?: string } | undefined)?.name,
+    'rewind-plugin'
+  );
+  assert.deepEqual(rewindCutSpans(chat), [{ start: 1, end: 4 }]);
+  assert.deepEqual(visibleChatKeys(chat), []);
+  // The candidate probe and the impact preview carry the same engine name.
+  const probes = chatOf([
+    message('user-1', 'user', 1),
+    rewindCommand('preview-2', 2, ' preview @1 both', undefined, 'success'),
+    rewindCommand('candidates-3', 3, '__candidates', undefined, 'success')
+  ]);
+  assert.deepEqual(visibleChatKeys(probes), ['user-1']);
+});
+
+test('the pre-fix name predicate reproduces the reported defect', () => {
+  // Regression evidence, not a wish: matching only the log spelling
+  // (`name === 'rewind'`) finds no cut source in a live snapshot, so every
+  // withdrawn row survives and the command is merely recorded.
+  const chat = chatOf([
+    message('user-1', 'user', 1),
+    message('assistant-2', 'assistant-step', 2),
+    rewindCommand('command-3', 3, ' @1 chat', 4)
+  ]);
+  const legacyCutSpans = (c: {
+    order: readonly string[];
+    nodes: { get(key: string): CutChatNode | undefined };
+  }) =>
+    c.order.flatMap(key => {
+      const node = c.nodes.get(key);
+      const data = node?.data as
+        | {
+            name?: string;
+            args?: unknown;
+            outcome?: { kind?: string; sourceEventSeq?: number };
+          }
+        | undefined;
+      if (node?.kind !== 'command' || data?.name !== 'rewind') return [];
+      if (data.outcome?.kind !== 'success') return [];
+      const marker = data.outcome.sourceEventSeq;
+      const match = typeof data.args === 'string' ? data.args.match(/@(\d+)/) : null;
+      return marker === undefined || match === null
+        ? []
+        : [{ start: Number(match[1]), end: marker }];
+    });
+  assert.deepEqual(legacyCutSpans(chat), []);
+  assert.notDeepEqual(legacyCutSpans(chat), rewindCutSpans(chat));
+});
+
+test('fractional synthetic anchors inside a cut are withdrawn', () => {
+  // The live snapshot anchors the turn's process disclosure at
+  // `controlAnchorSeq - 0.1` and the turn tail at `seq + 0.1`
+  // (`CHAT_SYNTHETIC_SEQ_OFFSETS`). An integer-only comparison lets the last
+  // synthetic row of a withdrawn turn survive on its own, which is exactly what
+  // the smoke test showed: the user bubble and every tool row vanished, and one
+  // lone process cell stayed behind.
+  const chat = chatOf([
+    message('user-1', 'user', 1),
+    {
+      key: 'process-9',
+      kind: 'turn-process',
+      anchorSeq: 9.9,
+      visibility: 'visible',
+      data: { turn: 1, controlAnchorSeq: 10 }
+    },
+    message('assistant-10', 'assistant-step', 10),
+    rewindCommand('command-11', 11, ' @1 chat', 12)
+  ]);
+  assert.deepEqual(rewindCutSpans(chat), [{ start: 1, end: 12 }]);
+  assert.equal(cutContains(rewindCutSpans(chat), 9.9), true);
+  assert.deepEqual(visibleChatKeys(chat), []);
+  // `anchorSeqOf` reports the render position, fractional included: it is the
+  // range check's input, not an identity check.
+  assert.equal(anchorSeqOf({ key: 'p', kind: 'turn-process', anchorSeq: 9.9 }), 9.9);
+  assert.equal(anchorSeqOf({ key: 'p', kind: 'turn-process', anchorSeq: -1 }), undefined);
+  assert.equal(anchorSeqOf({ key: 'p', kind: 'user', data: { seq: 7 } }), 7);
+});
+
+test('a fractional anchor before the cut start is not swept in', () => {
+  const chat = chatOf([
+    message('user-1', 'user', 1),
+    {
+      key: 'tail-0',
+      kind: 'turn-tail',
+      anchorSeq: 0.1,
+      visibility: 'visible',
+      data: { seq: 0 }
+    },
+    message('assistant-2', 'assistant-step', 2),
+    rewindCommand('command-3', 3, ' @2 chat', 4)
+  ]);
+  assert.deepEqual(rewindCutSpans(chat), [{ start: 2, end: 4 }]);
+  assert.deepEqual(visibleChatKeys(chat), ['user-1', 'tail-0']);
+});
+
+test('a withdrawn turn folds away instead of vanishing in one frame', () => {
+  // The third reported symptom: the rows were removed from the visible order and
+  // unmounted in the same commit, so nothing scrolled and the transcript snapped.
+  // The reader now renders every turn through a retiring lane that keeps a
+  // departing turn mounted until its collapse settles.
+  const motion = readFileSync(resolve(root, 'src/client/motion.tsx'), 'utf8');
+  assert.ok(motion.includes('export function RetiringTurns'));
+  // The lane must be able to release a slot when the collapse ends, otherwise a
+  // departing turn would stay mounted forever at zero height.
+  assert.ok(motion.includes('onRetired?: () => void'));
+  assert.ok(motion.includes('retired.current?.()'));
+  // Reduced motion and a hidden page settle immediately. A playing collapse
+  // still dies on the #60 retiring deadline if WAAPI never finishes.
+  assert.match(motion, /!enabled \|\| document\.hidden/);
+  assert.match(motion, /220 \+ 240/);
+  assert.match(motion, /visibilitychange/);
+  const reader = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  assert.ok(reader.includes('<RetiringTurns'));
+  assert.ok(reader.includes('RetiringTurns,'));
+  // The map was the seam that unmounted turns outright.
+  assert.doesNotMatch(reader, /\{groups\.map\(/);
+});
+
+test('the collapsing lane keeps the between-turns margin it dislodged', () => {
+  // Wrapping a turn adds a level of nesting, which breaks the sibling selector
+  // `.turn + .turn`. The margin has to be re-expressed one level in or every
+  // turn loses its 12px separation.
+  const css = readFileSync(resolve(root, 'src/client/Reader.module.css'), 'utf8');
+  assert.ok(css.includes('.retiringContent + .retiringContent > .turn { margin-top: 12px; }'));
+});
+
+test('the reading column restores focus without drawing a ring around the transcript', () => {
+  // The column is the last-resort focus target when a cut unmounts. In keyboard
+  // modality a programmatic focus matches :focus-visible, and the host painted
+  // the UA `auto 2px` outline around the whole column.
+  const reader = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  assert.match(reader, /className=\{css\.column\} data-chat-flow="" tabIndex=\{-1\}/);
+  const css = readFileSync(resolve(root, 'src/client/Reader.module.css'), 'utf8');
+  const rules = [...css.matchAll(/([^{}]+)\{([^}]*)\}/g)].map(([, selector, body]) => ({
+    selectors: selector!.replace(/\/\*[\s\S]*?\*\//g, '').split(',').map(part => part.trim()),
+    body: body!,
+  }));
+  for (const pseudo of [':focus', ':focus-visible']) {
+    const rule = rules.find(({ selectors }) => selectors.includes(`.column${pseudo}`));
+    assert.ok(rule, `.column${pseudo} has its own rule`);
+    assert.match(rule.body, /outline:\s*none/);
+  }
+  // Only the column itself: descendants keep their own focus rings.
+  const suppressed = rules.filter(({ body }) => /outline:\s*none/.test(body)).flatMap(({ selectors }) => selectors);
+  assert.ok(suppressed.every(selector => !/^\.column[\s>+~]|\.column\s.*:focus/.test(selector)));
+  assert.match(css, /\.root button:focus-visible, \.root summary:focus-visible \{ outline: 2px solid/);
+});
+
+test('streaming, re-render, and reconnect do not withdraw rows', () => {
+  const base = [message('user-1', 'user', 1), message('assistant-2', 'assistant-step', 2)];
+  const streaming = chatOf(base);
+  assert.equal(visibleChatKeys(streaming), streaming.order);
+  assert.deepEqual(rewindCutSpans(streaming), []);
+
+  // A text delta rewrites node data. The row set, and therefore the signature, stays.
+  const rewritten = chatOf(
+    base.map(node =>
+      node.key === 'assistant-2'
+        ? { ...node, data: { seq: 2, time: 1, content: [{ type: 'text', text: 'more tokens' }] } }
+        : node
+    )
+  );
+  assert.equal(visibleChatSignature(streaming), visibleChatSignature(rewritten));
+
+  // Reconnect builds a fresh snapshot of the same rows.
+  const reconnected = chatOf(base.map(node => ({ ...node })));
+  assert.equal(visibleChatSignature(streaming), visibleChatSignature(reconnected));
+  assert.deepEqual([...visibleChatKeys(reconnected)], ['user-1', 'assistant-2']);
+
+  // The model is still writing. A rewind command that has not succeeded is just a row.
+  const inflight = chatOf([
+    ...base,
+    {
+      key: 'command-3',
+      kind: 'command',
+      anchorSeq: 3,
+      visibility: 'visible',
+      data: { kind: 'command', seq: 3, name: 'rewind-plugin', args: '@1 chat', outcome: null }
+    },
+    message('assistant-4', 'assistant-step', 4)
+  ]);
+  assert.deepEqual(rewindCutSpans(inflight), []);
+  assert.deepEqual(
+    [...visibleChatKeys(inflight)],
+    ['user-1', 'assistant-2', 'command-3', 'assistant-4']
+  );
+});
+
+test('a non-rewind command that mentions an @seq does not cut', () => {
+  const chat = chatOf([
+    message('user-1', 'user', 1),
+    {
+      key: 'command-2',
+      kind: 'command',
+      anchorSeq: 2,
+      visibility: 'visible',
+      data: {
+        name: 'checkpoint',
+        args: '@1 chat',
+        outcome: { kind: 'success', sourceEventSeq: 3 }
+      }
+    }
+  ]);
+  assert.deepEqual(rewindCutSpans(chat), []);
+  assert.deepEqual([...visibleChatKeys(chat)], ['user-1', 'command-2']);
+});
+
+test('a successful preview that carries a marker does not roll the transcript back', () => {
+  const chat = chatOf([
+    message('user-1', 'user', 1),
+    message('assistant-2', 'assistant-step', 2),
+    rewindCommand('preview-3', 3, 'preview @1 both', 4, 'success')
+  ]);
+  assert.deepEqual(rewindCutSpans(chat), []);
+  assert.deepEqual([...visibleChatKeys(chat)], ['user-1', 'assistant-2']);
+});
+
+test('a rewind whose target is after its marker does not cut', () => {
+  const chat = chatOf([message('user-1', 'user', 1), rewindCommand('command-2', 2, '@9 chat', 3)]);
+  assert.deepEqual(rewindCutSpans(chat), []);
+  // The malformed command row is still an executed rewind, so it leaves.
+  // The earlier message does not.
+  assert.deepEqual([...visibleChatKeys(chat)], ['user-1']);
+});
+
+test('a mid-turn steering rewind keeps the earlier user message', () => {
+  const turn = { turn: 1, start: { seq: 5 }, end: { seq: 20 }, status: 'closed' };
+  const located = (
+    key: string,
+    kind: 'user' | 'steering' | 'assistant-step' | 'turn-process',
+    seq: number
+  ): CutChatNode => ({
+    key,
+    kind,
+    anchorSeq: seq,
+    visibility: 'visible',
+    location: { kind: kind === 'turn-process' ? 'turn' : 'step', turn, step: 1 },
+    data: { seq }
+  });
+  const chat = chatOf([
+    located('user-9', 'user', 9),
+    located('assistant-12', 'assistant-step', 12),
+    located('process-1', 'turn-process', 4.9),
+    located('steering-15', 'steering', 15),
+    located('assistant-18', 'assistant-step', 18),
+    rewindCommand('command-19', 19, ' @15 chat', 20)
+  ]);
+  assert.deepEqual(rewindCutSpans(chat), [{ start: 15, end: 20 }]);
+  assert.deepEqual([...visibleChatKeys(chat)], ['user-9', 'assistant-12', 'process-1']);
+});
+
+test("the next turn's process row, anchored just after the marker, stays", () => {
+  const next = { turn: 2, start: { seq: 5 }, end: { seq: 8 }, status: 'open' };
+  const chat = chatOf([
+    message('user-1', 'user', 1),
+    rewindCommand('command-3', 3, ' @1 chat', 4),
+    {
+      key: 'process-2',
+      kind: 'turn-process',
+      anchorSeq: 4.9,
+      visibility: 'visible',
+      location: { kind: 'turn', turn: next },
+      data: { controlAnchorSeq: 5 }
+    },
+    {
+      key: 'user-5',
+      kind: 'user',
+      anchorSeq: 5,
+      visibility: 'visible',
+      location: { kind: 'step', turn: next, step: 1 },
+      data: { seq: 5 }
+    }
+  ]);
+  assert.equal(cutContains(rewindCutSpans(chat), 4.9), false);
+  assert.deepEqual([...visibleChatKeys(chat)], ['process-2', 'user-5']);
+});
+
+test('re-rendering or streaming a turn does not retire it; a rewind does', () => {
+  const first = { key: 'turn:1', text: 'hello' };
+  const second = { key: 'turn:2', text: 'world' };
+  const initial = reconcileTurnSlots([], [first, second]);
+  assert.deepEqual(
+    initial.map(slot => [slot.group.key, slot.live]),
+    [
+      ['turn:1', true],
+      ['turn:2', true]
+    ]
+  );
+
+  // Same keys, new objects: a stream tick or a parent re-render.
+  const streamed = reconcileTurnSlots(initial, [
+    { key: 'turn:1', text: 'hello' },
+    { key: 'turn:2', text: 'world plus tokens' }
+  ]);
+  assert.deepEqual(
+    streamed.map(slot => slot.live),
+    [true, true]
+  );
+  assert.equal(streamed[1]?.group.text, 'world plus tokens');
+
+  // Reconnect mounts from the rows that are actually present. Nothing is pre-retired.
+  const reconnected = reconcileTurnSlots([], [{ key: 'turn:1', text: 'hello' }]);
+  assert.deepEqual(
+    reconnected.map(slot => [slot.group.key, slot.live]),
+    [['turn:1', true]]
+  );
+
+  // A rewind drops turn 2. It stays at its old index, and only that slot retires.
+  const rewound = reconcileTurnSlots(streamed, [{ key: 'turn:1', text: 'hello' }]);
+  assert.deepEqual(
+    rewound.map(slot => [slot.group.key, slot.live]),
+    [
+      ['turn:1', true],
+      ['turn:2', false]
+    ]
+  );
+  assert.equal(rewound[1]?.group.text, 'world plus tokens');
+});
+
+test('loading older history follows the incoming turn order', () => {
+  const keep = { key: 'turn:20' };
+  const older = { key: 'turn:19' };
+  const current = reconcileTurnSlots([], [keep]);
+  const prepended = reconcileTurnSlots(current, [older, keep]);
+  assert.deepEqual(prepended.map(slot => [slot.group.key, slot.live]), [
+    ['turn:19', true],
+    ['turn:20', true],
+  ]);
+  assert.equal(reconcileTurnSlots(prepended, [older, keep]), prepended);
+
+  const tail = { key: 'turn:21' };
+  const withTail = reconcileTurnSlots([], [keep, tail]);
+  const olderBesideDeparting = reconcileTurnSlots(withTail, [older, keep]);
+  assert.deepEqual(olderBesideDeparting.map(slot => [slot.group.key, slot.live]), [
+    ['turn:19', true],
+    ['turn:20', true],
+    ['turn:21', false],
+  ]);
+
+  const leading = { key: 'turn:1' };
+  const following = { key: 'turn:2' };
+  const opened = reconcileTurnSlots([], [leading, following]);
+  const droppedHead = reconcileTurnSlots(opened, [following]);
+  assert.deepEqual(droppedHead.map(slot => [slot.group.key, slot.live]), [
+    ['turn:1', false],
+    ['turn:2', true],
+  ]);
+});