opencode-sessions-explorer 0.1.0

package/dist/bin/dedupe-export.js

@@ -0,0 +1,798 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/bin/dedupe-export.ts
+import { readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join3 } from "path";
+
+// 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";
+  }
+}
+
+// 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 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 existsSync2, renameSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "fs";
+import { join as join2 } 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"
+];
+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 || "." };
+}
+
+// src/lib/export.ts
+var DEFAULT_EXPORT_ROOT = join2(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 PART_CHANNELS = CHANNELS.filter((c) => c !== "session-summary" && c !== "raw");
+function exportRoot() {
+  return process.env.OPENCODE_SESSIONS_EXPLORER_EXPORT_ROOT || DEFAULT_EXPORT_ROOT;
+}
+function ensureRoot(root = exportRoot()) {
+  mkdirSync(join2(root, "by-session"), { recursive: true });
+  return root;
+}
+function channelExportComplete(root = exportRoot()) {
+  return existsSync2(join2(root, CHANNEL_COMPLETE_MARKER));
+}
+function markChannelExportComplete(root = exportRoot()) {
+  const p = join2(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);
+}
+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 = join2(dir, "meta.json");
+  const tmp = p + ".tmp";
+  writeFileSync(tmp, JSON.stringify(meta, null, 2));
+  renameSync(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 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)) {
+      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));
+        } catch {}
+      }
+    }
+  } catch {}
+}
+function channelDir(root, channel, sessionId) {
+  return join2(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))
+      continue;
+    try {
+      for (const f of readdirSync(dir)) {
+        if (f === `${partId}.txt` || f.endsWith(`-${partId}.txt`)) {
+          try {
+            unlinkSync(join2(dir, f));
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+}
+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))
+      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))
+    mkdirSync(dir, { recursive: true });
+  const p = join2(dir, "summary.txt");
+  const tmp = p + ".tmp";
+  writeFileSync(tmp, buildSessionSummaryDocument(s));
+  renameSync(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 = readdirSync(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 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)
+      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);
+    if (rows.length === 0)
+      break;
+    for (const r of rows) {
+      if (opts.budgetMs && Date.now() - start > opts.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++;
+        }
+      }
+      progress.last_cursor = { ts: r.time_updated, id: r.id };
+    }
+    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);
+    }
+  }
+  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);
+    }
+  }
+  if (progress.last_cursor)
+    setLastSync(progress.last_cursor, root);
+  progress.updates = updates;
+  progress.inserts = inserts;
+  return progress;
+}
+
+// src/bin/dedupe-export.ts
+var argv = process.argv.slice(2);
+var apply = argv.includes("--apply");
+var root = join3(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_"));
+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);
+  let files;
+  try {
+    files = readdirSync2(dir);
+  } catch {
+    continue;
+  }
+  const byPartId = new Map;
+  for (const f of files) {
+    const m = /^(\d{5})-(prt_[A-Za-z0-9_-]+)\.txt$/.exec(f);
+    if (!m)
+      continue;
+    const seq = Number(m[1]);
+    const partId = m[2];
+    if (!byPartId.has(partId))
+      byPartId.set(partId, []);
+    byPartId.get(partId).push({ seq, filename: f });
+  }
+  let dirDups = 0;
+  for (const [partId, variants] of byPartId) {
+    if (variants.length <= 1)
+      continue;
+    variants.sort((a, b) => a.seq - b.seq);
+    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;
+      totalBytesFreed += sz;
+      totalDups++;
+      dirDups++;
+      if (apply) {
+        try {
+          unlinkSync2(path);
+        } catch (e) {
+          console.error(`  failed to delete ${path}: ${e.message}`);
+        }
+      }
+    }
+  }
+  if (dirDups > 0)
+    dirsAffected++;
+}
+console.log(`[dedupe-export] DONE`);
+console.log(`[dedupe-export]   duplicate files ${apply ? "deleted" : "to delete"}: ${totalDups}`);
+console.log(`[dedupe-export]   sessions affected:                     ${dirsAffected}`);
+console.log(`[dedupe-export]   disk ${apply ? "freed" : "to free"}: ${(totalBytesFreed / 1024 / 1024).toFixed(1)} MB`);
+if (!apply)
+  console.log(`[dedupe-export]   re-run with --apply to actually delete.`);