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/reader-plugin.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(' { // 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], ]); });