opencode-sessions-explorer 0.1.2 → 0.1.4

package/dist/bin/dedupe-export.js

@@ -2,8 +2,8 @@
 // @bun
 
 // src/bin/dedupe-export.ts
-import { readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
-import { join as join3 } from "path";
+import { readdirSync as readdirSync3, statSync as statSync3, unlinkSync as unlinkSync4 } from "fs";
+import { join as join6 } from "path";
 
 // src/lib/db.ts
 import { Database } from "bun:sqlite";
@@ -177,8 +177,8 @@ function decodeModel(modelStr) {
 }
 
 // src/lib/export.ts
-import { mkdirSync, existsSync as existsSync2, renameSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "fs";
-import { join as join2 } from "path";
+import { mkdirSync, existsSync as existsSync5, renameSync as renameSync2, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join5 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/lib/channel.ts
@@ -204,55 +204,511 @@ function compactPath(path, baseDir) {
   return { path, rel_path: rel || "." };
 }
 
+// src/lib/export-constants.ts
+var SEARCHABLE_TYPES = ["text", "reasoning", "tool", "file", "patch", "subtask"];
+
+// src/lib/export-lock.ts
+import { closeSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { hostname } from "os";
+import { join as join2 } from "path";
+import { randomUUID } from "crypto";
+var LOCK_FILE = ".export.lock";
+var DEFAULT_STALE_MS = 2 * 60 * 1000;
+var HEARTBEAT_MS = 15000;
+function acquireExportLock(root, staleMs = DEFAULT_STALE_MS) {
+  const path = join2(root, LOCK_FILE);
+  const first = tryCreateLock(path);
+  if (first)
+    return first;
+  const stale = staleCandidate(path, staleMs);
+  if (!stale)
+    return null;
+  if (!removeStaleLock(path, stale, staleMs))
+    return tryCreateLock(path);
+  return tryCreateLock(path);
+}
+function tryCreateLock(path) {
+  let fd = null;
+  try {
+    const token = randomUUID();
+    const now = Date.now();
+    const record = { token, pid: process.pid, hostname: hostname(), created_at: now, updated_at: now };
+    fd = openSync(path, "wx");
+    writeFileSync(fd, JSON.stringify(record));
+    closeSync(fd);
+    fd = null;
+    let lastHeartbeat = now;
+    return {
+      token,
+      release: () => releaseLock(path, token),
+      heartbeat: () => {
+        const current = Date.now();
+        if (current - lastHeartbeat < HEARTBEAT_MS)
+          return;
+        lastHeartbeat = current;
+        heartbeatLock(path, token, current);
+      }
+    };
+  } catch {
+    if (fd != null)
+      try {
+        closeSync(fd);
+      } catch {}
+    return null;
+  }
+}
+function staleCandidate(path, staleMs) {
+  try {
+    const stat = statSync(path);
+    const now = Date.now();
+    if (now - stat.mtimeMs <= staleMs)
+      return null;
+    const parsed = readLockRecord(path);
+    if (!parsed)
+      return { token: null, updatedAt: null, mtimeMs: stat.mtimeMs };
+    if (now - parsed.updated_at <= staleMs)
+      return null;
+    if (isLiveLocalOwner(parsed))
+      return null;
+    return { token: parsed.token, updatedAt: parsed.updated_at, mtimeMs: stat.mtimeMs };
+  } catch {
+    return { token: null, updatedAt: null, mtimeMs: 0 };
+  }
+}
+function removeStaleLock(path, stale, staleMs) {
+  try {
+    const stat = statSync(path);
+    if (stat.mtimeMs !== stale.mtimeMs)
+      return false;
+    if (stale.token) {
+      const current = readLockRecord(path);
+      if (current?.token !== stale.token)
+        return false;
+      if (current.updated_at !== stale.updatedAt)
+        return false;
+      const now = Date.now();
+      if (now - current.updated_at <= staleMs)
+        return false;
+      if (now - stat.mtimeMs <= staleMs)
+        return false;
+      if (isLiveLocalOwner(current))
+        return false;
+    } else {
+      if (Date.now() - stat.mtimeMs <= staleMs)
+        return false;
+    }
+    unlinkSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseLock(path, token) {
+  try {
+    const current = readLockRecord(path);
+    if (current?.token === token)
+      unlinkSync(path);
+  } catch {}
+}
+function heartbeatLock(path, token, now) {
+  try {
+    const current = readLockRecord(path);
+    if (current?.token !== token)
+      return;
+    writeFileSync(path, JSON.stringify({ ...current, updated_at: now }));
+  } catch {}
+}
+function readLockRecord(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed.token !== "string")
+      return null;
+    if (typeof parsed.pid !== "number" || !Number.isFinite(parsed.pid))
+      return null;
+    if (typeof parsed.hostname !== "string")
+      return null;
+    if (typeof parsed.created_at !== "number" || !Number.isFinite(parsed.created_at))
+      return null;
+    const updated = typeof parsed.updated_at === "number" && Number.isFinite(parsed.updated_at) ? parsed.updated_at : parsed.created_at;
+    return { token: parsed.token, pid: parsed.pid, hostname: parsed.hostname, created_at: parsed.created_at, updated_at: updated };
+  } catch {
+    return null;
+  }
+}
+function isLiveLocalOwner(record) {
+  if (record.hostname !== hostname())
+    return false;
+  if (!Number.isSafeInteger(record.pid) || record.pid <= 0)
+    return false;
+  try {
+    process.kill(record.pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
+// src/lib/export-tombstones.ts
+import { existsSync as existsSync2, readdirSync, rmSync, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join3 } from "path";
+var PART_FILE_RE = /^(?:\d{5}-)?(prt_[A-Za-z0-9_-]+)\.txt$/;
+function reconcileTombstones(root, heartbeat = () => {}) {
+  const progress = {
+    scanned_sessions: 0,
+    removed_sessions: 0,
+    removed_parts: 0,
+    removed_channel_sessions: 0
+  };
+  const bySession = join3(root, "by-session");
+  const sessions = loadSessionIds();
+  if (existsSync2(bySession)) {
+    for (const entry of safeReadDir(bySession)) {
+      const dir = join3(bySession, entry);
+      if (!isDirectory(dir))
+        continue;
+      if (!sessions.has(entry)) {
+        rmSync(dir, { recursive: true, force: true });
+        removeChannelSessionDirs(root, entry);
+        progress.removed_sessions++;
+        heartbeat();
+        continue;
+      }
+      progress.scanned_sessions++;
+      progress.removed_parts += removeOrphanPartFiles(root, entry, dir, heartbeat);
+      heartbeat();
+    }
+  }
+  progress.removed_channel_sessions += removeOrphanChannelSessions(root, sessions, heartbeat);
+  return progress;
+}
+function removeOrphanPartFiles(root, sessionId, dir, heartbeat) {
+  const livePartIds = loadSearchablePartIds(sessionId);
+  let removed = 0;
+  for (const file of safeReadDir(dir)) {
+    heartbeat();
+    const partId = partIdFromFile(file);
+    if (!partId || livePartIds.has(partId))
+      continue;
+    try {
+      unlinkSync2(join3(dir, file));
+      removeChannelPartFiles(root, sessionId, partId);
+      removed++;
+    } catch {}
+  }
+  return removed;
+}
+function removeOrphanChannelSessions(root, sessions, heartbeat) {
+  let removed = 0;
+  for (const channel of CHANNELS) {
+    const base = join3(root, "by-channel", channel, "by-session");
+    if (!existsSync2(base))
+      continue;
+    for (const sessionId of safeReadDir(base)) {
+      heartbeat();
+      const dir = join3(base, sessionId);
+      if (!isDirectory(dir) || sessions.has(sessionId))
+        continue;
+      rmSync(dir, { recursive: true, force: true });
+      removed++;
+    }
+  }
+  return removed;
+}
+function removeChannelSessionDirs(root, sessionId) {
+  for (const channel of CHANNELS) {
+    rmSync(channelDir(root, channel, sessionId), { recursive: true, force: true });
+  }
+}
+function removeChannelPartFiles(root, sessionId, partId) {
+  for (const channel of CHANNELS) {
+    const dir = channelDir(root, channel, sessionId);
+    if (!existsSync2(dir))
+      continue;
+    for (const file of safeReadDir(dir)) {
+      if (file === `${partId}.txt` || file.endsWith(`-${partId}.txt`)) {
+        try {
+          unlinkSync2(join3(dir, file));
+        } catch {}
+      }
+    }
+  }
+}
+function channelDir(root, channel, sessionId) {
+  return join3(root, "by-channel", channel, "by-session", sessionId);
+}
+function loadSessionIds() {
+  const rows = stmt(`SELECT id FROM session`).all();
+  return new Set(rows.map((row) => row.id));
+}
+function loadSearchablePartIds(sessionId) {
+  const placeholders = SEARCHABLE_TYPES.map(() => "?").join(",");
+  const rows = stmt(`
+    SELECT id
+      FROM part
+     WHERE session_id = ?
+       AND json_extract(data,'$.type') IN (${placeholders})
+  ORDER BY id ASC`).all(sessionId, ...SEARCHABLE_TYPES);
+  return new Set(rows.map((row) => row.id));
+}
+function safeReadDir(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function isDirectory(path) {
+  try {
+    return statSync2(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function partIdFromFile(file) {
+  const match = PART_FILE_RE.exec(file);
+  return match ? match[1] : null;
+}
+
+// src/lib/export-background.ts
+import { existsSync as existsSync3 } from "fs";
+import { fileURLToPath } from "url";
+var DEFAULT_MIN_INTERVAL_MS = 5 * 60 * 1000;
+var inFlight = false;
+var lastStartedAt = 0;
+function scheduleBackgroundReconcile(opts) {
+  const now = Date.now();
+  const minIntervalMs = opts.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+  if (inFlight)
+    return { scheduled: false, reason: "already_running" };
+  if (now - lastStartedAt < minIntervalMs)
+    return { scheduled: false, reason: "throttled" };
+  const url = resolveWorkerUrl();
+  try {
+    const worker = new Worker(url, { type: "module" });
+    inFlight = true;
+    lastStartedAt = now;
+    const cleanup = () => {
+      inFlight = false;
+      worker.terminate();
+    };
+    worker.addEventListener("message", cleanup, { once: true });
+    worker.addEventListener("error", cleanup, { once: true });
+    const maybeUnref = worker;
+    maybeUnref.unref?.();
+    const request = { root: opts.root, batchSize: opts.batchSize ?? 2000 };
+    worker.postMessage(request);
+    return { scheduled: true };
+  } catch {
+    inFlight = false;
+    return { scheduled: false, reason: "worker_unavailable" };
+  }
+}
+function resolveWorkerUrl() {
+  const js = new URL("./export-reconcile-worker.js", import.meta.url);
+  if (existsSync3(fileURLToPath(js)))
+    return js;
+  const ts = new URL("./export-reconcile-worker.ts", import.meta.url);
+  if (existsSync3(fileURLToPath(ts)))
+    return ts;
+  const bundled = new URL("./lib/export-reconcile-worker.js", import.meta.url);
+  if (existsSync3(fileURLToPath(bundled)))
+    return bundled;
+  return js;
+}
+
+// src/lib/export-state.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+var CURSOR_SCHEMA = "v3";
+var LAST_SYNC_FILE = ".last_sync";
+function freshSyncState(migratedFrom, legacyCursor = null) {
+  return {
+    schema: CURSOR_SCHEMA,
+    insert_cursor: { id: "" },
+    session_cursor: null,
+    session_dirty_hints: {},
+    reconcile_watermark: null,
+    failed_parts: {},
+    dead_letters: {},
+    last_reconcile_at: null,
+    legacy_cursor: legacyCursor,
+    migrated_from: migratedFrom
+  };
+}
+function getSyncState(root) {
+  const p = join4(root, LAST_SYNC_FILE);
+  if (!existsSync4(p))
+    return freshSyncState();
+  try {
+    return parseSyncState(readFileSync2(p, "utf8"));
+  } catch {
+    return freshSyncState("unreadable");
+  }
+}
+function setSyncState(state, root) {
+  const p = join4(root, LAST_SYNC_FILE);
+  const tmp = p + ".tmp";
+  writeFileSync2(tmp, `${CURSOR_SCHEMA} ${JSON.stringify(normalizeSyncState(state))}`);
+  renameSync(tmp, p);
+}
+function getLastSync(root) {
+  const p = join4(root, LAST_SYNC_FILE);
+  if (!existsSync4(p))
+    return null;
+  const state = getSyncState(root);
+  if (state.legacy_cursor)
+    return state.legacy_cursor;
+  if (!state.insert_cursor.id)
+    return null;
+  return { ts: 0, id: state.insert_cursor.id };
+}
+function parseSyncState(rawInput) {
+  const raw = rawInput.trim();
+  if (!raw)
+    return freshSyncState("empty");
+  if (raw.startsWith(`${CURSOR_SCHEMA} `)) {
+    const parsed = JSON.parse(raw.slice(CURSOR_SCHEMA.length + 1));
+    return normalizeSyncState(parsed);
+  }
+  if (raw.startsWith("{")) {
+    return normalizeSyncState(JSON.parse(raw));
+  }
+  if (raw.startsWith("v2 ")) {
+    return freshSyncState("v2", parseLegacyCursor(raw.slice(3)));
+  }
+  const legacy = parseLegacyCursor(raw);
+  return freshSyncState(legacy ? "v1" : "unknown", legacy);
+}
+function normalizeSyncState(input) {
+  if (!isRecord(input))
+    return freshSyncState("invalid");
+  const state = freshSyncState(asString(input.migrated_from) ?? undefined, cursorOrNull(input.legacy_cursor));
+  const insert = isRecord(input.insert_cursor) ? input.insert_cursor : null;
+  state.insert_cursor.id = asString(insert?.id) ?? "";
+  state.session_cursor = cursorOrNull(input.session_cursor);
+  state.session_dirty_hints = dirtyHints(input.session_dirty_hints);
+  state.reconcile_watermark = reconcileWatermark(input.reconcile_watermark);
+  state.failed_parts = failedParts(input.failed_parts);
+  state.dead_letters = failedParts(input.dead_letters);
+  state.last_reconcile_at = finiteOrNull(input.last_reconcile_at);
+  return state;
+}
+function parseLegacyCursor(raw) {
+  const idx = raw.indexOf(":");
+  if (idx <= 0)
+    return null;
+  const ts = Number(raw.slice(0, idx));
+  const id = raw.slice(idx + 1);
+  if (!Number.isFinite(ts) || !id)
+    return null;
+  return { ts, id };
+}
+function cursorOrNull(value) {
+  if (!isRecord(value))
+    return null;
+  const ts = finiteOrNull(value.ts);
+  const id = asString(value.id);
+  if (ts == null || !id)
+    return null;
+  return { ts, id };
+}
+function dirtyHints(value) {
+  if (!isRecord(value))
+    return {};
+  const out = {};
+  for (const [id, raw] of Object.entries(value)) {
+    if (!id)
+      continue;
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+      out[id] = { time_updated: raw, part_cursor: null };
+      continue;
+    }
+    if (!isRecord(raw))
+      continue;
+    const timeUpdated = finiteOrNull(raw.time_updated);
+    if (timeUpdated == null)
+      continue;
+    out[id] = { time_updated: timeUpdated, part_cursor: asString(raw.part_cursor) };
+  }
+  return out;
+}
+function reconcileWatermark(value) {
+  if (!isRecord(value))
+    return null;
+  const at = finiteOrNull(value.at);
+  if (at == null)
+    return null;
+  return {
+    part_id: asString(value.part_id),
+    session_id: asString(value.session_id),
+    at
+  };
+}
+function failedParts(value) {
+  if (!isRecord(value))
+    return {};
+  const out = {};
+  for (const [id, raw] of Object.entries(value)) {
+    if (!id || !isRecord(raw))
+      continue;
+    const attempts = finiteOrNull(raw.attempts);
+    const firstFailedAt = finiteOrNull(raw.first_failed_at);
+    const lastFailedAt = finiteOrNull(raw.last_failed_at);
+    if (attempts == null || firstFailedAt == null || lastFailedAt == null)
+      continue;
+    out[id] = {
+      id,
+      attempts,
+      first_failed_at: firstFailedAt,
+      last_failed_at: lastFailedAt,
+      last_error: asString(raw.last_error) ?? "unknown export failure"
+    };
+  }
+  return out;
+}
+function finiteOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/lib/export.ts
-var DEFAULT_EXPORT_ROOT = join2(homedir2(), ".local/share/opencode-sessions-explorer");
+var DEFAULT_EXPORT_ROOT = join5(homedir2(), ".local/share/opencode-sessions-explorer");
 var BODY_CAP_BYTES = 256 * 1024;
 var SAFETY_PART_CAP_BYTES = 50 * 1024 * 1024;
 var CHANNEL_COMPLETE_MARKER = ".channels_v1_complete";
-var SEARCHABLE_TYPES = ["text", "reasoning", "tool", "file", "patch", "subtask"];
+var INSERT_REWIND_MS = 3 * 60 * 1000;
+var INSERT_REWIND_MAX_ROWS = 512;
+var MAX_FAILED_ATTEMPTS = 5;
 var PART_CHANNELS = CHANNELS.filter((c) => c !== "session-summary" && c !== "raw");
 function exportRoot() {
   return process.env.OPENCODE_SESSIONS_EXPLORER_EXPORT_ROOT || DEFAULT_EXPORT_ROOT;
 }
+function getSyncState2(root = exportRoot()) {
+  return getSyncState(root);
+}
+function setSyncState2(state, root = exportRoot()) {
+  setSyncState(state, root);
+}
+function getLastSync2(root = exportRoot()) {
+  return getLastSync(root);
+}
 function ensureRoot(root = exportRoot()) {
-  mkdirSync(join2(root, "by-session"), { recursive: true });
+  mkdirSync(join5(root, "by-session"), { recursive: true });
   return root;
 }
 function channelExportComplete(root = exportRoot()) {
-  return existsSync2(join2(root, CHANNEL_COMPLETE_MARKER));
+  return existsSync5(join5(root, CHANNEL_COMPLETE_MARKER));
 }
 function markChannelExportComplete(root = exportRoot()) {
-  const p = join2(root, CHANNEL_COMPLETE_MARKER);
+  const p = join5(root, CHANNEL_COMPLETE_MARKER);
   const tmp = p + ".tmp";
-  writeFileSync(tmp, String(Date.now()));
-  renameSync(tmp, p);
-}
-var CURSOR_SCHEMA = "v2";
-function getLastSync(root = exportRoot()) {
-  const p = join2(root, ".last_sync");
-  if (!existsSync2(p))
-    return null;
-  try {
-    const raw = readFileSync(p, "utf8").trim();
-    if (!raw)
-      return null;
-    if (raw.startsWith(`${CURSOR_SCHEMA} `)) {
-      const [tsStr, id] = raw.slice(CURSOR_SCHEMA.length + 1).split(":");
-      const ts = Number(tsStr);
-      if (!Number.isFinite(ts) || !id)
-        return null;
-      return { ts, id };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function setLastSync(c, root = exportRoot()) {
-  const p = join2(root, ".last_sync");
-  const tmp = p + ".tmp";
-  writeFileSync(tmp, `${CURSOR_SCHEMA} ${c.ts}:${c.id}`);
-  renameSync(tmp, p);
+  writeFileSync3(tmp, String(Date.now()));
+  renameSync2(tmp, p);
 }
 var sessionCache = new Map;
 function getSession(id) {
@@ -495,46 +951,46 @@ function writeMeta(s, dir) {
     time_updated: s.time_updated,
     archived: s.time_archived != null
   };
-  const p = join2(dir, "meta.json");
+  const p = join5(dir, "meta.json");
   const tmp = p + ".tmp";
-  writeFileSync(tmp, JSON.stringify(meta, null, 2));
-  renameSync(tmp, p);
+  writeFileSync3(tmp, JSON.stringify(meta, null, 2));
+  renameSync2(tmp, p);
 }
 function writePartFile(dir, filename, content) {
-  const p = join2(dir, filename);
-  const tmp = join2(dir, "." + filename + ".tmp");
-  writeFileSync(tmp, content);
-  renameSync(tmp, p);
+  const p = join5(dir, filename);
+  const tmp = join5(dir, "." + filename + ".tmp");
+  writeFileSync3(tmp, content);
+  renameSync2(tmp, p);
   const m = /^(\d{5})-(prt_[A-Za-z0-9_-]+)\.txt$/.exec(filename);
   if (!m)
     return;
   const myPartId = m[2];
   try {
-    for (const f of readdirSync(dir)) {
+    for (const f of readdirSync2(dir)) {
       if (f === filename || !f.endsWith(".txt") || f.startsWith("."))
         continue;
       const fm = /^(\d{5})-(prt_[A-Za-z0-9_-]+)\.txt$/.exec(f);
       if (fm && fm[2] === myPartId) {
         try {
-          unlinkSync(join2(dir, f));
+          unlinkSync3(join5(dir, f));
         } catch {}
       }
     }
   } catch {}
 }
-function channelDir(root, channel, sessionId) {
-  return join2(root, "by-channel", channel, "by-session", sessionId);
+function channelDir2(root, channel, sessionId) {
+  return join5(root, "by-channel", channel, "by-session", sessionId);
 }
 function deleteChannelPartFiles(root, sessionId, partId) {
   for (const ch of PART_CHANNELS) {
-    const dir = channelDir(root, ch, sessionId);
-    if (!existsSync2(dir))
+    const dir = channelDir2(root, ch, sessionId);
+    if (!existsSync5(dir))
       continue;
     try {
-      for (const f of readdirSync(dir)) {
+      for (const f of readdirSync2(dir)) {
         if (f === `${partId}.txt` || f.endsWith(`-${partId}.txt`)) {
           try {
-            unlinkSync(join2(dir, f));
+            unlinkSync3(join5(dir, f));
           } catch {}
         }
       }
@@ -544,20 +1000,20 @@ function deleteChannelPartFiles(root, sessionId, partId) {
 function writeChannelFiles(root, sessionId, filename, partId, docs) {
   deleteChannelPartFiles(root, sessionId, partId);
   for (const doc of docs) {
-    const dir = channelDir(root, doc.channel, sessionId);
-    if (!existsSync2(dir))
+    const dir = channelDir2(root, doc.channel, sessionId);
+    if (!existsSync5(dir))
       mkdirSync(dir, { recursive: true });
     writePartFile(dir, filename, doc.content);
   }
 }
 function writeSessionSummaryChannel(s, dirRoot = exportRoot()) {
-  const dir = channelDir(dirRoot, "session-summary", s.id);
-  if (!existsSync2(dir))
+  const dir = channelDir2(dirRoot, "session-summary", s.id);
+  if (!existsSync5(dir))
     mkdirSync(dir, { recursive: true });
-  const p = join2(dir, "summary.txt");
+  const p = join5(dir, "summary.txt");
   const tmp = p + ".tmp";
-  writeFileSync(tmp, buildSessionSummaryDocument(s));
-  renameSync(tmp, p);
+  writeFileSync3(tmp, buildSessionSummaryDocument(s));
+  renameSync2(tmp, p);
 }
 function buildSessionSummaryDocument(s) {
   const firstPrompt = firstUserPrompt(s.id, "ASC");
@@ -611,7 +1067,7 @@ function getFileIndex(sessionId, dir) {
     return idx;
   idx = { nextSeq: 1, byPartId: new Map };
   try {
-    const files = readdirSync(dir).filter((f) => f.endsWith(".txt") && !f.startsWith("."));
+    const files = readdirSync2(dir).filter((f) => f.endsWith(".txt") && !f.startsWith("."));
     let max = 0;
     for (const f of files) {
       const m = /^(\d{5})-(prt_[A-Za-z0-9_-]+)\.txt$/.exec(f);
@@ -632,125 +1088,337 @@ function getFileIndex(sessionId, dir) {
 }
 async function runExport(opts = {}) {
   const root = ensureRoot(opts.root ?? exportRoot());
-  const cursor = opts.fromCursor !== undefined ? opts.fromCursor : getLastSync(root);
   const batchSize = opts.batchSize ?? 1000;
-  const start = Date.now();
-  const progress = { exported: 0, inserts: 0, updates: 0, skipped_nontext: 0, skipped_oversize: 0, failed: 0, last_cursor: cursor };
-  let where = "";
-  const params = [];
-  if (cursor) {
-    where = "WHERE (p.time_updated > ? OR (p.time_updated = ? AND p.id > ?))";
-    params.push(cursor.ts, cursor.ts, cursor.id);
-  }
-  let updates = 0;
-  let inserts = 0;
-  const touchedSessions = new Set;
-  while (true) {
-    if (opts.budgetMs && Date.now() - start > opts.budgetMs)
+  const progress = emptyProgress(getLastSync2(root));
+  const lock = acquireExportLock(root);
+  if (!lock) {
+    progress.lock_skipped = true;
+    return progress;
+  }
+  try {
+    const state = getSyncState2(root);
+    applyCursorOverride(state, opts.fromCursor);
+    const start = Date.now();
+    const touchedSessions = new Set;
+    retryFailedParts(root, state, progress, touchedSessions, start, opts.budgetMs, batchSize, opts.onProgress, lock.heartbeat);
+    runInsertFastPath(root, state, progress, touchedSessions, start, opts.budgetMs, batchSize, opts.onProgress, lock.heartbeat);
+    runSessionDirtyFastPath(root, state, progress, touchedSessions, start, opts.budgetMs, batchSize, opts.onProgress, lock.heartbeat);
+    refreshTouchedSessions(root, touchedSessions);
+    if (!opts.budgetMs) {
+      lock.heartbeat();
+      const tombstones = reconcileTombstones(root, lock.heartbeat);
+      applyTombstoneProgress(progress, tombstones);
+      state.last_reconcile_at = Date.now();
+      state.reconcile_watermark = {
+        part_id: state.insert_cursor.id || null,
+        session_id: state.session_cursor?.id ?? null,
+        at: state.last_reconcile_at
+      };
+    }
+    progress.last_cursor = state.legacy_cursor;
+    setSyncState2(state, root);
+  } finally {
+    lock.release();
+  }
+  if (opts.budgetMs && !opts.skipBackgroundReconcile) {
+    scheduleBackgroundReconcile({ root });
+  }
+  return progress;
+}
+function emptyProgress(cursor) {
+  return {
+    exported: 0,
+    inserts: 0,
+    updates: 0,
+    skipped_nontext: 0,
+    skipped_oversize: 0,
+    failed: 0,
+    retried: 0,
+    dead_lettered: 0,
+    tombstones_removed_parts: 0,
+    tombstones_removed_sessions: 0,
+    lock_skipped: false,
+    last_cursor: cursor
+  };
+}
+function applyCursorOverride(state, cursor) {
+  if (cursor === undefined)
+    return;
+  state.legacy_cursor = cursor;
+  state.insert_cursor.id = cursor?.id ?? "";
+  state.session_cursor = cursor && cursor.ts > 0 ? cursor : null;
+  state.session_dirty_hints = {};
+}
+function retryFailedParts(root, state, progress, touchedSessions, start, budgetMs, batchSize, onProgress, heartbeat) {
+  const ids = Object.keys(state.failed_parts).sort().slice(0, batchSize);
+  for (const id of ids) {
+    if (timeExceeded(start, budgetMs))
       break;
-    const rows = stmt(`
-      SELECT p.id, p.session_id, p.message_id, p.time_created, p.time_updated, p.data, LENGTH(p.data) AS data_bytes,
-             json_extract(m.data,'$.role') AS role
-        FROM part p
-        LEFT JOIN message m ON m.id = p.message_id
-        ${where}
-    ORDER BY p.time_updated ASC, p.id ASC
-       LIMIT ?`).all(...params, batchSize);
+    progress.retried++;
+    const row = loadPartById(id);
+    if (!row) {
+      clearPartFailure(state, id);
+      continue;
+    }
+    exportPartRow(root, state, row, progress, touchedSessions);
+    reportProgress(progress, onProgress, heartbeat);
+  }
+}
+function runInsertFastPath(root, state, progress, touchedSessions, start, budgetMs, batchSize, onProgress, heartbeat) {
+  const recentSafeRows = [];
+  let scanCursor = state.insert_cursor.id;
+  while (!timeExceeded(start, budgetMs)) {
+    const rows = loadPartRowsAfterId(scanCursor, batchSize);
     if (rows.length === 0)
       break;
-    for (const r of rows) {
-      if (opts.budgetMs && Date.now() - start > opts.budgetMs)
+    for (const row of rows) {
+      if (timeExceeded(start, budgetMs))
         break;
-      if (r.data_bytes > SAFETY_PART_CAP_BYTES) {
-        progress.skipped_oversize++;
-      } else {
-        try {
-          const s = getSession(r.session_id);
-          if (!s) {
-            progress.failed++;
-            continue;
-          }
-          const built = buildPartFile(r.id, r.session_id, r.message_id, r.data, s.time_archived != null);
-          if (!built) {
-            progress.skipped_nontext++;
-            continue;
-          }
-          const channelDocs = buildChannelDocuments(r.id, r.session_id, r.message_id, r.data, s.time_archived != null, r.role ?? null, s.directory);
-          const dir = join2(root, "by-session", r.session_id);
-          if (!existsSync2(dir)) {
-            mkdirSync(dir, { recursive: true });
-            writeMeta(s, dir);
-          }
-          const idx = getFileIndex(r.session_id, dir);
-          const existing = idx.byPartId.get(r.id);
-          if (existing) {
-            writePartFile(dir, existing, built.content);
-            updates++;
-          } else {
-            const seq = idx.nextSeq++;
-            const filename2 = safePartFilename(seq, r.id);
-            writePartFile(dir, filename2, built.content);
-            idx.byPartId.set(r.id, filename2);
-            inserts++;
-          }
-          const filename = idx.byPartId.get(r.id);
-          if (filename)
-            writeChannelFiles(root, r.session_id, filename, r.id, channelDocs);
-          touchedSessions.add(r.session_id);
-          progress.exported++;
-        } catch {
-          progress.failed++;
-        }
+      scanCursor = row.id;
+      const safe = exportPartRow(root, state, row, progress, touchedSessions);
+      if (safe)
+        rememberSafeRow(recentSafeRows, row);
+      reportProgress(progress, onProgress, heartbeat);
+    }
+    if (rows.length < batchSize)
+      break;
+  }
+  if (recentSafeRows.length > 0) {
+    state.insert_cursor.id = chooseInsertCursor(state.insert_cursor.id, recentSafeRows, budgetMs !== undefined);
+  }
+}
+function runSessionDirtyFastPath(root, state, progress, touchedSessions, start, budgetMs, batchSize, onProgress, heartbeat) {
+  scanDirtySessionHints(state, start, budgetMs, Math.min(batchSize, 500));
+  for (const [sessionId, hint] of sortedDirtyHints(state.session_dirty_hints)) {
+    while (!timeExceeded(start, budgetMs)) {
+      const rows = loadSessionPartRows(sessionId, hint.part_cursor, batchSize);
+      if (rows.length === 0) {
+        delete state.session_dirty_hints[sessionId];
+        break;
+      }
+      for (const row of rows) {
+        if (timeExceeded(start, budgetMs))
+          break;
+        hint.part_cursor = row.id;
+        exportPartRow(root, state, row, progress, touchedSessions);
+        reportProgress(progress, onProgress, heartbeat);
       }
-      progress.last_cursor = { ts: r.time_updated, id: r.id };
+      if (rows.length < batchSize) {
+        delete state.session_dirty_hints[sessionId];
+        break;
+      }
+    }
+    if (timeExceeded(start, budgetMs))
+      break;
+  }
+}
+function scanDirtySessionHints(state, start, budgetMs, limit) {
+  while (!timeExceeded(start, budgetMs)) {
+    const rows = loadDirtySessionsAfter(state.session_cursor, limit);
+    if (rows.length === 0)
+      break;
+    for (const row of rows) {
+      state.session_dirty_hints[row.id] = { time_updated: row.time_updated, part_cursor: null };
+      state.session_cursor = { ts: row.time_updated, id: row.id };
+    }
+    if (rows.length < limit)
+      break;
+  }
+}
+function exportPartRow(root, state, row, progress, touchedSessions) {
+  if (row.data_bytes > SAFETY_PART_CAP_BYTES) {
+    removeExistingPartExport(root, row.session_id, row.id);
+    progress.skipped_oversize++;
+    markSafeCursor(state, progress, row);
+    clearPartFailure(state, row.id);
+    return true;
+  }
+  try {
+    const session = getSession(row.session_id);
+    if (!session)
+      throw new Error(`missing session ${row.session_id}`);
+    const archived = session.time_archived != null;
+    const built = buildPartFile(row.id, row.session_id, row.message_id, row.data, archived);
+    if (!built) {
+      removeExistingPartExport(root, row.session_id, row.id);
+      progress.skipped_nontext++;
+      markSafeCursor(state, progress, row);
+      clearPartFailure(state, row.id);
+      return true;
     }
-    const last = rows[rows.length - 1];
-    where = "WHERE (p.time_updated > ? OR (p.time_updated = ? AND p.id > ?))";
-    params.length = 0;
-    params.push(last.time_updated, last.time_updated, last.id);
-    if (opts.onProgress && progress.exported % 5000 === 0)
-      opts.onProgress(progress);
-    if (progress.last_cursor && progress.exported > 0 && progress.exported % 5000 === 0) {
-      setLastSync(progress.last_cursor, root);
+    const channelDocs = buildChannelDocuments(row.id, row.session_id, row.message_id, row.data, archived, row.role, session.directory);
+    const dir = join5(root, "by-session", row.session_id);
+    if (!existsSync5(dir)) {
+      mkdirSync(dir, { recursive: true });
+      writeMeta(session, dir);
+    }
+    const idx = getFileIndex(row.session_id, dir);
+    const existing = idx.byPartId.get(row.id);
+    if (existing) {
+      writePartFile(dir, existing, built.content);
+      progress.updates++;
+    } else {
+      const filename2 = safePartFilename(idx.nextSeq++, row.id);
+      writePartFile(dir, filename2, built.content);
+      idx.byPartId.set(row.id, filename2);
+      progress.inserts++;
     }
+    const filename = idx.byPartId.get(row.id);
+    if (filename)
+      writeChannelFiles(root, row.session_id, filename, row.id, channelDocs);
+    touchedSessions.add(row.session_id);
+    progress.exported++;
+    markSafeCursor(state, progress, row);
+    clearPartFailure(state, row.id);
+    return true;
+  } catch (error) {
+    progress.failed++;
+    markPartFailure(state, row.id, errorMessage(error), progress);
+    return false;
   }
+}
+function removeExistingPartExport(root, sessionId, partId) {
+  const dir = join5(root, "by-session", sessionId);
+  try {
+    if (existsSync5(dir)) {
+      const idx = getFileIndex(sessionId, dir);
+      const existing = idx.byPartId.get(partId);
+      if (existing)
+        unlinkSync3(join5(dir, existing));
+      idx.byPartId.delete(partId);
+    }
+    deleteChannelPartFiles(root, sessionId, partId);
+  } catch {}
+}
+function markSafeCursor(state, progress, row) {
+  const cursor = { ts: row.time_updated, id: row.id };
+  state.legacy_cursor = cursor;
+  progress.last_cursor = cursor;
+}
+function markPartFailure(state, partId, message, progress) {
+  if (state.dead_letters[partId])
+    return;
+  const now = Date.now();
+  const existing = state.failed_parts[partId];
+  const failure = {
+    id: partId,
+    attempts: (existing?.attempts ?? 0) + 1,
+    first_failed_at: existing?.first_failed_at ?? now,
+    last_failed_at: now,
+    last_error: message
+  };
+  if (failure.attempts >= MAX_FAILED_ATTEMPTS) {
+    state.dead_letters[partId] = failure;
+    delete state.failed_parts[partId];
+    progress.dead_lettered++;
+  } else {
+    state.failed_parts[partId] = failure;
+  }
+}
+function clearPartFailure(state, partId) {
+  delete state.failed_parts[partId];
+}
+function rememberSafeRow(rows, row) {
+  rows.push(row);
+  const maxRows = INSERT_REWIND_MAX_ROWS * 4;
+  if (rows.length > maxRows)
+    rows.splice(0, rows.length - maxRows);
+}
+function chooseInsertCursor(previousId, rows, useRewind) {
+  const last = rows[rows.length - 1];
+  if (!last || !useRewind || rows.length <= INSERT_REWIND_MAX_ROWS)
+    return last?.id ?? previousId;
+  const maxCreated = rows.reduce((max, row) => Math.max(max, row.time_created), 0);
+  const cutoff = maxCreated - INSERT_REWIND_MS;
+  const timeIndex = rows.findIndex((row) => row.time_created >= cutoff);
+  const rewindIndex = Math.max(timeIndex <= 0 ? rows.length - INSERT_REWIND_MAX_ROWS : timeIndex - 1, rows.length - INSERT_REWIND_MAX_ROWS);
+  return rows[Math.max(0, rewindIndex)]?.id ?? last.id;
+}
+function sortedDirtyHints(hints) {
+  return Object.entries(hints).sort((a, b) => a[1].time_updated - b[1].time_updated || a[0].localeCompare(b[0]));
+}
+function refreshTouchedSessions(root, touchedSessions) {
   for (const sid of touchedSessions) {
-    const s = getSession(sid);
-    if (s) {
-      const dir = join2(root, "by-session", sid);
-      const fresh = stmt(`
-        SELECT id, title, project_id, directory, agent, model, cost,
-               time_created, time_updated, time_archived, parent_id
-          FROM session WHERE id = ?`).get(sid);
-      if (fresh)
-        writeMeta(fresh, dir);
-      if (fresh)
-        writeSessionSummaryChannel(fresh, root);
+    const dir = join5(root, "by-session", sid);
+    const fresh = stmt(`
+      SELECT id, title, project_id, directory, agent, model, cost,
+             time_created, time_updated, time_archived, parent_id
+        FROM session WHERE id = ?`).get(sid);
+    if (fresh) {
+      writeMeta(fresh, dir);
+      writeSessionSummaryChannel(fresh, root);
     }
   }
-  if (progress.last_cursor)
-    setLastSync(progress.last_cursor, root);
-  progress.updates = updates;
-  progress.inserts = inserts;
-  return progress;
+}
+function applyTombstoneProgress(progress, tombstones) {
+  progress.tombstones_removed_parts = tombstones.removed_parts;
+  progress.tombstones_removed_sessions = tombstones.removed_sessions;
+}
+function loadPartById(partId) {
+  return stmt(partSelectSql("WHERE p.id = ?")).get(partId);
+}
+function loadPartRowsAfterId(afterId, limit) {
+  if (!afterId)
+    return stmt(`${partSelectSql("")} ORDER BY p.id ASC LIMIT ?`).all(limit);
+  return stmt(`${partSelectSql("WHERE p.id > ?")} ORDER BY p.id ASC LIMIT ?`).all(afterId, limit);
+}
+function loadSessionPartRows(sessionId, afterId, limit) {
+  if (!afterId) {
+    return stmt(`${partSelectSql("WHERE p.session_id = ?")} ORDER BY p.id ASC LIMIT ?`).all(sessionId, limit);
+  }
+  return stmt(`${partSelectSql("WHERE p.session_id = ? AND p.id > ?")} ORDER BY p.id ASC LIMIT ?`).all(sessionId, afterId, limit);
+}
+function loadDirtySessionsAfter(cursor, limit) {
+  if (!cursor) {
+    return stmt(`SELECT id, time_updated FROM session ORDER BY time_updated ASC, id ASC LIMIT ?`).all(limit);
+  }
+  return stmt(`
+    SELECT id, time_updated
+      FROM session
+     WHERE (time_updated > ? OR (time_updated = ? AND id > ?))
+  ORDER BY time_updated ASC, id ASC
+     LIMIT ?`).all(cursor.ts, cursor.ts, cursor.id, limit);
+}
+function partSelectSql(where) {
+  return `
+    SELECT p.id, p.session_id, p.message_id, p.time_created, p.time_updated,
+           p.data, LENGTH(p.data) AS data_bytes,
+           json_extract(m.data,'$.role') AS role
+      FROM part p
+      LEFT JOIN message m ON m.id = p.message_id
+      ${where}`;
+}
+function timeExceeded(start, budgetMs) {
+  return budgetMs !== undefined && Date.now() - start > budgetMs;
+}
+function reportProgress(progress, onProgress, heartbeat) {
+  heartbeat();
+  if (!onProgress)
+    return;
+  const processed = progress.exported + progress.skipped_nontext + progress.skipped_oversize + progress.failed;
+  if (processed > 0 && processed % 5000 === 0)
+    onProgress(progress);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
 }
 
 // src/bin/dedupe-export.ts
 var argv = process.argv.slice(2);
 var apply = argv.includes("--apply");
-var root = join3(exportRoot(), "by-session");
+var root = join6(exportRoot(), "by-session");
 console.log(`[dedupe-export] root: ${root}`);
 console.log(`[dedupe-export] mode: ${apply ? "APPLY (will delete)" : "DRY-RUN (just report)"}`);
-var sessions = readdirSync2(root).filter((f) => f.startsWith("ses_"));
+var sessions = readdirSync3(root).filter((f) => f.startsWith("ses_"));
 console.log(`[dedupe-export] scanning ${sessions.length} session dirs...`);
 var totalDups = 0;
 var totalBytesFreed = 0;
 var dirsAffected = 0;
 for (const ses of sessions) {
-  const dir = join3(root, ses);
+  const dir = join6(root, ses);
   let files;
   try {
-    files = readdirSync2(dir);
+    files = readdirSync3(dir);
   } catch {
     continue;
   }
@@ -773,14 +1441,14 @@ for (const ses of sessions) {
     const keep = variants[0];
     const deletables = variants.slice(1);
     for (const d of deletables) {
-      const path = join3(dir, d.filename);
-      const sz = statSync2(path).size;
+      const path = join6(dir, d.filename);
+      const sz = statSync3(path).size;
       totalBytesFreed += sz;
       totalDups++;
       dirDups++;
       if (apply) {
         try {
-          unlinkSync2(path);
+          unlinkSync4(path);
         } catch (e) {
           console.error(`  failed to delete ${path}: ${e.message}`);
         }