dsh-rewind-plugin 0.7.5 → 0.9.0-alpha.1

package/lib/index.js

@@ -1,7 +1,6 @@
 // src/index.ts
-import { createAssistantMessage } from "@deepseek-ai/dsh-llm";
-import { unlink as unlink2 } from "node:fs/promises";
-import * as dshSettings from "@deepseek-ai/dsh-settings";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { unlink as unlink3 } from "node:fs/promises";
 import "@deepseek-ai/schemastery";
 
 // src/locales.ts
@@ -51,7 +50,26 @@ var en = {
   "cleanup.clearActive": "Could not clear session {sessionId}: the session is still running and could not be stopped. Try again once it is idle.",
   "cleanup.clearCancelled": "Clear cancelled.",
   "cleanup.clearFailed": "Could not clear session {sessionId}: {detail}.",
-  "cleanup.usage": "Usage:\n  /snapshot-auto-cleanup                 show status\n  /snapshot-auto-cleanup on|off          enable/disable auto-cleanup\n  /snapshot-auto-cleanup max-age <days>  set the idle cutoff\n  /snapshot-auto-cleanup run [--apply]   dry-run, or execute with --apply\n  /snapshot-auto-cleanup run --current [--apply]   dry-run/clear this session's snapshots"
+  "cleanup.usage": "Usage:\n  /snapshot-auto-cleanup                 show status\n  /snapshot-auto-cleanup on|off          enable/disable auto-cleanup\n  /snapshot-auto-cleanup max-age <days>  set the idle cutoff\n  /snapshot-auto-cleanup run [--apply]   dry-run, or execute with --apply\n  /snapshot-auto-cleanup run --current [--apply]   dry-run/clear this session's snapshots",
+  "rewindfix.description": "Update legacy rewind markers (A/B) in closed sessions to the current form-C shape",
+  "rewindfix.inputHint": "no args = dry-run preview; --apply = execute (takes minutes)",
+  "rewindfix.dryRun": "=== dry-run: {scan} sessions scanned / {will} will be updated / {skip} skipped / {fail} failed ({secs}s) ===",
+  "rewindfix.done": "=== done: {repair} updated / {skip} skipped / {fail} failed ({secs}s) ===",
+  "rewindfix.cancelled": "=== cancelled ===",
+  "rewindfix.launcherGuard": "! This session itself needs updating; it is open and cannot be modified in place. Start a NEW session (or close it) \u2014 a closed session is updated when no window holds it.",
+  "rewindfix.counts": "A={a} B={b} \u2192 C={c}",
+  "rewindfix.writeOk": "\u21B3 snapCleared \u2713 written \u2713",
+  "rewindfix.skip.loaded": "SKIP (loaded)",
+  "rewindfix.skip.noMarkers": "SKIP (no markers)",
+  "rewindfix.skip.noArtifact": "SKIP (no artifact)",
+  "rewindfix.skip.loadedNow": "SKIP (loaded now)",
+  "rewindfix.fail.unreadable": "FAIL (unreadable) {error}",
+  "rewindfix.fail.repair": "FAIL (update) {error}",
+  "rewindfix.fail.locked": "FAIL (locked) {error}",
+  "rewindfix.fail.generic": "FAIL: {error}",
+  "rewindfix.persistenceUnavailable": "Session persistence is unavailable; cannot run the rewind-fix command.",
+  "rewindfix.sessionStoreUnavailable": "The session store is unavailable; cannot run the rewind-fix command.",
+  "rewindfix.locked": "locked by another process"
 };
 var zh = {
   "usage.title": "\u7528\u6CD5\uFF1A",
@@ -99,7 +117,26 @@ var zh = {
   "cleanup.clearActive": "\u65E0\u6CD5\u6E05\u9664\u4F1A\u8BDD {sessionId}\uFF1A\u4F1A\u8BDD\u4ECD\u5728\u8FD0\u884C\u4E14\u672A\u80FD\u505C\u6B62\uFF0C\u8BF7\u5F85\u5176\u7A7A\u95F2\u540E\u91CD\u8BD5\u3002",
   "cleanup.clearCancelled": "\u6E05\u7A7A\u5DF2\u53D6\u6D88\u3002",
   "cleanup.clearFailed": "\u65E0\u6CD5\u6E05\u9664\u4F1A\u8BDD {sessionId}\uFF1A{detail}\u3002",
-  "cleanup.usage": "\u7528\u6CD5\uFF1A\n  /snapshot-auto-cleanup                 \u67E5\u770B\u72B6\u6001\n  /snapshot-auto-cleanup on|off          \u5F00\u542F/\u5173\u95ED\u81EA\u52A8\u6E05\u7406\n  /snapshot-auto-cleanup max-age <\u5929\u6570>  \u8BBE\u7F6E\u5931\u6D3B\u9608\u503C\uFF08\u5929\uFF09\n  /snapshot-auto-cleanup run [--apply]   \u9884\u6F14\uFF0C\u6216\u52A0 --apply \u6267\u884C\n  /snapshot-auto-cleanup run --current [--apply]  \u9884\u6F14/\u6E05\u9664\u672C\u4F1A\u8BDD\u5FEB\u7167"
+  "cleanup.usage": "\u7528\u6CD5\uFF1A\n  /snapshot-auto-cleanup                 \u67E5\u770B\u72B6\u6001\n  /snapshot-auto-cleanup on|off          \u5F00\u542F/\u5173\u95ED\u81EA\u52A8\u6E05\u7406\n  /snapshot-auto-cleanup max-age <\u5929\u6570>  \u8BBE\u7F6E\u5931\u6D3B\u9608\u503C\uFF08\u5929\uFF09\n  /snapshot-auto-cleanup run [--apply]   \u9884\u6F14\uFF0C\u6216\u52A0 --apply \u6267\u884C\n  /snapshot-auto-cleanup run --current [--apply]  \u9884\u6F14/\u6E05\u9664\u672C\u4F1A\u8BDD\u5FEB\u7167",
+  "rewindfix.description": "\u5C06\u5DF2\u5173\u95ED\u4F1A\u8BDD\u4E2D\u7684\u65E7\u7248 rewind \u6807\u8BB0\uFF08A/B\uFF09\u66F4\u65B0\u4E3A\u5F53\u524D form-C \u5F62\u6001",
+  "rewindfix.inputHint": "\u65E0\u53C2 = dry-run \u9884\u89C8\uFF1B--apply = \u6267\u884C\uFF08\u9700\u6570\u5206\u949F\uFF09",
+  "rewindfix.dryRun": "=== \u9884\u6F14\uFF1A\u626B\u63CF {scan} \u4E2A\u4F1A\u8BDD / \u5C06\u66F4\u65B0 {will} \u4E2A / \u8DF3\u8FC7 {skip} \u4E2A / \u5931\u8D25 {fail} \u4E2A\uFF08{secs}s\uFF09===",
+  "rewindfix.done": "=== \u5B8C\u6210\uFF1A\u66F4\u65B0 {repair} \u4E2A / \u8DF3\u8FC7 {skip} \u4E2A / \u5931\u8D25 {fail} \u4E2A\uFF08{secs}s\uFF09===",
+  "rewindfix.cancelled": "=== \u5DF2\u53D6\u6D88 ===",
+  "rewindfix.launcherGuard": "! \u4F60\u6B63\u5728\u4E00\u4E2A\u672C\u8EAB\u9700\u8981\u66F4\u65B0\u7684\u4F1A\u8BDD\u91CC\u8FD0\u884C\uFF1B\u5B83\u5904\u4E8E\u6253\u5F00\u72B6\u6001\uFF0C\u65E0\u6CD5\u539F\u5730\u4FEE\u6539\u3002\u8BF7\u65B0\u5EFA\u4E00\u4E2A\u4F1A\u8BDD\uFF08\u6216\u5173\u95ED\u5B83\uFF09\u2014\u2014\u5173\u95ED\u7684\u4F1A\u8BDD\u4F1A\u5728\u6CA1\u6709\u7A97\u53E3\u6301\u6709\u5B83\u65F6\u88AB\u66F4\u65B0\u3002",
+  "rewindfix.counts": "A={a} B={b} \u2192 C={c}",
+  "rewindfix.writeOk": "\u21B3 \u5FEB\u7167\u5DF2\u6E05 \u2713 \u5DF2\u5199\u56DE \u2713",
+  "rewindfix.skip.loaded": "\u8DF3\u8FC7\uFF08\u5DF2\u52A0\u8F7D\uFF09",
+  "rewindfix.skip.noMarkers": "\u8DF3\u8FC7\uFF08\u65E0\u6807\u8BB0\uFF09",
+  "rewindfix.skip.noArtifact": "\u8DF3\u8FC7\uFF08\u65E0\u4EA7\u7269\uFF09",
+  "rewindfix.skip.loadedNow": "\u8DF3\u8FC7\uFF08\u73B0\u5DF2\u52A0\u8F7D\uFF09",
+  "rewindfix.fail.unreadable": "\u5931\u8D25\uFF08\u65E0\u6CD5\u8BFB\u53D6\uFF09{error}",
+  "rewindfix.fail.repair": "\u5931\u8D25\uFF08\u66F4\u65B0\uFF09{error}",
+  "rewindfix.fail.locked": "\u5931\u8D25\uFF08\u88AB\u9501\u5B9A\uFF09{error}",
+  "rewindfix.fail.generic": "\u5931\u8D25\uFF1A{error}",
+  "rewindfix.persistenceUnavailable": "\u4F1A\u8BDD\u6301\u4E45\u5C42\u4E0D\u53EF\u7528\uFF0C\u65E0\u6CD5\u6267\u884C rewind-fix \u547D\u4EE4\u3002",
+  "rewindfix.sessionStoreUnavailable": "\u4F1A\u8BDD\u5B58\u50A8\u4E0D\u53EF\u7528\uFF0C\u65E0\u6CD5\u6267\u884C rewind-fix \u547D\u4EE4\u3002",
+  "rewindfix.locked": "\u5DF2\u88AB\u53E6\u4E00\u8FDB\u7A0B\u9501\u5B9A"
 };
 var HOST_DICTS = { en, zh };
 function translate(lang, key, params = {}) {
@@ -111,20 +148,6 @@ function translate(lang, key, params = {}) {
   return text;
 }
 
-// src/session-events.ts
-function eventsOf(session) {
-  const s = session;
-  if (s.snapshotEvents !== void 0) return s.snapshotEvents();
-  if (s.events !== void 0) return s.events;
-  return [];
-}
-
-// src/settings-locale.ts
-function readSettingsSection(provider, ns, brand) {
-  const key = brand?.(ns) ?? ns;
-  return provider.get(key);
-}
-
 // src/rewind.ts
 var RewindError = class extends Error {
   constructor(code, message) {
@@ -136,24 +159,6 @@ var RewindError = class extends Error {
 };
 var CANDIDATE_PREVIEW_CHARS = 80;
 var DEFAULT_CANDIDATE_LIMIT = 100;
-function markerTurnOf(events) {
-  let lastStarted = 0;
-  for (const event of events) {
-    if (event.type === "turn/start" && event.data.turn > lastStarted) {
-      lastStarted = event.data.turn;
-    }
-  }
-  return lastStarted;
-}
-function markerStepOf(events, turn) {
-  let lastStarted = 0;
-  for (const event of events) {
-    if (event.type === "step/start" && event.data.turn === turn && event.data.step > lastStarted) {
-      lastStarted = event.data.step;
-    }
-  }
-  return lastStarted + 1;
-}
 function isUserMessageEvent(event) {
   return event.type === "user/message";
 }
@@ -1335,8 +1340,467 @@ async function reconcileTracked(store, sessionId, anchorSeq, tracked, probe = de
   return recorded;
 }
 
+// src/rewind-marker-repair.ts
+var REWIND_MARKER_SOURCE = { kind: "plugin", plugin: "dsh-rewind" };
+var REWIND_MARKER_CONTENT = [];
+function buildRewindMarkerData(id) {
+  return {
+    role: "user",
+    content: REWIND_MARKER_CONTENT,
+    source: { ...REWIND_MARKER_SOURCE },
+    ...id !== void 0 ? { id } : {}
+  };
+}
+function isReplaceSurfaceOp(value) {
+  return typeof value === "object" && value !== null && value.op === "replace" && typeof value.start === "number" && typeof value.end === "number";
+}
+function isLegacyRewindMarker(event) {
+  return isLegacyRewindMarkerRow(asRow(event));
+}
+function repairRewindMarkers(input) {
+  const rows = input.map(toRow);
+  const stats = { a: 0, b: 0, c: 0, removedGhosts: 0 };
+  for (const row of rows) {
+    if (isFormCMarkerRow(row)) stats.c += 1;
+  }
+  const removed = /* @__PURE__ */ new Set();
+  for (let i = 0; i < rows.length; i += 1) {
+    const row = rows[i];
+    if (!isLegacyRewindMarkerRow(row)) continue;
+    const prev = rows[i - 1];
+    const next = rows[i + 1];
+    const hasBefore = prev !== void 0 && prev.type === "step/start";
+    const hasAfter = next !== void 0 && next.type === "step/end";
+    if (hasBefore && hasAfter) {
+      removed.add(i - 1);
+      removed.add(i + 1);
+      stats.b += 1;
+      stats.removedGhosts += 2;
+    } else {
+      stats.a += 1;
+    }
+  }
+  const survivors = [];
+  const oldToNew = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rows.length; i += 1) {
+    if (removed.has(i)) continue;
+    const original = rows[i];
+    const newSeq = survivors.length;
+    oldToNew.set(original.seq, newSeq);
+    survivors.push(isLegacyRewindMarkerRow(original) ? toEvent(retargetToC(original, newSeq)) : toEvent({ ...original, seq: newSeq }));
+  }
+  const mapSeq = (old) => {
+    const mapped = oldToNew.get(old);
+    if (mapped === void 0) {
+      throw new Error(`rewind-fix: reference targets consumed seq ${old} (not a surviving event)`);
+    }
+    return mapped;
+  };
+  const events = survivors.map((event) => toEvent(remapReferences(toRow(event), mapSeq)));
+  return { events, mapSeq: oldToNew, stats };
+}
+function isLegacyRewindMarkerRow(row) {
+  if (row.type !== "assistant/message") return false;
+  const message = row.data["message"];
+  const source = message?.["source"];
+  if (source?.["kind"] !== "model") return false;
+  if (source?.["provider"] !== "dsh-rewind" || source?.["model"] !== "rewind-marker") return false;
+  return isReplaceSurfaceOp(row.surfaceOp);
+}
+function isFormCMarkerRow(row) {
+  if (row.type !== "user/message") return false;
+  const source = row.data["source"];
+  return source?.["kind"] === "plugin" && source?.["plugin"] === "dsh-rewind";
+}
+function asRow(event) {
+  const e = event;
+  return {
+    type: e.type,
+    seq: e.seq,
+    time: e.time,
+    data: { ...e.data },
+    ..."surfaceOp" in e ? { surfaceOp: e.surfaceOp } : {},
+    ...Array.isArray(e.sourceEventSeqs) ? { sourceEventSeqs: [...e.sourceEventSeqs] } : {},
+    ..."ignorable" in e ? { ignorable: e.ignorable } : {}
+  };
+}
+function toRow(event) {
+  return asRow(event);
+}
+function toEvent(row) {
+  const e = {
+    type: row.type,
+    seq: row.seq,
+    time: row.time,
+    data: row.data
+  };
+  if (row.surfaceOp !== void 0) e["surfaceOp"] = row.surfaceOp;
+  if (row.sourceEventSeqs !== void 0) e["sourceEventSeqs"] = row.sourceEventSeqs;
+  if (row.ignorable !== void 0) e["ignorable"] = row.ignorable;
+  return e;
+}
+function retargetToC(row, seq) {
+  const message = row.data["message"];
+  const id = typeof message?.["id"] === "string" ? message["id"] : void 0;
+  return {
+    type: "user/message",
+    seq,
+    time: row.time,
+    data: buildRewindMarkerData(id),
+    surfaceOp: row.surfaceOp,
+    sourceEventSeqs: row.sourceEventSeqs
+  };
+}
+function remapReferences(row, mapSeq) {
+  const map = (value) => mapSeq(value);
+  if (row.sourceEventSeqs !== void 0) {
+    row.sourceEventSeqs = row.sourceEventSeqs.map(map);
+  }
+  if (isReplaceSurfaceOp(row.surfaceOp)) {
+    row.surfaceOp = { op: "replace", start: map(row.surfaceOp.start), end: map(row.surfaceOp.end) };
+  }
+  const data = row.data;
+  const range = data["shadowedRange"];
+  if (range !== void 0 && typeof range === "object") {
+    data["shadowedRange"] = { start: map(range.start), end: map(range.end) };
+  }
+  for (const key of ["shadowedSeqs", "messageSeqs"]) {
+    const seqs = data[key];
+    if (Array.isArray(seqs)) data[key] = seqs.map(map);
+  }
+  const singleSeq = data["sourceEventSeq"];
+  if (typeof singleSeq === "number") data["sourceEventSeq"] = map(singleSeq);
+  return row;
+}
+
+// src/rewind-fix.ts
+import { copyFile, rename as rename2, unlink, writeFile as writeFile2, readFile as readFile2, open } from "node:fs/promises";
+import { isDeepStrictEqual } from "node:util";
+
+// src/session-log-io.ts
+import { constants, zstdCompress, zstdDecompress } from "node:zlib";
+import { promisify } from "node:util";
+import {
+  decodeSeqRanges,
+  decodeStorageRecord,
+  encodeSeqRanges,
+  packChunkRuns
+} from "@deepseek-ai/dsh-session";
+var zstdCompressAsync = promisify(zstdCompress);
+var zstdDecompressAsync = promisify(zstdDecompress);
+async function compressZstdFrame(input) {
+  return zstdCompressAsync(Buffer.from(input), { params: { [constants.ZSTD_c_checksumFlag]: 1 } });
+}
+function splitSession(plaintext) {
+  const nl = plaintext.indexOf("\n");
+  if (nl === -1) throw new Error("session plaintext has no header line");
+  return { headerLine: plaintext.slice(0, nl), body: plaintext.slice(nl + 1) };
+}
+function expandProvenanceFromStorage(parsed) {
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new TypeError("stored session records must be objects");
+  }
+  const record = parsed;
+  if (record.sourceEventSeqs === void 0) return parsed;
+  if (!Number.isSafeInteger(record.seq) || record.seq < 0) {
+    throw new TypeError("stored session event seq must be a non-negative safe integer");
+  }
+  return { ...record, sourceEventSeqs: decodeSeqRanges(record.sourceEventSeqs, record.seq) };
+}
+function decodeEventBody(body) {
+  const events = [];
+  for (const line of body.split("\n")) {
+    if (line.length === 0) continue;
+    const record = JSON.parse(line);
+    const expanded = expandProvenanceFromStorage(record);
+    events.push(...decodeStorageRecord(expanded));
+  }
+  return events;
+}
+function eventLines(events, packChunks) {
+  const records = packChunks ? packChunkRuns(events) : events;
+  return records.map((record) => {
+    const provenance = record.sourceEventSeqs;
+    if (provenance !== void 0) {
+      return JSON.stringify({ ...record, sourceEventSeqs: encodeSeqRanges(provenance) });
+    }
+    return JSON.stringify(record);
+  }).join("\n");
+}
+async function encodeSessionLog(headerLine, events, options = {}) {
+  const packChunks = options.packChunks ?? true;
+  const headerOut = headerLine + "\n";
+  const bodyOut = eventLines(events, packChunks) + "\n";
+  const [headerFrame, eventFrame] = await Promise.all([compressZstdFrame(headerOut), compressZstdFrame(bodyOut)]);
+  return Buffer.concat([headerFrame, eventFrame]);
+}
+
+// src/rewind-fix.ts
+function isApplyInput(raw) {
+  return raw.trim() === "--apply";
+}
+function registerRewindFix(ctx, store, render) {
+  let persistence;
+  ctx.inject(["sessionPersistence"], (scope) => {
+    persistence = scope.sessionPersistence;
+  });
+  ctx.effect(function* () {
+    yield ctx.commands.register({
+      name: "dsh-rewind-fix",
+      description: render("rewindfix.description"),
+      input: { hint: render("rewindfix.inputHint") },
+      handler: (invocation) => handleRewindFix(ctx, store, persistence, invocation, render)
+    });
+  }, "dsh-rewind-fix command");
+}
+async function handleRewindFix(ctx, store, persistence, invocation, render) {
+  if (persistence === void 0) {
+    return { kind: "error", text: render("rewindfix.persistenceUnavailable") };
+  }
+  const sessionStore = ctx.get("sessions");
+  if (sessionStore === void 0) {
+    return { kind: "error", text: render("rewindfix.sessionStoreUnavailable") };
+  }
+  const launcher = invocation.agent?.session;
+  const deps = {
+    listSnapshots: (signal) => persistence.listSnapshots(signal),
+    readRaw: (id, signal) => persistence.readRaw(id, signal),
+    locate: (header) => persistence.locate(header),
+    isSessionLoaded: (id) => sessionStore.get(id) !== void 0,
+    clearSession: (id) => store.clearSession(id)
+  };
+  const result = await runRewindFix(deps, {
+    apply: isApplyInput(invocation.rawInput),
+    launcherHasMarkers: (launcher?.snapshotEvents() ?? []).some(isLegacyRewindMarker),
+    signal: invocation.signal
+  });
+  return { kind: "success", text: renderRewindFixReport(result, render) };
+}
+async function runRewindFix(deps, opts) {
+  const snapshots = await deps.listSnapshots(opts.signal);
+  const total = snapshots.length;
+  const started = Date.now();
+  let cancelled = false;
+  const concurrency = Math.max(1, Math.min(opts.concurrency ?? 4, total));
+  const results = new Array(total);
+  let cursor = 0;
+  const worker = async () => {
+    for (; ; ) {
+      if (opts.signal?.aborted) {
+        cancelled = true;
+        return;
+      }
+      const i = cursor++;
+      if (i >= total) return;
+      results[i] = await processOneSession(deps, opts, snapshots[i].header);
+    }
+  };
+  await Promise.all(Array.from({ length: concurrency }, () => worker()));
+  const sessions = results.filter((o) => o !== void 0);
+  return {
+    launcherHasMarkers: opts.launcherHasMarkers,
+    cancelled,
+    scanned: total,
+    durationMs: Date.now() - started,
+    apply: opts.apply,
+    sessions
+  };
+}
+async function processOneSession(deps, opts, header) {
+  const id = header.id;
+  if (deps.isSessionLoaded(header.id)) {
+    return { id, status: "skipped", a: 0, b: 0, c: 0, reason: "loaded" };
+  }
+  let decoded;
+  try {
+    decoded = await readEvents(deps, header.id, opts.signal);
+  } catch (error) {
+    return { id, status: "failed", a: 0, b: 0, c: 0, reason: "unreadable", error: textOf(error) };
+  }
+  if (decoded === void 0) {
+    return { id, status: "skipped", a: 0, b: 0, c: 0, reason: "no-artifact" };
+  }
+  let repair;
+  try {
+    repair = repairRewindMarkers(decoded.events);
+  } catch (error) {
+    return { id, status: "failed", a: 0, b: 0, c: 0, reason: "repair", error: textOf(error) };
+  }
+  const hasMarkers = repair.stats.a + repair.stats.b > 0;
+  if (!hasMarkers) {
+    return { id, status: "skipped", a: 0, b: 0, c: 0, reason: "no-markers" };
+  }
+  if (!opts.apply) {
+    return { id, status: "repaired", a: repair.stats.a, b: repair.stats.b, c: repair.stats.a + repair.stats.b + repair.stats.c };
+  }
+  return executeSession(deps, header, decoded.headerLine, repair);
+}
+async function executeSession(deps, header, headerLine, repair) {
+  const base = {
+    id: header.id,
+    a: repair.stats.a,
+    b: repair.stats.b,
+    c: repair.stats.a + repair.stats.b + repair.stats.c
+  };
+  if (deps.isSessionLoaded(header.id)) {
+    return { ...base, status: "skipped", reason: "loaded-between", error: "loaded between scan and write" };
+  }
+  const location = deps.locate(header);
+  if (location === void 0) return { ...base, status: "failed", error: "locate() returned no path" };
+  const path = location.path;
+  const lockPath = `${path}.rewind-fix.lock`;
+  const tmpPath = `${path}.rewind-fix.tmp`;
+  const bakPath = `${path}.rewind-fix.bak`;
+  const lock = await acquireSessionLock(lockPath);
+  if (lock === void 0) {
+    return { ...base, status: "failed", reason: "locked", error: "another process holds the session lock" };
+  }
+  try {
+    await copyFile(path, bakPath);
+    const buffer = await encodeSessionLog(headerLine, repair.events);
+    await writeFile2(tmpPath, buffer);
+    await rename2(tmpPath, path);
+    const verification = await verifyWritten(deps, header.id);
+    if (verification === void 0) throw new Error("written artifact could not be re-read");
+    if (!isDeepStrictEqual(normalizeForVerify(verification), normalizeForVerify(repair.events))) {
+      throw new Error("round-trip mismatch after write");
+    }
+    await deps.clearSession(idOf(header));
+    return { ...base, status: "repaired" };
+  } catch (error) {
+    await unlink(tmpPath).catch(() => {
+    });
+    await rename2(bakPath, path).catch(() => {
+    });
+    return { ...base, status: "failed", error: textOf(error) };
+  } finally {
+    await lock.close().catch(() => {
+    });
+    await unlink(lockPath).catch(() => {
+    });
+    await unlink(bakPath).catch(() => {
+    });
+  }
+}
+async function readEvents(deps, id, signal) {
+  const raw = await deps.readRaw(id, signal);
+  if (raw === void 0) return void 0;
+  const { headerLine, body } = splitSession(raw.content);
+  return { events: decodeEventBody(body), headerLine };
+}
+async function verifyWritten(deps, id) {
+  const raw = await deps.readRaw(id);
+  if (raw === void 0) return void 0;
+  return decodeEventBody(splitSession(raw.content).body);
+}
+function normalizeForVerify(events) {
+  return events.map((e) => ({ type: e.type, seq: e.seq, data: e.data }));
+}
+function textOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function idOf(header) {
+  return header.id;
+}
+async function acquireSessionLock(lockPath) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const handle = await open(lockPath, "wx");
+      await handle.writeFile(String(process.pid));
+      return handle;
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") throw error;
+      if (attempt === 1) return void 0;
+      if (await removeStaleLock(lockPath)) continue;
+      return void 0;
+    }
+  }
+  return void 0;
+}
+async function removeStaleLock(lockPath) {
+  let pid = 0;
+  try {
+    pid = Number((await readFile2(lockPath, "utf8")).trim());
+  } catch {
+    return false;
+  }
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  if (pidAlive(pid)) return false;
+  await unlink(lockPath).catch(() => {
+  });
+  return true;
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function renderRewindFixReport(result, render) {
+  const parts = [];
+  if (result.launcherHasMarkers) parts.push(render("rewindfix.launcherGuard"));
+  parts.push(headline(result, render));
+  result.sessions.forEach((outcome, i) => parts.push(...sessionLines(outcome, i + 1, result.scanned, result.apply, render)));
+  return parts.join("\n");
+}
+function headline(result, render) {
+  if (result.cancelled) return render("rewindfix.cancelled");
+  const repaired = result.sessions.filter((o) => o.status === "repaired").length;
+  const skipped = result.sessions.filter((o) => o.status === "skipped").length;
+  const failed = result.sessions.filter((o) => o.status === "failed").length;
+  const secs = (result.durationMs / 1e3).toFixed(1);
+  if (!result.apply) {
+    return render("rewindfix.dryRun", { scan: result.scanned, will: repaired, skip: skipped, fail: failed, secs });
+  }
+  return render("rewindfix.done", { repair: repaired, skip: skipped, fail: failed, secs });
+}
+function sessionLines(outcome, index, total, apply2, render) {
+  const head = `[${index}/${total}] ${outcome.id}`;
+  if (outcome.status === "repaired") {
+    const counts = render("rewindfix.counts", { a: outcome.a, b: outcome.b, c: outcome.c });
+    if (!apply2) return [`${head}  ${counts}`];
+    return [`${head}  ${counts}`, `  ${render("rewindfix.writeOk")}`];
+  }
+  if (outcome.status === "skipped") {
+    return [`${head}  ${skipLabel(outcome, render)}`];
+  }
+  return [`${head}  ${failLabel(outcome, render)}`];
+}
+function skipLabel(outcome, render) {
+  switch (outcome.reason) {
+    case "no-markers":
+      return render("rewindfix.skip.noMarkers");
+    case "no-artifact":
+      return render("rewindfix.skip.noArtifact");
+    case "loaded-between": {
+      const label = render("rewindfix.skip.loadedNow");
+      return outcome.error ? `${label} ${outcome.error}` : label;
+    }
+    case "loaded":
+    default:
+      return render("rewindfix.skip.loaded");
+  }
+}
+function failLabel(outcome, render) {
+  switch (outcome.reason) {
+    case "unreadable":
+      return render("rewindfix.fail.unreadable", { error: outcome.error ?? "" });
+    case "repair":
+      return render("rewindfix.fail.repair", { error: outcome.error ?? "" });
+    case "locked":
+      return render("rewindfix.fail.locked", {
+        error: `${render("rewindfix.locked")}${outcome.error ? ` (${outcome.error})` : ""}`
+      });
+    default:
+      return render("rewindfix.fail.generic", { error: outcome.error ?? "" });
+  }
+}
+
 // src/snapshot-cleanup.ts
-import { mkdir as mkdir2, readFile as readFile2, rename as rename2, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile3, rename as rename3, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname2, join as join2 } from "node:path";
 import { resolveDshHome as resolveDshHome2 } from "@deepseek-ai/dsh-home-paths";
 import z from "@deepseek-ai/schemastery";
@@ -1363,16 +1827,16 @@ async function migrateLegacyCleanupConfig(legacyPath, scope, log) {
   if (!loaded.ok) {
     log(`[dsh-rewind] legacy snapshot-cleanup config invalid, migrating defaults and removing: ${loaded.error}`);
     await scope.update({ enabled: false, maxAgeDays: DEFAULT_MAX_AGE_DAYS });
-    await unlink(legacyPath).catch(() => void 0);
+    await unlink2(legacyPath).catch(() => void 0);
     return true;
   }
   if (!loaded.fromFile) return false;
   if (loaded.config.enabled === DEFAULT_CLEANUP_CONFIG.enabled && loaded.config.maxAgeDays === DEFAULT_CLEANUP_CONFIG.maxAgeDays) {
-    await unlink(legacyPath).catch(() => void 0);
+    await unlink2(legacyPath).catch(() => void 0);
     return true;
   }
   await scope.update({ enabled: loaded.config.enabled, maxAgeDays: loaded.config.maxAgeDays });
-  await unlink(legacyPath).catch(() => void 0);
+  await unlink2(legacyPath).catch(() => void 0);
   log(`[dsh-rewind] migrated legacy snapshot-cleanup config (enabled=${String(loaded.config.enabled)}, maxAgeDays=${String(loaded.config.maxAgeDays)})`);
   return true;
 }
@@ -1386,7 +1850,7 @@ function resolveCleanupStatePath(dshHome) {
 }
 async function loadLastSweepAt(path) {
   try {
-    const raw = JSON.parse(await readFile2(path, "utf8"));
+    const raw = JSON.parse(await readFile3(path, "utf8"));
     const value = raw["lastSweepAt"];
     return typeof value === "number" && Number.isFinite(value) ? value : 0;
   } catch {
@@ -1396,8 +1860,8 @@ async function loadLastSweepAt(path) {
 async function saveLastSweepAt(path, ms) {
   const tmp = `${path}.tmp`;
   await mkdir2(dirname2(path), { recursive: true });
-  await writeFile2(tmp, JSON.stringify({ lastSweepAt: ms }), "utf8");
-  await rename2(tmp, path);
+  await writeFile3(tmp, JSON.stringify({ lastSweepAt: ms }), "utf8");
+  await rename3(tmp, path);
 }
 async function runAutoCleanupCheck(deps, sessionId) {
   try {
@@ -1437,7 +1901,7 @@ function parseCleanupConfig(raw) {
 async function loadCleanupConfig(path) {
   let text;
   try {
-    text = await readFile2(path, "utf8");
+    text = await readFile3(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return { ok: true, config: { ...DEFAULT_CLEANUP_CONFIG }, fromFile: false };
@@ -1524,7 +1988,7 @@ function mutationPathOf(exec) {
   return void 0;
 }
 function anchorSeqOf(session, cache) {
-  const events = eventsOf(session);
+  const events = session.snapshotEvents();
   const cached = cache.get(session);
   if (cached !== void 0 && cached.eventsLength === events.length) return cached.anchor;
   let anchor = cached?.anchor;
@@ -1591,10 +2055,11 @@ async function commitEntry(store, pending, anchorCache, trackedBySession, exec,
   }
   tracked.add(capture.path);
 }
+var REWIND_MARKER_CONTENT2 = [];
 function buildMarker() {
-  return createAssistantMessage({
-    content: [],
-    source: { provider: "dsh-rewind", model: "rewind-marker" }
+  return createUserMessage({
+    content: REWIND_MARKER_CONTENT2,
+    source: REWIND_MARKER_SOURCE
   });
 }
 function describeTarget(target) {
@@ -1702,26 +2167,17 @@ async function executeRewind(ctx, store, fs, invocation, rawTarget, mode, inflig
     }
     let plan;
     try {
-      plan = resolveOrError(eventsOf(agent.session), agent.session.surface.nodes, rawTarget);
+      plan = resolveOrError(agent.session.snapshotEvents(), agent.session.surface.nodes, rawTarget);
     } catch (error) {
       return rewindErrorResult(error);
     }
     const marker = buildMarker();
     let event;
     try {
-      const turn = markerTurnOf(eventsOf(agent.session));
-      const step = markerStepOf(eventsOf(agent.session), turn);
-      agent.session.append("step/start", { turn, step });
-      try {
-        event = agent.session.append("assistant/message", { turn, step, message: marker }, {
-          surfaceOp: { op: "replace", start: plan.surfaceStart, end: plan.surfaceEnd },
-          sourceEventSeqs: [...plan.shadowedSeqs]
-        });
-      } catch (error) {
-        agent.session.append("step/end", { turn, step });
-        throw error;
-      }
-      agent.session.append("step/end", { turn, step });
+      event = agent.session.append("user/message", marker, {
+        surfaceOp: { op: "replace", start: plan.surfaceStart, end: plan.surfaceEnd },
+        sourceEventSeqs: [...plan.shadowedSeqs]
+      });
     } catch (error) {
       return {
         kind: "error",
@@ -1730,7 +2186,7 @@ async function executeRewind(ctx, store, fs, invocation, rawTarget, mode, inflig
     }
     let restore = "";
     if (mode === "both") {
-      const outcome = await store.restoreAfter(agent.session.id, plan.targetSeq, (path) => unlink2(path));
+      const outcome = await store.restoreAfter(agent.session.id, plan.targetSeq, (path) => unlink3(path));
       await syncRestoreObservations(ctx, fs, agent, outcome);
       const parts = [];
       if (outcome.restored.length > 0) parts.push(t("restore.count", { count: outcome.restored.length }));
@@ -1764,7 +2220,7 @@ async function handleRewind(ctx, store, fs, invocation, inflight) {
   const session = invocation.agent.session;
   const input = invocation.rawInput.trim();
   if (input === "") {
-    const candidates = listRewindCandidates(eventsOf(session), session.surface.nodes, 1);
+    const candidates = listRewindCandidates(session.snapshotEvents(), session.surface.nodes, 1);
     if (candidates.length === 0) {
       return { kind: "error", text: t("noUserMessages") };
     }
@@ -1776,7 +2232,7 @@ async function handleRewind(ctx, store, fs, invocation, inflight) {
     if (target2 === void 0) return { kind: "error", text: usage() };
     let plan;
     try {
-      plan = resolveOrError(eventsOf(session), session.surface.nodes, target2);
+      plan = resolveOrError(session.snapshotEvents(), session.surface.nodes, target2);
     } catch (error) {
       return rewindErrorResult(error);
     }
@@ -1784,7 +2240,7 @@ async function handleRewind(ctx, store, fs, invocation, inflight) {
     return { kind: "success", text: formatPlan(plan, impacts) };
   }
   if (parts[0] === "__candidates") {
-    const candidates = listRewindCandidates(eventsOf(session), session.surface.nodes);
+    const candidates = listRewindCandidates(session.snapshotEvents(), session.surface.nodes);
     return { kind: "success", text: formatCandidateList(candidates) };
   }
   const target = parts[0];
@@ -1930,15 +2386,16 @@ function apply(ctx, config) {
   const trackedBySession = /* @__PURE__ */ new Map();
   let fsService;
   ctx.inject(["settings"], (settingsCtx) => {
-    const section = readSettingsSection(
-      settingsCtx.settings,
-      "locale",
-      dshSettings.settingsNamespace
-    );
+    const settings = settingsCtx;
+    const section = settings.settings.get("locale");
     if (section?.preference === "zh" || section?.preference === "en") {
       activeLocale = section.preference;
     }
-    const cleanupScope = settingsCtx.settings.register(CLEANUP_SETTINGS_NAMESPACE, CleanupConfigSchema, { base: DEFAULT_CLEANUP_CONFIG });
+    const cleanupScope = settings.settings.register(
+      CLEANUP_SETTINGS_NAMESPACE,
+      CleanupConfigSchema,
+      { base: DEFAULT_CLEANUP_CONFIG }
+    );
     cleanupStore = settingsCleanupStore(cleanupScope);
     void migrateLegacyCleanupConfig(
       resolveCleanupConfigPath(dshHome),
@@ -1967,6 +2424,7 @@ function apply(ctx, config) {
       handler: (invocation) => handleSnapshotCleanup(store, invocation, dshHome, trackedBySession)
     });
   }, "dsh-rewind command");
+  registerRewindFix(ctx, store, (key, params) => t(key, params));
   ctx.on("session/event", (session, event) => {
     if (event.type !== "user/message") return;
     const header = session.header;