dsh-rewind-plugin 0.9.1 → 0.10.0-alpha.2

package/lib/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
-import { unlink as unlink3 } from "node:fs/promises";
+import { unlink } from "node:fs/promises";
 import "@deepseek-ai/schemastery";
 
 // src/locales.ts
@@ -50,27 +50,7 @@ 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",
-  "rewindfix.description": "Update legacy rewind markers (A/B) in closed sessions to form-C, and fill old empty form-C content with the (empty message) placeholder",
-  "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.args": "\xB7 rewired args target {n}",
-  "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"
+  "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"
 };
 var zh = {
   "usage.title": "\u7528\u6CD5\uFF1A",
@@ -118,27 +98,7 @@ 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",
-  "rewindfix.description": "\u5C06\u5DF2\u5173\u95ED\u4F1A\u8BDD\u4E2D\u7684\u65E7\u7248 rewind \u6807\u8BB0\uFF08A/B\uFF09\u66F4\u65B0\u4E3A form-C\uFF0C\u5E76\u628A\u65E7\u7684\u7A7A form-C \u5185\u5BB9\u8865\u6210 (empty message) \u5360\u4F4D",
-  "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.args": "\xB7 \u4FEE\u6B63 args \u76EE\u6807 {n}",
-  "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"
+  "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"
 };
 var HOST_DICTS = { en, zh };
 function translate(lang, key, params = {}) {
@@ -1342,553 +1302,11 @@ 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 = [{ type: "text", text: "(empty message)" }];
-function isCanonicalMarkerContent(content) {
-  return Array.isArray(content) && content.length === 1 && content[0]?.type === "text" && content[0]?.text === "(empty message)";
-}
-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 isFormCMarker(event) {
-  return isFormCMarkerRow(asRow(event));
-}
-function repairRewindMarkers(input) {
-  const rows = input.map(toRow);
-  const stats = { a: 0, b: 0, c: 0, removedGhosts: 0 };
-  let contentUpgrades = 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);
-    if (!isRewindMarkerRow(original) || isCanonicalCMarker(original)) {
-      survivors.push(toEvent({ ...original, seq: newSeq }));
-    } else {
-      if (isFormCMarkerRow(original)) contentUpgrades += 1;
-      survivors.push(toEvent(retargetToC(original, 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, contentUpgrades };
-}
-function rowSource(row) {
-  const message = row.data["message"];
-  return message?.["source"] ?? row.data["source"];
-}
-function isLegacyRewindMarkerRow(row) {
-  if (row.type !== "assistant/message") return false;
-  const source = rowSource(row);
-  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" && row.type !== "assistant/message") return false;
-  if (!isReplaceSurfaceOp(row.surfaceOp)) return false;
-  const source = rowSource(row);
-  return source?.["kind"] === "plugin" && source?.["plugin"] === "dsh-rewind";
-}
-function isRewindMarkerRow(row) {
-  return isLegacyRewindMarkerRow(row) || isFormCMarkerRow(row);
-}
-function isCanonicalCMarker(row) {
-  return row.type === "user/message" && isFormCMarkerRow(row) && isCanonicalMarkerContent(row.data["content"]);
-}
-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"] : typeof row.data["id"] === "string" ? row.data["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);
-  if (row.type === "command/run" && data["name"] === "rewind") {
-    const args = data["args"];
-    if (typeof args === "string") {
-      data["args"] = args.replace(/@(\d+)/g, (match, seqText) => {
-        const seq = Number(seqText);
-        return Number.isSafeInteger(seq) ? `@${mapSeq(seq)}` : match;
-      });
-    }
-  }
-  return row;
-}
-function rewindTargetSeqOfArgs(args) {
-  if (typeof args !== "string") return void 0;
-  const match = args.match(/@(\d+)/);
-  return match !== null ? Number(match[1]) : void 0;
-}
-function repairStaleArgs(input) {
-  const markerBySeq = /* @__PURE__ */ new Map();
-  for (const event of input) {
-    if (isFormCMarker(event)) markerBySeq.set(event.seq, event);
-  }
-  const markerSeqByCommandId = /* @__PURE__ */ new Map();
-  for (const event of input) {
-    if (event.type !== "command/done") continue;
-    const data = event.data;
-    if (typeof data.commandId === "string" && typeof data.sourceEventSeq === "number") {
-      markerSeqByCommandId.set(data.commandId, data.sourceEventSeq);
-    }
-  }
-  let fixed = 0;
-  const events = input.map((event) => {
-    if (event.type !== "command/run") return event;
-    const data = event.data;
-    if (data.name !== "rewind" || typeof data.commandId !== "string" || typeof data.args !== "string") {
-      return event;
-    }
-    const markerSeq = markerSeqByCommandId.get(data.commandId);
-    const marker = markerSeq === void 0 ? void 0 : markerBySeq.get(markerSeq);
-    const start = marker?.surfaceOp?.start;
-    const target = rewindTargetSeqOfArgs(data.args);
-    if (start === void 0 || target === void 0 || target === start) return event;
-    const newArgs = data.args.replace(new RegExp(`@${target}(?!\\d)`), `@${start}`);
-    if (newArgs === data.args) return event;
-    fixed += 1;
-    return { ...event, data: { ...data, args: newArgs } };
-  });
-  return { events, fixed };
-}
-
-// 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, staleArgs: 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, staleArgs: 0, reason: "unreadable", error: textOf(error) };
-  }
-  if (decoded === void 0) {
-    return { id, status: "skipped", a: 0, b: 0, c: 0, staleArgs: 0, reason: "no-artifact" };
-  }
-  let converted;
-  try {
-    converted = repairRewindMarkers(decoded.events);
-  } catch (error) {
-    return { id, status: "failed", a: 0, b: 0, c: 0, staleArgs: 0, reason: "repair", error: textOf(error) };
-  }
-  let stale;
-  try {
-    stale = repairStaleArgs(converted.events);
-  } catch (error) {
-    return { id, status: "failed", a: 0, b: 0, c: 0, staleArgs: 0, reason: "repair", error: textOf(error) };
-  }
-  const a = converted.stats.a;
-  const b = converted.stats.b;
-  const c = converted.stats.a + converted.stats.b + converted.stats.c;
-  const staleArgs = stale.fixed;
-  const contentUpgrades = converted.contentUpgrades;
-  const needsRepair = a + b > 0 || staleArgs > 0 || contentUpgrades > 0;
-  if (!needsRepair) {
-    return { id, status: "skipped", a, b, c, staleArgs, reason: "no-markers" };
-  }
-  if (!opts.apply) {
-    return { id, status: "repaired", a, b, c, staleArgs };
-  }
-  const repair = { events: stale.events, a, b, c, staleArgs };
-  return executeSession(deps, header, decoded.headerLine, repair);
-}
-async function executeSession(deps, header, headerLine, repair) {
-  const base = {
-    id: header.id,
-    a: repair.a,
-    b: repair.b,
-    c: repair.c,
-    staleArgs: repair.staleArgs
-  };
-  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 });
-    const argsNote = outcome.staleArgs > 0 ? " " + render("rewindfix.args", { n: outcome.staleArgs }) : "";
-    if (!apply2) return [`${head}  ${counts}${argsNote}`];
-    return [`${head}  ${counts}${argsNote}`, `  ${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 readFile3, rename as rename3, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } 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";
-var CLEANUP_CONFIG_FILENAME = "snapshot-cleanup.json";
 var DEFAULT_MAX_AGE_DAYS = 30;
 var DEFAULT_CLEANUP_CONFIG = { enabled: false, maxAgeDays: DEFAULT_MAX_AGE_DAYS };
 var CLEANUP_SETTINGS_NAMESPACE = "dsh-rewind-snapshot-cleanup";
@@ -1906,35 +1324,14 @@ function settingsCleanupStore(scope) {
     }
   };
 }
-async function migrateLegacyCleanupConfig(legacyPath, scope, log) {
-  const loaded = await loadCleanupConfig(legacyPath);
-  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 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 unlink2(legacyPath).catch(() => void 0);
-    return true;
-  }
-  await scope.update({ enabled: loaded.config.enabled, maxAgeDays: loaded.config.maxAgeDays });
-  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;
-}
 var AUTO_SWEEP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-function resolveCleanupConfigPath(dshHome) {
-  return join2(resolveDshHome2(dshHome), CLEANUP_CONFIG_FILENAME);
-}
 var STATE_FILENAME = "snapshot-cleanup-last-sweep.json";
 function resolveCleanupStatePath(dshHome) {
-  return join2(dirname2(resolveCleanupConfigPath(dshHome)), STATE_FILENAME);
+  return join2(resolveDshHome2(dshHome), STATE_FILENAME);
 }
 async function loadLastSweepAt(path) {
   try {
-    const raw = JSON.parse(await readFile3(path, "utf8"));
+    const raw = JSON.parse(await readFile2(path, "utf8"));
     const value = raw["lastSweepAt"];
     return typeof value === "number" && Number.isFinite(value) ? value : 0;
   } catch {
@@ -1944,8 +1341,8 @@ async function loadLastSweepAt(path) {
 async function saveLastSweepAt(path, ms) {
   const tmp = `${path}.tmp`;
   await mkdir2(dirname2(path), { recursive: true });
-  await writeFile3(tmp, JSON.stringify({ lastSweepAt: ms }), "utf8");
-  await rename3(tmp, path);
+  await writeFile2(tmp, JSON.stringify({ lastSweepAt: ms }), "utf8");
+  await rename2(tmp, path);
 }
 async function runAutoCleanupCheck(deps, sessionId) {
   try {
@@ -1982,26 +1379,6 @@ function parseCleanupConfig(raw) {
   }
   return { ok: true, config: { enabled, maxAgeDays } };
 }
-async function loadCleanupConfig(path) {
-  let text;
-  try {
-    text = await readFile3(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return { ok: true, config: { ...DEFAULT_CLEANUP_CONFIG }, fromFile: false };
-    }
-    return { ok: false, error: `config file unreadable: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  let raw;
-  try {
-    raw = JSON.parse(text);
-  } catch (error) {
-    return { ok: false, error: `config file is not valid JSON: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  const parsed = parseCleanupConfig(raw);
-  if (!parsed.ok) return { ok: false, error: parsed.error };
-  return { ok: true, config: parsed.config, fromFile: true };
-}
 function parseCleanupCommand(rawInput) {
   const parts = rawInput.trim().split(/\s+/).filter(Boolean);
   if (parts.length === 0) return { action: "status" };
@@ -2045,8 +1422,7 @@ function shouldRunAutoSweep(lastAtMs, nowMs) {
 // src/index.ts
 var name = "dsh-rewind";
 var inject = ["commands", "tools"];
-var TRACKED_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "str_replace_editor"]);
-var MUTATING_EDITOR_COMMANDS = /* @__PURE__ */ new Set(["create", "str_replace", "insert"]);
+var TRACKED_TOOLS = /* @__PURE__ */ new Set(["write", "edit"]);
 var activeLocale = "en";
 var cleanupStore;
 function t(key, params) {
@@ -2065,10 +1441,6 @@ function mutationPathOf(exec) {
   if (exec.name === "write" || exec.name === "edit") {
     return typeof args.file_path === "string" ? args.file_path : void 0;
   }
-  if (exec.name === "str_replace_editor") {
-    if (typeof args.command !== "string" || !MUTATING_EDITOR_COMMANDS.has(args.command)) return void 0;
-    return typeof args.path === "string" ? args.path : void 0;
-  }
   return void 0;
 }
 function anchorSeqOf(session, cache) {
@@ -2139,6 +1511,8 @@ async function commitEntry(store, pending, anchorCache, trackedBySession, exec,
   }
   tracked.add(capture.path);
 }
+var REWIND_MARKER_SOURCE = { kind: "plugin", plugin: "dsh-rewind" };
+var REWIND_MARKER_CONTENT = [{ type: "text", text: "(empty message)" }];
 function buildMarker() {
   return createUserMessage({
     content: REWIND_MARKER_CONTENT,
@@ -2269,7 +1643,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) => unlink3(path));
+      const outcome = await store.restoreAfter(agent.session.id, plan.targetSeq, (path) => unlink(path));
       await syncRestoreObservations(ctx, fs, agent, outcome);
       const parts = [];
       if (outcome.restored.length > 0) parts.push(t("restore.count", { count: outcome.restored.length }));
@@ -2480,13 +1854,6 @@ function apply(ctx, config) {
       { base: DEFAULT_CLEANUP_CONFIG }
     );
     cleanupStore = settingsCleanupStore(cleanupScope);
-    void migrateLegacyCleanupConfig(
-      resolveCleanupConfigPath(dshHome),
-      cleanupScope,
-      (msg) => ctx.logger.warn(msg)
-    ).catch((error) => {
-      ctx.logger.warn(`[dsh-rewind] snapshot cleanup migration failed: ${error instanceof Error ? error.message : String(error)}`);
-    });
   });
   ctx.effect(function* () {
     const rewindHandler = (invocation) => handleRewind(ctx, store, fsService, invocation, inflight);
@@ -2507,7 +1874,6 @@ 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;