dsh-session-rewind 1.2.8 → 1.3.1

package/lib/client.js

@@ -65,7 +65,9 @@ loader.load({
     const INPLACE_ROUTE = '/api/session-rewind.inplace';
     const CUTS_ROUTE = '/api/session-rewind.cuts';
     const DIAGNOSE_ROUTE = '/api/session-rewind.diagnose';
-    const BOOT_REVISION = '1.2.5';
+    const TAIL_ROUTE = '/api/session-rewind.tail';
+    const BOOT_REVISION = '1.3.1';
+    const HIDDEN_ATTR = 'data-session-rewind-hidden';
 
     /** One per-message bridge per session, shared by every TurnRewind instance. */
     const bridgeRegistry = new Map();
@@ -236,6 +238,7 @@ loader.load({
       '.dshSessionRewindRoundFiles{flex:none;font-size:10px;line-height:15px;color:var(--dsw-alias-label-secondary)}',
       '.dshSessionRewindModeText{margin:0;font-size:12px;line-height:18px;color:var(--dsw-alias-label-primary);',
       'font-family:var(--dsw-font-family);word-break:break-word;max-height:96px;overflow:auto}',
+    '[data-session-rewind-hidden="true"]{display:none !important}',
     ].join('\n');
     //#endregion
 
@@ -767,7 +770,7 @@ loader.load({
       const state = {
         disposed: false,
         turnToSeq: new Map(),
-        cutTurn: null,
+        hiddenTurns: new Set(),
         buttons: new Map(),
         hiddenRows: new Map(),
         observer: null,
@@ -867,6 +870,7 @@ loader.load({
               : `${tr('notice.failed')}（HTTP ${response.status}）`),
           );
           error.status = response.status;
+          error.code = value !== null && typeof value === 'object' && typeof value.code === 'string' ? value.code : null;
           throw error;
         }
         return value;
@@ -908,24 +912,33 @@ loader.load({
       };
 
       /** Hide or restore the rendered rows at or after the executed cut. */
+      /**
+       * Hide exactly the rows of the Turns a rewind withdrew.
+       *
+       * The attribute (plus a `display: none !important` rule in SHEET) is used
+       * instead of an inline style because the Chat re-renders its rows and would
+       * drop an inline override; an unknown attribute survives that. Turns the user
+       * starts after rewinding are not in the set, so they stay visible.
+       */
       const applyHiding = () => {
         if (state.disposed) return;
         const rows = document.querySelectorAll('[data-chat-turn]');
         for (const row of rows) {
           const turn = Number(row.getAttribute('data-chat-turn'));
           if (!Number.isInteger(turn)) continue;
-          const shouldHide = state.cutTurn !== null && turn >= state.cutTurn;
-          const already = state.hiddenRows.get(row);
-          if (shouldHide && already === undefined) {
-            state.hiddenRows.set(row, row.style.display);
-            row.style.display = 'none';
-          } else if (!shouldHide && already !== undefined) {
-            row.style.display = already;
-            state.hiddenRows.delete(row);
+          if (state.hiddenTurns.has(turn)) {
+            if (!row.hasAttribute(HIDDEN_ATTR)) row.setAttribute(HIDDEN_ATTR, 'true');
+          } else if (row.hasAttribute(HIDDEN_ATTR)) {
+            row.removeAttribute(HIDDEN_ATTR);
           }
         }
       };
 
+      const revealAll = () => {
+        state.hiddenTurns.clear();
+        for (const row of document.querySelectorAll(`[${HIDDEN_ATTR}]`)) row.removeAttribute(HIDDEN_ATTR);
+      };
+
       const closePopover = () => {
         if (state.popover !== null) {
           try {
@@ -937,12 +950,19 @@ loader.load({
         }
       };
 
-      const runRewind = async (seq, restoreFiles, notice) => {
+      const runRewind = async (seq, restoreFiles, notice, fromTurn = null) => {
         notice(tr('notice.working'));
         try {
           const result = await postJson(INPLACE_ROUTE, { sessionId, seq, restoreFiles });
           if (state.disposed) return;
           if (Number.isInteger(result.hiddenFromTurn)) state.cutTurn = result.hiddenFromTurn;
+          if (Array.isArray(result.hiddenTurns) && result.hiddenTurns.length > 0) {
+            for (const turn of result.hiddenTurns) {
+              if (Number.isInteger(turn)) state.hiddenTurns.add(turn);
+            }
+          } else if (Number.isInteger(result.hiddenFromTurn)) {
+            state.hiddenTurns = new Set([result.hiddenFromTurn]);
+          }
           applyHiding();
           const filled = setComposer(typeof result.prompt === 'string' ? result.prompt : '');
           sendDiagnose(sessionId, {
@@ -953,7 +973,7 @@ loader.load({
             promptChars: typeof result.prompt === 'string' ? result.prompt.length : 0,
             restore: result.restore ?? null,
             injected: state.buttons.size,
-            hiddenRows: state.hiddenRows.size,
+            hiddenRows: state.hiddenTurns.size,
           });
           const restore = result.restore;
           const parts = [];
@@ -963,11 +983,24 @@ loader.load({
           }
           notice(parts.length === 0 ? tr('notice.rewound') : `${tr('notice.rewound')} · ${parts.join(' · ')}`);
         } catch (error) {
+          const code = error !== null && typeof error === 'object' ? error.code ?? null : null;
           sendDiagnose(sessionId, {
             reason: 'rewind-failed',
             error: String(error && error.message ? error.message : error),
+            code,
             sequence: seq,
           });
+          if (code === 'not-on-surface') {
+            // Already withdrawn by an earlier rewind: hide the row and say so,
+            // instead of reporting a failure the user cannot act on.
+            const turn = Number.isInteger(fromTurn) ? fromTurn : null;
+            if (Number.isInteger(turn)) {
+              state.hiddenTurns.add(turn);
+              applyHiding();
+            }
+            notice(tr('notice.already'));
+            return;
+          }
           notice(error instanceof Error && error.message !== '' ? error.message : tr('notice.failed'));
         }
       };
@@ -1020,11 +1053,11 @@ loader.load({
         };
         popover.appendChild(makeButton(tr('popover.chat'), () => {
           closePopover();
-          void runRewind(seq, false, notice);
+          void runRewind(seq, false, notice, turn);
         }));
         popover.appendChild(makeButton(tr('popover.both'), () => {
           closePopover();
-          void runRewind(seq, true, notice);
+          void runRewind(seq, true, notice, turn);
         }));
         document.body.appendChild(popover);
         state.popover = popover;
@@ -1152,6 +1185,7 @@ loader.load({
           button.addEventListener('click', (event) => {
             event.preventDefault();
             event.stopPropagation();
+            sendDiagnose(sessionId, { reason: 'click', turn, seq, buttons: state.buttons.size, mapped: state.turnToSeq.size });
             openPopover(button, seq, notice);
           });
           anchor.appendChild(button);
@@ -1219,7 +1253,11 @@ loader.load({
         try {
           const value = await postJson(CUTS_ROUTE, { sessionId });
           if (state.disposed) return;
-          state.cutTurn = Number.isInteger(value.hiddenFromTurn) ? value.hiddenFromTurn : null;
+          if (Array.isArray(value.hiddenTurns)) {
+            state.hiddenTurns = new Set(value.hiddenTurns.filter((turn) => Number.isInteger(turn)));
+          } else if (Number.isInteger(value.hiddenFromTurn)) {
+            state.hiddenTurns = new Set([value.hiddenFromTurn]);
+          }
           applyHiding();
         } catch {
           /* ignore */

package/locale/en.json

@@ -2,5 +2,6 @@
   "meta": {
     "title": "Session Rewind",
     "description": "Adds a rewind control to every finished Turn plus one entry in the session header. Pick a Turn to branch the conversation there into a new session, put that Turn's original prompt back in the composer so you can edit and resend it, and restore the workspace files that Turn changed to their pre-Turn content."
-  }
+  },
+  "notice.already": "That message was already rewound; its row is now hidden."
 }

package/locale/zh.json

@@ -2,5 +2,6 @@
   "meta": {
     "title": "会话回退",
     "description": "在每个已完成的回合旁加一个回退按钮，并在会话标题栏提供总入口：选中某个回合即可把对话从该回合处分叉成新会话，把该回合原本的输入放回输入框以便修改后重发，同时把该回合改动过的工作区文件恢复到修改前的内容。"
-  }
+  },
+  "notice.already": "这条消息已经回退过了，已从界面隐藏。"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-rewind",
-  "version": "1.2.8",
+  "version": "1.3.1",
   "type": "module",
   "description": "Rewind a finished Turn: branch the conversation at any Turn (session header or per-Turn control) and restore every workspace file that Turn changed. · 回合回退：从任意已完成的回合重新开始，并把该回合改动过的工作区文件恢复原状。",
   "icon": "./icon.svg",

package/src/lib/inplace.js

@@ -10,7 +10,7 @@
 
 import { randomUUID } from 'node:crypto';
 
-import { hiddenFromSeq, markerPayload, planInPlace, textOf } from './surface.js';
+import { hiddenFromSeq, markerPayload, planInPlace, textOf, withdrawnTurns } from './surface.js';
 
 /** Waiting budget for a cancelled Turn to reach quiescence. */
 const IDLE_TIMEOUT_MS = 20_000;
@@ -128,7 +128,14 @@ export function describeInPlace(session, seq) {
  *   hiddenFromSeq: number | null, restore?: object,
  * }>}
  */
-export async function executeInPlace({ ctx, sessionId, seq, restoreTurns, timeoutMs = IDLE_TIMEOUT_MS }) {
+export async function executeInPlace({
+  ctx,
+  sessionId,
+  seq,
+  restoreTurns,
+  readEvents,
+  timeoutMs = IDLE_TIMEOUT_MS,
+}) {
   const agent = liveAgentOf(ctx, sessionId);
   if (agent === undefined) {
     const error = new Error('this session is not live, so it cannot be rewound in place');
@@ -192,12 +199,21 @@ export async function executeInPlace({ ctx, sessionId, seq, restoreTurns, timeou
     hidden = plan.surfaceStart;
   }
 
+  let hiddenTurns = [];
+  try {
+    const after = typeof readEvents === 'function' ? await readEvents(sessionId) : [];
+    hiddenTurns = [...withdrawnTurns(after)];
+  } catch {
+    /* the cut still applied; the client falls back to hiding from plan.turn */
+  }
+
   return {
     markerSeq: typeof event?.seq === 'number' ? event.seq : -1,
     targetSeq: plan.targetSeq,
     prompt: plan.prompt,
     turn: plan.turn,
     hiddenFromSeq: hidden,
+    hiddenTurns,
     ...(restore === undefined ? {} : { restore }),
   };
 }

package/src/lib/route.js

@@ -21,6 +21,8 @@ export const CANDIDATES_PATH = '/api/session-rewind.candidates';
 export const INPLACE_PATH = '/api/session-rewind.inplace';
 export const CUTS_PATH = '/api/session-rewind.cuts';
 export const DIAGNOSE_PATH = '/api/session-rewind.diagnose';
+export const TAIL_PATH = '/api/session-rewind.tail';
+export const SURFACE_PATH = '/api/session-rewind.surface';
 export const SELFCHECK_PATH = '/api/session-rewind.selfcheck';
 
 /** A rewind request is a session id plus a Turn number or a seq. */
@@ -198,6 +200,129 @@ function targetOf(value) {
   return { sessionId, turn, seq };
 }
 
+/**
+ * Build the surface route.
+ *
+ * `planInPlace` refuses a rewind when the target Seq is not a node of the live
+ * Session's surface, so when a click is refused the only useful question is what
+ * that surface actually contains. This exposes it read-only.
+ *
+ * @param {{
+ *   surfaceOf: (sessionId: string) => { nodes?: readonly unknown[]; replaceGeneration?: number; contentGeneration?: number } | null,
+ *   trustedHosts?: () => readonly string[],
+ *   onError?: (error: unknown) => void,
+ * }} options
+ * @returns {(request: import('node:http').IncomingMessage, response: import('node:http').ServerResponse) => Promise<void>}
+ */
+export function createSurfaceHandler({ surfaceOf, trustedHosts = () => [], onError = () => {} }) {
+  return async (request, response) => {
+    try {
+      if (request.method !== 'POST') {
+        writeText(response, 405, 'method not allowed');
+        return;
+      }
+      if (!isTrustedRequest(request, hostsOf(trustedHosts))) {
+        writeText(response, 403, 'forbidden');
+        return;
+      }
+      const mediaType = header(request.headers, 'content-type')?.split(';', 1)[0]?.trim().toLowerCase();
+      if (mediaType !== 'application/json') {
+        writeText(response, 415, 'content type must be application/json');
+        return;
+      }
+      const value = await readJsonBody(request);
+      if (!isRecord(value)) throw new RequestBoundaryError(400, 'request body must be a JSON object');
+      const sessionId = typeof value.sessionId === 'string' ? value.sessionId : '';
+      if (sessionId === '') throw new RequestBoundaryError(400, 'sessionId is required');
+      const live = surfaceOf(sessionId);
+      if (live === null) throw new RequestBoundaryError(409, 'this session is not open right now');
+      const nodes = Array.isArray(live.nodes) ? live.nodes.map((node) => (typeof node === 'number' ? node : null)) : [];
+      const tail = Number.isInteger(value.tail) && value.tail > 0 && value.tail <= 200 ? value.tail : 20;
+      writeJson(response, 200, {
+        ok: true,
+        count: nodes.length,
+        replaceGeneration: live.replaceGeneration ?? null,
+        contentGeneration: live.contentGeneration ?? null,
+        head: nodes.slice(0, 10),
+        tail: nodes.slice(-tail),
+      });
+    } catch (error) {
+      fail(response, error, onError);
+    }
+  };
+}
+
+/**
+ * Build the event-tail route.
+ *
+ * Returns the last N events of a Session in reading order with just enough shape
+ * to reason about a rewind: seq, type, source kind and a short text sample. It is
+ * the only way to see whether a marker actually landed, because the on-disk log is
+ * compressed and may lag behind the live surface.
+ *
+ * @param {{
+ *   events: (sessionId: string) => Promise<readonly unknown[]>,
+ *   trustedHosts?: () => readonly string[],
+ *   onError?: (error: unknown) => void,
+ * }} options
+ * @returns {(request: import('node:http').IncomingMessage, response: import('node:http').ServerResponse) => Promise<void>}
+ */
+export function createTailHandler({ events, trustedHosts = () => [], onError = () => {} }) {
+  return async (request, response) => {
+    try {
+      if (request.method !== 'POST') {
+        writeText(response, 405, 'method not allowed');
+        return;
+      }
+      if (!isTrustedRequest(request, hostsOf(trustedHosts))) {
+        writeText(response, 403, 'forbidden');
+        return;
+      }
+      const mediaType = header(request.headers, 'content-type')?.split(';', 1)[0]?.trim().toLowerCase();
+      if (mediaType !== 'application/json') {
+        writeText(response, 415, 'content type must be application/json');
+        return;
+      }
+      const value = await readJsonBody(request);
+      if (!isRecord(value)) throw new RequestBoundaryError(400, 'request body must be a JSON object');
+      const sessionId = typeof value.sessionId === 'string' ? value.sessionId : '';
+      if (sessionId === '') throw new RequestBoundaryError(400, 'sessionId is required');
+      const limit = Number.isInteger(value.limit) && value.limit > 0 && value.limit <= 300 ? value.limit : 40;
+      const all = await events(sessionId);
+      const slice = all.slice(-limit);
+      writeJson(response, 200, {
+        ok: true,
+        total: all.length,
+        events: slice.map((event) => summarizeEvent(event)),
+      });
+    } catch (error) {
+      fail(response, error, onError);
+    }
+  };
+}
+
+/**
+ * Reduce one Session event to the fields worth inspecting.
+ *
+ * @param {unknown} event
+ * @returns {{ seq: number | null, type: string, sourceKind: string | null, role: string | null, text: string | null }}
+ */
+function summarizeEvent(event) {
+  const record = isRecord(event) ? event : {};
+  const data = isRecord(record.data) ? record.data : {};
+  const source = isRecord(data.source) ? data.source : {};
+  const content = Array.isArray(data.content) ? data.content : [];
+  const first = content.find((part) => isRecord(part) && part.type === 'text');
+  const text = isRecord(first) && typeof first.text === 'string' ? first.text.slice(0, 60) : null;
+  return {
+    seq: Number.isInteger(record.seq) ? record.seq : null,
+    type: typeof record.type === 'string' ? record.type : '(none)',
+    sourceKind: typeof source.kind === 'string' ? source.kind : null,
+    role: typeof data.role === 'string' ? data.role : null,
+    text,
+  };
+}
+
 /**
  * Build the browser-diagnostics route.
  *

package/src/lib/surface.js

@@ -169,6 +169,45 @@ export function hiddenFromTurn(events) {
   return Number.isInteger(turn) ? turn : null;
 }
 
+/**
+ * Turns whose rows belong to a withdrawn stretch of the log.
+ *
+ * A Session can be rewound more than once, and each rewind appends its own
+ * marker, so the withdrawn turns are the union over every marker of the turns
+ * spanned by `[surfaceOp.startSeq, markerSeq)`. Taking only the earliest marker —
+ * as the first version did — leaves the turns withdrawn later still on screen.
+ *
+ * @param {readonly unknown[]} events
+ * @returns {readonly number[]}
+ */
+export function withdrawnTurns(events) {
+  const spans = [];
+  for (const event of events) {
+    if (!isRecord(event) || event.type !== 'user/message') continue;
+    if (event.data?.source?.kind !== MARKER_SOURCE_KIND) continue;
+    if (typeof event.seq !== 'number') continue;
+    const op = event.surfaceOp;
+    if (!isRecord(op) || op.op !== 'replace' || typeof op.startSeq !== 'number') continue;
+    spans.push({ from: op.startSeq, before: event.seq });
+  }
+  if (spans.length === 0) return [];
+  const turns = new Set();
+  let current = null;
+  for (const event of events) {
+    if (!isRecord(event) || typeof event.seq !== 'number') continue;
+    const turn = event.data?.turn;
+    if (Number.isInteger(turn) && (event.type === 'turn/start' || event.type === 'turn/end')) current = turn;
+    if (!Number.isInteger(current)) continue;
+    for (const span of spans) {
+      if (event.seq >= span.from && event.seq < span.before) {
+        turns.add(current);
+        break;
+      }
+    }
+  }
+  return [...turns].sort((left, right) => left - right);
+}
+
 /**
  * Build the marker event payload. `id` is minted here because the Host's own
  * `createUserMessage` helper is not importable from a profile bundle.

package/src/plugin.js

@@ -29,6 +29,8 @@ import {
   CUTS_PATH,
   DIAGNOSE_PATH,
   INPLACE_PATH,
+  SURFACE_PATH,
+  TAIL_PATH,
   PLAN_PATH,
   RESTORE_PATH,
   SELFCHECK_PATH,
@@ -36,12 +38,14 @@ import {
   createCutsHandler,
   createDiagnoseHandler,
   createInplaceHandler,
+  createSurfaceHandler,
+  createTailHandler,
   createPlanHandler,
   createRestoreHandler,
   createSelfcheckHandler,
 } from './lib/route.js';
 import { describeInPlace, executeInPlace, liveAgentOf } from './lib/inplace.js';
-import { hiddenFromSeq, hiddenFromTurn } from './lib/surface.js';
+import { hiddenFromSeq, hiddenFromTurn, withdrawnTurns } from './lib/surface.js';
 
 export const name = 'session-rewind';
 
@@ -473,12 +477,17 @@ export function apply(ctx) {
         restoreTurns: restoreFiles === true
           ? async (fromTurn) => restoreTurns(sessionId, fromTurn)
           : undefined,
+        readEvents: (id) => readEvents(ctx, id),
       });
 
       const cutsOf = async (sessionId) => {
         // Read the durable log: the client needs the cut after a page reload too.
         const events = await readEvents(ctx, sessionId);
-        return { hiddenFromSeq: hiddenFromSeq(events), hiddenFromTurn: hiddenFromTurn(events) };
+        return {
+          hiddenFromSeq: hiddenFromSeq(events),
+          hiddenFromTurn: hiddenFromTurn(events),
+          hiddenTurns: withdrawnTurns(events),
+        };
       };
 
       /**
@@ -588,7 +597,7 @@ export function apply(ctx) {
             plugin: 'dsh-session-rewind',
             archive: { directory: archive.directory, ...archiveStats },
             client: { discovered: clientPath !== null, path: clientPath },
-            routes: [SELFCHECK_PATH, DIAGNOSE_PATH, CANDIDATES_PATH, INPLACE_PATH, CUTS_PATH, PLAN_PATH, RESTORE_PATH],
+            routes: [SELFCHECK_PATH, DIAGNOSE_PATH, TAIL_PATH, SURFACE_PATH, CANDIDATES_PATH, INPLACE_PATH, CUTS_PATH, PLAN_PATH, RESTORE_PATH],
           };
         },
         trustedHosts,
@@ -622,6 +631,18 @@ export function apply(ctx) {
         onError,
       });
 
+      const surfaceHandler = createSurfaceHandler({
+        surfaceOf: (sessionId) => liveAgentOf(ctx, sessionId)?.session?.surface ?? null,
+        trustedHosts,
+        onError,
+      });
+
+      const tailHandler = createTailHandler({
+        events: async (sessionId) => readEvents(ctx, sessionId),
+        trustedHosts,
+        onError,
+      });
+
       const cutsHandler = createCutsHandler({
         cutsOf,
         trustedHosts,
@@ -637,6 +658,14 @@ export function apply(ctx) {
           () => scope.webServer.register({ kind: 'exact', path: SELFCHECK_PATH, handler: statusHandler }),
           'session-rewind: selfcheck route',
         );
+        scope.effect(
+          () => scope.webServer.register({ kind: 'exact', path: SURFACE_PATH, handler: surfaceHandler }),
+          'session-rewind: surface route',
+        );
+        scope.effect(
+          () => scope.webServer.register({ kind: 'exact', path: TAIL_PATH, handler: tailHandler }),
+          'session-rewind: tail route',
+        );
         scope.effect(
           () => scope.webServer.register({ kind: 'exact', path: CANDIDATES_PATH, handler: candidatesHandler }),
           'session-rewind: candidates route',

package/test/find-markers.mjs

@@ -0,0 +1,42 @@
+// Search decompressed session logs for a needle and print the sessions + events.
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { zstdDecompressSync } from 'node:zlib';
+
+const NEEDLE = process.argv[2] ?? 'session-rewind';
+const ROOT = 'C:/Users/23107/.dsh/sessions';
+
+const hits = [];
+for (const workspace of readdirSync(ROOT)) {
+  const workspaceDir = join(ROOT, workspace);
+  if (!statSync(workspaceDir).isDirectory()) continue;
+  for (const session of readdirSync(workspaceDir)) {
+    const sessionDir = join(workspaceDir, session);
+    if (!statSync(sessionDir).isDirectory()) continue;
+    const file = join(sessionDir, 'session.v4.jsonl.zstd');
+    let text;
+    try {
+      text = zstdDecompressSync(readFileSync(file)).toString('utf8');
+    } catch {
+      continue;
+    }
+    if (!text.includes(NEEDLE)) continue;
+    const lines = text.split('\n').filter((line) => line !== '');
+    const marked = lines.filter((line) => line.includes(NEEDLE));
+    hits.push({
+      session,
+      modified: statSync(file).mtime.toISOString(),
+      events: lines.length,
+      marked: marked.length,
+      samples: marked.slice(-2).map((line) => line.slice(0, 260)),
+    });
+  }
+}
+
+hits.sort((a, b) => (a.modified < b.modified ? 1 : -1));
+console.log(`sessions containing ${JSON.stringify(NEEDLE)}: ${hits.length}`);
+for (const hit of hits.slice(0, 6)) {
+  console.log(`\n=== ${hit.session}`);
+  console.log(`modified: ${hit.modified}  events: ${hit.events}  marked: ${hit.marked}`);
+  for (const sample of hit.samples) console.log(`  ${sample}`);
+}

package/test/selftest.mjs

@@ -20,6 +20,7 @@ import {
   listCandidates,
   markerPayload,
   planInPlace,
+  withdrawnTurns,
 } from '../src/lib/surface.js';
 
 const events = [
@@ -95,6 +96,45 @@ assert.equal(payload.content[0].text, MARKER_TEXT);
 assert.notEqual(payload.content[0].text, '');
 assert.deepEqual(payload.source, { kind: MARKER_SOURCE_KIND });
 
+// --- withdrawn turns ------------------------------------------------------
+// A rewind at seq 7 withdraws turns 1-2 up to the marker; turn 3 starts after it
+// and must stay visible.
+{
+  const rewound = [
+    { seq: 0, type: 'session', data: {} },
+    { seq: 1, type: 'turn/start', data: { turn: 1 } },
+    { seq: 2, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'one' }] } },
+    { seq: 5, type: 'turn/end', data: { turn: 1 } },
+    { seq: 6, type: 'turn/start', data: { turn: 2 } },
+    { seq: 7, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'two' }] } },
+    { seq: 9, type: 'turn/end', data: { turn: 2 } },
+    { seq: 10, type: 'user/message', data: { source: { kind: MARKER_SOURCE_KIND } }, surfaceOp: { op: 'replace', startSeq: 7, endSeq: 9 } },
+    { seq: 11, type: 'turn/start', data: { turn: 3 } },
+    { seq: 12, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'three' }] } },
+  ];
+  assert.deepEqual(withdrawnTurns(rewound), [2]);
+  assert.deepEqual(withdrawnTurns(events), []);
+}
+
+// --- two rewinds in one Session -------------------------------------------
+// Each marker withdraws its own span; the union is what must disappear. Missing
+// the second marker is what left the later turns on screen.
+{
+  const twice = [
+    { seq: 1, type: 'turn/start', data: { turn: 1 } },
+    { seq: 2, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'one' }] } },
+    { seq: 5, type: 'turn/end', data: { turn: 1 } },
+    { seq: 6, type: 'user/message', data: { source: { kind: MARKER_SOURCE_KIND } }, surfaceOp: { op: 'replace', startSeq: 2, endSeq: 5 } },
+    { seq: 7, type: 'turn/start', data: { turn: 2 } },
+    { seq: 8, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'two' }] } },
+    { seq: 11, type: 'turn/end', data: { turn: 2 } },
+    { seq: 12, type: 'user/message', data: { source: { kind: MARKER_SOURCE_KIND } }, surfaceOp: { op: 'replace', startSeq: 8, endSeq: 11 } },
+    { seq: 13, type: 'turn/start', data: { turn: 3 } },
+    { seq: 14, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'three' }] } },
+  ];
+  assert.deepEqual(withdrawnTurns(twice), [1, 2]);
+}
+
 // --- archive -------------------------------------------------------------
 const root = await mkdtemp(join(tmpdir(), 'rewind-test-'));
 const archiveDir = join(root, 'archive');