opencode-sessions-explorer 0.1.2 → 0.1.4

package/dist/lib/export-reconcile-worker.js

@@ -0,0 +1,1519 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/lib/db.ts
+import { Database } from "bun:sqlite";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+
+// src/lib/errors.ts
+class SessionsError extends Error {
+  code;
+  hint;
+  constructor(code, message, hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.name = "SessionsError";
+  }
+}
+function asStructured(e) {
+  if (e instanceof SessionsError) {
+    return { code: e.code, message: e.message, ...e.hint ? { hint: e.hint } : {} };
+  }
+  if (e instanceof Error) {
+    return { code: "INTERNAL", message: e.message };
+  }
+  return { code: "INTERNAL", message: String(e) };
+}
+
+// src/lib/db.ts
+var ENV_VAR = "OPENCODE_SESSIONS_EXPLORER_DB";
+function platformDefault() {
+  const home = homedir();
+  switch (platform()) {
+    case "darwin":
+    case "linux": {
+      const dataHome = process.env.XDG_DATA_HOME ?? join(home, ".local", "share");
+      return join(dataHome, "opencode", "opencode.db");
+    }
+    case "win32": {
+      const local = process.env.LOCALAPPDATA ?? join(home, "AppData", "Local");
+      return join(local, "opencode", "opencode.db");
+    }
+    default:
+      return null;
+  }
+}
+var cachedPath = null;
+function locateDb() {
+  if (cachedPath)
+    return cachedPath;
+  const env = process.env[ENV_VAR];
+  if (env) {
+    if (!existsSync(env))
+      throw new SessionsError("DB_NOT_FOUND", `opencode-sessions-explorer: $${ENV_VAR} points to missing file: ${env}`);
+    cachedPath = env;
+    return env;
+  }
+  const def = platformDefault();
+  if (!def || !existsSync(def)) {
+    throw new SessionsError("DB_NOT_FOUND", `opencode-sessions-explorer: DB not found. Set $${ENV_VAR} or install OpenCode. Tried: ${def ?? `(no default for ${platform()})`}`);
+  }
+  cachedPath = def;
+  return def;
+}
+var _db = null;
+var _stmts = new Map;
+var STMT_CACHE_LIMIT = 256;
+function db() {
+  if (_db)
+    return _db;
+  const path = locateDb();
+  _db = new Database(path, { readonly: true, create: false, safeIntegers: false });
+  _db.exec("PRAGMA query_only = 1;");
+  _db.exec("PRAGMA busy_timeout = 5000;");
+  _db.exec("PRAGMA temp_store = MEMORY;");
+  _db.exec("PRAGMA cache_size = -32000;");
+  return _db;
+}
+function stmt(sql) {
+  let s = _stmts.get(sql);
+  if (!s) {
+    if (_stmts.size >= STMT_CACHE_LIMIT) {
+      const oldest = _stmts.keys().next().value;
+      if (oldest)
+        _stmts.delete(oldest);
+    }
+    s = db().query(sql);
+    _stmts.set(sql, s);
+  }
+  return s;
+}
+
+// src/lib/decode.ts
+function safeParse(jsonStr) {
+  try {
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
+  }
+}
+function decodeMessage(dataStr) {
+  const d = safeParse(dataStr) ?? {};
+  const role = d.role === "user" || d.role === "assistant" || d.role === "system" ? d.role : "unknown";
+  const tokens = d.tokens ? {
+    input: Number(d.tokens.input ?? 0),
+    output: Number(d.tokens.output ?? 0),
+    reasoning: Number(d.tokens.reasoning ?? 0),
+    cache_read: Number(d.tokens.cache?.read ?? d.tokens.cache_read ?? 0),
+    cache_write: Number(d.tokens.cache?.write ?? d.tokens.cache_write ?? 0)
+  } : null;
+  return {
+    role,
+    agent: d.agent ?? null,
+    providerID: d.model?.providerID ?? d.providerID ?? null,
+    modelID: d.model?.modelID ?? d.modelID ?? null,
+    parentID: d.parentID ?? null,
+    cost: typeof d.cost === "number" ? d.cost : null,
+    tokens
+  };
+}
+function decodePart(dataStr) {
+  const d = safeParse(dataStr);
+  if (!d || typeof d !== "object")
+    return { type: "unknown", raw_type: null };
+  const t = d.type ?? "";
+  switch (t) {
+    case "text":
+      return { type: "text", text: typeof d.text === "string" ? d.text : "" };
+    case "reasoning":
+      return { type: "reasoning", text: typeof d.text === "string" ? d.text : "" };
+    case "tool": {
+      const s = d.state ?? {};
+      const md = s.metadata ?? {};
+      const time = s.time ?? {};
+      const start = typeof time.start === "number" ? time.start : null;
+      const end = typeof time.end === "number" ? time.end : null;
+      return {
+        type: "tool",
+        tool: typeof d.tool === "string" ? d.tool : "",
+        callID: typeof d.callID === "string" ? d.callID : null,
+        status: ["pending", "running", "completed", "error"].includes(s.status) ? s.status : "unknown",
+        input: s.input ?? null,
+        output: typeof s.output === "string" ? s.output : null,
+        error: typeof s.error === "string" ? s.error : null,
+        outputPath: typeof md.outputPath === "string" ? md.outputPath : null,
+        truncated: md.truncated === true,
+        start,
+        end,
+        duration_ms: start != null && end != null ? end - start : null,
+        title: typeof s.title === "string" ? s.title : null
+      };
+    }
+    case "file":
+      return {
+        type: "file",
+        url: typeof d.url === "string" ? d.url : null,
+        filename: typeof d.filename === "string" ? d.filename : null,
+        mime: typeof d.mime === "string" ? d.mime : null,
+        sourcePath: typeof d.source?.path === "string" ? d.source.path : null
+      };
+    case "patch":
+      return {
+        type: "patch",
+        hash: typeof d.hash === "string" ? d.hash : null,
+        files: Array.isArray(d.files) ? d.files.filter((x) => typeof x === "string") : []
+      };
+    case "step-start":
+      return { type: "step-start", snapshot: typeof d.snapshot === "string" ? d.snapshot : null };
+    case "step-finish":
+      return {
+        type: "step-finish",
+        reason: typeof d.reason === "string" ? d.reason : null,
+        snapshot: typeof d.snapshot === "string" ? d.snapshot : null,
+        cost: typeof d.cost === "number" ? d.cost : null
+      };
+    case "compaction":
+      return { type: "compaction", auto: d.auto === true };
+    case "subtask":
+      return {
+        type: "subtask",
+        prompt: typeof d.prompt === "string" ? d.prompt : "",
+        description: typeof d.description === "string" ? d.description : null,
+        agent: typeof d.agent === "string" ? d.agent : null
+      };
+    default:
+      return { type: "unknown", raw_type: typeof t === "string" ? t : null };
+  }
+}
+function decodeModel(modelStr) {
+  if (!modelStr)
+    return { id: null, providerID: null, variant: null };
+  const d = safeParse(modelStr);
+  if (!d || typeof d !== "object")
+    return { id: null, providerID: null, variant: null };
+  return {
+    id: typeof d.id === "string" ? d.id : null,
+    providerID: typeof d.providerID === "string" ? d.providerID : null,
+    variant: typeof d.variant === "string" ? d.variant : null
+  };
+}
+
+// src/lib/export.ts
+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
+var CHANNELS = [
+  "conversation",
+  "session-summary",
+  "tool-input-summary",
+  "tool-error",
+  "code-touch",
+  "tool-output",
+  "patch-summary",
+  "reasoning",
+  "file",
+  "raw"
+];
+var DEFAULT_RECALL_CHANNELS = ["conversation", "session-summary"];
+function channelsForSurface(surface, q = "") {
+  const inferred = inferSurface(q, surface);
+  switch (inferred) {
+    case "debug_trace":
+      return ["conversation", "session-summary", "tool-error", "tool-input-summary"];
+    case "tool_audit":
+      return ["tool-input-summary", "tool-error"];
+    case "code":
+      return ["conversation", "session-summary", "code-touch", "patch-summary", "tool-input-summary"];
+    case "forensics":
+      return ["raw"];
+    case "recall":
+    default:
+      return DEFAULT_RECALL_CHANNELS;
+  }
+}
+function inferSurface(q, explicit = "recall") {
+  if (explicit !== "recall")
+    return explicit;
+  const s = q.toLowerCase();
+  if (/\b(error|exception|stack trace|failed|failure|crash|timeout|logs?|stderr|stdout)\b/.test(s))
+    return "debug_trace";
+  if (/\b(tool calls?|bash|command|grep|read tool|edit tool|apply_patch|mcp|jira tool|github tool)\b/.test(s))
+    return "tool_audit";
+  if (/\b(file|path|class|function|symbol|diff|patch|edited|wrote|changed|src\/|\.kt\b|\.ts\b|\.tsx\b|\.js\b|\.py\b)\b/.test(s))
+    return "code";
+  return "recall";
+}
+function channelWeight(channel) {
+  switch (channel) {
+    case "session-summary":
+      return 7;
+    case "conversation":
+      return 6;
+    case "tool-error":
+      return 5;
+    case "code-touch":
+      return 4;
+    case "patch-summary":
+      return 3;
+    case "tool-input-summary":
+      return 3;
+    case "file":
+      return 2;
+    case "tool-output":
+      return 1;
+    case "reasoning":
+      return 0;
+    case "raw":
+      return 0;
+  }
+}
+function normalizeForDedupe(s) {
+  return s.toLowerCase().replace(/\s+/g, " ").replace(/[\u27e6\u27e7]/g, "").trim();
+}
+function normalizePrompt(s) {
+  return s.toLowerCase().replace(/\b[A-Z][A-Z0-9_]+-\d+\b/gi, "<jira>").replace(/https?:\/\/\S+/g, "<url>").replace(/(?:\/[\w .@-]+){2,}/g, "<path>").replace(/\b[0-9a-f]{12,}\b/gi, "<id>").replace(/\bses_[A-Za-z0-9_-]+\b/g, "<session>").replace(/\bmsg_[A-Za-z0-9_-]+\b/g, "<message>").replace(/\bprt_[A-Za-z0-9_-]+\b/g, "<part>").replace(/\s+/g, " ").trim();
+}
+function normalizeError(s) {
+  return s.replace(/https?:\/\/\S+/g, "<url>").replace(/(?:\/[\w .@-]+){2,}/g, "<path>").replace(/\b[A-Z][A-Z0-9_]+-\d+\b/g, "<jira>").replace(/\b(?:0x)?[0-9a-f]{8,}\b/gi, "<id>").replace(/\b(line|column|col)[:= ]+\d+\b/gi, "$1:<n>").replace(/:\d+:\d+/g, ":<n>:<n>").replace(/\s+/g, " ").trim();
+}
+function compactPath(path, baseDir) {
+  if (!baseDir || !path.startsWith(baseDir))
+    return { path, rel_path: null };
+  const rel = path.slice(baseDir.length).replace(/^\/+/, "");
+  return { path, rel_path: rel || "." };
+}
+function looksLikeExactIdentifier(q) {
+  return /\b(?:[A-Z][A-Z0-9_]+-\d+|ses_[A-Za-z0-9_-]+|msg_[A-Za-z0-9_-]+|prt_[A-Za-z0-9_-]+)\b/.test(q) || /https?:\/\/\S+/.test(q) || /(?:\/[\w .@-]+){2,}/.test(q);
+}
+
+// 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 = 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 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(join5(root, "by-session"), { recursive: true });
+  return root;
+}
+function channelExportComplete(root = exportRoot()) {
+  return existsSync5(join5(root, CHANNEL_COMPLETE_MARKER));
+}
+var sessionCache = new Map;
+function getSession(id) {
+  const cached = sessionCache.get(id);
+  if (cached)
+    return cached;
+  const row = stmt(`
+    SELECT id, title, project_id, directory, agent, model, cost,
+           time_created, time_updated, time_archived, parent_id
+      FROM session WHERE id = ?`).get(id);
+  if (!row)
+    return null;
+  sessionCache.set(id, row);
+  return row;
+}
+function buildPartFile(partId, sessionId, messageId, data, archived) {
+  let decoded;
+  try {
+    decoded = decodePart(data);
+  } catch {
+    return null;
+  }
+  if (!SEARCHABLE_TYPES.includes(decoded.type))
+    return null;
+  const lines = [];
+  lines.push(`PART_ID: ${partId}`);
+  lines.push(`SESSION_ID: ${sessionId}`);
+  lines.push(`MESSAGE_ID: ${messageId}`);
+  lines.push(`TYPE: ${decoded.type}`);
+  lines.push(`ARCHIVED: ${archived}`);
+  let body = "";
+  switch (decoded.type) {
+    case "text":
+      body = decoded.text;
+      break;
+    case "reasoning":
+      body = decoded.text;
+      break;
+    case "tool": {
+      lines.push(`TOOL: ${decoded.tool}`);
+      lines.push(`STATUS: ${decoded.status}`);
+      if (decoded.start != null && decoded.end != null)
+        lines.push(`TIME: ${decoded.start} - ${decoded.end}`);
+      const parts = [];
+      try {
+        parts.push("INPUT: " + JSON.stringify(decoded.input));
+      } catch {
+        parts.push("INPUT: <unserializable>");
+      }
+      if (decoded.output)
+        parts.push(`OUTPUT:
+` + decoded.output);
+      if (decoded.error)
+        parts.push(`ERROR:
+` + decoded.error);
+      body = parts.join(`
+`);
+      break;
+    }
+    case "file":
+      lines.push(`MIME: ${decoded.mime ?? "?"}`);
+      body = `FILENAME: ${decoded.filename ?? "?"}
+URL: ${decoded.url ?? "?"}
+SOURCE_PATH: ${decoded.sourcePath ?? "?"}`;
+      break;
+    case "patch":
+      lines.push(`HASH: ${decoded.hash ?? "?"}`);
+      lines.push(`FILES_COUNT: ${decoded.files.length}`);
+      body = `FILES:
+` + decoded.files.join(`
+`);
+      break;
+    case "subtask":
+      lines.push(`AGENT: ${decoded.agent ?? "?"}`);
+      if (decoded.description)
+        body += `DESCRIPTION: ${decoded.description}
+`;
+      body += `PROMPT:
+${decoded.prompt}`;
+      break;
+    default:
+      return null;
+  }
+  lines.push("---BODY---");
+  const enc = new TextEncoder;
+  let bodyBytes = enc.encode(body).length;
+  if (bodyBytes > BODY_CAP_BYTES) {
+    const truncMarker = `
+\u2026[truncated; ${bodyBytes} bytes original; call get_part('${partId}') for full content]`;
+    const markerBytes = enc.encode(truncMarker).length;
+    const sliced = enc.encode(body).slice(0, Math.max(0, BODY_CAP_BYTES - markerBytes));
+    body = new TextDecoder("utf-8", { fatal: false }).decode(sliced).replace(/\uFFFD+$/, "") + truncMarker;
+    bodyBytes = enc.encode(body).length;
+  }
+  lines.push(body);
+  return { content: lines.join(`
+`), type: decoded.type };
+}
+function buildChannelDocuments(partId, sessionId, messageId, data, archived, role, sessionDirectory) {
+  let decoded;
+  try {
+    decoded = decodePart(data);
+  } catch {
+    return [];
+  }
+  const docs = [];
+  const baseHeaders = [
+    `PART_ID: ${partId}`,
+    `SESSION_ID: ${sessionId}`,
+    `MESSAGE_ID: ${messageId}`,
+    `ROLE: ${role ?? "unknown"}`,
+    `TYPE: ${decoded.type}`,
+    `ARCHIVED: ${archived}`
+  ];
+  const emit = (channel, body, extra = []) => {
+    const trimmed = body.trim();
+    if (!trimmed)
+      return;
+    docs.push({ channel, content: [...baseHeaders, `CHANNEL: ${channel}`, ...extra, "---BODY---", capBody(trimmed, partId)].join(`
+`) });
+  };
+  switch (decoded.type) {
+    case "text":
+      emit("conversation", decoded.text);
+      break;
+    case "reasoning":
+      emit("reasoning", decoded.text);
+      break;
+    case "subtask":
+      emit("conversation", `${decoded.description ? `DESCRIPTION: ${decoded.description}
+` : ""}PROMPT:
+${decoded.prompt}`, [`AGENT: ${decoded.agent ?? "?"}`]);
+      break;
+    case "tool": {
+      const extra = [`TOOL: ${decoded.tool}`, `STATUS: ${decoded.status}`];
+      const inputSummary = summarizeToolInput(decoded.tool, decoded.input, sessionDirectory);
+      emit("tool-input-summary", inputSummary || `${decoded.tool} ${decoded.status}`, extra);
+      if (decoded.status === "error" && decoded.error)
+        emit("tool-error", normalizeError(decoded.error), extra);
+      if (decoded.output)
+        emit("tool-output", decoded.output, extra);
+      const codeTouch = summarizeCodeTouch(decoded.tool, decoded.input, sessionDirectory);
+      if (codeTouch)
+        emit("code-touch", codeTouch, extra);
+      break;
+    }
+    case "patch": {
+      const body = decoded.files.map((f) => compactPath(f, sessionDirectory).rel_path ?? f).join(`
+`);
+      emit("patch-summary", body, [`HASH: ${decoded.hash ?? "?"}`, `FILES_COUNT: ${decoded.files.length}`]);
+      emit("code-touch", body, [`SOURCE: patch`, `FILES_COUNT: ${decoded.files.length}`]);
+      break;
+    }
+    case "file":
+      emit("file", `FILENAME: ${decoded.filename ?? "?"}
+URL: ${decoded.url ?? "?"}
+SOURCE_PATH: ${decoded.sourcePath ?? "?"}`);
+      break;
+  }
+  return docs;
+}
+function capBody(body, partId) {
+  const enc = new TextEncoder;
+  const bytes = enc.encode(body).length;
+  if (bytes <= BODY_CAP_BYTES)
+    return body;
+  const marker = `
+...[truncated; ${bytes} bytes original; call get_part('${partId}') for full content]`;
+  const markerBytes = enc.encode(marker).length;
+  const sliced = enc.encode(body).slice(0, Math.max(0, BODY_CAP_BYTES - markerBytes));
+  return new TextDecoder("utf-8", { fatal: false }).decode(sliced).replace(/\uFFFD+$/, "") + marker;
+}
+function summarizeToolInput(tool, input, sessionDirectory) {
+  if (!input || typeof input !== "object")
+    return stringifySafe(input);
+  const obj = input;
+  const lines = [];
+  const add = (label, value) => {
+    if (typeof value === "string" && value.trim())
+      lines.push(`${label}: ${compactPath(value, sessionDirectory).rel_path ?? value}`);
+    else if (typeof value === "number" || typeof value === "boolean")
+      lines.push(`${label}: ${value}`);
+  };
+  lines.push(`TOOL: ${tool}`);
+  for (const key of ["command", "description", "filePath", "path", "url", "query", "pattern", "session_id", "message_id", "part_id", "issue_key", "pullNumber"]) {
+    add(key, obj[key]);
+  }
+  if (Array.isArray(obj.paths))
+    for (const p of obj.paths.slice(0, 20))
+      add("path", p);
+  if (Array.isArray(obj.files))
+    for (const p of obj.files.slice(0, 20))
+      add("file", p);
+  return lines.length > 1 ? lines.join(`
+`) : stringifySafe(input);
+}
+function summarizeCodeTouch(tool, input, sessionDirectory) {
+  if (!input || typeof input !== "object")
+    return null;
+  const obj = input;
+  const paths = [];
+  for (const key of ["filePath", "path"]) {
+    if (typeof obj[key] === "string")
+      paths.push(obj[key]);
+  }
+  for (const key of ["paths", "files"]) {
+    if (Array.isArray(obj[key])) {
+      for (const p of obj[key])
+        if (typeof p === "string")
+          paths.push(p);
+    }
+  }
+  if (paths.length === 0)
+    return null;
+  return [`TOOL: ${tool}`, ...paths.slice(0, 50).map((p) => compactPath(p, sessionDirectory).rel_path ?? p)].join(`
+`);
+}
+function stringifySafe(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "<unserializable>";
+  }
+}
+function safePartFilename(seq, partId) {
+  const safe = partId.replace(/[^A-Za-z0-9_-]/g, "_");
+  return `${String(seq).padStart(5, "0")}-${safe}.txt`;
+}
+function writeMeta(s, dir) {
+  const meta = {
+    id: s.id,
+    title: s.title,
+    project_id: s.project_id,
+    directory: s.directory,
+    agent: s.agent,
+    model: decodeModel(s.model),
+    cost: Number(s.cost ?? 0),
+    parent_id: s.parent_id,
+    time_created: s.time_created,
+    time_updated: s.time_updated,
+    archived: s.time_archived != null
+  };
+  const p = join5(dir, "meta.json");
+  const tmp = p + ".tmp";
+  writeFileSync3(tmp, JSON.stringify(meta, null, 2));
+  renameSync2(tmp, p);
+}
+function writePartFile(dir, filename, content) {
+  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 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 {
+          unlinkSync3(join5(dir, f));
+        } catch {}
+      }
+    }
+  } catch {}
+}
+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 = channelDir2(root, ch, sessionId);
+    if (!existsSync5(dir))
+      continue;
+    try {
+      for (const f of readdirSync2(dir)) {
+        if (f === `${partId}.txt` || f.endsWith(`-${partId}.txt`)) {
+          try {
+            unlinkSync3(join5(dir, f));
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+}
+function writeChannelFiles(root, sessionId, filename, partId, docs) {
+  deleteChannelPartFiles(root, sessionId, partId);
+  for (const doc of docs) {
+    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 = channelDir2(dirRoot, "session-summary", s.id);
+  if (!existsSync5(dir))
+    mkdirSync(dir, { recursive: true });
+  const p = join5(dir, "summary.txt");
+  const tmp = p + ".tmp";
+  writeFileSync3(tmp, buildSessionSummaryDocument(s));
+  renameSync2(tmp, p);
+}
+function buildSessionSummaryDocument(s) {
+  const firstPrompt = firstUserPrompt(s.id, "ASC");
+  const lastPrompt = firstUserPrompt(s.id, "DESC");
+  const model = decodeModel(s.model);
+  const lines = [
+    `SESSION_ID: ${s.id}`,
+    `CHANNEL: session-summary`,
+    `TITLE: ${s.title}`,
+    `PROJECT_ID: ${s.project_id}`,
+    `DIRECTORY: ${s.directory}`,
+    `AGENT: ${s.agent ?? "unknown"}`,
+    `MODEL: ${model.id ?? "unknown"}`,
+    `ARCHIVED: ${s.time_archived != null}`,
+    `PARENT_ID: ${s.parent_id ?? ""}`,
+    "---BODY---",
+    `TITLE: ${s.title}`,
+    `DIRECTORY: ${s.directory}`,
+    firstPrompt ? `FIRST_USER_PROMPT:
+${firstPrompt}` : "FIRST_USER_PROMPT:",
+    lastPrompt && lastPrompt !== firstPrompt ? `LAST_USER_PROMPT:
+${lastPrompt}` : ""
+  ].filter(Boolean);
+  return lines.join(`
+`);
+}
+function firstUserPrompt(sessionId, direction) {
+  const msg = stmt(`
+    SELECT id
+      FROM message
+     WHERE session_id = ? AND json_extract(data,'$.role') = 'user'
+  ORDER BY time_created ${direction}, id ${direction}
+     LIMIT 1`).get(sessionId);
+  if (!msg)
+    return null;
+  const rows = stmt(`
+    SELECT json_extract(data,'$.text') AS text
+      FROM part
+     WHERE message_id = ? AND json_extract(data,'$.type') = 'text'
+  ORDER BY time_created ASC, id ASC`).all(msg.id);
+  const joined = rows.map((r) => r.text ?? "").join(`
+`).trim();
+  if (!joined)
+    return null;
+  return capBody(joined, "summary");
+}
+var fileIndexBySession = new Map;
+function getFileIndex(sessionId, dir) {
+  let idx = fileIndexBySession.get(sessionId);
+  if (idx)
+    return idx;
+  idx = { nextSeq: 1, byPartId: new Map };
+  try {
+    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);
+      if (m) {
+        const seq = Number(m[1]);
+        const partId = m[2];
+        idx.byPartId.set(partId, f);
+        if (seq > max)
+          max = seq;
+      } else if (/^prt_[A-Za-z0-9_-]+\.txt$/.test(f)) {
+        idx.byPartId.set(f.replace(/\.txt$/, ""), f);
+      }
+    }
+    idx.nextSeq = max + 1;
+  } catch {}
+  fileIndexBySession.set(sessionId, idx);
+  return idx;
+}
+async function runExport(opts = {}) {
+  const root = ensureRoot(opts.root ?? exportRoot());
+  const batchSize = opts.batchSize ?? 1000;
+  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;
+    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 row of rows) {
+      if (timeExceeded(start, budgetMs))
+        break;
+      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);
+      }
+      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 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 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);
+    }
+  }
+}
+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/lib/export-reconcile-worker.ts
+var scope = globalThis;
+scope.onmessage = (event) => {
+  reconcile(event.data);
+};
+async function reconcile(request) {
+  try {
+    const progress = await runExport({
+      root: request.root,
+      batchSize: request.batchSize ?? 2000,
+      skipBackgroundReconcile: true
+    });
+    scope.postMessage({ ok: true, progress });
+  } catch (error) {
+    scope.postMessage({
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}